uifw/EikStd/coctlsrc/aknitemactionmenuregisterarray.cpp
branchRCL_3
changeset 10 9f56a4e1b8ab
parent 0 2f259fa3e83a
child 55 aecbbf00d063
equal deleted inserted replaced
9:aabf2c525e0f 10:9f56a4e1b8ab
    17 #include <akncollection.h>
    17 #include <akncollection.h>
    18 #include <aknitemactionmenu.h>
    18 #include <aknitemactionmenu.h>
    19 #include <eikmenub.h>
    19 #include <eikmenub.h>
    20 
    20 
    21 #include "aknitemactionmenuregisterarray.h"
    21 #include "aknitemactionmenuregisterarray.h"
       
    22 #include "akntrace.h"
    22 
    23 
    23 // ---------------------------------------------------------------------------
    24 // ---------------------------------------------------------------------------
    24 // CCAknItemActionMenuRegisterArray::NewL
    25 // CCAknItemActionMenuRegisterArray::NewL
    25 // ---------------------------------------------------------------------------
    26 // ---------------------------------------------------------------------------
    26 //
    27 //
    27 CAknItemActionMenuRegisterArray* CAknItemActionMenuRegisterArray::NewL()
    28 CAknItemActionMenuRegisterArray* CAknItemActionMenuRegisterArray::NewL()
    28     {
    29     {
       
    30     _AKNTRACE_FUNC_ENTER;
    29     CAknItemActionMenuRegisterArray* self =
    31     CAknItemActionMenuRegisterArray* self =
    30         CAknItemActionMenuRegisterArray::NewLC();
    32         CAknItemActionMenuRegisterArray::NewLC();
    31     CleanupStack::Pop( self );
    33     CleanupStack::Pop( self );
       
    34     _AKNTRACE_FUNC_EXIT;
    32     return self;
    35     return self;
    33     }
    36     }
    34 
    37 
    35 
    38 
    36 // ---------------------------------------------------------------------------
    39 // ---------------------------------------------------------------------------
    37 // CCAknItemActionMenuRegisterArray::NewLC
    40 // CCAknItemActionMenuRegisterArray::NewLC
    38 // ---------------------------------------------------------------------------
    41 // ---------------------------------------------------------------------------
    39 //
    42 //
    40 CAknItemActionMenuRegisterArray* CAknItemActionMenuRegisterArray::NewLC()
    43 CAknItemActionMenuRegisterArray* CAknItemActionMenuRegisterArray::NewLC()
    41     {
    44     {
       
    45     _AKNTRACE_FUNC_ENTER;
    42     CAknItemActionMenuRegisterArray* self =
    46     CAknItemActionMenuRegisterArray* self =
    43         new ( ELeave ) CAknItemActionMenuRegisterArray();
    47         new ( ELeave ) CAknItemActionMenuRegisterArray();
    44     CleanupStack::PushL( self );
    48     CleanupStack::PushL( self );
       
    49     _AKNTRACE_FUNC_EXIT;
    45     return self;
    50     return self;
    46     }
    51     }
    47 
    52 
    48 
    53 
    49 // ---------------------------------------------------------------------------
    54 // ---------------------------------------------------------------------------
    50 // CAknItemActionMenuRegisterArray::~CAknItemActionMenuRegisterArray
    55 // CAknItemActionMenuRegisterArray::~CAknItemActionMenuRegisterArray
    51 // ---------------------------------------------------------------------------
    56 // ---------------------------------------------------------------------------
    52 //
    57 //
    53 CAknItemActionMenuRegisterArray::~CAknItemActionMenuRegisterArray()
    58 CAknItemActionMenuRegisterArray::~CAknItemActionMenuRegisterArray()
    54     {
    59     {
       
    60     _AKNTRACE_FUNC_ENTER;
    55     iRegisterArray.ResetAndDestroy();
    61     iRegisterArray.ResetAndDestroy();
    56     iRegisterArray.Close();
    62     iRegisterArray.Close();
       
    63     _AKNTRACE_FUNC_EXIT;
    57     }
    64     }
    58 
    65 
    59 
    66 
    60 // ---------------------------------------------------------------------------
    67 // ---------------------------------------------------------------------------
    61 // CAknItemActionMenuRegisterArray::AddEntryL
    68 // CAknItemActionMenuRegisterArray::AddEntryL
    62 // ---------------------------------------------------------------------------
    69 // ---------------------------------------------------------------------------
    63 //
    70 //
    64 void CAknItemActionMenuRegisterArray::AddEntryL(
    71 void CAknItemActionMenuRegisterArray::AddEntryL(
    65         CEikMenuBar& aMenuBar, CAknItemActionMenu& aItemActionMenu )
    72         CEikMenuBar& aMenuBar, CAknItemActionMenu& aItemActionMenu )
    66     {
    73     {
       
    74     _AKNTRACE_FUNC_ENTER;
    67     CRegisterEntry* newEntry = CRegisterEntry::NewLC(
    75     CRegisterEntry* newEntry = CRegisterEntry::NewLC(
    68             aMenuBar, aItemActionMenu );
    76             aMenuBar, aItemActionMenu );
    69     iRegisterArray.AppendL( newEntry );
    77     iRegisterArray.AppendL( newEntry );
    70     CleanupStack::Pop( newEntry );
    78     CleanupStack::Pop( newEntry );
       
    79     _AKNTRACE_FUNC_EXIT;
    71     }
    80     }
    72 
    81 
    73 
    82 
    74 // ---------------------------------------------------------------------------
    83 // ---------------------------------------------------------------------------
    75 // CAknItemActionMenuRegisterArray::UnregisterMenuBar
    84 // CAknItemActionMenuRegisterArray::UnregisterMenuBar
    76 // ---------------------------------------------------------------------------
    85 // ---------------------------------------------------------------------------
    77 //
    86 //
    78 void CAknItemActionMenuRegisterArray::UnregisterMenuBar(
    87 void CAknItemActionMenuRegisterArray::UnregisterMenuBar(
    79         CEikMenuBar& aMenuBar )
    88         CEikMenuBar& aMenuBar )
    80     {
    89     {
       
    90     _AKNTRACE_FUNC_ENTER;
    81     CRegisterEntry* entry( NULL );
    91     CRegisterEntry* entry( NULL );
    82     for ( TInt i = 0; i < iRegisterArray.Count(); i++ )
    92     for ( TInt i = 0; i < iRegisterArray.Count(); i++ )
    83         {
    93         {
    84         entry = iRegisterArray[ i ];
    94         entry = iRegisterArray[ i ];
    85         if ( entry->MenuBar() == &aMenuBar )
    95         if ( entry->MenuBar() == &aMenuBar )
    95                 RemoveEntry( i );
   105                 RemoveEntry( i );
    96                 }
   106                 }
    97             break;
   107             break;
    98             }
   108             }
    99         }
   109         }
       
   110     _AKNTRACE_FUNC_EXIT;
   100     }
   111     }
   101 
   112 
   102 
   113 
   103 // ---------------------------------------------------------------------------
   114 // ---------------------------------------------------------------------------
   104 // CAknItemActionMenuRegisterArray::UnregisterItemActionMenu
   115 // CAknItemActionMenuRegisterArray::UnregisterItemActionMenu
   105 // ---------------------------------------------------------------------------
   116 // ---------------------------------------------------------------------------
   106 //
   117 //
   107 void CAknItemActionMenuRegisterArray::UnregisterItemActionMenu(
   118 void CAknItemActionMenuRegisterArray::UnregisterItemActionMenu(
   108         CAknItemActionMenu& aItemActionMenu )
   119         CAknItemActionMenu& aItemActionMenu )
   109     {
   120     {
       
   121     _AKNTRACE_FUNC_ENTER;
   110     CRegisterEntry* entry( NULL );
   122     CRegisterEntry* entry( NULL );
   111 
   123 
   112     for ( TInt i = 0; i < iRegisterArray.Count(); i++ )
   124     for ( TInt i = 0; i < iRegisterArray.Count(); i++ )
   113         {
   125         {
   114         entry = iRegisterArray[ i ];
   126         entry = iRegisterArray[ i ];
   120                 RemoveEntry( i );
   132                 RemoveEntry( i );
   121                 }
   133                 }
   122             break;
   134             break;
   123             }
   135             }
   124         }
   136         }
       
   137     _AKNTRACE_FUNC_EXIT;
   125     }
   138     }
   126 
   139 
   127 
   140 
   128 // ---------------------------------------------------------------------------
   141 // ---------------------------------------------------------------------------
   129 // CAknItemActionMenuRegisterArray::RegisterCollectionObserverL
   142 // CAknItemActionMenuRegisterArray::RegisterCollectionObserverL
   130 // ---------------------------------------------------------------------------
   143 // ---------------------------------------------------------------------------
   131 //
   144 //
   132 TBool CAknItemActionMenuRegisterArray::RegisterCollectionObserverL(
   145 TBool CAknItemActionMenuRegisterArray::RegisterCollectionObserverL(
   133         CEikMenuBar& aMenuBar, MAknCollectionObserver& aObserver )
   146         CEikMenuBar& aMenuBar, MAknCollectionObserver& aObserver )
   134     {
   147     {
       
   148     _AKNTRACE_FUNC_ENTER;
   135     TBool menuBarFound( EFalse );
   149     TBool menuBarFound( EFalse );
   136     CRegisterEntry* entry( NULL );
   150     CRegisterEntry* entry( NULL );
   137     for ( TInt i = 0; i < iRegisterArray.Count(); i++ )
   151     for ( TInt i = 0; i < iRegisterArray.Count(); i++ )
   138         {
   152         {
   139         entry = iRegisterArray[ i ];
   153         entry = iRegisterArray[ i ];
   146                 }
   160                 }
   147             menuBarFound = ETrue;
   161             menuBarFound = ETrue;
   148             break;
   162             break;
   149             }
   163             }
   150         }
   164         }
       
   165     _AKNTRACE_FUNC_EXIT;
   151     return menuBarFound;
   166     return menuBarFound;
   152     }
   167     }
   153 
   168 
   154 
   169 
   155 // ---------------------------------------------------------------------------
   170 // ---------------------------------------------------------------------------
   157 // ---------------------------------------------------------------------------
   172 // ---------------------------------------------------------------------------
   158 //
   173 //
   159 void CAknItemActionMenuRegisterArray::UnregisterCollectionObserver(
   174 void CAknItemActionMenuRegisterArray::UnregisterCollectionObserver(
   160         MAknCollectionObserver& aObserver )
   175         MAknCollectionObserver& aObserver )
   161     {
   176     {
       
   177     _AKNTRACE_FUNC_ENTER;
   162     CRegisterEntry* entry( NULL );
   178     CRegisterEntry* entry( NULL );
   163 
   179 
   164     for ( TInt i = 0; i < iRegisterArray.Count(); i++ )
   180     for ( TInt i = 0; i < iRegisterArray.Count(); i++ )
   165         {
   181         {
   166         entry = iRegisterArray[ i ];
   182         entry = iRegisterArray[ i ];
   167         if ( entry->ItemActionMenu() )
   183         if ( entry->ItemActionMenu() )
   168             {
   184             {
   169             entry->ItemActionMenu()->RemoveCollectionObserver( aObserver );
   185             entry->ItemActionMenu()->RemoveCollectionObserver( aObserver );
   170             }
   186             }
   171         }
   187         }
       
   188     _AKNTRACE_FUNC_EXIT;
   172     }
   189     }
   173 
   190 
   174 
   191 
   175 // ---------------------------------------------------------------------------
   192 // ---------------------------------------------------------------------------
   176 // CAknItemActionMenuRegisterArray::CAknItemActionMenuRegisterArray
   193 // CAknItemActionMenuRegisterArray::CAknItemActionMenuRegisterArray
   194 // CAknItemActionMenuRegisterArray::RemoveEntry
   211 // CAknItemActionMenuRegisterArray::RemoveEntry
   195 // ---------------------------------------------------------------------------
   212 // ---------------------------------------------------------------------------
   196 //
   213 //
   197 void CAknItemActionMenuRegisterArray::RemoveEntry( TInt aIndex )
   214 void CAknItemActionMenuRegisterArray::RemoveEntry( TInt aIndex )
   198     {
   215     {
       
   216     _AKNTRACE_FUNC_ENTER;
   199     if ( aIndex >= 0 && aIndex < iRegisterArray.Count() )
   217     if ( aIndex >= 0 && aIndex < iRegisterArray.Count() )
   200         {
   218         {
   201         CRegisterEntry* entry = iRegisterArray[ aIndex ];
   219         CRegisterEntry* entry = iRegisterArray[ aIndex ];
   202         delete entry;
   220         delete entry;
   203         entry = NULL;
   221         entry = NULL;
   204         iRegisterArray.Remove( aIndex );
   222         iRegisterArray.Remove( aIndex );
   205         }
   223         }
       
   224     _AKNTRACE_FUNC_EXIT;
   206     }
   225     }
   207 
   226 
   208 
   227 
   209 // ---------------------------------------------------------------------------
   228 // ---------------------------------------------------------------------------
   210 // CCAknItemActionMenuRegisterArray::CRegisterEntry::NewL
   229 // CCAknItemActionMenuRegisterArray::CRegisterEntry::NewL
   212 //
   231 //
   213 CAknItemActionMenuRegisterArray::CRegisterEntry*
   232 CAknItemActionMenuRegisterArray::CRegisterEntry*
   214     CAknItemActionMenuRegisterArray::CRegisterEntry::NewL(
   233     CAknItemActionMenuRegisterArray::CRegisterEntry::NewL(
   215             CEikMenuBar& aMenuBar, CAknItemActionMenu& aItemActionMenu )
   234             CEikMenuBar& aMenuBar, CAknItemActionMenu& aItemActionMenu )
   216     {
   235     {
       
   236     _AKNTRACE_FUNC_ENTER;
   217     CRegisterEntry* self = CRegisterEntry::NewLC( aMenuBar, aItemActionMenu );
   237     CRegisterEntry* self = CRegisterEntry::NewLC( aMenuBar, aItemActionMenu );
   218     CleanupStack::Pop( self );
   238     CleanupStack::Pop( self );
       
   239     _AKNTRACE_FUNC_EXIT;
   219     return self;
   240     return self;
   220     }
   241     }
   221 
   242 
   222 
   243 
   223 // ---------------------------------------------------------------------------
   244 // ---------------------------------------------------------------------------
   226 //
   247 //
   227 CAknItemActionMenuRegisterArray::CRegisterEntry*
   248 CAknItemActionMenuRegisterArray::CRegisterEntry*
   228     CAknItemActionMenuRegisterArray::CRegisterEntry::NewLC(
   249     CAknItemActionMenuRegisterArray::CRegisterEntry::NewLC(
   229             CEikMenuBar& aMenuBar, CAknItemActionMenu& aItemActionMenu )
   250             CEikMenuBar& aMenuBar, CAknItemActionMenu& aItemActionMenu )
   230     {
   251     {
       
   252     _AKNTRACE_FUNC_ENTER;
   231     CRegisterEntry* self =
   253     CRegisterEntry* self =
   232         new ( ELeave ) CRegisterEntry( aMenuBar, aItemActionMenu );
   254         new ( ELeave ) CRegisterEntry( aMenuBar, aItemActionMenu );
   233     CleanupStack::PushL( self );
   255     CleanupStack::PushL( self );
       
   256     _AKNTRACE_FUNC_EXIT;
   234     return self;
   257     return self;
   235     }
   258     }
   236 
   259 
   237 
   260 
   238 // ---------------------------------------------------------------------------
   261 // ---------------------------------------------------------------------------
   239 // CAknItemActionMenuRegisterArray::CRegisterEntry::~CRegisterEntry
   262 // CAknItemActionMenuRegisterArray::CRegisterEntry::~CRegisterEntry
   240 // ---------------------------------------------------------------------------
   263 // ---------------------------------------------------------------------------
   241 //
   264 //
   242 CAknItemActionMenuRegisterArray::CRegisterEntry::~CRegisterEntry()
   265 CAknItemActionMenuRegisterArray::CRegisterEntry::~CRegisterEntry()
   243     {
   266     {
       
   267     _AKNTRACE_FUNC_ENTER;
   244     delete iActionMenu;
   268     delete iActionMenu;
       
   269     _AKNTRACE_FUNC_EXIT;
   245     }
   270     }
   246 
   271 
   247 
   272 
   248 // ---------------------------------------------------------------------------
   273 // ---------------------------------------------------------------------------
   249 // CAknItemActionMenuRegisterArray::CRegisterEntry::RemoveMenuBar
   274 // CAknItemActionMenuRegisterArray::CRegisterEntry::RemoveMenuBar
   250 // ---------------------------------------------------------------------------
   275 // ---------------------------------------------------------------------------
   251 //
   276 //
   252 void CAknItemActionMenuRegisterArray::CRegisterEntry::RemoveMenuBar()
   277 void CAknItemActionMenuRegisterArray::CRegisterEntry::RemoveMenuBar()
   253     {
   278     {
       
   279     _AKNTRACE_FUNC_ENTER;
   254     iMenuBar = NULL;
   280     iMenuBar = NULL;
       
   281     _AKNTRACE_FUNC_EXIT;
   255     }
   282     }
   256 
   283 
   257 
   284 
   258 // ---------------------------------------------------------------------------
   285 // ---------------------------------------------------------------------------
   259 // CAknItemActionMenuRegisterArray::CRegisterEntry::MenuBar
   286 // CAknItemActionMenuRegisterArray::CRegisterEntry::MenuBar
   260 // ---------------------------------------------------------------------------
   287 // ---------------------------------------------------------------------------
   261 //
   288 //
   262 CEikMenuBar* CAknItemActionMenuRegisterArray::CRegisterEntry::MenuBar()
   289 CEikMenuBar* CAknItemActionMenuRegisterArray::CRegisterEntry::MenuBar()
   263     {
   290     {
       
   291     _AKNTRACE_FUNC_ENTER;
       
   292     _AKNTRACE_FUNC_EXIT;
   264     return iMenuBar;
   293     return iMenuBar;
   265     }
   294     }
   266 
   295 
   267 
   296 
   268 // ---------------------------------------------------------------------------
   297 // ---------------------------------------------------------------------------
   269 // CAknItemActionMenuRegisterArray::CRegisterEntry::RemoveItemActionMenu
   298 // CAknItemActionMenuRegisterArray::CRegisterEntry::RemoveItemActionMenu
   270 // ---------------------------------------------------------------------------
   299 // ---------------------------------------------------------------------------
   271 //
   300 //
   272 void CAknItemActionMenuRegisterArray::CRegisterEntry::RemoveItemActionMenu()
   301 void CAknItemActionMenuRegisterArray::CRegisterEntry::RemoveItemActionMenu()
   273     {
   302     {
       
   303     _AKNTRACE_FUNC_ENTER;
   274     delete iActionMenu;
   304     delete iActionMenu;
   275     iActionMenu = NULL;
   305     iActionMenu = NULL;
       
   306     _AKNTRACE_FUNC_EXIT;
   276     }
   307     }
   277 
   308 
   278 
   309 
   279 // ---------------------------------------------------------------------------
   310 // ---------------------------------------------------------------------------
   280 // CAknItemActionMenuRegisterArray::CRegisterEntry::ItemActionMenu
   311 // CAknItemActionMenuRegisterArray::CRegisterEntry::ItemActionMenu
   281 // ---------------------------------------------------------------------------
   312 // ---------------------------------------------------------------------------
   282 //
   313 //
   283 CAknItemActionMenu*
   314 CAknItemActionMenu*
   284     CAknItemActionMenuRegisterArray::CRegisterEntry::ItemActionMenu()
   315     CAknItemActionMenuRegisterArray::CRegisterEntry::ItemActionMenu()
   285     {
   316     {
       
   317     _AKNTRACE_FUNC_ENTER;
       
   318     _AKNTRACE_FUNC_EXIT;
   286     return iActionMenu;
   319     return iActionMenu;
   287     }
   320     }
   288 
   321 
   289 
   322 
   290 // ---------------------------------------------------------------------------
   323 // ---------------------------------------------------------------------------