--- /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);
+ }
+