32 // --------------------------------------------------------------------------- |
33 // --------------------------------------------------------------------------- |
33 // |
34 // |
34 EXPORT_C void AknItemActionMenuRegister::SetConstructingMenuBarOwnerL( |
35 EXPORT_C void AknItemActionMenuRegister::SetConstructingMenuBarOwnerL( |
35 MObjectProvider* aMenuBarOwner ) |
36 MObjectProvider* aMenuBarOwner ) |
36 { |
37 { |
|
38 _AKNTRACE_FUNC_ENTER; |
|
39 |
|
40 AknItemActionMenuRegister* instance( Instance() ); |
|
41 |
|
42 if ( instance ) |
|
43 { |
|
44 instance->iMenuBarOwner = aMenuBarOwner; |
|
45 } |
|
46 |
|
47 _AKNTRACE_FUNC_EXIT; |
|
48 } |
|
49 |
|
50 |
|
51 // --------------------------------------------------------------------------- |
|
52 // AknItemActionMenuRegister::SetOverridingMenuBarOwnerL |
|
53 // --------------------------------------------------------------------------- |
|
54 // |
|
55 EXPORT_C void AknItemActionMenuRegister::SetOverridingMenuBarOwnerL( |
|
56 MObjectProvider* aMenuBarOwner, TUint /*aFlags*/ ) |
|
57 { |
|
58 _AKNTRACE_FUNC_ENTER; |
|
59 |
37 if ( AppUiSingleClickCompatible() ) |
60 if ( AppUiSingleClickCompatible() ) |
38 { |
61 { |
39 AknItemActionMenuRegister* instance( Instance() ); |
62 AknItemActionMenuRegister* instance( Instance() ); |
40 if ( instance ) |
63 if ( instance ) |
41 { |
64 { |
42 instance->iMenuBarOwner = aMenuBarOwner; |
65 instance->iOverridingMenuBarOwner = aMenuBarOwner; |
43 } |
66 } |
44 } |
67 } |
45 } |
68 |
46 |
69 _AKNTRACE_FUNC_EXIT; |
47 |
70 } |
48 // --------------------------------------------------------------------------- |
71 |
49 // AknItemActionMenuRegister::SetOverridingMenuBarOwnerL |
72 |
50 // --------------------------------------------------------------------------- |
73 // --------------------------------------------------------------------------- |
51 // |
74 // AknItemActionMenuRegister::RegisterCollectionL |
52 EXPORT_C void AknItemActionMenuRegister::SetOverridingMenuBarOwnerL( |
75 // --------------------------------------------------------------------------- |
53 MObjectProvider* aMenuBarOwner, TUint /*aFlags*/ ) |
76 // |
54 { |
77 CAknItemActionMenu* AknItemActionMenuRegister::RegisterCollectionL( |
|
78 MAknCollection& aCollectionState ) |
|
79 { |
|
80 _AKNTRACE_FUNC_ENTER; |
|
81 |
|
82 CAknItemActionMenu* menu( NULL ); |
55 if ( AppUiSingleClickCompatible() ) |
83 if ( AppUiSingleClickCompatible() ) |
56 { |
84 { |
57 AknItemActionMenuRegister* instance( Instance() ); |
85 AknItemActionMenuRegister* instance( Instance() ); |
58 if ( instance ) |
86 if ( instance ) |
59 { |
87 { |
60 instance->iOverridingMenuBarOwner = aMenuBarOwner; |
88 menu = instance->DoRegisterCollectionL( aCollectionState ); |
61 } |
89 } |
62 } |
90 } |
63 } |
91 |
64 |
92 _AKNTRACE_FUNC_EXIT; |
65 |
93 return menu; |
66 // --------------------------------------------------------------------------- |
94 } |
67 // AknItemActionMenuRegister::RegisterCollectionL |
95 |
68 // --------------------------------------------------------------------------- |
96 |
69 // |
97 // --------------------------------------------------------------------------- |
70 CAknItemActionMenu* AknItemActionMenuRegister::RegisterCollectionL( |
98 // AknItemActionMenuRegister::RegisterMenuBarL |
71 MAknCollection& aCollectionState ) |
99 // --------------------------------------------------------------------------- |
72 { |
100 // |
73 CAknItemActionMenu* menu( NULL ); |
101 void AknItemActionMenuRegister::RegisterMenuBarL( |
|
102 CEikMenuBar& aMenuBar ) |
|
103 { |
|
104 _AKNTRACE_FUNC_ENTER; |
|
105 |
74 if ( AppUiSingleClickCompatible() ) |
106 if ( AppUiSingleClickCompatible() ) |
75 { |
107 { |
76 AknItemActionMenuRegister* instance( Instance() ); |
108 AknItemActionMenuRegister* instance( Instance() ); |
77 if ( instance ) |
109 if ( instance ) |
78 { |
110 { |
79 menu = instance->DoRegisterCollectionL( aCollectionState ); |
111 instance->DoRegisterMenuBarL( aMenuBar ); |
80 } |
112 } |
81 } |
113 } |
82 return menu; |
114 |
83 } |
115 _AKNTRACE_FUNC_EXIT; |
84 |
116 } |
85 |
117 |
86 // --------------------------------------------------------------------------- |
118 |
87 // AknItemActionMenuRegister::RegisterMenuBarL |
119 // --------------------------------------------------------------------------- |
88 // --------------------------------------------------------------------------- |
120 // AknItemActionMenuRegister::UnregisterMenuBar |
89 // |
121 // --------------------------------------------------------------------------- |
90 void AknItemActionMenuRegister::RegisterMenuBarL( |
122 // |
|
123 void AknItemActionMenuRegister::UnregisterMenuBar( |
91 CEikMenuBar& aMenuBar ) |
124 CEikMenuBar& aMenuBar ) |
92 { |
125 { |
|
126 _AKNTRACE_FUNC_ENTER; |
|
127 |
93 if ( AppUiSingleClickCompatible() ) |
128 if ( AppUiSingleClickCompatible() ) |
94 { |
129 { |
95 AknItemActionMenuRegister* instance( Instance() ); |
130 AknItemActionMenuRegister* instance( Instance() ); |
96 if ( instance ) |
131 if ( instance ) |
97 { |
132 { |
98 instance->DoRegisterMenuBarL( aMenuBar ); |
133 instance->DoUnregisterMenuBar( aMenuBar ); |
99 } |
134 } |
100 } |
135 } |
101 } |
136 |
102 |
137 _AKNTRACE_FUNC_EXIT; |
103 |
138 } |
104 // --------------------------------------------------------------------------- |
139 |
105 // AknItemActionMenuRegister::UnregisterMenuBar |
140 |
106 // --------------------------------------------------------------------------- |
141 // --------------------------------------------------------------------------- |
107 // |
142 // AknItemActionMenuRegister::RegisterItemActionMenuL |
108 void AknItemActionMenuRegister::UnregisterMenuBar( |
143 // --------------------------------------------------------------------------- |
109 CEikMenuBar& aMenuBar ) |
144 // |
110 { |
145 void AknItemActionMenuRegister::RegisterItemActionMenuL( |
|
146 CAknItemActionMenu& aItemActionMenu ) |
|
147 { |
|
148 _AKNTRACE_FUNC_ENTER; |
|
149 |
|
150 AknItemActionMenuRegister* instance( Instance() ); |
|
151 if ( instance ) |
|
152 { |
|
153 instance->DoRegisterItemActionMenuL( aItemActionMenu ); |
|
154 } |
|
155 |
|
156 _AKNTRACE_FUNC_EXIT; |
|
157 } |
|
158 |
|
159 |
|
160 // --------------------------------------------------------------------------- |
|
161 // AknItemActionMenuRegister::UnregisterItemActionMenu |
|
162 // --------------------------------------------------------------------------- |
|
163 // |
|
164 void AknItemActionMenuRegister::UnregisterItemActionMenu( |
|
165 CAknItemActionMenu& aItemActionMenu ) |
|
166 { |
|
167 _AKNTRACE_FUNC_ENTER; |
|
168 |
111 if ( AppUiSingleClickCompatible() ) |
169 if ( AppUiSingleClickCompatible() ) |
112 { |
170 { |
113 AknItemActionMenuRegister* instance( Instance() ); |
171 AknItemActionMenuRegister* instance( Instance() ); |
114 if ( instance ) |
172 if ( instance ) |
115 { |
173 { |
116 instance->DoUnregisterMenuBar( aMenuBar ); |
174 instance->DoUnregisterItemActionMenu( aItemActionMenu ); |
117 } |
175 } |
118 } |
176 } |
119 } |
177 |
120 |
178 _AKNTRACE_FUNC_EXIT; |
121 |
179 } |
122 // --------------------------------------------------------------------------- |
180 |
123 // AknItemActionMenuRegister::RegisterItemActionMenuL |
181 |
124 // --------------------------------------------------------------------------- |
182 // --------------------------------------------------------------------------- |
125 // |
183 // AknItemActionMenuRegister::RegisterCollectionObserverL |
126 void AknItemActionMenuRegister::RegisterItemActionMenuL( |
184 // --------------------------------------------------------------------------- |
127 CAknItemActionMenu& aItemActionMenu ) |
185 // |
128 { |
186 void AknItemActionMenuRegister::RegisterCollectionObserverL( |
129 AknItemActionMenuRegister* instance( Instance() ); |
187 MAknCollectionObserver& aObserver ) |
130 if ( instance ) |
188 { |
131 { |
189 _AKNTRACE_FUNC_ENTER; |
132 instance->DoRegisterItemActionMenuL( aItemActionMenu ); |
190 |
133 } |
|
134 } |
|
135 |
|
136 |
|
137 // --------------------------------------------------------------------------- |
|
138 // AknItemActionMenuRegister::UnregisterItemActionMenu |
|
139 // --------------------------------------------------------------------------- |
|
140 // |
|
141 void AknItemActionMenuRegister::UnregisterItemActionMenu( |
|
142 CAknItemActionMenu& aItemActionMenu ) |
|
143 { |
|
144 if ( AppUiSingleClickCompatible() ) |
191 if ( AppUiSingleClickCompatible() ) |
145 { |
192 { |
146 AknItemActionMenuRegister* instance( Instance() ); |
193 AknItemActionMenuRegister* instance( Instance() ); |
147 if ( instance ) |
194 if ( instance ) |
148 { |
195 { |
149 instance->DoUnregisterItemActionMenu( aItemActionMenu ); |
196 instance->DoRegisterCollectionObserverL( aObserver ); |
150 } |
197 } |
151 } |
198 } |
152 } |
199 |
153 |
200 _AKNTRACE_FUNC_EXIT; |
154 |
201 } |
155 // --------------------------------------------------------------------------- |
202 |
156 // AknItemActionMenuRegister::RegisterCollectionObserverL |
203 |
157 // --------------------------------------------------------------------------- |
204 // --------------------------------------------------------------------------- |
158 // |
205 // AknItemActionMenuRegister::UnregisterCollectionObserver |
159 void AknItemActionMenuRegister::RegisterCollectionObserverL( |
206 // --------------------------------------------------------------------------- |
|
207 // |
|
208 void AknItemActionMenuRegister::UnregisterCollectionObserver( |
160 MAknCollectionObserver& aObserver ) |
209 MAknCollectionObserver& aObserver ) |
161 { |
210 { |
|
211 _AKNTRACE_FUNC_ENTER; |
|
212 |
162 if ( AppUiSingleClickCompatible() ) |
213 if ( AppUiSingleClickCompatible() ) |
163 { |
214 { |
164 AknItemActionMenuRegister* instance( Instance() ); |
215 AknItemActionMenuRegister* instance( Instance() ); |
165 if ( instance ) |
216 if ( instance ) |
166 { |
217 { |
167 instance->DoRegisterCollectionObserverL( aObserver ); |
|
168 } |
|
169 } |
|
170 } |
|
171 |
|
172 |
|
173 // --------------------------------------------------------------------------- |
|
174 // AknItemActionMenuRegister::UnregisterCollectionObserver |
|
175 // --------------------------------------------------------------------------- |
|
176 // |
|
177 void AknItemActionMenuRegister::UnregisterCollectionObserver( |
|
178 MAknCollectionObserver& aObserver ) |
|
179 { |
|
180 if ( AppUiSingleClickCompatible() ) |
|
181 { |
|
182 AknItemActionMenuRegister* instance( Instance() ); |
|
183 if ( instance ) |
|
184 { |
|
185 instance->DoUnregisterCollectionObserver( aObserver ); |
218 instance->DoUnregisterCollectionObserver( aObserver ); |
186 } |
219 } |
187 } |
220 } |
|
221 |
|
222 _AKNTRACE_FUNC_EXIT; |
188 } |
223 } |
189 |
224 |
190 |
225 |
191 // --------------------------------------------------------------------------- |
226 // --------------------------------------------------------------------------- |
192 // AknItemActionMenuRegister::~AknItemActionMenuRegister |
227 // AknItemActionMenuRegister::~AknItemActionMenuRegister |
193 // --------------------------------------------------------------------------- |
228 // --------------------------------------------------------------------------- |
194 // |
229 // |
195 AknItemActionMenuRegister::~AknItemActionMenuRegister() |
230 AknItemActionMenuRegister::~AknItemActionMenuRegister() |
196 { |
231 { |
|
232 _AKNTRACE_FUNC_ENTER; |
|
233 |
197 for ( TInt i = 0; i < iUnregisteredMenus.Count(); i++ ) |
234 for ( TInt i = 0; i < iUnregisteredMenus.Count(); i++ ) |
198 { |
235 { |
199 TAknUnregisteredMenuData& data( iUnregisteredMenus[ i ] ); |
236 TAknUnregisteredMenuData& data( iUnregisteredMenus[ i ] ); |
200 delete data.iMenu; |
237 delete data.iMenu; |
201 data.iMenu = NULL; |
238 data.iMenu = NULL; |
202 } |
239 } |
203 iUnregisteredMenus.Close(); |
240 iUnregisteredMenus.Close(); |
204 iUnregisteredObservers.Close(); |
241 iUnregisteredObservers.Close(); |
205 delete iRegisterArray; |
242 delete iRegisterArray; |
|
243 |
|
244 _AKNTRACE_FUNC_EXIT; |
206 } |
245 } |
207 |
246 |
208 |
247 |
209 // --------------------------------------------------------------------------- |
248 // --------------------------------------------------------------------------- |
210 // AknItemActionMenuRegister::AknItemActionMenuRegister |
249 // AknItemActionMenuRegister::AknItemActionMenuRegister |
212 // |
251 // |
213 AknItemActionMenuRegister::AknItemActionMenuRegister() |
252 AknItemActionMenuRegister::AknItemActionMenuRegister() |
214 : CCoeStatic( KAknItemActionMenuRegister, KRegisterDestructionPriority ), |
253 : CCoeStatic( KAknItemActionMenuRegister, KRegisterDestructionPriority ), |
215 iMenuBarOwner( NULL ) |
254 iMenuBarOwner( NULL ) |
216 { |
255 { |
|
256 _AKNTRACE_FUNC_ENTER; |
|
257 _AKNTRACE_FUNC_EXIT; |
217 } |
258 } |
218 |
259 |
219 |
260 |
220 // --------------------------------------------------------------------------- |
261 // --------------------------------------------------------------------------- |
221 // AknItemActionMenuRegister::ConstructL |
262 // AknItemActionMenuRegister::ConstructL |
222 // --------------------------------------------------------------------------- |
263 // --------------------------------------------------------------------------- |
223 // |
264 // |
224 void AknItemActionMenuRegister::ConstructL() |
265 void AknItemActionMenuRegister::ConstructL() |
225 { |
266 { |
|
267 _AKNTRACE_FUNC_ENTER; |
|
268 |
226 iRegisterArray = CAknItemActionMenuRegisterArray::NewL(); |
269 iRegisterArray = CAknItemActionMenuRegisterArray::NewL(); |
|
270 |
|
271 _AKNTRACE_FUNC_EXIT; |
227 } |
272 } |
228 |
273 |
229 |
274 |
230 // --------------------------------------------------------------------------- |
275 // --------------------------------------------------------------------------- |
231 // AknItemActionMenuRegister::AppUiSingleClickCompatible |
276 // AknItemActionMenuRegister::AppUiSingleClickCompatible |
232 // --------------------------------------------------------------------------- |
277 // --------------------------------------------------------------------------- |
233 // |
278 // |
234 TBool AknItemActionMenuRegister::AppUiSingleClickCompatible() |
279 TBool AknItemActionMenuRegister::AppUiSingleClickCompatible() |
235 { |
280 { |
236 CAknAppUi* appUi = |
281 _AKNTRACE_FUNC_ENTER; |
237 static_cast<CAknAppUi*>( CEikonEnv::Static()->AppUi() ); |
282 |
238 return appUi->IsSingleClickCompatible(); |
283 TBool isCompatible = EFalse; |
|
284 CAknAppUi* appUi = AppUI(); |
|
285 |
|
286 if ( appUi ) |
|
287 { |
|
288 isCompatible = appUi->IsSingleClickCompatible(); |
|
289 } |
|
290 |
|
291 _AKNTRACE_FUNC_EXIT; |
|
292 |
|
293 return isCompatible; |
239 } |
294 } |
240 |
295 |
241 // --------------------------------------------------------------------------- |
296 // --------------------------------------------------------------------------- |
242 // AknItemActionMenuRegister::Instance |
297 // AknItemActionMenuRegister::Instance |
243 // --------------------------------------------------------------------------- |
298 // --------------------------------------------------------------------------- |
244 // |
299 // |
245 AknItemActionMenuRegister* AknItemActionMenuRegister::Instance() |
300 AknItemActionMenuRegister* AknItemActionMenuRegister::Instance() |
246 { |
301 { |
|
302 _AKNTRACE_FUNC_ENTER; |
|
303 |
247 AknItemActionMenuRegister* instance = |
304 AknItemActionMenuRegister* instance = |
248 static_cast<AknItemActionMenuRegister*>( |
305 static_cast<AknItemActionMenuRegister*>( |
249 CCoeEnv::Static( KAknItemActionMenuRegister ) ); |
306 CCoeEnv::Static( KAknItemActionMenuRegister ) ); |
250 if ( !instance ) |
307 if ( !instance ) |
251 { |
308 { |
252 TRAP_IGNORE( instance = CreateInstanceL() ); |
309 TRAP_IGNORE( instance = CreateInstanceL() ); |
253 } |
310 } |
|
311 |
|
312 _AKNTRACE_FUNC_EXIT; |
|
313 |
254 return instance; |
314 return instance; |
255 } |
315 } |
256 |
316 |
257 |
317 |
258 // --------------------------------------------------------------------------- |
318 // --------------------------------------------------------------------------- |
285 { |
352 { |
286 menu = data.iMenu; |
353 menu = data.iMenu; |
287 if ( menu ) |
354 if ( menu ) |
288 { |
355 { |
289 AddRegisterEntryL( aMenuBar, *menu ); |
356 AddRegisterEntryL( aMenuBar, *menu ); |
|
357 iUnregisteredMenus.Remove( i ); |
290 } |
358 } |
291 iUnregisteredMenus.Remove( i ); |
|
292 break; |
359 break; |
293 } |
360 } |
294 } |
361 } |
|
362 |
|
363 _AKNTRACE_FUNC_EXIT; |
295 } |
364 } |
296 |
365 |
297 |
366 |
298 // --------------------------------------------------------------------------- |
367 // --------------------------------------------------------------------------- |
299 // AknItemActionMenuRegister::DoUnregisterMenuBar |
368 // AknItemActionMenuRegister::DoUnregisterMenuBar |
300 // --------------------------------------------------------------------------- |
369 // --------------------------------------------------------------------------- |
301 // |
370 // |
302 void AknItemActionMenuRegister::DoUnregisterMenuBar( CEikMenuBar& aMenuBar ) |
371 void AknItemActionMenuRegister::DoUnregisterMenuBar( CEikMenuBar& aMenuBar ) |
303 { |
372 { |
|
373 _AKNTRACE_FUNC_ENTER; |
|
374 |
304 iRegisterArray->UnregisterMenuBar( aMenuBar ); |
375 iRegisterArray->UnregisterMenuBar( aMenuBar ); |
|
376 |
|
377 _AKNTRACE_FUNC_EXIT; |
305 } |
378 } |
306 |
379 |
307 |
380 |
308 // --------------------------------------------------------------------------- |
381 // --------------------------------------------------------------------------- |
309 // AknItemActionMenuRegister::DoRegisterItemActionMenuL |
382 // AknItemActionMenuRegister::DoRegisterItemActionMenuL |
310 // --------------------------------------------------------------------------- |
383 // --------------------------------------------------------------------------- |
311 // |
384 // |
312 void AknItemActionMenuRegister::DoRegisterItemActionMenuL( |
385 void AknItemActionMenuRegister::DoRegisterItemActionMenuL( |
313 CAknItemActionMenu& aItemActionMenu ) |
386 CAknItemActionMenu& aItemActionMenu ) |
314 { |
387 { |
|
388 _AKNTRACE_FUNC_ENTER; |
|
389 |
315 CEikMenuBar* menuBar( NULL ); |
390 CEikMenuBar* menuBar( NULL ); |
316 for ( TInt i = 0; i < iUnregisteredMenus.Count(); i++ ) |
391 for ( TInt i = 0; i < iUnregisteredMenus.Count(); i++ ) |
317 { |
392 { |
318 TAknUnregisteredMenuData& data( iUnregisteredMenus[ i ] ); |
393 TAknUnregisteredMenuData& data( iUnregisteredMenus[ i ] ); |
319 if ( data.iMenu == &aItemActionMenu ) |
394 if ( data.iMenu == &aItemActionMenu ) |
320 { |
395 { |
321 data.iOwner->MopGetObjectNoChaining( menuBar ); |
396 data.iOwner->MopGetObjectNoChaining( menuBar ); |
322 if ( menuBar ) |
397 if ( menuBar ) |
323 { |
398 { |
324 AddRegisterEntryL( *menuBar, aItemActionMenu ); |
399 AddRegisterEntryL( *menuBar, aItemActionMenu ); |
|
400 iUnregisteredMenus.Remove( i ); |
325 } |
401 } |
326 iUnregisteredMenus.Remove( i ); |
|
327 break; |
402 break; |
328 } |
403 } |
329 } |
404 } |
|
405 |
|
406 _AKNTRACE_FUNC_EXIT; |
330 } |
407 } |
331 |
408 |
332 |
409 |
333 // --------------------------------------------------------------------------- |
410 // --------------------------------------------------------------------------- |
334 // AknItemActionMenuRegister::DoUnregisterItemActionMenu |
411 // AknItemActionMenuRegister::DoUnregisterItemActionMenu |
335 // --------------------------------------------------------------------------- |
412 // --------------------------------------------------------------------------- |
336 // |
413 // |
337 void AknItemActionMenuRegister::DoUnregisterItemActionMenu( |
414 void AknItemActionMenuRegister::DoUnregisterItemActionMenu( |
338 CAknItemActionMenu& aItemActionMenu ) |
415 CAknItemActionMenu& aItemActionMenu ) |
339 { |
416 { |
|
417 _AKNTRACE_FUNC_ENTER; |
|
418 |
340 iRegisterArray->UnregisterItemActionMenu( aItemActionMenu ); |
419 iRegisterArray->UnregisterItemActionMenu( aItemActionMenu ); |
341 |
420 |
342 for ( TInt i = 0; i < iUnregisteredMenus.Count(); i++ ) |
421 for ( TInt i = 0; i < iUnregisteredMenus.Count(); i++ ) |
343 { |
422 { |
344 TAknUnregisteredMenuData& data( iUnregisteredMenus[ i ] ); |
423 TAknUnregisteredMenuData& data( iUnregisteredMenus[ i ] ); |
347 delete data.iMenu; |
426 delete data.iMenu; |
348 iUnregisteredMenus.Remove( i ); |
427 iUnregisteredMenus.Remove( i ); |
349 break; |
428 break; |
350 } |
429 } |
351 } |
430 } |
|
431 |
|
432 _AKNTRACE_FUNC_EXIT; |
352 } |
433 } |
353 |
434 |
354 |
435 |
355 // --------------------------------------------------------------------------- |
436 // --------------------------------------------------------------------------- |
356 // AknItemActionMenuRegister::DoRegisterCollectionObserverL |
437 // AknItemActionMenuRegister::DoRegisterCollectionObserverL |
357 // --------------------------------------------------------------------------- |
438 // --------------------------------------------------------------------------- |
358 // |
439 // |
359 void AknItemActionMenuRegister::DoRegisterCollectionObserverL( |
440 void AknItemActionMenuRegister::DoRegisterCollectionObserverL( |
360 MAknCollectionObserver& aObserver ) |
441 MAknCollectionObserver& aObserver ) |
361 { |
442 { |
|
443 _AKNTRACE_FUNC_ENTER; |
|
444 |
362 CEikMenuBar* menuBar = FindCurrentMenuBarL(); |
445 CEikMenuBar* menuBar = FindCurrentMenuBarL(); |
363 if ( !menuBar || !iRegisterArray->RegisterCollectionObserverL( |
446 if ( !menuBar || !iRegisterArray->RegisterCollectionObserverL( |
364 *menuBar, aObserver ) ) |
447 *menuBar, aObserver ) ) |
365 { |
448 { |
366 TAknUnregisteredObserverData newData( menuBar, aObserver ); |
449 TAknUnregisteredObserverData newData( menuBar, |
|
450 aObserver, Owner() ); |
|
451 |
|
452 |
|
453 _AKNTRACE( " Added observer %d", &aObserver ); |
367 iUnregisteredObservers.AppendL( newData ); |
454 iUnregisteredObservers.AppendL( newData ); |
368 } |
455 } |
|
456 |
|
457 _AKNTRACE_FUNC_EXIT; |
369 } |
458 } |
370 |
459 |
371 |
460 |
372 // --------------------------------------------------------------------------- |
461 // --------------------------------------------------------------------------- |
373 // AknItemActionMenuRegister::DoUnregisterCollectionObserver |
462 // AknItemActionMenuRegister::DoUnregisterCollectionObserver |
374 // --------------------------------------------------------------------------- |
463 // --------------------------------------------------------------------------- |
375 // |
464 // |
376 void AknItemActionMenuRegister::DoUnregisterCollectionObserver( |
465 void AknItemActionMenuRegister::DoUnregisterCollectionObserver( |
377 MAknCollectionObserver& aObserver ) |
466 MAknCollectionObserver& aObserver ) |
378 { |
467 { |
|
468 _AKNTRACE_FUNC_ENTER; |
|
469 |
379 iRegisterArray->UnregisterCollectionObserver( aObserver ); |
470 iRegisterArray->UnregisterCollectionObserver( aObserver ); |
380 |
471 |
381 for ( TInt i = 0; i < iUnregisteredObservers.Count(); i++ ) |
472 for ( TInt i = 0; i < iUnregisteredObservers.Count(); i++ ) |
382 { |
473 { |
383 TAknUnregisteredObserverData& data( iUnregisteredObservers[ i ] ); |
474 TAknUnregisteredObserverData& data( iUnregisteredObservers[ i ] ); |
384 if ( &data.iObserver == &aObserver ) |
475 if ( &data.iObserver == &aObserver ) |
385 { |
476 { |
386 iUnregisteredObservers.Remove( i ); |
477 iUnregisteredObservers.Remove( i ); |
|
478 _AKNTRACE_FUNC_EXIT; |
|
479 |
387 return; |
480 return; |
388 } |
481 } |
389 } |
482 } |
390 |
483 |
391 for ( TInt i = 0; i < iUnregisteredMenus.Count(); i++ ) |
484 for ( TInt i = 0; i < iUnregisteredMenus.Count(); i++ ) |
392 { |
485 { |
393 TAknUnregisteredMenuData& data( iUnregisteredMenus[ i ] ); |
486 TAknUnregisteredMenuData& data( iUnregisteredMenus[ i ] ); |
394 data.iMenu->RemoveCollectionObserver( aObserver ); |
487 data.iMenu->RemoveCollectionObserver( aObserver ); |
395 } |
488 } |
|
489 |
|
490 _AKNTRACE_FUNC_EXIT; |
396 } |
491 } |
397 |
492 |
398 |
493 |
399 // --------------------------------------------------------------------------- |
494 // --------------------------------------------------------------------------- |
400 // AknItemActionMenuRegister::DialogMenuBar |
495 // AknItemActionMenuRegister::DialogMenuBar |
401 // --------------------------------------------------------------------------- |
496 // --------------------------------------------------------------------------- |
402 // |
497 // |
403 CEikMenuBar* AknItemActionMenuRegister::DialogMenuBar( CAknAppUi* aAppUi ) |
498 CEikMenuBar* AknItemActionMenuRegister::DialogMenuBar( CAknAppUi* aAppUi ) |
404 { |
499 { |
|
500 _AKNTRACE_FUNC_ENTER; |
|
501 |
405 CEikMenuBar* menuBar( NULL ); |
502 CEikMenuBar* menuBar( NULL ); |
406 // Check if there is an active dialog and fetch its menubar |
503 // Check if there is an active dialog and fetch its menubar |
407 if ( aAppUi->IsDisplayingMenuOrDialog() ) |
504 if ( aAppUi && aAppUi->IsDisplayingMenuOrDialog() ) |
408 { |
505 { |
409 CCoeControl* ctrl = aAppUi->TopFocusedControl(); |
506 CCoeControl* ctrl = aAppUi->TopFocusedControl(); |
410 if ( ctrl ) |
507 if ( ctrl ) |
411 { |
508 { |
412 CEikDialog* dialog = ctrl->MopGetObjectNoChaining( dialog ); |
509 CEikDialog* dialog = ctrl->MopGetObjectNoChaining( dialog ); |
414 { |
511 { |
415 dialog->MopGetObject( menuBar ); |
512 dialog->MopGetObject( menuBar ); |
416 } |
513 } |
417 } |
514 } |
418 } |
515 } |
|
516 |
|
517 _AKNTRACE_FUNC_EXIT; |
|
518 |
419 return menuBar; |
519 return menuBar; |
420 } |
520 } |
421 |
521 |
422 |
522 |
423 // --------------------------------------------------------------------------- |
523 // --------------------------------------------------------------------------- |
424 // AknItemActionMenuRegister::ViewMenuBar |
524 // AknItemActionMenuRegister::ViewMenuBar |
425 // --------------------------------------------------------------------------- |
525 // --------------------------------------------------------------------------- |
426 // |
526 // |
427 CEikMenuBar* AknItemActionMenuRegister::ViewMenuBar( CAknAppUi* aAppUi ) |
527 CEikMenuBar* AknItemActionMenuRegister::ViewMenuBar( CAknAppUi* aAppUi ) |
428 { |
528 { |
|
529 _AKNTRACE_FUNC_ENTER; |
|
530 |
429 CEikMenuBar* menuBar( NULL ); |
531 CEikMenuBar* menuBar( NULL ); |
430 CAknViewAppUi* appUi( static_cast<CAknViewAppUi*>( aAppUi ) ); |
532 CAknView* view = View( aAppUi ); |
431 |
533 |
432 // Check if there is an active view |
534 if ( view ) |
433 TVwsViewId uid; |
535 { |
434 if ( appUi->GetActiveViewId( uid ) == KErrNone ) |
536 menuBar = view->MenuBar(); |
435 { |
537 } |
436 if ( uid.iAppUid != uid.iViewUid ) |
538 |
437 { |
539 _AKNTRACE_FUNC_EXIT; |
438 CAknView* view = appUi->View( uid.iViewUid ); |
540 |
439 if ( view ) |
|
440 { |
|
441 menuBar = view->MenuBar(); |
|
442 } |
|
443 } |
|
444 } |
|
445 return menuBar; |
541 return menuBar; |
446 } |
542 } |
447 |
543 |
448 |
544 |
449 // --------------------------------------------------------------------------- |
545 // --------------------------------------------------------------------------- |
450 // AknItemActionMenuRegister::ConstructingObjectMenuBar |
546 // AknItemActionMenuRegister::ConstructingObjectMenuBar |
451 // --------------------------------------------------------------------------- |
547 // --------------------------------------------------------------------------- |
452 // |
548 // |
453 CEikMenuBar* AknItemActionMenuRegister::ConstructingObjectMenuBar() |
549 CEikMenuBar* AknItemActionMenuRegister::ConstructingObjectMenuBar() |
454 { |
550 { |
|
551 _AKNTRACE_FUNC_ENTER; |
|
552 |
455 CEikMenuBar* menuBar( NULL ); |
553 CEikMenuBar* menuBar( NULL ); |
456 if ( iMenuBarOwner ) |
554 if ( iMenuBarOwner ) |
457 { |
555 { |
458 iMenuBarOwner->MopGetObjectNoChaining( menuBar ); |
556 iMenuBarOwner->MopGetObjectNoChaining( menuBar ); |
459 } |
557 } |
|
558 |
|
559 _AKNTRACE_FUNC_EXIT; |
|
560 |
460 return menuBar; |
561 return menuBar; |
461 } |
562 } |
462 |
563 |
463 |
564 |
464 // --------------------------------------------------------------------------- |
565 // --------------------------------------------------------------------------- |
465 // AknItemActionMenuRegister::OverridingObjectMenuBar |
566 // AknItemActionMenuRegister::OverridingObjectMenuBar |
466 // --------------------------------------------------------------------------- |
567 // --------------------------------------------------------------------------- |
467 // |
568 // |
468 CEikMenuBar* AknItemActionMenuRegister::OverridingObjectMenuBar() |
569 CEikMenuBar* AknItemActionMenuRegister::OverridingObjectMenuBar() |
469 { |
570 { |
|
571 _AKNTRACE_FUNC_ENTER; |
|
572 |
470 CEikMenuBar* menuBar( NULL ); |
573 CEikMenuBar* menuBar( NULL ); |
471 if ( iOverridingMenuBarOwner ) |
574 if ( iOverridingMenuBarOwner ) |
472 { |
575 { |
473 iOverridingMenuBarOwner->MopGetObjectNoChaining( menuBar ); |
576 iOverridingMenuBarOwner->MopGetObjectNoChaining( menuBar ); |
474 } |
577 } |
|
578 |
|
579 _AKNTRACE_FUNC_EXIT; |
|
580 |
475 return menuBar; |
581 return menuBar; |
|
582 } |
|
583 |
|
584 |
|
585 // --------------------------------------------------------------------------- |
|
586 // AknItemActionMenuRegister::Owner |
|
587 // --------------------------------------------------------------------------- |
|
588 // |
|
589 MObjectProvider* AknItemActionMenuRegister::Owner() const |
|
590 { |
|
591 _AKNTRACE_FUNC_ENTER; |
|
592 |
|
593 MObjectProvider* owner = NULL; |
|
594 CAknAppUi* appUi = AppUI(); |
|
595 |
|
596 if ( iOverridingMenuBarOwner ) |
|
597 { |
|
598 owner = iOverridingMenuBarOwner; |
|
599 } |
|
600 else |
|
601 { |
|
602 owner = View( appUi ); |
|
603 |
|
604 if ( !owner ) |
|
605 { |
|
606 owner = iMenuBarOwner; |
|
607 } |
|
608 } |
|
609 |
|
610 if ( !owner ) |
|
611 { |
|
612 owner = appUi; |
|
613 } |
|
614 |
|
615 __ASSERT_DEBUG( owner, User::Invariant() ); |
|
616 _AKNTRACE_FUNC_EXIT; |
|
617 |
|
618 return owner; |
|
619 } |
|
620 |
|
621 |
|
622 // --------------------------------------------------------------------------- |
|
623 // AknItemActionMenuRegister::View |
|
624 // --------------------------------------------------------------------------- |
|
625 // |
|
626 CAknView* AknItemActionMenuRegister::View( CAknAppUi* aAppUi ) const |
|
627 { |
|
628 _AKNTRACE_FUNC_ENTER; |
|
629 |
|
630 CAknView* view = NULL; |
|
631 |
|
632 if ( aAppUi ) |
|
633 { |
|
634 // Check if there is an active view |
|
635 TVwsViewId uid; |
|
636 |
|
637 if ( aAppUi->GetActiveViewId( uid ) == KErrNone ) |
|
638 { |
|
639 if ( uid.iAppUid != uid.iViewUid ) |
|
640 { |
|
641 view = static_cast<CAknViewAppUi*>( |
|
642 aAppUi )->View( uid.iViewUid ); |
|
643 } |
|
644 } |
|
645 } |
|
646 |
|
647 _AKNTRACE_FUNC_EXIT; |
|
648 |
|
649 return view; |
|
650 } |
|
651 |
|
652 |
|
653 // --------------------------------------------------------------------------- |
|
654 // AknItemActionMenuRegister::AppUI |
|
655 // --------------------------------------------------------------------------- |
|
656 // |
|
657 CAknAppUi* AknItemActionMenuRegister::AppUI() |
|
658 { |
|
659 _AKNTRACE_FUNC_ENTER; |
|
660 |
|
661 CAknAppUi* appUi = NULL; |
|
662 CCoeEnv* env = CCoeEnv::Static(); |
|
663 |
|
664 if ( env ) |
|
665 { |
|
666 appUi = static_cast<CAknAppUi*>( env->AppUi() ); |
|
667 } |
|
668 |
|
669 |
|
670 _AKNTRACE_FUNC_EXIT; |
|
671 |
|
672 return appUi; |
476 } |
673 } |
477 |
674 |
478 |
675 |
479 // --------------------------------------------------------------------------- |
676 // --------------------------------------------------------------------------- |
480 // AknItemActionMenuRegister::RegisterStateToItemActionMenuL |
677 // AknItemActionMenuRegister::RegisterStateToItemActionMenuL |
523 } |
722 } |
524 } |
723 } |
525 // No unregistered menu found -> create one and add to list |
724 // No unregistered menu found -> create one and add to list |
526 if ( !viewRegistered ) |
725 if ( !viewRegistered ) |
527 { |
726 { |
528 menu = CAknItemActionMenu::NewL( aCollectionState ); |
727 menu = CAknItemActionMenu::NewLC( aCollectionState, Owner() ); |
529 TAknUnregisteredMenuData newData; |
728 TAknUnregisteredMenuData newData; |
530 newData.iOwner = iMenuBarOwner; |
729 newData.iOwner = iMenuBarOwner; |
531 newData.iMenu = menu; |
730 newData.iMenu = menu; |
532 iUnregisteredMenus.AppendL( newData ); |
731 iUnregisteredMenus.AppendL( newData ); |
|
732 CleanupStack::Pop( menu ); |
533 } |
733 } |
534 } |
734 } |
535 if ( menu ) |
735 if ( menu ) |
536 { |
736 { |
537 // Set observers with menubar to menu |
737 // Set observers with menubar to menu |
538 AddObserversToItemActionMenuL( aMenuBar, *menu ); |
738 AddObserversToItemActionMenuL( *menu ); |
539 } |
739 } |
|
740 |
|
741 _AKNTRACE_FUNC_EXIT; |
|
742 |
540 return menu; |
743 return menu; |
541 } |
744 } |
542 |
745 |
543 |
746 |
544 // --------------------------------------------------------------------------- |
747 // --------------------------------------------------------------------------- |
545 // AknItemActionMenuRegister::FindCurrentMenuBarL |
748 // AknItemActionMenuRegister::FindCurrentMenuBarL |
546 // --------------------------------------------------------------------------- |
749 // --------------------------------------------------------------------------- |
547 // |
750 // |
548 CEikMenuBar* AknItemActionMenuRegister::FindCurrentMenuBarL() |
751 CEikMenuBar* AknItemActionMenuRegister::FindCurrentMenuBarL() |
549 { |
752 { |
|
753 _AKNTRACE_FUNC_ENTER; |
|
754 |
|
755 CAknAppUi* appUi = AppUI(); |
550 CEikonEnv* eikonEnv( CEikonEnv::Static() ); |
756 CEikonEnv* eikonEnv( CEikonEnv::Static() ); |
551 CAknAppUi* appUi( static_cast<CAknAppUi*>( eikonEnv->AppUi() ) ); |
|
552 TBool isConstructingDialog( EFalse ); |
757 TBool isConstructingDialog( EFalse ); |
553 CEikMenuBar* menuBar( NULL ); |
758 CEikMenuBar* menuBar( NULL ); |
554 |
759 |
555 // If overriding menubar owner is set then it's the one to obey. If the |
760 // If overriding menubar owner is set then it's the one to obey. If the |
556 // overriding menubar owner doesn't supply a menubar object then there |
761 // overriding menubar owner doesn't supply a menubar object then there |
557 // isn't proper one available. |
762 // isn't proper one available. |
558 if ( iOverridingMenuBarOwner ) |
763 if ( iOverridingMenuBarOwner ) |
559 { |
764 { |
|
765 _AKNTRACE_FUNC_EXIT; |
560 return OverridingObjectMenuBar(); |
766 return OverridingObjectMenuBar(); |
561 } |
767 } |
562 |
768 |
563 // Check if there is existing constructing dialog |
769 // Check if there is existing constructing dialog |
564 if ( iMenuBarOwner ) |
770 if ( iMenuBarOwner ) |
602 // --------------------------------------------------------------------------- |
811 // --------------------------------------------------------------------------- |
603 // |
812 // |
604 void AknItemActionMenuRegister::AddRegisterEntryL( |
813 void AknItemActionMenuRegister::AddRegisterEntryL( |
605 CEikMenuBar& aMenuBar, CAknItemActionMenu& aItemActionMenu ) |
814 CEikMenuBar& aMenuBar, CAknItemActionMenu& aItemActionMenu ) |
606 { |
815 { |
|
816 _AKNTRACE_FUNC_ENTER; |
|
817 |
607 aMenuBar.SetItemActionMenu( &aItemActionMenu ); |
818 aMenuBar.SetItemActionMenu( &aItemActionMenu ); |
608 iRegisterArray->AddEntryL( aMenuBar, aItemActionMenu ); |
819 iRegisterArray->AddEntryL( aMenuBar, aItemActionMenu ); |
609 AddObserversToItemActionMenuL( &aMenuBar, aItemActionMenu ); |
820 AddObserversToItemActionMenuL( aItemActionMenu ); |
|
821 |
|
822 _AKNTRACE_FUNC_EXIT; |
610 } |
823 } |
611 |
824 |
612 |
825 |
613 // --------------------------------------------------------------------------- |
826 // --------------------------------------------------------------------------- |
614 // AknItemActionMenuRegister::AddObserversToItemActionMenuL |
827 // AknItemActionMenuRegister::AddObserversToItemActionMenuL |
615 // --------------------------------------------------------------------------- |
828 // --------------------------------------------------------------------------- |
616 // |
829 // |
617 void AknItemActionMenuRegister::AddObserversToItemActionMenuL( |
830 void AknItemActionMenuRegister::AddObserversToItemActionMenuL( |
618 CEikMenuBar* aMenuBar, CAknItemActionMenu& aItemActionMenu ) |
831 CAknItemActionMenu& aItemActionMenu ) |
619 { |
832 { |
620 for ( TInt i = 0; i < iUnregisteredObservers.Count(); i++ ) |
833 _AKNTRACE_FUNC_ENTER; |
621 { |
834 |
622 TAknUnregisteredObserverData& data( iUnregisteredObservers[ i ] ); |
835 TInt i = 0; |
623 // Add if matching menubar or observer with no menubar |
836 |
624 if ( data.iMenuBar == aMenuBar || !data.iMenuBar ) |
837 while ( i < iUnregisteredObservers.Count() ) |
625 { |
838 { |
|
839 TAknUnregisteredObserverData& data( iUnregisteredObservers[i] ); |
|
840 |
|
841 // Register to item action menu if observer's owner matches item action |
|
842 // menu's owner. |
|
843 if ( data.iOwner == aItemActionMenu.Owner() ) |
|
844 { |
|
845 _AKNTRACE( " Observer %d added to item action menu", &data.iObserver ); |
|
846 |
626 aItemActionMenu.RegisterCollectionObserverL( |
847 aItemActionMenu.RegisterCollectionObserverL( |
627 data.iObserver ); |
848 data.iObserver ); |
628 } |
849 |
629 } |
850 iUnregisteredObservers.Remove( i ); |
630 iUnregisteredObservers.Reset(); |
851 } |
631 } |
852 else |
|
853 { |
|
854 ++i; |
|
855 } |
|
856 } |
|
857 |
|
858 _AKNTRACE_FUNC_EXIT; |
|
859 } |
|
860 |
632 |
861 |
633 // --------------------------------------------------------------------------- |
862 // --------------------------------------------------------------------------- |
634 // AknItemActionMenuRegister::CreateInstanceL |
863 // AknItemActionMenuRegister::CreateInstanceL |
635 // --------------------------------------------------------------------------- |
864 // --------------------------------------------------------------------------- |
636 // |
865 // |
637 AknItemActionMenuRegister* AknItemActionMenuRegister::CreateInstanceL() |
866 AknItemActionMenuRegister* AknItemActionMenuRegister::CreateInstanceL() |
638 { |
867 { |
|
868 _AKNTRACE_FUNC_ENTER; |
|
869 |
639 AknItemActionMenuRegister* instance = NULL; |
870 AknItemActionMenuRegister* instance = NULL; |
640 instance = new ( ELeave ) AknItemActionMenuRegister(); |
871 instance = new ( ELeave ) AknItemActionMenuRegister(); |
641 CleanupStack::PushL( instance ); |
872 CleanupStack::PushL( instance ); |
642 instance->ConstructL(); |
873 instance->ConstructL(); |
643 CleanupStack::Pop( instance ); |
874 CleanupStack::Pop( instance ); |
|
875 |
|
876 _AKNTRACE_FUNC_EXIT; |
644 return instance; |
877 return instance; |
645 } |
878 } |
|
879 |
646 |
880 |
647 // --------------------------------------------------------------------------- |
881 // --------------------------------------------------------------------------- |
648 // AknItemActionMenuRegister::TAknUnregisteredObserverData |
882 // AknItemActionMenuRegister::TAknUnregisteredObserverData |
649 // ::TAknUnregisteredObserverData |
883 // ::TAknUnregisteredObserverData |
650 // --------------------------------------------------------------------------- |
884 // --------------------------------------------------------------------------- |
651 // |
885 // |
652 AknItemActionMenuRegister::TAknUnregisteredObserverData::\ |
886 AknItemActionMenuRegister::TAknUnregisteredObserverData::\ |
653 TAknUnregisteredObserverData( |
887 TAknUnregisteredObserverData( |
654 CEikMenuBar* aMenuBar, MAknCollectionObserver& aObserver ) |
888 CEikMenuBar* aMenuBar, MAknCollectionObserver& aObserver, |
|
889 MObjectProvider* aOwner ) |
655 : iMenuBar( aMenuBar ), |
890 : iMenuBar( aMenuBar ), |
656 iObserver( aObserver ) |
891 iObserver( aObserver ), |
657 { |
892 iOwner( aOwner ) |
658 } |
893 { |
659 |
894 } |
660 |
895 |
661 // End of File |
896 // End of File |
662 |
897 |