1 /*

     2 * Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:   Implements CNcdSearchNodeFolder class

    15 *

    16 */

    17 

    18 

    19 #include "ncdsearchnodefolder.h"

    20 #include "ncdnodefolderlink.h"

    21 #include "ncdnodefoldermetadata.h"

    22 #include "ncdnodemanager.h"

    23 #include "ncdnodeclassids.h"

    24 #include "ncdnodeidentifier.h"

    25 #include "ncdnodefunctionids.h"

    26 #include "catalogsbasemessage.h"

    27 #include "catalogsutils.h"

    28 #include "ncdutils.h"

    29 

    30 #include "catalogsdebug.h"

    31 

    32 CNcdSearchNodeFolder* CNcdSearchNodeFolder::NewL( CNcdNodeManager& aNodeManager,

    33                                                   const CNcdNodeIdentifier& aIdentifier,

    34                                                   TBool aIsTransparent )

    35     {

    36     CNcdSearchNodeFolder* self = 

    37         CNcdSearchNodeFolder::NewLC( aNodeManager, aIdentifier, aIsTransparent );

    38     CleanupStack::Pop( self );

    39     return self;        

    40     }

    41 

    42 CNcdSearchNodeFolder* CNcdSearchNodeFolder::NewLC( CNcdNodeManager& aNodeManager,

    43                                                    const CNcdNodeIdentifier& aIdentifier,

    44                                                    TBool aIsTransparent )

    45     {

    46     CNcdSearchNodeFolder* self = 

    47         new( ELeave ) CNcdSearchNodeFolder( aNodeManager,

    48             NcdNodeClassIds::ENcdSearchFolderNodeClassId, aIsTransparent );

    49     CleanupClosePushL( *self );

    50     self->ConstructL( aIdentifier );

    51     return self;        

    52     }

    53 

    54 CNcdSearchNodeFolder::CNcdSearchNodeFolder( CNcdNodeManager& aNodeManager,

    55     NcdNodeClassIds::TNcdNodeClassId aNodeClassId, TBool aIsTransparent )

    56 : CNcdParentOfTransparentNode( aNodeManager,

    57             aNodeClassId ), iIsTransparent( aIsTransparent )

    58     {

    59     }

    60 

    61 void CNcdSearchNodeFolder::ConstructL( const CNcdNodeIdentifier& aIdentifier )

    62     {

    63     DLTRACEIN(("this: %X", this ));

    64 

    65     CNcdParentOfTransparentNode::ConstructL( aIdentifier );

    66     iSearchFilter = CNcdSearchFilter::NewL();

    67     iOriginIdentifier = CNcdNodeIdentifier::NewL();

    68     DLTRACEOUT((""));

    69     }

    70 

    71 

    72 CNcdSearchNodeFolder::~CNcdSearchNodeFolder()

    73     {

    74     DLTRACEIN(("this: %X", this));

    75     delete iSearchFilter;

    76     delete iOriginIdentifier;

    77     DLTRACEOUT((""));

    78     }

    79 

    80 void CNcdSearchNodeFolder::SetSearchFilterL( const CNcdSearchFilter& aFilter )

    81     {

    82     DLTRACEIN((""));

    83     

    84     DeletePtr( iSearchFilter );

    85     iSearchFilter = CNcdSearchFilter::NewL( aFilter );

    86     

    87     #ifdef CATALOGS_BUILD_CONFIG_DEBUG

    88     const MDesCArray& keywords = aFilter.Keywords();

    89     DLINFO(("Search filter: "));

    90     for ( TInt i = 0; i < keywords.MdcaCount(); i++ ) 

    91         {

    92         DLINFO((_L("%S"), &keywords.MdcaPoint( i ) ));

    93         }

    94     #endif

    95     }

    96     

    97 void CNcdSearchNodeFolder::SetOriginIdentifierL(

    98     const CNcdNodeIdentifier& aOriginIdentifier )

    99     {

   100     DLTRACEIN((""))

   101     CNcdNodeIdentifier* originIdentifier = NULL;

   102     originIdentifier = CNcdNodeIdentifier::NewL( aOriginIdentifier );

   103     delete iOriginIdentifier;

   104     iOriginIdentifier = originIdentifier;

   105     }

   106 

   107 const CNcdNodeIdentifier& CNcdSearchNodeFolder::OriginIdentifierL() const

   108     {

   109     DLTRACEIN((""));

   110     if( iOriginIdentifier->ContainsEmptyFields() )

   111         {

   112         DLTRACE((_L("Origin identifier not present") ));

   113         // own origin identifier is empty, ask from parent

   114         // NOTE: this will leave if parent folder can't be acquired, this is ok

   115         // because some folder in the parent hierarchy must always have an origin

   116         // identifier.

   117         if( ClassId() == NcdNodeClassIds::ENcdSearchRootNodeClassId )

   118             {

   119             DLERROR((_L("Already at root and no origin found! Leave!") ));

   120             User::Leave( KErrNotFound );

   121             }

   122         DLTRACE((_L("Asking Origin identifier from parent") ));

   123         return NodeManager().SearchFolderL( NodeLinkL().ParentIdentifier() )

   124             .OriginIdentifierL();

   125         }

   126     else

   127         {

   128         DLTRACE((_L("Origin identifier present, id: %S"), &iOriginIdentifier->NodeId() ));

   129         return *iOriginIdentifier;

   130         }

   131     }

   132 

   133 void CNcdSearchNodeFolder::ExternalizeL( RWriteStream& aStream )

   134     {

   135     DLTRACEIN(("this: %X", this ));

   136 

   137     CNcdParentOfTransparentNode::ExternalizeL( aStream );

   138     

   139     iSearchFilter->ExternalizeL( aStream );

   140     iOriginIdentifier->ExternalizeL( aStream );

   141     aStream.WriteInt32L( iIsTransparent );

   142     DLTRACEOUT((""));

   143     }

   144 

   145 void CNcdSearchNodeFolder::InternalizeL( RReadStream& aStream )

   146     {

   147     DLTRACEIN(("this: %X", this));

   148 

   149     CNcdParentOfTransparentNode::InternalizeL( aStream );

   150     

   151     iSearchFilter->InternalizeL( aStream );

   152     iOriginIdentifier->InternalizeL( aStream );

   153     iIsTransparent = aStream.ReadInt32L();

   154     DLTRACEOUT((""));

   155     }

   156 

   157 void CNcdSearchNodeFolder::ExternalizeDataForRequestL( RWriteStream& aStream ) const

   158     {

   159     DLTRACEIN(("this: %X", this));

   160 

   161     CNcdParentOfTransparentNode::ExternalizeDataForRequestL( aStream );

   162 

   163     iSearchFilter->ExternalizeL( aStream );

   164         

   165     DLTRACEOUT((""));

   166     }

   167     

   168 TBool CNcdSearchNodeFolder::IsTransparent() const

   169     {

   170     DLTRACEIN((""));

   171     return iIsTransparent;

   172     }

   173     

   174 void CNcdSearchNodeFolder::SetTransparent( TBool aIsTransparent )

   175     {

   176     DLTRACEIN((""));

   177     iIsTransparent = aIsTransparent;

   178     }

   179