diff -r 000000000000 -r b16258d2340f applayerpluginsandutils/bookmarksupport/src/bkmrkbase.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/applayerpluginsandutils/bookmarksupport/src/bkmrkbase.cpp	Tue Feb 02 01:09:52 2010 +0200
@@ -0,0 +1,376 @@
+// Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// Internal class for the bookmark item base class.
+// @internalComponent
+// 
+//
+
+//#include <bookmarkdef.h>
+#include "bkmrk.h"
+#include "bkmrkfolder.h"
+
+CBookmarkBase::CBookmarkBase(CBookmarkDb& aDb, CRepository& aRepository)
+	: CRepositoryAccessor(), iDatabase(aDb), iRefCount(0), iId(Bookmark::KNullItemID), iParent(NULL), iFlags(EFlagPublic|EFlagWritable)
+	{
+	SetRepository(aRepository);
+	iStatus = EStatusCreating;
+	}
+
+CBookmarkBase::~CBookmarkBase()
+	{
+	if (iParent)
+		{
+		iParent->Remove(*this);
+		}
+	}
+
+Bookmark::TItemId CBookmarkBase::Id()
+	{
+	return iId;
+	}
+
+void CBookmarkBase::AssignIdL()
+	{
+	iId = NextIndexL();
+	if (Type() == Bookmark::ETypeFolder)
+		{
+		iId |= KFolderIdMaskID;
+		}
+	}
+
+void CBookmarkBase::SetId(Bookmark::TItemId aId)
+	{
+	iId = aId;
+	}
+
+RBkNode CBookmarkBase::OpenItemL()
+	{
+	RBkNode item;
+	item.SetItem(*this);
+	return item;
+	}
+
+void CBookmarkBase::SetDirty()
+	{
+	if (!iDatabase.IsLoading())
+		{
+		CRepositoryAccessor::SetDirty();
+		}
+	}
+
+Bookmark::TItemId CBookmarkBase::ParentId() const
+	{
+	return iParentId;
+	}
+
+CBookmarkFolder* CBookmarkBase::Parent() const
+	{
+	return iParent;
+	}
+
+// Should not be used. Use CBookmarkFolder::AppendL or InsertL
+// to an item to another folders.
+void CBookmarkBase::SetParentL(CBookmarkFolder& aNewParent)
+	{
+	// No item should set it's parent to itself
+	__ASSERT_ALWAYS(&aNewParent != this, User::Panic(Bookmark::KBookmarkErrParent, Bookmark::KErrCyclicLoop));
+	LeaveIfNotWritableL();
+
+	// Ensure we're not trying to set the parent of an item to a folder it owns.
+	if (this->Type() == Bookmark::ETypeFolder &&
+		aNewParent.IsAChild(static_cast<CBookmarkFolder*>(this)))
+		{
+		User::Leave(Bookmark::KErrCyclicLoop);
+		}
+
+	iParent = &aNewParent;
+	iParentId = aNewParent.Id();
+	SetDirty();
+	}
+
+void CBookmarkBase::SetTitleL(const TDesC& aTitle)
+	{
+	// The aTitle must be smaller that the maximim descriptor storage size
+	__ASSERT_ALWAYS(aTitle.Length() <= Bookmark::KMaxDescriptorLength, User::Panic(Bookmark::KBookmarkErrTooLong, KErrArgument));
+	
+	if (Type() == Bookmark::ETypeFolder && 
+		(iDatabase.FindFolder(aTitle) != NULL || 
+		iDatabase.FindUnloadedFolder(aTitle) != NULL))
+		{
+		User::Leave(Bookmark::KErrTitleAlreadyUsed);
+		}
+
+	LeaveIfNotWritableL();
+	if (iTitle)
+		{
+		delete iTitle;
+		}
+
+	iTitle = NULL;
+	iTitle = aTitle.AllocL();
+	SetDirty();
+	}
+
+const TDesC& CBookmarkBase::Title() const
+	{
+	if ( !iTitle )
+		{
+		return KNullDesC;
+		}
+ 	return *iTitle;
+	}
+
+void CBookmarkBase::IncRefCount()
+	{
+	++iRefCount;
+	}
+
+void CBookmarkBase::DecRefCount()
+	{
+	__ASSERT_ALWAYS(iRefCount > 0, User::Panic(Bookmark::KBookmarkErrNegativeRefCount, KErrGeneral));
+	--iRefCount;
+	}
+
+TUint CBookmarkBase::RefCount()
+	{
+	return iRefCount;
+	}
+
+TBool CBookmarkBase::IsPublic()
+	{
+	return iFlags & EFlagPublic;
+	}
+
+void CBookmarkBase::SetPublicL(TBool aPublic)
+	{
+	LeaveIfNotWritableL();
+	
+	// The home page cannot be set as private
+	if (!aPublic &&
+		Type() == Bookmark::ETypeBookmark &&		
+		static_cast<CBookmark*>(this)->IsHomePage())
+		{
+		User::Leave(Bookmark::KErrOperationDenied);
+		}
+	
+	// You can't change the public-ness of an item in public only and private only modes.
+	if (iDatabase.Visibility() == Bookmark::EVisibilityPublic || iDatabase.Visibility() == Bookmark::EVisibilityPrivate)
+		{
+		User::Leave(KErrPermissionDenied);
+		}
+		
+	if (aPublic)
+		{
+		iFlags = iFlags | EFlagPublic;
+		}
+	else
+		{
+		RThread thread;
+		TSecurityInfo secInfo(thread);
+		SetOwnerL(secInfo.iSecureId);
+		}
+	SetDirty();
+	}
+
+TBool CBookmarkBase::IsWritable()
+	{
+	return iFlags & EFlagWritable;
+	}
+
+void CBookmarkBase::SetWritableL(TBool aWritable)
+	{
+	if (aWritable)
+		{
+		LeaveIfNotInManagerModeL ();
+		iFlags = iFlags | EFlagWritable;
+		}
+	else
+		{
+		iFlags = iFlags & ~EFlagWritable;
+		}
+	SetDirty();
+	}
+
+TBool CBookmarkBase::IsOrphaned()
+	{
+	return iFlags & EFlagOrphaned;
+	}
+
+void CBookmarkBase::SetOrphaned(TBool aOrphaned)
+	{
+	if (aOrphaned)
+		{
+		iFlags = iFlags | EFlagOrphaned;
+		}
+	else
+		{
+		iFlags = iFlags & ~EFlagOrphaned;
+		}
+	}
+
+void CBookmarkBase::GetOwnerL(TSecureId& aOwner)
+	{
+	TInt id = Bookmark::KNoOwnerId;
+	TInt err = iRepository->Get(IndexBase() + KCmnOwnerIndex, id);
+	if (err != KErrNone && err != KErrNotFound)
+		{
+		User::Leave(err);
+		}
+	aOwner.iId = static_cast<TUint32>(id);
+	}
+
+void CBookmarkBase::SetOwnerL(TSecureId aOwner)
+	{
+	if ( iDatabase.Visibility() != Bookmark::EVisibilityManager )
+		{
+		RThread thread;
+		TSecurityInfo secInfo ( thread );
+		
+		if ( aOwner != secInfo.iSecureId )
+			{
+			User::Leave ( KErrPermissionDenied );
+			}
+		}
+	
+	// The owner is never stored in the class as a member variable
+	if (iStatus == EStatusCreating)
+		{
+		// the owner id is not stored in the class so it can't be set until the bookmark 
+		// had been committed at least once
+		User::Leave(Bookmark::KErrNotCommitted);
+		}
+	else
+		{
+		TInt id = Bookmark::KNoOwnerId;
+		if (aOwner != Bookmark::KNoOwnerId)
+			{
+			id = static_cast<TInt>(aOwner.iId);
+			}
+		User::LeaveIfError(iRepository->Set(IndexBase() + KCmnOwnerIndex, id));
+		}
+	iFlags = iFlags & ~EFlagPublic;
+	SetDirty();
+	}
+
+TInt CBookmarkBase::Rank()
+	{
+	return iRank;
+	}
+
+void CBookmarkBase::LeaveIfNotWritableL()
+	{
+	if ( iDatabase.Visibility() != Bookmark::EVisibilityManager && 
+		!iDatabase.IsLoading() && 
+		!IsWritable())
+ 		{
+ 		User::Leave(Bookmark::KErrReadOnly);
+ 		}	
+ 	}
+
+void CBookmarkBase::LeaveIfNotInManagerModeL ()
+	{
+	if ( iDatabase.Visibility() != Bookmark::EVisibilityManager )
+ 		{
+		User::Leave ( KErrPermissionDenied );
+ 		}
+ 	}
+
+TBool CBookmarkBase::IsAChild(CBookmarkFolder* aAncestor)
+	{
+	CBookmarkFolder* parent = iParent;
+	for (TInt folderDepth = 0; parent != NULL && folderDepth < Bookmark::KMaxFolderDepth; ++folderDepth)
+		{
+		if (parent == aAncestor)
+			{
+			return ETrue;
+			}
+		parent = parent->Parent();
+		}
+
+	return EFalse;
+	}
+
+CBkmrkProperties& CBookmarkBase::ExtendedPropertiesL()
+	{
+	if (Type() == Bookmark::ETypeFolder)
+		{
+		return static_cast<CBookmarkFolder*>(this)->BkmrkPropertiesL();
+		}
+	else
+		{
+		return static_cast<CBookmark*>(this)->BkmrkExtendedPropertiesL();
+		}		
+	}
+
+void CBookmarkBase::TransNewL()
+	{
+	TUint32 indexBase = IndexBase();
+	// create entries in the repository
+	iRepository->Create(indexBase + KCmnTitleIndex, Title());
+	iRepository->Create(indexBase + KCmnParentIndex, static_cast<TInt>(iParent->Id()));
+	iRepository->Create(indexBase + KCmnFlagsIndex, static_cast<TInt>(iFlags));
+	TInt rank = iParent->Index(*this);
+	iRepository->Create(indexBase + KCmnRankIndex, rank);
+
+	TInt id = Bookmark::KNoOwnerId;
+	if (!(iFlags & EFlagPublic))
+		{
+		RThread thread;
+		TSecurityInfo secInfo(thread);
+		id = static_cast<TInt>(secInfo.iSecureId);
+		}
+	iRepository->Create(indexBase + KCmnOwnerIndex, id);
+	}
+
+void CBookmarkBase::TransSaveL()
+	{
+	TUint32 indexBase = IndexBase();
+	// create entries in the repository
+	iRepository->Set(indexBase + KCmnTitleIndex, Title());
+	iRepository->Set(indexBase + KCmnParentIndex, static_cast<TInt>(iParent->Id()));
+	iRepository->Set(indexBase + KCmnFlagsIndex, static_cast<TInt>(iFlags));
+	TInt rank = iParent->Index(*this);
+	iRepository->Set(indexBase + KCmnRankIndex, rank);
+	}
+
+void CBookmarkBase::TransLoadL()
+	{
+	TUint32 indexBase = IndexBase();
+	HBufC* titleBuffer = HBufC::NewLC(Bookmark::KMaxDescriptorLength);
+	TPtr titlePtr = titleBuffer->Des();
+	User::LeaveIfError(iRepository->Get(indexBase + KCmnTitleIndex, titlePtr));
+	delete iTitle;
+	iTitle = NULL;
+	iTitle = titlePtr.AllocL();
+	CleanupStack::PopAndDestroy(titleBuffer);
+
+	TInt retInt = 0;
+	User::LeaveIfError(iRepository->Get(indexBase + KCmnParentIndex, retInt));
+	iParentId = static_cast<Bookmark::TItemId>(retInt);
+	User::LeaveIfError(iRepository->Get(indexBase + KCmnFlagsIndex, retInt));
+	iFlags = static_cast<TUint32>(retInt);
+	User::LeaveIfError(iRepository->Get(indexBase + KCmnRankIndex, iRank))	;
+	SetClean();
+	}
+
+void CBookmarkBase::TransRemoveL()
+	{
+	TUint32 indexBase = IndexBase();
+	iRepository->Delete(indexBase + KCmnTitleIndex);
+	iRepository->Delete(indexBase + KCmnParentIndex);
+	iRepository->Delete(indexBase + KCmnFlagsIndex);
+	iRepository->Delete(indexBase + KCmnRankIndex);
+	iRepository->Delete(indexBase + KCmnOwnerIndex);
+	}
+