author | Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com> |
Tue, 14 Sep 2010 20:58:58 +0300 | |
branch | RCL_3 |
changeset 88 | 3321d3e205b6 |
parent 83 | 5456b4e8b3a8 |
child 102 | ba63c83f4716 |
permissions | -rw-r--r-- |
83 | 1 |
/* |
2 |
* Copyright (c) 2007 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: Application UI class |
|
88
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
15 |
* Version : %version: MM_176.1.28.1.87 % << Don't touch! Updated by Synergy at check-out. |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
16 |
* Version : %version: MM_176.1.28.1.87 % << Don't touch! Updated by Synergy at check-out. |
83 | 17 |
* |
18 |
*/ |
|
19 |
||
20 |
#include <e32base.h> |
|
21 |
#include <e32cmn.h> |
|
22 |
#include <avkon.hrh> |
|
23 |
#include <avkon.rsg> |
|
24 |
#include <akntitle.h> |
|
25 |
#include <eikmenub.h> |
|
26 |
#include <akntoolbar.h> |
|
27 |
#include <aknbutton.h> |
|
28 |
#include <e32hashtab.h> |
|
29 |
#include <layoutmetadata.cdl.h> |
|
30 |
#include <gulicon.h> |
|
31 |
#include <fbs.h> |
|
32 |
#include <eikcmbut.h> |
|
33 |
#include <hlplch.h> |
|
34 |
#include <aknlists.h> |
|
35 |
#include <StringLoader.h> |
|
36 |
#include <activeidle2domainpskeys.h> |
|
37 |
#include <UikonInternalPSKeys.h> |
|
38 |
#include <e32property.h> |
|
39 |
#include <AknTaskList.h> |
|
40 |
#include <AknSgcc.h> // for transition effects |
|
41 |
#include <featmgr.h> |
|
42 |
#include <matrixmenu.rsg> |
|
43 |
#include <akntabgrp.h> |
|
44 |
#include <apgcli.h> |
|
45 |
#include <AknDef.hrh> |
|
46 |
#include <AknDlgShut.h> |
|
47 |
#include <mmenuinternalPSkeys.h> |
|
48 |
#include <aknstyluspopupmenu.h> //stylus popup for long tap event |
|
49 |
#include <apgwgnam.h> |
|
50 |
||
51 |
#include "mmgui.hrh" |
|
52 |
#include "mmguiconstants.h" |
|
53 |
#include "mmappui.h" |
|
54 |
#include "menudebug.h" |
|
55 |
#include "hnengine.h" |
|
56 |
#include "hnglobals.h" |
|
57 |
#include "hnsuitemodelcontainer.h" |
|
58 |
#include "hnmenuitemmodel.h" |
|
59 |
#include "hntoolbarmodel.h" |
|
60 |
#include "hnbuttonmodel.h" |
|
61 |
#include "hnitemmodel.h" |
|
62 |
#include "hnconvutils.h" |
|
63 |
#include "hnsuitemodel.h" |
|
64 |
#include "hnmdbasekey.h" |
|
65 |
#include "hnmdkeyfactory.h" |
|
66 |
#include "mmwidgetcontainer.h" |
|
67 |
#include "mmtemplatelibrary.h" |
|
68 |
#include "mmextensionmanager.h" |
|
69 |
#include "hnitemsorder.h" |
|
70 |
||
71 |
#include "mmnomemory.h" |
|
72 |
#include "mmappkeyhandler.h" |
|
73 |
||
74 |
enum TMenuTransEffectContext |
|
75 |
{ |
|
76 |
EMenuOpenFolderEffect = 1001, |
|
77 |
EMenuCloseFolderEffect = 1002 |
|
78 |
}; |
|
79 |
||
80 |
#define AI_UID3_AIFW_COMMON 0x102750F0 |
|
81 |
||
82 |
// ============================ MEMBER FUNCTIONS ============================= |
|
83 |
||
84 |
// --------------------------------------------------------------------------- |
|
85 |
// |
|
86 |
// --------------------------------------------------------------------------- |
|
87 |
// |
|
88 |
void CMmAppUi::ConstructL() |
|
89 |
{ |
|
90 |
DEBUG(("_Mm_:CMmAppUi::ConstructL IN")); |
|
91 |
MMPERF(("Test Logger speed...")); |
|
92 |
MMPERF(("Test Logger speed - DONE")); |
|
93 |
MMPERF(("GO!")); |
|
94 |
||
95 |
//set matrix to be system app |
|
96 |
iEikonEnv->SetSystem( ETrue ); |
|
97 |
||
98 |
TInt appUiFlags = AknLayoutUtils::PenEnabled() ? |
|
99 |
EAknEnableSkin | EAknSingleClickCompatible : |
|
100 |
EAknEnableSkin | EAknEnableMSK; |
|
101 |
BaseConstructL( appUiFlags ); |
|
102 |
//hide Menu from TS at startup |
|
103 |
HideApplicationFromFSW( ETrue ); |
|
104 |
isHiddenFromFS = ETrue; |
|
105 |
FeatureManager::InitializeLibL(); |
|
106 |
iIsKastorEffectStarted = EFalse; |
|
107 |
StartLayoutSwitchFullScreen( AknTransEffect::EApplicationStart ); |
|
108 |
||
109 |
Cba()->MakeVisible( EFalse ); |
|
88
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
110 |
StatusPane()->MakeVisible( EFalse ); |
83 | 111 |
StatusPane()->SwitchLayoutL( R_AVKON_STATUS_PANE_LAYOUT_USUAL ); |
112 |
||
113 |
iDummyTemplateLib = CMmTemplateLibrary::NewL(); |
|
114 |
iDummyContainer = CMmWidgetContainer::NewGridContainerL( ClientRect(), |
|
115 |
this, iDummyTemplateLib ); |
|
116 |
iDummyContainer->SetEmptyTextL( KNullDesC ); |
|
117 |
iDummyContainer->MakeVisible( EFalse ); |
|
118 |
AddToStackL( iDummyContainer, ECoeStackPriorityDefault, |
|
119 |
ECoeStackFlagRefusesFocus | ECoeStackFlagRefusesAllKeys ); |
|
120 |
||
121 |
iHNInterface = CHnEngine::NewL( *this ); |
|
122 |
iTemplateLibrary = CMmTemplateLibrary::NewL(); |
|
123 |
InitializeL(); |
|
124 |
||
125 |
iMmExtManager = CMMExtensionManager::NewL( *this ); |
|
126 |
||
127 |
iScreenOn = ETrue; |
|
128 |
iSkinChangeNeeded = EFalse; |
|
129 |
iSkinChangeInProgress = EFalse; |
|
130 |
iHasFocus = ETrue; |
|
131 |
||
132 |
iSkinSrvSession.Connect(this); |
|
133 |
iAppkeyHandler = CMmAppkeyHandler::NewL(); |
|
134 |
||
135 |
RProperty::Define( KMMenuPSCat, KMMenuLastViewKey, RProperty::EText ); |
|
136 |
||
137 |
MMPERF(("CMmAppUi::ConstructL - HN ready")); |
|
138 |
DEBUG(("_Mm_:CMmAppUi::ConstructL OUT")); |
|
139 |
} |
|
140 |
||
141 |
// --------------------------------------------------------------------------- |
|
142 |
// |
|
143 |
// --------------------------------------------------------------------------- |
|
144 |
// |
|
145 |
TBool CMmAppUi::IsRootdisplayedL() |
|
146 |
{ |
|
147 |
TBool ret( EFalse ); |
|
148 |
if( iHNInterface && iHNInterface->GetSuiteModelsCountL() == KModelCountForRoot ) |
|
149 |
{ |
|
150 |
ret = ETrue; |
|
151 |
} |
|
152 |
return ret; |
|
153 |
} |
|
154 |
||
155 |
// --------------------------------------------------------------------------- |
|
156 |
// |
|
157 |
// --------------------------------------------------------------------------- |
|
158 |
// |
|
159 |
CMmAppUi::CMmAppUi() |
|
160 |
{ |
|
161 |
// No implementation required |
|
162 |
} |
|
163 |
||
164 |
// --------------------------------------------------------------------------- |
|
165 |
// |
|
166 |
// --------------------------------------------------------------------------- |
|
167 |
// |
|
168 |
CMmAppUi::~CMmAppUi() |
|
169 |
{ |
|
170 |
DEBUG(("_Mm_:CMmAppUi::~CMmAppUi IN")); |
|
171 |
||
172 |
delete iOutOfMemoryHandler; |
|
173 |
if (iCurrentSuiteModel) |
|
174 |
{ |
|
175 |
iCurrentSuiteModel->UnregisterSuiteObserver( this ); |
|
176 |
} |
|
177 |
delete iToolbar; |
|
178 |
iCascadeMenuMap.Close(); |
|
179 |
RemoveFromStack( iCurrentContainer ); |
|
180 |
RemoveFromStack( iDummyContainer ); |
|
181 |
iDummyContainer->MakeVisible( EFalse ); |
|
182 |
delete iDummyContainer; |
|
183 |
ResetContainerMap(); |
|
184 |
iGarbage.ResetAndDestroy(); |
|
185 |
delete iHNInterface; |
|
186 |
FeatureManager::UnInitializeLib(); |
|
187 |
delete iMmExtManager; |
|
188 |
delete iTemplateLibrary; |
|
189 |
delete iDummyTemplateLib; |
|
190 |
delete iAppkeyHandler; |
|
191 |
delete iPopupMenu; |
|
192 |
iSkinSrvSession.Close(); |
|
193 |
||
194 |
MMPERF(("Matrix closed")); |
|
195 |
DEBUG(("_Mm_:CMmAppUi::~CMmAppUi OUT")); |
|
196 |
||
197 |
} |
|
198 |
||
199 |
// --------------------------------------------------------------------------- |
|
200 |
// |
|
201 |
// --------------------------------------------------------------------------- |
|
202 |
// |
|
203 |
void CMmAppUi::HandleResourceChangeL( TInt aType ) |
|
204 |
{ |
|
205 |
CAknAppUi::HandleResourceChangeL( aType ); |
|
206 |
||
207 |
//we're interested in layout change events |
|
208 |
//only if container is available |
|
209 |
if ( aType == KEikDynamicLayoutVariantSwitch && |
|
210 |
iCurrentContainer && iCurrentSuiteModel ) |
|
211 |
{ |
|
212 |
MMPERF(("Layout change START")); |
|
213 |
// Do not call StartLayoutSwitchFullScreen(), |
|
214 |
// layout switch effect is started automatically |
|
215 |
iIsKastorEffectStarted = ETrue; |
|
216 |
TInt lastItemIndex = iCurrentContainer->NumberOfItems() - 1; |
|
217 |
||
218 |
if ( lastItemIndex >= 0 && iCurrentContainer->ItemIsFullyVisible( lastItemIndex ) |
|
219 |
&& !iCurrentContainer->IsHighlightVisible() ) |
|
220 |
{ |
|
221 |
iCurrentContainer->SetManualHighlightL( lastItemIndex, EFalse ); |
|
222 |
} |
|
223 |
else if( !iCurrentContainer->IsHighlightVisible() |
|
224 |
&& iCurrentContainer->Widget()->TopItemIndex() > -1) |
|
225 |
{ |
|
226 |
iCurrentContainer->SetManualHighlightL( |
|
227 |
iCurrentContainer->Widget()->TopItemIndex(), EFalse ); |
|
228 |
} |
|
229 |
||
230 |
iCurrentContainer->SetRect( ClientRect() ); |
|
231 |
iDummyContainer->SetRect( ClientRect() ); |
|
232 |
||
233 |
THashMapIter< TInt, CMmWidgetContainer* > iterator( iContainerMap ); |
|
234 |
while( iterator.NextKey() ) |
|
235 |
{ |
|
236 |
CMmWidgetContainer* container = *iterator.CurrentValue(); |
|
237 |
if ( container != iCurrentContainer ) |
|
238 |
{ |
|
239 |
container->SetRect( ClientRect() ); |
|
240 |
container->HandleResourceChange( aType ); |
|
241 |
} |
|
242 |
} |
|
243 |
ShowSuiteL(); |
|
244 |
EndFullScreen(); |
|
245 |
MMPERF(("Layout change END")); |
|
246 |
} |
|
247 |
||
248 |
if ( aType == KEikMessageFadeAllWindows && iCurrentContainer ) |
|
249 |
{ |
|
250 |
iCurrentContainer->SetIsFaded( ETrue ); |
|
251 |
} |
|
252 |
else if ( aType == KEikMessageUnfadeWindows && iCurrentContainer ) |
|
253 |
{ |
|
254 |
iCurrentContainer->SetIsFaded( EFalse ); |
|
255 |
} |
|
256 |
} |
|
257 |
||
258 |
// --------------------------------------------------------------------------- |
|
259 |
// |
|
260 |
// --------------------------------------------------------------------------- |
|
261 |
// |
|
262 |
TBool CMmAppUi::ProcessCommandParametersL( TApaCommand aCommand, |
|
263 |
TFileName& aDocumentName, |
|
264 |
const TDesC8& aTail ) |
|
265 |
{ |
|
266 |
DEBUG(("_Mm_:CMmAppUi::ProcessCommandParametersL IN")); |
|
267 |
DEBUG8(("\t_Mm_:tail: %S", &aTail)); |
|
268 |
||
269 |
if ( aTail.Length() ) |
|
270 |
{ |
|
271 |
DEBUG(("\t_Mm_:call HandleMessageL")); |
|
272 |
HandleMessageL( aTail ); |
|
273 |
} |
|
274 |
||
275 |
TBool result = CEikAppUi::ProcessCommandParametersL( aCommand, |
|
276 |
aDocumentName, |
|
277 |
aTail ); |
|
278 |
||
279 |
MMPERF(("Matrix started and ready!")); |
|
280 |
DEBUG(("_Mm_:CMmAppUi::ProcessCommandParametersL OUT")); |
|
281 |
return result; |
|
282 |
} |
|
283 |
||
284 |
// --------------------------------------------------------------------------- |
|
285 |
// |
|
286 |
// --------------------------------------------------------------------------- |
|
287 |
// |
|
288 |
void CMmAppUi::ProcessCommandL(TInt aCommand) |
|
289 |
{ |
|
290 |
TBool ignoreCommand = EFalse; |
|
291 |
||
292 |
// ignore options click in edit mode and intermediate states for non-touch |
|
293 |
if ( aCommand == EAknSoftkeyOptions && iEditModeStatus != ENoEditMode && |
|
294 |
!AknLayoutUtils::PenEnabled() ) |
|
295 |
{ |
|
296 |
ignoreCommand = ETrue; |
|
297 |
} |
|
298 |
||
299 |
// ignore keyselect for non-touch while in edit mode or stopping edit mode |
|
300 |
if ( aCommand == KKeyIdSelect && !AknLayoutUtils::PenEnabled() && |
|
301 |
( iEditModeStatus == ETransitionFromEditMode || IsEditMode() ) ) |
|
302 |
{ |
|
303 |
ignoreCommand = ETrue; |
|
304 |
} |
|
305 |
||
306 |
if ( !ignoreCommand ) |
|
307 |
{ |
|
308 |
CAknAppUi::ProcessCommandL( aCommand ); |
|
309 |
} |
|
310 |
||
311 |
if ( iCurrentContainer ) |
|
312 |
{ |
|
313 |
iCurrentContainer->EndLongTapL(); |
|
314 |
} |
|
315 |
} |
|
316 |
||
317 |
// --------------------------------------------------------------------------- |
|
318 |
// |
|
319 |
// --------------------------------------------------------------------------- |
|
320 |
// |
|
321 |
void CMmAppUi::ProcessMessageL( TUid /*aUid*/, const TDesC8& aParams ) |
|
322 |
{ |
|
323 |
DEBUG(("_Mm_:CMmAppUi::ProcessMessageL IN")); |
|
324 |
DEBUG8(("\t_Mm_:params: %S", &aParams)); |
|
325 |
MMPERF(("APA Message Recieved")); |
|
326 |
||
327 |
// fix for the CR 417-35490 |
|
328 |
// Handle empty message sends by AVKON after app key press or switch |
|
329 |
// to Menu via task swapper. |
|
330 |
if( !aParams.Compare( KNullDesC8 ) ) |
|
331 |
{ |
|
332 |
if ( !iAppkeyHandler->IsActive() ) |
|
333 |
{ |
|
334 |
//make dummy container visible when returning |
|
335 |
//to menu by AppKey |
|
336 |
if( iDummyContainer && iCurrentContainer ) |
|
337 |
{ |
|
338 |
iDummyContainer->MakeVisible( ETrue ); |
|
339 |
RefreshUiPanesL( ETrue ); |
|
340 |
iCurrentContainer->MakeVisible( EFalse ); |
|
341 |
iDummyContainer->DrawNow(); |
|
342 |
} |
|
88
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
343 |
CleanupForExitL( ECommingFromBackground ); |
83 | 344 |
User::LeaveIfError( iCoeEnv->WsSession().SetWindowGroupOrdinalPosition( |
345 |
CEikonEnv::Static()->RootWin().Identifier(), 0 ) ); |
|
346 |
iAppkeyHandler->StartL(); |
|
347 |
} |
|
348 |
} |
|
349 |
||
350 |
// first refresh model, show afterwords |
|
351 |
if ( aParams.Length() ) |
|
352 |
{ |
|
353 |
DEBUG(("\t_Mm_:call HandleMessageL")); |
|
354 |
HandleMessageL( aParams ); |
|
355 |
} |
|
356 |
||
357 |
MMPERF(("APA Message Processed")); |
|
358 |
DEBUG(("_Mm_:CMmAppUi::ProcessMessageL OUT")); |
|
359 |
} |
|
360 |
||
361 |
// --------------------------------------------------------------------------- |
|
362 |
// |
|
363 |
// --------------------------------------------------------------------------- |
|
364 |
// |
|
365 |
MCoeMessageObserver::TMessageResponse CMmAppUi::HandleMessageL( |
|
366 |
TUint32 aClientHandleOfTargetWindowGroup, |
|
367 |
TUid aMessageUid, |
|
368 |
const TDesC8& aMessageParameters ) |
|
369 |
{ |
|
370 |
if ( aMessageUid.iUid == KUidApaMessageSwitchOpenFileValue ) |
|
371 |
{ |
|
372 |
ProcessMessageL( aMessageUid, aMessageParameters ); |
|
373 |
return EMessageHandled; |
|
374 |
} |
|
375 |
else |
|
376 |
{ |
|
377 |
return CAknAppUi::HandleMessageL( |
|
378 |
aClientHandleOfTargetWindowGroup, |
|
379 |
aMessageUid, |
|
380 |
aMessageParameters ); |
|
381 |
} |
|
382 |
} |
|
383 |
||
384 |
// --------------------------------------------------------------------------- |
|
385 |
// |
|
386 |
// --------------------------------------------------------------------------- |
|
387 |
// |
|
388 |
void CMmAppUi::HandleCommandL( TInt aCommand ) |
|
389 |
{ |
|
390 |
DEBUG(("_Mm_:CMmAppUi::HandleCommandL IN")); |
|
391 |
DEBUG(("\t_Mm_:aCommand: %d",aCommand)); |
|
392 |
||
393 |
// in case something has gone wrong |
|
394 |
ClearTransitionFromEditModeFlag(); |
|
395 |
||
396 |
switch( aCommand ) |
|
397 |
{ |
|
398 |
case EEikCmdExit: |
|
399 |
{ |
|
400 |
DEBUG(("\t_Mm_:EEikCmdExit")); |
|
401 |
// Simply exit |
|
402 |
Exit(); |
|
403 |
} |
|
404 |
break; |
|
405 |
||
406 |
case EMmOptionsExit: |
|
407 |
{ |
|
408 |
MMPERF(("Options->Exit pressed")); |
|
409 |
DEBUG(("\t_Mm_:EMmOptionsExit")); |
|
410 |
||
411 |
//Check if it is a folder suite.If Yes really exit. |
|
412 |
//Otherwise behave like LSK. |
|
413 |
if( iCurrentSuiteModel && |
|
414 |
iCurrentSuiteModel->SuiteName().Compare( KFolderSuite) ) |
|
415 |
{ |
|
416 |
if( iCurrentSuiteModel->ExitMode() == EExitModeHide ) |
|
417 |
{ |
|
418 |
// hide and reset menu |
|
419 |
TApaTaskList taskList( iCoeEnv->WsSession() ); |
|
420 |
TApaTask me = taskList.FindApp( KUidMatrixMenuApp ); |
|
421 |
me.SendToBackground(); |
|
422 |
CleanupForExitL( EExitKeyApplication ); |
|
423 |
} |
|
424 |
else |
|
425 |
{ |
|
426 |
StartLayoutSwitchFullScreen( EMenuCloseFolderEffect ); |
|
427 |
HandleBackCommandL(); |
|
428 |
} |
|
429 |
} |
|
430 |
else |
|
431 |
{ |
|
432 |
ExitMatrix( EExitReally ); |
|
433 |
} |
|
434 |
} |
|
435 |
break; |
|
436 |
||
437 |
case EAknSoftkeyExit: |
|
438 |
{ |
|
439 |
MMPERF(("SoftkeyExit pressed")); |
|
440 |
DEBUG(("\t_Mm_:EAknSoftkeyExit")); |
|
441 |
ExitMatrix( EExitToPhone ); |
|
442 |
} |
|
443 |
break; |
|
444 |
||
445 |
case EAknSoftkeyBack: |
|
446 |
{ |
|
447 |
StartLayoutSwitchFullScreen( EMenuCloseFolderEffect ); |
|
448 |
||
449 |
if( iCurrentSuiteModel && iCurrentSuiteModel->ExitMode() == EExitModeHide ) |
|
450 |
{ |
|
451 |
// hide and reset menu |
|
452 |
TApaTaskList taskList( iCoeEnv->WsSession() ); |
|
453 |
TApaTask me = taskList.FindApp( KUidMatrixMenuApp ); |
|
454 |
me.SendToBackground(); |
|
455 |
if ( iCurrentContainer ) |
|
456 |
{ |
|
457 |
iCurrentContainer->MakeVisible( EFalse ); |
|
458 |
} |
|
459 |
iDummyContainer->MakeVisible( ETrue ); |
|
460 |
RefreshCbaL(); |
|
461 |
iDummyContainer->DrawNow(); |
|
462 |
CleanupForExitL( EExitKeyApplication ); |
|
463 |
} |
|
464 |
else if( iCurrentSuiteModel ) |
|
465 |
{ |
|
466 |
HandleBackCommandL(); |
|
467 |
} |
|
468 |
} |
|
469 |
break; |
|
470 |
||
471 |
case EAknSoftkeyOk: |
|
472 |
case EAknSoftkeyDone: |
|
473 |
{ |
|
474 |
ASSERT( IsEditMode() ); |
|
475 |
SetEditModeL( EFalse ); |
|
476 |
} |
|
477 |
break; |
|
478 |
default: |
|
479 |
{ |
|
480 |
ForwardEventToHNL( aCommand ); |
|
481 |
} |
|
482 |
break; |
|
483 |
} |
|
484 |
DEBUG(("_Mm_:CMmAppUi::HandleCommandL OUT")); |
|
485 |
} |
|
486 |
||
487 |
// --------------------------------------------------------------------------- |
|
488 |
// |
|
489 |
// --------------------------------------------------------------------------- |
|
490 |
// |
|
491 |
void CMmAppUi::HandleBackCommandL() |
|
492 |
{ |
|
493 |
DEBUG(("_Mm_:CMmAppUi::HandleBackCommandL IN")); |
|
494 |
MMPERF(("CMmAppUi::HandleBackCommandL - START")); |
|
495 |
DEBUG16(("\t_Mm_:current genre: %S",&iCurrentSuiteModel->SuiteName())); |
|
496 |
||
497 |
iHNInterface->HandleBackEventL( iCurrentSuiteModel->SuiteName() ); |
|
498 |
||
499 |
MMPERF(("CMmAppUi::HandleBackCommandL - DONE")); |
|
500 |
DEBUG(("_Mm_:CMmAppUi::HandleBackCommandL OUT")); |
|
501 |
} |
|
502 |
||
503 |
// --------------------------------------------------------------------------- |
|
504 |
// |
|
505 |
// --------------------------------------------------------------------------- |
|
506 |
// |
|
507 |
CMmWidgetContainer* CMmAppUi::GetAppropriateContainerToLoadL() |
|
508 |
{ |
|
509 |
CMmWidgetContainer* retContainer = NULL; |
|
510 |
if ( iCurrentSuiteModel ) |
|
511 |
{ |
|
512 |
TInt currentSuiteId = iCurrentSuiteModel->GetItemsOrder()->GetSuiteId(); |
|
513 |
||
514 |
CMmWidgetContainer** ret = iContainerMap.Find( currentSuiteId ); |
|
515 |
retContainer = (ret) ? *ret : NULL; |
|
516 |
||
517 |
if ( ret && (*ret)->WidgetType() != iCurrentSuiteModel->WidgetType() ) |
|
518 |
{ |
|
519 |
iMakeHightlightedItemFullyVisible = ETrue; |
|
520 |
iGarbage.AppendL( *ret ); |
|
521 |
iContainerMap.Remove( |
|
522 |
iCurrentSuiteModel->GetItemsOrder()->GetSuiteId() ); |
|
523 |
retContainer = NULL; |
|
524 |
} |
|
525 |
} |
|
526 |
return retContainer; |
|
527 |
} |
|
528 |
||
529 |
// --------------------------------------------------------------------------- |
|
530 |
// |
|
531 |
// --------------------------------------------------------------------------- |
|
532 |
// |
|
533 |
void CMmAppUi::ShowSuiteL() |
|
534 |
{ |
|
535 |
DEBUG(("_Mm_:CMmAppUi::ShowSuiteL IN")); |
|
536 |
// DEBUG16(("\t_Mm_:current genre: %S", &iCurrentSuiteModel->SuiteName())); |
|
537 |
||
538 |
if ( iCurrentSuiteModel ) |
|
539 |
{ |
|
540 |
CMmWidgetContainer* containerToLoad = GetAppropriateContainerToLoadL(); |
|
541 |
TBool makeHandlePresentationChange( ETrue ); |
|
542 |
||
543 |
if (!containerToLoad) |
|
544 |
{ |
|
545 |
makeHandlePresentationChange = CreateNewContainerL( |
|
546 |
iCurrentSuiteModel, containerToLoad ); |
|
547 |
} |
|
548 |
||
549 |
if( makeHandlePresentationChange ) |
|
550 |
{ |
|
551 |
HandlePresentationChangeL( containerToLoad ); |
|
552 |
} |
|
553 |
} |
|
554 |
||
555 |
DEBUG(("_Mm_:CMmAppUi::ShowSuiteL OUT")); |
|
556 |
} |
|
557 |
||
558 |
// --------------------------------------------------------------------------- |
|
559 |
// |
|
560 |
// --------------------------------------------------------------------------- |
|
561 |
// |
|
562 |
TBool CMmAppUi::CreateNewContainerL( |
|
563 |
CHnSuiteModel* aSuiteModel, CMmWidgetContainer*& aContainerToLoad ) |
|
564 |
{ |
|
565 |
TRect rect = ClientRect(); |
|
566 |
switch( aSuiteModel->WidgetType() ) |
|
567 |
{ |
|
568 |
case ECoverFlowWidget : |
|
569 |
case EGridWidget : |
|
570 |
aContainerToLoad = CMmWidgetContainer::NewGridContainerL( |
|
571 |
rect, this, iTemplateLibrary ); |
|
572 |
break; |
|
573 |
case EListWidget : |
|
574 |
aContainerToLoad = CMmWidgetContainer::NewListBoxContainerL( |
|
575 |
rect, this, iTemplateLibrary ); |
|
576 |
break; |
|
577 |
case EUnspecified: |
|
578 |
default: |
|
579 |
return EFalse; |
|
580 |
} |
|
581 |
aContainerToLoad->SetLongTapObserver(this); |
|
582 |
aContainerToLoad->HandleItemAdditionL(); |
|
583 |
iContainerMap.InsertL( |
|
584 |
aSuiteModel->GetItemsOrder()->GetSuiteId(), |
|
585 |
aContainerToLoad ); |
|
586 |
return ETrue; |
|
587 |
} |
|
588 |
||
589 |
// --------------------------------------------------------------------------- |
|
590 |
// |
|
591 |
// --------------------------------------------------------------------------- |
|
592 |
// |
|
593 |
void CMmAppUi::ForwardEventToHNL( TInt aEvent, TInt aItemId, |
|
594 |
CLiwGenericParamList* aEventParams ) |
|
595 |
{ |
|
596 |
DEBUG(("\t_Mm_:event ID: %d for item ID %d", aEvent, aItemId)); |
|
597 |
||
598 |
TInt id = iCurrentSuiteModel->IdByIndex( aItemId ); |
|
599 |
if ( id >= 0 ) |
|
600 |
{ |
|
601 |
MMPERF(("Handling event %d for item %d - START",aEvent,aItemId)); |
|
602 |
||
603 |
if( aEvent == KKeyIdSelect ) |
|
604 |
{ |
|
605 |
MMPERF(("This is a 'select' event")); |
|
606 |
||
607 |
TInt modelId = iCurrentSuiteModel->IdByIndex( aItemId ); |
|
608 |
CHnItemModel* itemModel = |
|
609 |
iCurrentSuiteModel->GetItemModel( modelId ); |
|
610 |
TInt effect = GetKastorEffectL( itemModel ); |
|
611 |
TRect rect = GetKastorRectL( itemModel, aItemId ); |
|
612 |
TUid appUid = itemModel->GetItemType() == EItemTypeApplication ? |
|
613 |
itemModel->GetItemUid() : KUidMatrixMenuApp; |
|
614 |
||
615 |
if (iScreenOn && IsForeground() && effect |
|
616 |
!= AknTransEffect::ENone) |
|
617 |
{ |
|
618 |
DEBUG(("_MM_:CMmAppUi::ForwardEventToHNL Foreground")); |
|
619 |
GfxTransEffect::BeginFullScreen( |
|
620 |
effect, rect, |
|
621 |
AknTransEffect::EParameterType, |
|
622 |
AknTransEffect::GfxTransParam( appUid , KUidMatrixMenuApp ) ); |
|
623 |
} |
|
624 |
} |
|
625 |
||
626 |
iHNInterface->TriggerHnEventL( aEvent, id, aEventParams ); |
|
627 |
MMPERF(("Handling event - END")); |
|
628 |
} |
|
629 |
} |
|
630 |
||
631 |
// --------------------------------------------------------------------------- |
|
632 |
// |
|
633 |
// --------------------------------------------------------------------------- |
|
634 |
// |
|
635 |
TInt CMmAppUi::GetKastorEffectL( CHnItemModel* aItemModel ) |
|
636 |
{ |
|
637 |
TInt effect( AknTransEffect::ENone ); |
|
638 |
if ((IsEditMode() || iEditModeStatus == ETransitionFromEditMode) |
|
639 |
&& !AknLayoutUtils::PenEnabled()) |
|
640 |
{ |
|
641 |
return effect; |
|
642 |
} |
|
643 |
switch( aItemModel->GetItemType() ) |
|
644 |
{ |
|
645 |
case EItemTypeApplication: |
|
646 |
{ |
|
647 |
if( !IsEditMode() && !aItemModel->IsDrmExpired() ) |
|
648 |
{ |
|
649 |
if( aItemModel->IsRunning() ) |
|
650 |
{ |
|
651 |
effect = AknTransEffect::EApplicationStartSwitchRect; |
|
652 |
} |
|
653 |
else |
|
654 |
{ |
|
655 |
effect = AknTransEffect::EApplicationStartRect; |
|
656 |
} |
|
657 |
} |
|
658 |
break; |
|
659 |
} |
|
660 |
case EItemTypeSuite: |
|
661 |
{ |
|
662 |
if( !IsEditMode() ) |
|
663 |
{ |
|
664 |
effect = EMenuOpenFolderEffect; |
|
665 |
iIsKastorEffectStarted = ETrue; |
|
666 |
} |
|
667 |
break; |
|
668 |
} |
|
669 |
case EItemTypeParentFolder: |
|
670 |
{ |
|
671 |
effect = EMenuCloseFolderEffect; |
|
672 |
iIsKastorEffectStarted = ETrue; |
|
673 |
break; |
|
674 |
} |
|
675 |
case EItemTypeFolder: |
|
676 |
{ |
|
677 |
if (!(IsEditMode() && aItemModel->IsDeleteLocked())) |
|
678 |
{ |
|
679 |
effect = EMenuOpenFolderEffect; |
|
680 |
iIsKastorEffectStarted = ETrue; |
|
681 |
} |
|
682 |
break; |
|
683 |
} |
|
684 |
case EItemTypeUnknown: |
|
685 |
default: |
|
686 |
{ |
|
687 |
effect = AknTransEffect::ENone; |
|
688 |
break; |
|
689 |
} |
|
690 |
} |
|
691 |
return effect; |
|
692 |
} |
|
693 |
||
694 |
// --------------------------------------------------------------------------- |
|
695 |
// |
|
696 |
// --------------------------------------------------------------------------- |
|
697 |
// |
|
698 |
TRect CMmAppUi::GetKastorRectL( CHnItemModel* aItemModel, TInt aItemId ) |
|
699 |
{ |
|
700 |
TRect rect = TRect(); |
|
701 |
if( aItemModel->GetItemType() == EItemTypeApplication ) |
|
702 |
{ |
|
703 |
rect = iCurrentContainer->GetItemRectL( aItemId ); |
|
704 |
RRegion region; CleanupClosePushL( region ); |
|
705 |
StatusPane()->GetShapeL( region, true, true ); |
|
706 |
TInt statusPaneHeight = region.BoundingRect().Height(); |
|
707 |
rect.iBr.iY += statusPaneHeight; |
|
708 |
rect.iTl.iY += statusPaneHeight; |
|
709 |
CleanupStack::PopAndDestroy( ®ion ); |
|
710 |
} |
|
711 |
return rect; |
|
712 |
} |
|
713 |
||
714 |
// --------------------------------------------------------------------------- |
|
715 |
// |
|
716 |
// --------------------------------------------------------------------------- |
|
717 |
// |
|
718 |
void CMmAppUi::ForwardEventToHNL( TInt aEvent ) |
|
719 |
{ |
|
720 |
DEBUG(("_Mm_:CMmAppUi::ForwardEventToHNL IN")); |
|
721 |
DEBUG(("\t_Mm_:event ID: %d", aEvent)); |
|
722 |
||
723 |
if ( iCurrentContainer ) |
|
724 |
{ |
|
725 |
TBool idByContainer = iCurrentContainer->IsHighlightVisible() && |
|
726 |
iCurrentContainer->GetSuiteModelL()->GetItemModelsCount() > 1; |
|
727 |
TInt current = idByContainer ? |
|
728 |
iCurrentContainer->GetHighlight(): |
|
729 |
iCurrentContainer->GetSuiteModelL()->GetSuiteHighlight(); |
|
730 |
ForwardEventToHNL( aEvent, current ); |
|
731 |
} |
|
732 |
||
733 |
DEBUG(("_Mm_:CMmAppUi::ForwardEventToHNL OUT")); |
|
734 |
} |
|
735 |
||
736 |
// --------------------------------------------------------------------------- |
|
737 |
// |
|
738 |
// --------------------------------------------------------------------------- |
|
739 |
// |
|
740 |
void CMmAppUi::NotifyUiRefreshL( const THnUiRefreshType aRefreshType ) |
|
741 |
{ |
|
742 |
DEBUG(("_Mm_:CMmAppUi::NotifyUiRefreshL IN")); |
|
743 |
DEBUG(("\t_Mm_:refresh type: %d", aRefreshType)); |
|
744 |
||
745 |
switch (aRefreshType) |
|
746 |
{ |
|
747 |
case ERefreshSuite: |
|
748 |
TRAPD( err, ShowSuiteL() ); |
|
749 |
if ( KErrNoMemory == err ) |
|
750 |
{ |
|
751 |
HandleOutOfMemoryL(); |
|
752 |
User::Leave( KErrNoMemory ); |
|
753 |
} |
|
754 |
break; |
|
755 |
case ERefreshToolbar: |
|
756 |
RefreshToolbarL(); |
|
757 |
break; |
|
758 |
case EStartEditMode: |
|
759 |
SetEditModeL( ETrue ); |
|
760 |
break; |
|
761 |
case EStopEditMode: |
|
762 |
SetEditModeL( EFalse ); |
|
763 |
break; |
|
764 |
case EForegroundGain: |
|
765 |
{ |
|
766 |
DEBUG(("_MM_:CMmAppUi::NotifyUiRefreshL Foreground")); |
|
767 |
TApaTaskList taskList( iCoeEnv->WsSession() ); |
|
768 |
TApaTask me = taskList.FindApp( KUidMatrixMenuApp ); |
|
769 |
me.BringToForeground(); |
|
770 |
} |
|
771 |
break; |
|
772 |
case EBackgroundGain: |
|
773 |
{ |
|
774 |
DEBUG(("_MM_:CMmAppUi::NotifyUiRefreshL Foreground")); |
|
775 |
TApaTaskList taskList( iCoeEnv->WsSession() ); |
|
776 |
TApaTask me = taskList.FindApp( KUidMatrixMenuApp ); |
|
777 |
me.SendToBackground(); |
|
778 |
} |
|
779 |
break; |
|
780 |
case ELightOn: |
|
781 |
{ |
|
782 |
DEBUG(("_Mm_:CMmAppUi::NotifyUiRefreshL - ELightOn")); |
|
783 |
iScreenOn = ETrue; |
|
784 |
if ( iCurrentContainer ) |
|
785 |
{ |
|
786 |
iCurrentContainer->HandleForegroundGainedL(); |
|
787 |
} |
|
788 |
} |
|
789 |
break; |
|
790 |
case ELightOff: |
|
791 |
{ |
|
792 |
DEBUG(("_Mm_:CMmAppUi::NotifyUiRefreshL - ELightOff")); |
|
793 |
iScreenOn = EFalse; |
|
794 |
if (iCurrentContainer) |
|
795 |
{ |
|
796 |
iCurrentContainer->HandleBackgroundGainedL(); |
|
797 |
if (IsEditMode() && iCurrentContainer->IsDraggable()) |
|
798 |
{ |
|
799 |
iCurrentContainer->CancelDragL(EFalse); |
|
800 |
} |
|
801 |
} |
|
802 |
} |
|
803 |
break; |
|
804 |
case ERemoveLiwObjects: |
|
805 |
{ |
|
806 |
THashMapIter< TInt, CMmWidgetContainer* > iterator( iContainerMap ); |
|
807 |
while( iterator.NextKey() ) |
|
808 |
{ |
|
809 |
CMmWidgetContainer** container = iterator.CurrentValue(); |
|
810 |
(*container)->RemoveLiwObjects(); |
|
811 |
} |
|
812 |
} |
|
813 |
break; |
|
814 |
default: |
|
815 |
ASSERT( false ); |
|
816 |
} |
|
817 |
DEBUG(("_Mm_:CMmAppUi::NotifyUiRefreshL OUT")); |
|
818 |
} |
|
819 |
||
820 |
// --------------------------------------------------------------------------- |
|
821 |
// |
|
822 |
// --------------------------------------------------------------------------- |
|
823 |
// |
|
824 |
void CMmAppUi::RefreshToolbarL() |
|
825 |
{ |
|
826 |
DEBUG(("_Mm_:CMmAppUi::RefreshToolbarL IN")); |
|
827 |
HandleToolbarVisibilityL(); |
|
828 |
UpdateToolbarL(); |
|
829 |
DEBUG(("_Mm_:CMmAppUi::RefreshToolbarL OUT")); |
|
830 |
} |
|
831 |
||
832 |
// --------------------------------------------------------------------------- |
|
833 |
// |
|
834 |
// --------------------------------------------------------------------------- |
|
835 |
// |
|
836 |
void CMmAppUi::RefreshUiPanesL( TBool aReset ) |
|
837 |
{ |
|
838 |
// refresh status pane |
|
839 |
CAknTitlePane* titlePane = |
|
840 |
static_cast<CAknTitlePane*>( |
|
841 |
StatusPane()->ControlL( |
|
842 |
TUid::Uid( EEikStatusPaneUidTitle ) ) ); |
|
843 |
||
844 |
if( aReset ) |
|
845 |
{ |
|
846 |
titlePane->SetTextL( KNullDesC ); |
|
847 |
} |
|
848 |
else |
|
849 |
{ |
|
850 |
if ( IsEditMode() && iCurrentSuiteModel ) |
|
851 |
{ |
|
852 |
HBufC* title = NULL; |
|
853 |
if ( IsRootdisplayedL() ) |
|
854 |
{ |
|
855 |
title = StringLoader::LoadLC( R_ORG_ROOT_EDITING_TITLE ); |
|
856 |
} |
|
857 |
else |
|
858 |
{ |
|
859 |
title = StringLoader::LoadLC( |
|
860 |
R_ORG_FOLDER_EDITING_TITLE, |
|
861 |
iCurrentSuiteModel->Title() ); |
|
862 |
} |
|
863 |
ASSERT( title ); |
|
864 |
titlePane->SetTextL( title->Des() ); |
|
865 |
CleanupStack::PopAndDestroy( title ); |
|
866 |
} |
|
867 |
else if ( iCurrentSuiteModel && iCurrentContainer ) |
|
868 |
{ |
|
869 |
// refresh status pane |
|
870 |
titlePane->SetTextL( iCurrentSuiteModel->Title() ); |
|
871 |
||
872 |
// inform AVKON about current suite to allow proper handling |
|
873 |
// of AppKey and FSW |
|
874 |
RProperty::Set( KMMenuPSCat, KMMenuLastViewKey, iCurrentSuiteModel->SuiteName() ); |
|
875 |
} |
|
876 |
else |
|
877 |
{ |
|
878 |
titlePane->SetTextL( KNullDesC ); |
|
879 |
} |
|
880 |
} |
|
881 |
||
882 |
RefreshCbaL(); |
|
883 |
SetMiddleSoftKeyL(); |
|
884 |
||
885 |
StatusPane()->DrawNow(); |
|
886 |
Cba()->DrawNow(); |
|
887 |
} |
|
888 |
||
889 |
// --------------------------------------------------------------------------- |
|
890 |
// |
|
891 |
// --------------------------------------------------------------------------- |
|
892 |
// |
|
893 |
void CMmAppUi::RefreshCbaL() |
|
894 |
{ |
|
895 |
if ( ( iDummyContainer && iDummyContainer->IsVisible() ) || |
|
896 |
!iCurrentSuiteModel ) |
|
897 |
{ |
|
898 |
// R_MENU_SOFTKEYS_EMPTY__EMPTY looks much better than |
|
899 |
// R_AVKON_SOFTKEYS_EMPTY |
|
900 |
Cba()->SetCommandSetL( R_MENU_SOFTKEYS_EMPTY__EMPTY ); |
|
901 |
} |
|
902 |
else |
|
903 |
{ |
|
904 |
if ( IsEditMode() ) |
|
905 |
{ |
|
906 |
Cba()->SetCommandSetL( AknLayoutUtils::PenEnabled() ? |
|
907 |
R_AVKON_SOFTKEYS_OPTIONS_DONE : |
|
908 |
R_AVKON_SOFTKEYS_OK_EMPTY__OK ); |
|
909 |
} |
|
910 |
else if ( IsRootdisplayedL() ) |
|
911 |
{ |
|
912 |
Cba()->SetCommandSetL( AknLayoutUtils::PenEnabled() ? |
|
913 |
R_AVKON_SOFTKEYS_OPTIONS_EXIT : |
|
914 |
R_AVKON_SOFTKEYS_OPTIONS_EXIT__SELECT ); |
|
915 |
} |
|
916 |
else if ( iCurrentSuiteModel && |
|
917 |
iCurrentSuiteModel->SuiteName().Compare(KParamFolderSuite) ) |
|
918 |
{ |
|
919 |
Cba()->SetCommandSetL( AknLayoutUtils::PenEnabled() ? |
|
920 |
R_MENU_SOFTKEYS_OPTIONS_BEXIT : |
|
921 |
R_MENU_SOFTKEYS_OPTIONS_BEXIT__SELECT ); |
|
922 |
} |
|
923 |
else |
|
924 |
{ |
|
925 |
Cba()->SetCommandSetL( AknLayoutUtils::PenEnabled() ? |
|
926 |
R_AVKON_SOFTKEYS_OPTIONS_BACK : |
|
927 |
R_AVKON_SOFTKEYS_OPTIONS_BACK__SELECT ); |
|
928 |
} |
|
929 |
} |
|
930 |
} |
|
931 |
||
932 |
// --------------------------------------------------------------------------- |
|
933 |
// |
|
934 |
// --------------------------------------------------------------------------- |
|
935 |
// |
|
936 |
TKeyResponse CMmAppUi::HandleKeyPressedL( const TKeyEvent &aKeyEvent, |
|
937 |
TEventCode aType ) |
|
938 |
{ |
|
939 |
TKeyResponse resp = EKeyWasNotConsumed; |
|
940 |
||
941 |
// handling enter key - touch & non touch |
|
942 |
if ( ( aKeyEvent.iScanCode == EStdKeyEnter || |
|
943 |
aKeyEvent.iScanCode == EStdKeyNkpEnter || |
|
944 |
aKeyEvent.iScanCode == EStdKeyDevice3 ) && aType == EEventKeyDown ) |
|
945 |
{ |
|
946 |
if ( iCurrentContainer->IsHighlightVisible() ) |
|
947 |
{ |
|
948 |
DEBUG(("_Mm_:CMmAppUi::HandleKeyPressedL - enter")); |
|
949 |
ForwardEventToHNL( KKeyIdSelect ); |
|
950 |
resp = EKeyWasConsumed; |
|
951 |
} |
|
952 |
} |
|
953 |
||
954 |
//handling enter key - non touch / edit mode |
|
955 |
if ( ( aKeyEvent.iScanCode == EStdKeyEnter || |
|
956 |
aKeyEvent.iScanCode == EStdKeyDevice3 ) && |
|
957 |
aType == EEventKeyDown && |
|
958 |
IsEditMode() && !Layout_Meta_Data::IsPenEnabled() ) |
|
959 |
{ |
|
960 |
DEBUG(("_Mm_:CMmAppUi::HandleKeyPressedL - enter in edit mode")); |
|
961 |
HandleCommandL( EAknSoftkeyOk ); |
|
962 |
resp = EKeyWasConsumed; |
|
963 |
} |
|
964 |
||
965 |
// handle the key exactly as container does (the same conditions) |
|
966 |
if ( ( aKeyEvent.iRepeats > 0 && aType == EEventKey ) || |
|
967 |
( aKeyEvent.iRepeats == 0 && aType == EEventKeyUp ) ) |
|
968 |
{ |
|
969 |
TBool navigationEvent = |
|
970 |
aKeyEvent.iScanCode == EStdKeyRightArrow || |
|
971 |
aKeyEvent.iScanCode == EStdKeyLeftArrow || |
|
972 |
aKeyEvent.iScanCode == EStdKeyUpArrow || |
|
973 |
aKeyEvent.iScanCode == EStdKeyDownArrow; |
|
974 |
||
975 |
if ( navigationEvent ) |
|
976 |
{ |
|
977 |
DEBUG(("_Mm_:CMmAppUi::HandleKeyPressedL - navi event: %d", |
|
978 |
aKeyEvent.iScanCode)); |
|
979 |
MMPERF(("Rocker navigation - START")); |
|
980 |
UpdateToolbarL(); |
|
981 |
SetMiddleSoftKeyL(); |
|
982 |
resp = EKeyWasConsumed; |
|
983 |
MMPERF(("Rocker navigation - END")); |
|
984 |
} |
|
985 |
else if ( aKeyEvent.iScanCode == EStdKeyBackspace ) |
|
986 |
{ |
|
987 |
// handle clear key event |
|
988 |
DEBUG(("_Mm_:CMmAppUi::HandleKeyPressedL - clear key")); |
|
989 |
ForwardEventToHNL( KKeyIdClear ); |
|
990 |
resp = EKeyWasConsumed; |
|
991 |
} |
|
992 |
} |
|
993 |
||
994 |
if( aType == EEventUser ) |
|
995 |
{ |
|
996 |
if ( aKeyEvent.iScanCode == EStdKeyNull && |
|
997 |
iCurrentContainer->IsHighlightVisible() ) |
|
998 |
{ |
|
999 |
DEBUG(("_Mm_:CMmAppUi::HandleKeyPressedL - User press -> forward key:select to HN")); |
|
1000 |
UpdateToolbarL(); |
|
1001 |
SetMiddleSoftKeyL(); |
|
1002 |
ForwardEventToHNL( KKeyIdSelect ); |
|
1003 |
resp = EKeyWasConsumed; |
|
1004 |
} |
|
1005 |
} |
|
1006 |
||
1007 |
return resp; |
|
1008 |
} |
|
1009 |
||
1010 |
// ----------------------------------------------------------------------------- |
|
1011 |
// |
|
1012 |
// |
|
1013 |
// ----------------------------------------------------------------------------- |
|
1014 |
// |
|
1015 |
void CMmAppUi::HandleDragStartL( TInt aModelItemIndex ) |
|
1016 |
{ |
|
1017 |
MMPERF(("CMmAppUi::HandleDragStartL - START")); |
|
1018 |
||
1019 |
if ( IsEditMode() ) |
|
1020 |
{ |
|
1021 |
TInt modelId = iCurrentSuiteModel->IdByIndex( aModelItemIndex ); |
|
1022 |
if (modelId != KErrNotFound) |
|
1023 |
{ |
|
1024 |
CHnItemModel *itModel = iCurrentSuiteModel->GetItemModel( modelId ); |
|
1025 |
if (itModel->GetItemType() == EItemTypeParentFolder) |
|
1026 |
{ |
|
1027 |
iCurrentContainer->CancelDragL( EFalse ); |
|
1028 |
} |
|
1029 |
else |
|
1030 |
{ |
|
1031 |
iItemDragged = aModelItemIndex; |
|
1032 |
iIdDragged = iCurrentSuiteModel->IdByIndex( aModelItemIndex ); |
|
1033 |
} |
|
1034 |
} |
|
1035 |
} |
|
1036 |
MMPERF(("CMmAppUi::HandleDragStartL - STOP")); |
|
1037 |
} |
|
1038 |
||
1039 |
// ----------------------------------------------------------------------------- |
|
1040 |
// |
|
1041 |
// |
|
1042 |
// ----------------------------------------------------------------------------- |
|
1043 |
// |
|
1044 |
void CMmAppUi::HandleDragOverL( TInt /* aModelItemIndex */ ) |
|
1045 |
{ |
|
1046 |
MMPERF(("CMmAppUi::HandleDragOverL - START")); |
|
1047 |
||
1048 |
MMPERF(("CMmAppUi::HandleDragOverL - STOP")); |
|
1049 |
} |
|
1050 |
||
1051 |
// ----------------------------------------------------------------------------- |
|
1052 |
// |
|
1053 |
// ----------------------------------------------------------------------------- |
|
1054 |
// |
|
1055 |
void CMmAppUi::HandleDraggedIndexUpdatedL( TInt aModelItemIndex ) |
|
1056 |
{ |
|
1057 |
MMPERF(("CMmAppUi::HandleDraggedIndexUpdatedL - START")); |
|
1058 |
iItemDragged = aModelItemIndex; |
|
1059 |
MMPERF(("CMmAppUi::HandleDraggedIndexUpdatedL - STOP")); |
|
1060 |
} |
|
1061 |
||
1062 |
// ----------------------------------------------------------------------------- |
|
1063 |
// |
|
1064 |
// ----------------------------------------------------------------------------- |
|
1065 |
// |
|
1066 |
void CMmAppUi::HandleDragStopL( TInt aModelItemIndex ) |
|
1067 |
{ |
|
1068 |
MMPERF(("CMmAppUi::HandleDragStopL - START")); |
|
1069 |
if( IsEditMode() ) |
|
1070 |
{ |
|
1071 |
TInt itemId = iCurrentSuiteModel->IdByIndex( aModelItemIndex ); |
|
1072 |
TMcsItemType typeCurr = |
|
1073 |
iCurrentSuiteModel->GetItemType( aModelItemIndex ); |
|
1074 |
TBool isOverFolder = ( AknLayoutUtils::PenEnabled() && |
|
1075 |
( typeCurr == EItemTypeParentFolder || typeCurr == EItemTypeFolder ) ); |
|
1076 |
TBool isDeleteLocked = (itemId != KErrNotFound) |
|
1077 |
? iCurrentSuiteModel->GetItemModel( itemId )->IsDeleteLocked() |
|
1078 |
: EFalse; |
|
1079 |
||
1080 |
TBuf8<KMaxLength> beforeCustomId; |
|
1081 |
beforeCustomId.Num( KErrNotFound ); |
|
1082 |
if( aModelItemIndex + 1 < iCurrentContainer->NumberOfItems() ) |
|
1083 |
{ |
|
1084 |
beforeCustomId.Num( iCurrentSuiteModel->GetItemModel( |
|
1085 |
iCurrentSuiteModel->IdByIndex( aModelItemIndex + 1 ) )->CustomId() ); |
|
1086 |
} |
|
1087 |
||
1088 |
TBuf8<KMaxLength> draggedCustomId; |
|
1089 |
draggedCustomId.Num( KErrNotFound ); |
|
1090 |
CHnItemModel* draggedModel = iCurrentSuiteModel->GetItemModel( iIdDragged ); |
|
1091 |
if( draggedModel ) |
|
1092 |
{ |
|
1093 |
draggedCustomId.Num( iCurrentSuiteModel->GetItemModel( iIdDragged )->CustomId() ); |
|
1094 |
} |
|
1095 |
||
1096 |
CLiwGenericParamList* eventParameters = CLiwGenericParamList::NewL(); |
|
1097 |
CleanupStack::PushL( eventParameters ); |
|
1098 |
CHnMdBaseKey* tempKeys = HnMdKeyFactory::CreateL( |
|
1099 |
HnEvent::KEventArgNamespace8(), KKeyTypeMap(), KNullDesC8() ); |
|
1100 |
CleanupStack::PushL( tempKeys ); |
|
1101 |
||
1102 |
CHnMdBaseKey* baseKey = HnMdKeyFactory::CreateL( |
|
1103 |
HnEvent::KEventArgNamespace8(), KKeyTypeMap(), KNullDesC8() ); |
|
1104 |
CleanupStack::PushL( baseKey ); |
|
1105 |
baseKey->AddSubKeyL( HnMdKeyFactory::CreateL( HnEvent::KDroppedBefore8(), |
|
1106 |
KKeyTypeInteger(), beforeCustomId ) ); |
|
1107 |
baseKey->AddSubKeyL( HnMdKeyFactory::CreateL( HnEvent::KDragged8(), |
|
1108 |
KKeyTypeInteger(), draggedCustomId ) ); |
|
1109 |
CleanupStack::Pop( baseKey ); |
|
1110 |
tempKeys->AddSubKeyL( baseKey ); |
|
1111 |
||
1112 |
tempKeys->ToGenericParamListL( *eventParameters ); |
|
1113 |
CleanupStack::PopAndDestroy( tempKeys ); |
|
1114 |
||
1115 |
TBool allowMoveInto = iCurrentContainer->AllowMove(); |
|
1116 |
||
1117 |
if( iIdDragged != itemId && isOverFolder && !isDeleteLocked |
|
1118 |
&& allowMoveInto ) |
|
1119 |
{ |
|
1120 |
iCurrentSuiteModel->RemoveItemL( iIdDragged ); |
|
1121 |
if( iItemDragged < aModelItemIndex ) |
|
1122 |
{ |
|
1123 |
// indices of all items after iItemDragged have been |
|
1124 |
// decreased when the dragged item got removed from the |
|
1125 |
// current suite; prevent highlighted item change |
|
1126 |
iCurrentSuiteModel->SetSuiteHighlightL( aModelItemIndex - 1 ); |
|
1127 |
iCurrentContainer->SetManualHighlightL( |
|
1128 |
iCurrentContainer->GetHighlight() - 1, EFalse ); |
|
1129 |
} |
|
1130 |
||
1131 |
iCurrentContainer->HandleItemRemovalL(); |
|
1132 |
iCurrentContainer->CancelDragL( EFalse ); |
|
1133 |
||
1134 |
iHNInterface->TriggerHnEventL( KKeyIdMoveInto, itemId, eventParameters ); |
|
1135 |
iMakeHightlightedItemFullyVisible = ETrue; |
|
1136 |
} |
|
1137 |
else if( iIdDragged == itemId ) |
|
1138 |
{ |
|
1139 |
iCurrentContainer->CancelDragL( ETrue ); |
|
1140 |
iCurrentContainer->SetTriggerMoveItemL( itemId, eventParameters ); |
|
1141 |
// fix for: edit->move, then LSK->Up->LSK->LSK FAST... (short options show up) |
|
1142 |
if( !AknLayoutUtils::PenEnabled() ) |
|
1143 |
{ |
|
1144 |
CLiwGenericParamList* paramList = CLiwGenericParamList::NewLC(); |
|
1145 |
TLiwGenericParam command(KHnRequest, TLiwVariant( KEvaluateMdModel)); |
|
1146 |
paramList->AppendL( command ); |
|
1147 |
HandleRequestL( *paramList ); |
|
1148 |
CleanupStack::PopAndDestroy( paramList ); |
|
1149 |
} |
|
1150 |
} |
|
1151 |
else |
|
1152 |
{ |
|
1153 |
iCurrentContainer->CancelDragL( ETrue ); |
|
1154 |
if( !AknLayoutUtils::PenEnabled() ) |
|
1155 |
{ |
|
1156 |
CLiwGenericParamList* paramList = CLiwGenericParamList::NewLC(); |
|
1157 |
TLiwGenericParam command(KHnRequest, TLiwVariant( KEvaluateMdModel)); |
|
1158 |
paramList->AppendL( command ); |
|
1159 |
HandleRequestL( *paramList ); |
|
1160 |
CleanupStack::PopAndDestroy( paramList ); |
|
1161 |
} |
|
1162 |
} |
|
1163 |
||
1164 |
CleanupStack::PopAndDestroy( eventParameters ); |
|
1165 |
} |
|
1166 |
MMPERF(("CMmAppUi::HandleDragStopL - STOP")); |
|
1167 |
} |
|
1168 |
||
1169 |
// --------------------------------------------------------------------------- |
|
1170 |
// |
|
1171 |
// --------------------------------------------------------------------------- |
|
1172 |
// |
|
1173 |
void CMmAppUi::HandleEventDraggingActionedL() |
|
1174 |
{ |
|
1175 |
SetMiddleSoftKeyL(); |
|
1176 |
UpdateToolbarL(); |
|
1177 |
iKeyClickLocked = ETrue; |
|
1178 |
} |
|
1179 |
// --------------------------------------------------------------------------- |
|
1180 |
// |
|
1181 |
// --------------------------------------------------------------------------- |
|
1182 |
// |
|
1183 |
void CMmAppUi::HandleListBoxEventL( CEikListBox* /*aListBox*/, |
|
1184 |
MEikListBoxObserver::TListBoxEvent aEventType ) |
|
1185 |
{ |
|
1186 |
DEBUG(("_Mm_:CMmAppUi::HandleListBoxEventL IN")); |
|
1187 |
DEBUG(("\t_Mm_: aEventType = %d", (TInt) aEventType ) ); |
|
1188 |
||
1189 |
TInt currentHighlight = iCurrentContainer->GetHighlight(); |
|
1190 |
||
1191 |
DEBUG(("\t_Mm_: CurrentHighlight = %d", currentHighlight ) ); |
|
1192 |
||
1193 |
if ( aEventType == MEikListBoxObserver::EEventItemDraggingActioned ) |
|
1194 |
{ |
|
1195 |
DEBUG8(("\t_Mm_:CMmAppUi::HandleListBoxEventL EEventItemDraggingActioned")); |
|
1196 |
HandleEventDraggingActionedL(); |
|
1197 |
} |
|
1198 |
else if ( aEventType == MEikListBoxObserver::EEventPenDownOnItem ) |
|
1199 |
{ |
|
1200 |
DEBUG(("\t_Mm_:CMmAppUi::HandleListBoxEventL EEventItemClicked")); |
|
1201 |
HandleHighlightItemPenDownL( iCurrentContainer->GetHighlight() ); |
|
1202 |
} |
|
1203 |
else if ( aEventType == MEikListBoxObserver::EEventItemDoubleClicked ) |
|
1204 |
{ |
|
1205 |
DEBUG(("\t_Mm_:CMmAppUi::HandleListBoxEventL EEventItemDoubleClicked")); |
|
1206 |
HandleHighlightItemDoubleClickedL( iCurrentContainer->GetHighlight() ); |
|
1207 |
} |
|
1208 |
else if ( aEventType == MEikListBoxObserver::EEventItemSingleClicked ) |
|
1209 |
{ |
|
1210 |
DEBUG(("\t_Mm_:CMmAppUi::HandleListBoxEventL EEventItemSingleClicked")); |
|
1211 |
HandleHighlightItemSingleClickedL( iCurrentContainer->Widget()->CurrentItemIndex() ); |
|
1212 |
} |
|
1213 |
else if ( aEventType == MEikListBoxObserver::EEventPanningStarted ) |
|
1214 |
{ |
|
1215 |
iKeyClickLocked = ETrue; |
|
1216 |
} |
|
1217 |
||
1218 |
DEBUG(("_Mm_:CMmAppUi::HandleListBoxEventL OUT")); |
|
1219 |
} |
|
1220 |
||
1221 |
// --------------------------------------------------------------------------- |
|
1222 |
// |
|
1223 |
// --------------------------------------------------------------------------- |
|
1224 |
// |
|
1225 |
void CMmAppUi::HandleLongTapEventL( const TPoint& aPenEventLocation ) |
|
1226 |
{ |
|
1227 |
TBool popupMenuDisplayed(EFalse); |
|
1228 |
if (iPopupMenu) |
|
1229 |
{ |
|
1230 |
delete iPopupMenu; |
|
1231 |
iPopupMenu = NULL; |
|
1232 |
} |
|
1233 |
iPopupMenu = CAknStylusPopUpMenu::NewL(this,aPenEventLocation); |
|
1234 |
||
1235 |
if ( AknLayoutUtils::LayoutMirrored() ) |
|
1236 |
{ |
|
1237 |
iPopupMenu->SetPosition( aPenEventLocation, |
|
1238 |
CAknStylusPopUpMenu::EPositionTypeRightBottom ); |
|
1239 |
} |
|
1240 |
else |
|
1241 |
{ |
|
1242 |
iPopupMenu->SetPosition( aPenEventLocation, |
|
1243 |
CAknStylusPopUpMenu::EPositionTypeLeftBottom ); |
|
1244 |
} |
|
1245 |
||
1246 |
if( iCurrentSuiteModel == iHNInterface->GetLastSuiteModelL() |
|
1247 |
&& iCurrentContainer->IsHighlightVisible() |
|
1248 |
&& iCurrentContainer->GetSuiteModelL()->GetItemModelsCount() > 1 ) |
|
1249 |
{ |
|
1250 |
MMPERF(("CMmAppUi::DynInitMenuPaneL - START")); |
|
1251 |
//fill the main menu structure, look for cascade menus |
|
1252 |
//reset the helper hash map |
|
1253 |
iCascadeMenuMap.Close(); |
|
1254 |
||
1255 |
MHnMenuItemModelIterator* menuIterator = |
|
1256 |
iCurrentSuiteModel->GetMenuStructureL( |
|
1257 |
iCurrentSuiteModel->IdByIndex( |
|
1258 |
iCurrentContainer->GetHighlight() ) ); |
|
1259 |
||
1260 |
// check if there is a menu structure available |
|
1261 |
// for the specified item |
|
1262 |
if ( menuIterator ) |
|
1263 |
{ |
|
1264 |
//create item sorting helper objects |
|
1265 |
RArray<TInt> positionArray; |
|
1266 |
CleanupClosePushL( positionArray ); |
|
1267 |
RHashMap<TInt, CEikMenuPaneItem::SData> menuItemMap; |
|
1268 |
CleanupClosePushL( menuItemMap ); |
|
1269 |
||
1270 |
while ( menuIterator->HasNextSpecific() ) |
|
1271 |
{ |
|
1272 |
CHnMenuItemModel* childItem = menuIterator->GetNextSpecific(); |
|
1273 |
CEikMenuPaneItem::SData childData; |
|
1274 |
childData.iCommandId = childItem->Command(); |
|
1275 |
childData.iText = childItem->NameL(). |
|
1276 |
Left( CEikMenuPaneItem::SData::ENominalTextLength ); |
|
1277 |
childData.iFlags = 0; |
|
1278 |
childData.iCascadeId = 0; |
|
1279 |
||
1280 |
positionArray.AppendL( childItem->Position() ); |
|
1281 |
menuItemMap.InsertL( childItem->Position(), childData ); |
|
1282 |
} |
|
1283 |
||
1284 |
positionArray.Sort(); |
|
1285 |
||
1286 |
//add items in correct order |
|
1287 |
for ( TInt i = 0; i < positionArray.Count(); ++i ) |
|
1288 |
{ |
|
1289 |
iPopupMenu->AddMenuItemL( |
|
1290 |
menuItemMap.FindL( positionArray[i] ).iText, |
|
1291 |
menuItemMap.FindL( positionArray[i] ).iCommandId ); |
|
1292 |
} |
|
1293 |
||
1294 |
if (positionArray.Count()>0) |
|
1295 |
{ |
|
1296 |
iPopupMenu->ShowMenu(); |
|
1297 |
popupMenuDisplayed = ETrue; |
|
1298 |
} |
|
1299 |
CleanupStack::PopAndDestroy( &menuItemMap ); |
|
1300 |
CleanupStack::PopAndDestroy( &positionArray ); |
|
1301 |
} |
|
1302 |
MMPERF(("CMmAppUi::DynInitMenuPaneL - STOP")); |
|
1303 |
} |
|
1304 |
||
1305 |
if ( !popupMenuDisplayed && iCurrentContainer ) |
|
1306 |
{ |
|
1307 |
iCurrentContainer->EndLongTapL( ETrue ); |
|
1308 |
HandleHighlightItemSingleClickedL( |
|
1309 |
iCurrentContainer->Widget()->CurrentItemIndex() ); |
|
1310 |
} |
|
1311 |
} |
|
1312 |
||
1313 |
// --------------------------------------------------------------------------- |
|
1314 |
// |
|
1315 |
// --------------------------------------------------------------------------- |
|
1316 |
// |
|
1317 |
void CMmAppUi::HandleHighlightItemDoubleClickedL( TInt aIndex ) |
|
1318 |
{ |
|
1319 |
if ( iKeyClickLocked ) |
|
1320 |
return; |
|
1321 |
||
1322 |
if ( iCurrentSuiteModel->WidgetType() == EListWidget |
|
1323 |
&& iCurrentContainer->GetPreviousHighlight() == aIndex ) |
|
1324 |
{ |
|
1325 |
ForwardEventToHNL( KKeyIdSelect, aIndex ); |
|
1326 |
} |
|
1327 |
else if ( iCurrentSuiteModel->WidgetType() == EGridWidget |
|
1328 |
&& IsEditMode() && iCurrentContainer->GetPreviousHighlight() == aIndex |
|
1329 |
&& !iCurrentContainer->IsDraggable()) |
|
1330 |
{ |
|
1331 |
ForwardEventToHNL( KKeyIdSelect, aIndex ); |
|
1332 |
} |
|
1333 |
} |
|
1334 |
||
1335 |
// --------------------------------------------------------------------------- |
|
1336 |
// |
|
1337 |
// --------------------------------------------------------------------------- |
|
1338 |
// |
|
1339 |
void CMmAppUi::HandleHighlightItemPenDownL( TInt /* aIndex */ ) |
|
1340 |
{ |
|
1341 |
DEBUG(("CMmAppUi::HandleHighlightItemPenDownL - IN")); |
|
1342 |
UpdateToolbarL(); |
|
1343 |
SetMiddleSoftKeyL(); |
|
1344 |
iKeyClickLocked = EFalse; |
|
1345 |
DEBUG(("CMmAppUi::HandleHighlightItemPenDownL - OUT")); |
|
1346 |
} |
|
1347 |
||
1348 |
// --------------------------------------------------------------------------- |
|
1349 |
// |
|
1350 |
// --------------------------------------------------------------------------- |
|
1351 |
// |
|
1352 |
void CMmAppUi::HandleHighlightItemSingleClickedL( TInt aIndex ) |
|
1353 |
{ |
|
1354 |
if ( !iKeyClickLocked && !IsFaded() ) |
|
1355 |
{ |
|
1356 |
ForwardEventToHNL( KKeyIdSelect, aIndex ); |
|
1357 |
} |
|
1358 |
} |
|
1359 |
||
1360 |
// --------------------------------------------------------------------------- |
|
1361 |
// |
|
1362 |
// --------------------------------------------------------------------------- |
|
1363 |
// |
|
1364 |
void CMmAppUi::ResetContainerMap() |
|
1365 |
{ |
|
1366 |
THashMapIter< TInt, CMmWidgetContainer* > iterator( iContainerMap ); |
|
1367 |
while( iterator.NextKey() ) |
|
1368 |
{ |
|
1369 |
CMmWidgetContainer** container = iterator.CurrentValue(); |
|
1370 |
delete *container; |
|
1371 |
iterator.RemoveCurrent(); |
|
1372 |
} |
|
1373 |
iContainerMap.Close(); |
|
1374 |
} |
|
1375 |
||
1376 |
// --------------------------------------------------------------------------- |
|
1377 |
// |
|
1378 |
// --------------------------------------------------------------------------- |
|
1379 |
// |
|
1380 |
void CMmAppUi::ResetContainerMapToRootL() |
|
1381 |
{ |
|
1382 |
TInt err( KErrNone ); |
|
1383 |
CHnSuiteModel* currentSuite = iHNInterface->GetLastSuiteModelL(); |
|
1384 |
||
1385 |
// there is a loaded suite configuration |
|
1386 |
if( currentSuite ) |
|
1387 |
{ |
|
1388 |
TInt id( currentSuite->GetItemsOrder()->GetSuiteId() ); |
|
1389 |
TRAP( err, iCurrentContainer = iContainerMap.FindL( id ) ); |
|
1390 |
||
1391 |
// configuration loaded but there is no container |
|
1392 |
if( err != KErrNone ) |
|
1393 |
{ |
|
1394 |
HandleSuiteModelInitializedL( currentSuite ); |
|
1395 |
} |
|
1396 |
else if( iContainerMap.Count() > 0 ) |
|
1397 |
{ |
|
1398 |
THashMapIter< TInt, CMmWidgetContainer* > iterator( iContainerMap ); |
|
1399 |
while( iterator.NextKey() ) |
|
1400 |
{ |
|
1401 |
CMmWidgetContainer** container = iterator.CurrentValue(); |
|
1402 |
if( iCurrentContainer != *container ) |
|
1403 |
{ |
|
1404 |
RemoveFromStack( *container ); |
|
1405 |
iGarbage.AppendL( *container ); |
|
1406 |
iterator.RemoveCurrent(); |
|
1407 |
} |
|
1408 |
} |
|
1409 |
} |
|
1410 |
} |
|
1411 |
else |
|
1412 |
{ |
|
1413 |
ResetContainerMap(); |
|
1414 |
InitializeL(); |
|
1415 |
} |
|
1416 |
} |
|
1417 |
||
1418 |
// --------------------------------------------------------------------------- |
|
1419 |
// |
|
1420 |
// --------------------------------------------------------------------------- |
|
1421 |
// |
|
1422 |
void CMmAppUi::HandleMessageL( const TDesC8& aMessage ) |
|
1423 |
{ |
|
1424 |
if( iMmExtManager ) |
|
1425 |
{ |
|
1426 |
iMmExtManager->ExecuteActionL(TUid::Null(), KCommandDeleteDialog, NULL ); |
|
1427 |
} |
|
1428 |
if ( IsEditMode() ) |
|
1429 |
{ |
|
1430 |
SetEditModeL( EFalse ); |
|
1431 |
} |
|
1432 |
if ( aMessage.Find( KRootWithPref ) != KErrNotFound ) |
|
1433 |
{ |
|
1434 |
RemoveFromStack( iCurrentContainer ); |
|
1435 |
iDummyContainer->MakeVisible( ETrue ); |
|
1436 |
RefreshCbaL(); |
|
1437 |
iGarbage.ResetAndDestroy(); |
|
1438 |
ResetContainerMap(); |
|
1439 |
iCurrentSuiteModel = NULL; |
|
1440 |
iCurrentContainer = NULL; |
|
1441 |
} |
|
1442 |
||
1443 |
TRAPD( err, iHNInterface->LoadSuitesFromUriL( aMessage ) ); |
|
1444 |
||
1445 |
if ( err && iCurrentContainer && ( aMessage.Find( KSetFocusWithPref ) == KErrNotFound ) ) |
|
1446 |
{ |
|
1447 |
HandleSuiteEventL( ESuiteModelInitialized, iHNInterface->GetLastSuiteModelL() ); |
|
1448 |
} |
|
1449 |
} |
|
1450 |
||
1451 |
// --------------------------------------------------------------------------- |
|
1452 |
// |
|
1453 |
// --------------------------------------------------------------------------- |
|
1454 |
// |
|
1455 |
void CMmAppUi::DynInitMenuPaneL( TInt aResourceId, |
|
1456 |
CEikMenuPane* aMenuPane ) |
|
1457 |
{ |
|
1458 |
aMenuPane->EnableMarqueeL( ETrue ); |
|
1459 |
if( iCurrentSuiteModel == iHNInterface->GetLastSuiteModelL() ) |
|
1460 |
{ |
|
1461 |
switch ( aResourceId ) |
|
1462 |
{ |
|
1463 |
case R_MAIN_MENU_PANE: |
|
1464 |
{ |
|
1465 |
MMPERF(("CMmAppUi::DynInitMenuPaneL - START")); |
|
1466 |
//fill the main menu structure, look for cascade menus |
|
1467 |
//reset the helper hash map |
|
1468 |
iCascadeMenuMap.Close(); |
|
1469 |
||
1470 |
MHnMenuItemModelIterator* menuIterator = NULL; |
|
1471 |
TBool ignoreItemSpecific( EFalse ); |
|
1472 |
if ( iCurrentSuiteModel ) |
|
1473 |
{ |
|
1474 |
TInt itemId( KErrNotFound ); |
|
1475 |
TBool suiteModelHasItems = iCurrentContainer->GetSuiteModelL()->GetItemModelsCount() > 1; |
|
1476 |
TBool highlightVisible = iCurrentContainer->IsHighlightVisible(); |
|
1477 |
if ( !highlightVisible && suiteModelHasItems ) |
|
1478 |
{ |
|
1479 |
// if there is no highlight, but there are items, show menuitems for logically |
|
1480 |
// current suite highlight fetched from suite model. |
|
1481 |
TInt suiteHighlight = iCurrentSuiteModel->GetSuiteHighlight(); |
|
1482 |
ASSERT( suiteHighlight != KErrNotFound ); |
|
1483 |
itemId = iCurrentSuiteModel->IdByIndex( suiteHighlight ); |
|
1484 |
ignoreItemSpecific = ETrue; |
|
1485 |
} |
|
1486 |
else |
|
1487 |
{ |
|
1488 |
TBool idByContainer = highlightVisible && suiteModelHasItems; |
|
1489 |
itemId = idByContainer |
|
1490 |
? iCurrentSuiteModel->IdByIndex( iCurrentContainer->GetHighlight() ) |
|
1491 |
: iCurrentSuiteModel->IdByIndex( KErrNotFound ); |
|
1492 |
} |
|
1493 |
menuIterator = iCurrentSuiteModel->GetMenuStructureL( itemId ); |
|
1494 |
} |
|
1495 |
||
1496 |
// check if there is a menu structure available |
|
1497 |
// for the specified item |
|
1498 |
if ( menuIterator ) |
|
1499 |
{ |
|
1500 |
//create item sorting helper objects |
|
1501 |
RArray<TInt> positionArray; |
|
1502 |
CleanupClosePushL( positionArray ); |
|
1503 |
RHashMap<TInt, CEikMenuPaneItem::SData> menuItemMap; |
|
1504 |
CleanupClosePushL( menuItemMap ); |
|
1505 |
||
1506 |
//get original (rss defined) items positions |
|
1507 |
for ( TInt i = 0; i < aMenuPane->NumberOfItemsInPane(); ++i ) |
|
1508 |
{ |
|
1509 |
//multiply to make space for suite defined entries |
|
1510 |
//first item has 100th conceptual position |
|
1511 |
positionArray.AppendL( ( i + 1 ) * KMenuPosMultiplier ); |
|
1512 |
//store items, position as the key |
|
1513 |
menuItemMap.InsertL( ( i + 1 ) * KMenuPosMultiplier, |
|
1514 |
aMenuPane-> |
|
1515 |
ItemData( aMenuPane->MenuItemCommandId( i ) ) ); |
|
1516 |
} |
|
1517 |
||
1518 |
||
1519 |
//get custom menu items and their positions |
|
1520 |
while ( menuIterator->HasNext() ) |
|
1521 |
{ |
|
1522 |
CHnMenuItemModel* menuItem = menuIterator->GetNext(); |
|
1523 |
if ( (menuItem->MenuItemType() == CHnMenuItemModel::EItemApplication) || !ignoreItemSpecific ) |
|
1524 |
{ |
|
1525 |
CEikMenuPaneItem::SData menuData; |
|
1526 |
menuData.iCommandId = menuItem->Command(); |
|
1527 |
menuData.iText = menuItem->NameL(). |
|
1528 |
Left( CEikMenuPaneItem::SData::ENominalTextLength ); |
|
1529 |
menuData.iFlags = 0; |
|
1530 |
||
1531 |
//check for children |
|
1532 |
MHnMenuItemModelIterator* childIterator = |
|
1533 |
menuItem->GetMenuStructure(); |
|
1534 |
if ( childIterator->HasNext() ) |
|
1535 |
{ |
|
1536 |
//this is a cascade item |
|
1537 |
//one menu item can contain only one cascade menu |
|
1538 |
//check if there are available cascade menu containers |
|
1539 |
TInt freeResource = GetNextCascadeMenuResourceId(); |
|
1540 |
if ( freeResource != KErrNotFound ) |
|
1541 |
{ |
|
1542 |
//error checking |
|
1543 |
if( !iCascadeMenuMap.Insert( freeResource, |
|
1544 |
childIterator ) ) |
|
1545 |
{ |
|
1546 |
//add item only if there is an |
|
1547 |
//available resource |
|
1548 |
menuData.iCascadeId = freeResource; |
|
1549 |
} |
|
1550 |
} |
|
1551 |
} |
|
1552 |
else |
|
1553 |
{ |
|
1554 |
//normal entry |
|
1555 |
menuData.iCascadeId = 0; |
|
1556 |
} |
|
1557 |
positionArray.AppendL( menuItem->Position() ); |
|
1558 |
menuItemMap.InsertL( menuItem->Position(), menuData ); |
|
1559 |
} |
|
1560 |
} |
|
1561 |
||
1562 |
aMenuPane->Reset(); |
|
1563 |
positionArray.Sort(); |
|
1564 |
||
1565 |
//add items in correct order |
|
1566 |
for ( TInt i = 0; i < positionArray.Count(); ++i ) |
|
1567 |
{ |
|
1568 |
aMenuPane-> |
|
1569 |
AddMenuItemL( |
|
1570 |
( menuItemMap.FindL( positionArray[i] ) ) ); |
|
1571 |
} |
|
1572 |
||
1573 |
CleanupStack::PopAndDestroy( &menuItemMap ); |
|
1574 |
CleanupStack::PopAndDestroy( &positionArray ); |
|
1575 |
} |
|
1576 |
MMPERF(("CMmAppUi::DynInitMenuPaneL - STOP")); |
|
1577 |
} |
|
1578 |
break; |
|
1579 |
||
1580 |
case R_CASCADE_MENU_PANE_1: |
|
1581 |
case R_CASCADE_MENU_PANE_2: |
|
1582 |
case R_CASCADE_MENU_PANE_3: |
|
1583 |
{ |
|
1584 |
//realod cascade menu map |
|
1585 |
ReloadCascadeMenuMapL(); |
|
1586 |
//fill the cascade menu panes |
|
1587 |
MHnMenuItemModelIterator* childIteratorPtr = |
|
1588 |
iCascadeMenuMap.FindL( aResourceId ); |
|
1589 |
||
1590 |
// check if child iterator available |
|
1591 |
if ( childIteratorPtr ) |
|
1592 |
{ |
|
1593 |
childIteratorPtr->Reset(); |
|
1594 |
||
1595 |
//create item sorting helper objects |
|
1596 |
RArray<TInt> positionArray; |
|
1597 |
CleanupClosePushL( positionArray ); |
|
1598 |
RHashMap<TInt, CEikMenuPaneItem::SData> menuItemMap; |
|
1599 |
CleanupClosePushL( menuItemMap ); |
|
1600 |
||
1601 |
while ( childIteratorPtr->HasNext() ) |
|
1602 |
{ |
|
1603 |
CHnMenuItemModel* childItem = childIteratorPtr->GetNext(); |
|
1604 |
||
1605 |
CEikMenuPaneItem::SData childData; |
|
1606 |
childData.iCommandId = childItem->Command(); |
|
1607 |
childData.iText = childItem->NameL(). |
|
1608 |
Left( CEikMenuPaneItem::SData::ENominalTextLength ); |
|
1609 |
childData.iFlags = 0; |
|
1610 |
childData.iCascadeId = 0; |
|
1611 |
||
1612 |
positionArray.AppendL( childItem->Position() ); |
|
1613 |
menuItemMap.InsertL( childItem->Position(), childData ); |
|
1614 |
} |
|
1615 |
||
1616 |
positionArray.Sort(); |
|
1617 |
//add items in correct order |
|
1618 |
for ( TInt i = 0; i < positionArray.Count(); ++i ) |
|
1619 |
{ |
|
1620 |
aMenuPane->AddMenuItemL( |
|
1621 |
( menuItemMap.FindL( positionArray[i] ) ) ); |
|
1622 |
} |
|
1623 |
||
1624 |
CleanupStack::PopAndDestroy( &menuItemMap ); |
|
1625 |
CleanupStack::PopAndDestroy( &positionArray ); |
|
1626 |
} |
|
1627 |
} |
|
1628 |
break; |
|
1629 |
||
1630 |
default: |
|
1631 |
break; |
|
1632 |
} |
|
1633 |
} |
|
1634 |
else if( aResourceId == R_MAIN_MENU_PANE ) |
|
1635 |
{ |
|
1636 |
aMenuPane->SetItemDimmed( EMmOptionsExit, ETrue ); |
|
1637 |
} |
|
1638 |
} |
|
1639 |
||
1640 |
// --------------------------------------------------------------------------- |
|
1641 |
// |
|
1642 |
// --------------------------------------------------------------------------- |
|
1643 |
// |
|
1644 |
void CMmAppUi::ReloadCascadeMenuMapL() |
|
1645 |
{ |
|
1646 |
iCascadeMenuMap.Close(); |
|
1647 |
MHnMenuItemModelIterator* menuIterator = NULL; |
|
1648 |
if ( iCurrentSuiteModel ) |
|
1649 |
{ |
|
1650 |
TBool idByContainer = iCurrentContainer->IsHighlightVisible() && |
|
1651 |
iCurrentContainer->GetSuiteModelL()->GetItemModelsCount() > 1; |
|
1652 |
TInt itemId = idByContainer ? |
|
1653 |
iCurrentSuiteModel->IdByIndex( iCurrentContainer->GetHighlight() ) : |
|
1654 |
iCurrentSuiteModel->IdByIndex( KErrNotFound ); |
|
1655 |
menuIterator = iCurrentSuiteModel->GetMenuStructureL( itemId ); |
|
1656 |
} |
|
1657 |
||
1658 |
if ( menuIterator ) |
|
1659 |
{ |
|
1660 |
while ( menuIterator->HasNext() ) |
|
1661 |
{ |
|
1662 |
CHnMenuItemModel* menuItem = menuIterator->GetNext(); |
|
1663 |
||
1664 |
MHnMenuItemModelIterator* childIterator = |
|
1665 |
menuItem->GetMenuStructure(); |
|
1666 |
if ( childIterator->HasNext() ) |
|
1667 |
{ |
|
1668 |
TInt freeResource = GetNextCascadeMenuResourceId(); |
|
1669 |
if ( freeResource != KErrNotFound ) |
|
1670 |
{ |
|
1671 |
iCascadeMenuMap.Insert( freeResource, childIterator ); |
|
1672 |
} |
|
1673 |
} |
|
1674 |
} |
|
1675 |
} |
|
1676 |
} |
|
1677 |
||
1678 |
// --------------------------------------------------------------------------- |
|
1679 |
// |
|
1680 |
// --------------------------------------------------------------------------- |
|
1681 |
// |
|
1682 |
TInt CMmAppUi::GetNextCascadeMenuResourceId() |
|
1683 |
{ |
|
1684 |
//if needed add additional placeholders in matrixmenu.rss |
|
1685 |
//next add additional cases in this method and the |
|
1686 |
//CMmAppUi::DynInitMenuPaneL |
|
1687 |
||
1688 |
TInt freeResource( KErrNotFound ); |
|
1689 |
switch ( iCascadeMenuMap.Count() ) |
|
1690 |
{ |
|
1691 |
case 0: |
|
1692 |
{ |
|
1693 |
freeResource = R_CASCADE_MENU_PANE_1; |
|
1694 |
} |
|
1695 |
break; |
|
1696 |
case 1: |
|
1697 |
{ |
|
1698 |
freeResource = R_CASCADE_MENU_PANE_2; |
|
1699 |
} |
|
1700 |
break; |
|
1701 |
case 2: |
|
1702 |
{ |
|
1703 |
freeResource = R_CASCADE_MENU_PANE_3; |
|
1704 |
} |
|
1705 |
break; |
|
1706 |
default: |
|
1707 |
break; |
|
1708 |
} |
|
1709 |
return freeResource; |
|
1710 |
} |
|
1711 |
||
1712 |
// --------------------------------------------------------------------------- |
|
1713 |
// |
|
1714 |
// --------------------------------------------------------------------------- |
|
1715 |
// |
|
1716 |
void CMmAppUi::HandleWidgetChangeRefreshL( |
|
1717 |
CMmWidgetContainer* aWidgetContainer ) |
|
1718 |
{ |
|
1719 |
DEBUG(("_Mm_:CMmAppUi::HandleWidgetChangeRefreshL IN")); |
|
1720 |
||
1721 |
CMmWidgetContainer* previousContainer = iCurrentContainer; |
|
1722 |
if (previousContainer) |
|
1723 |
{ |
|
1724 |
previousContainer->SetObserver(NULL); |
|
1725 |
RemoveFromStack(previousContainer); |
|
1726 |
} |
|
1727 |
||
1728 |
iCurrentContainer = aWidgetContainer; |
|
1729 |
iCurrentContainer->Widget()->View()->SetDisableRedraw(ETrue); |
|
1730 |
if( isHiddenFromFS ) |
|
1731 |
{ |
|
1732 |
iCurrentContainer->MakeVisible( EFalse ); |
|
1733 |
} |
|
1734 |
else |
|
1735 |
{ |
|
1736 |
iDummyContainer->MakeVisible( ETrue ); |
|
1737 |
} |
|
1738 |
||
1739 |
RefreshCbaL(); |
|
1740 |
iCurrentContainer->SetEditModeL( IsEditMode() ); |
|
1741 |
iCurrentContainer->SetSuiteModelL( iCurrentSuiteModel ); |
|
1742 |
iCurrentContainer->HandleResourceChange( KAknsMessageSkinChange ); |
|
1743 |
iCurrentContainer->HandleResourceChange( KUidValueCoeColorSchemeChangeEvent ); |
|
1744 |
iCurrentContainer->SetEmptyTextL( iCurrentSuiteModel->EmptyText() ); |
|
1745 |
iCurrentContainer->SetHasFocusL( iHasFocus ); |
|
1746 |
iCurrentContainer->SetIsFaded( IsFaded() ); |
|
1747 |
iCurrentContainer->SetObserver( this ); |
|
1748 |
||
1749 |
if ( previousContainer && previousContainer->WidgetType() != iCurrentContainer->WidgetType() |
|
1750 |
&& previousContainer->GetSuiteModelL() == iCurrentContainer->GetSuiteModelL() ) |
|
1751 |
{ |
|
1752 |
iCurrentSuiteModel->SetSuiteHighlightL( KErrNotFound ); |
|
1753 |
} |
|
1754 |
||
1755 |
AddToStackL( iCurrentContainer ); |
|
1756 |
if ( previousContainer ) |
|
1757 |
{ |
|
1758 |
previousContainer->MakeVisible( EFalse ); |
|
1759 |
} |
|
1760 |
||
1761 |
DEBUG(("_Mm_:CMmAppUi::HandleWidgetChangeRefreshL OUT")); |
|
1762 |
} |
|
1763 |
||
1764 |
// --------------------------------------------------------------------------- |
|
1765 |
// |
|
1766 |
// --------------------------------------------------------------------------- |
|
1767 |
// |
|
1768 |
void CMmAppUi::HandleNoWidgetChangeRefreshL() |
|
1769 |
{ |
|
1770 |
if ( iCurrentSuiteModel ) |
|
1771 |
{ |
|
1772 |
iCurrentContainer->Widget()->View()->SetDisableRedraw(ETrue); |
|
1773 |
iCurrentContainer->SetEditModeL( IsEditMode() ); |
|
1774 |
iCurrentContainer->SetSuiteModelL( iCurrentSuiteModel ); |
|
1775 |
iCurrentContainer->SetEmptyTextL( iCurrentSuiteModel->EmptyText() ); |
|
1776 |
iCurrentContainer->SetHasFocusL( iHasFocus ); |
|
1777 |
iCurrentContainer->SetIsFaded( IsFaded() ); |
|
1778 |
iCurrentContainer->SetObserver(this); |
|
1779 |
} |
|
1780 |
} |
|
1781 |
||
1782 |
// --------------------------------------------------------------------------- |
|
1783 |
// |
|
1784 |
// --------------------------------------------------------------------------- |
|
1785 |
// |
|
1786 |
TBool CMmAppUi::IsEditMode() |
|
1787 |
{ |
|
1788 |
return (iEditModeStatus == EEditMode |
|
1789 |
|| iEditModeStatus == ETransitionToEditMode); |
|
1790 |
} |
|
1791 |
// --------------------------------------------------------------------------- |
|
1792 |
// |
|
1793 |
// --------------------------------------------------------------------------- |
|
1794 |
// |
|
1795 |
void CMmAppUi::HandlePresentationChangeL( |
|
1796 |
CMmWidgetContainer* aWidgetContainer ) |
|
1797 |
{ |
|
1798 |
DEBUG(("_Mm_:CMmAppUi::HandlePresentationChangeL IN")); |
|
1799 |
||
1800 |
if ( iToolbar && iToolbar->IsShown() ) |
|
1801 |
{ |
|
1802 |
iToolbar->SetToolbarVisibility( EFalse ); |
|
1803 |
} |
|
1804 |
||
1805 |
TBool scrollView( EFalse ); |
|
1806 |
if( iCurrentContainer != aWidgetContainer ) |
|
1807 |
{ |
|
1808 |
// During open new folder cancel longTap. |
|
1809 |
if( iCurrentContainer && iCurrentContainer->IsEditMode() ) |
|
1810 |
iCurrentContainer->EnableLongTapAnimation( EFalse ); |
|
1811 |
||
1812 |
// We want a highlight to be visible while switching between |
|
1813 |
// grid and list views but no highlight should be visible |
|
1814 |
// after opening a folder. |
|
1815 |
TBool highlightVisibleBefore = |
|
1816 |
iCurrentContainer && |
|
1817 |
aWidgetContainer && |
|
1818 |
iCurrentContainer->IsHighlightVisible() && |
|
1819 |
iCurrentContainer->WidgetType() != aWidgetContainer->WidgetType(); |
|
88
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
1820 |
|
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
1821 |
if( iCurrentContainer && !highlightVisibleBefore ) |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
1822 |
{ |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
1823 |
iCurrentContainer->SetHighlightVisibilityL( EFalse ); |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
1824 |
} |
83 | 1825 |
|
1826 |
HandleWidgetChangeRefreshL( aWidgetContainer ); |
|
1827 |
||
1828 |
if ( highlightVisibleBefore ) |
|
1829 |
{ |
|
1830 |
iCurrentContainer->SetHighlightVisibilityL( ETrue ); |
|
1831 |
} |
|
1832 |
scrollView = ETrue; |
|
1833 |
} |
|
1834 |
else |
|
1835 |
{ |
|
1836 |
HandleNoWidgetChangeRefreshL(); |
|
1837 |
} |
|
1838 |
||
1839 |
if( iCurrentContainer ) |
|
1840 |
{ |
|
1841 |
iCurrentContainer->SetRect(ClientRect()); |
|
1842 |
iDummyContainer->SetRect(ClientRect()); |
|
1843 |
if( IsForeground() || IsFaded() ) |
|
1844 |
{ |
|
1845 |
// should be called before MakeVisible (and after SetRect or SetupLayout, |
|
1846 |
// so that default highlight is displayed correctly when zoomed) |
|
1847 |
ApplyHighlightFromModelL(); |
|
1848 |
||
1849 |
// There is defferences in code because behaviour in non-touch edit mode |
|
1850 |
// and non-touch edit mode is different. |
|
1851 |
if (!AknLayoutUtils::PenEnabled()) |
|
1852 |
{ |
|
1853 |
// While starting non-touch edit mode we have to scroll view in case when |
|
1854 |
// higlighted item is placed on top/bottow row of view and there |
|
1855 |
// are more rows over/under one to show all needed indicator arrows. |
|
1856 |
// DrawNow() method caused jumping both scrollbar and view to old positions. |
|
1857 |
iCurrentContainer->MakeVisible(ETrue); |
|
1858 |
iCurrentContainer->Widget()->View()->SetDisableRedraw(EFalse); |
|
1859 |
iCurrentContainer->SetEditModeL(IsEditMode()); |
|
1860 |
iDummyContainer->MakeVisible(EFalse); |
|
1861 |
} |
|
1862 |
else |
|
1863 |
{ |
|
1864 |
// For touch normal mode we have to redraw container in case |
|
1865 |
// we back "parent folder" which was edited in edit mode. |
|
1866 |
// Thanks to DrawNow() method we avoid drawing items's backdrop icons |
|
1867 |
// and switching between edit mode's and normal mode's views |
|
1868 |
iCurrentContainer->SetEditModeL(IsEditMode()); |
|
1869 |
iCurrentContainer->MakeVisible(ETrue); |
|
1870 |
||
1871 |
// cache widget position so that we can restore it after DrawNow(), which |
|
1872 |
// changes it for no apparent reason when using list view. |
|
1873 |
iCurrentContainer->CacheWidgetPosition(); |
|
1874 |
||
1875 |
// draw container before effects gets snapshot |
|
1876 |
iCurrentContainer->DrawNow(); |
|
1877 |
iCurrentContainer->Widget()->View()->SetDisableRedraw(EFalse); |
|
1878 |
iDummyContainer->MakeVisible(EFalse); |
|
1879 |
||
1880 |
// restore the correct widget position |
|
1881 |
iCurrentContainer->RestoreWidgetPosition(); |
|
1882 |
// force scroll view to highlighted item in case we've been backing back |
|
1883 |
// and change presentation mode (to list view) had been done. |
|
1884 |
if( scrollView && iCurrentContainer->WidgetType() == EListWidget |
|
1885 |
&& iCurrentSuiteModel->GetSuiteHighlight() > KErrNotFound |
|
1886 |
&& !iCurrentContainer->ItemIsFullyVisible( |
|
1887 |
iCurrentSuiteModel->GetSuiteHighlight() )) |
|
1888 |
{ |
|
1889 |
iCurrentContainer->ScrollToItemL( |
|
1890 |
iCurrentSuiteModel->GetSuiteHighlight() ); |
|
1891 |
} |
|
1892 |
} |
|
1893 |
||
1894 |
// refresh changed items only |
|
1895 |
iCurrentContainer->DrawView(); |
|
1896 |
RefreshUiPanesL(); |
|
1897 |
RefreshToolbarL(); |
|
1898 |
} |
|
1899 |
else |
|
1900 |
{ |
|
1901 |
iCurrentContainer->SetupWidgetLayoutL(); |
|
1902 |
iCurrentContainer->Widget()->View()->SetDisableRedraw( EFalse ); |
|
1903 |
ApplyHighlightFromModelL(); |
|
1904 |
} |
|
1905 |
} |
|
1906 |
||
1907 |
MMPERF(("CMmAppUi::HandlePresentationChangeL - model swapped")); |
|
1908 |
DEBUG(("_Mm_:CMmAppUi::HandlePresentationChangeL OUT")); |
|
1909 |
} |
|
1910 |
||
1911 |
// --------------------------------------------------------------------------- |
|
1912 |
// |
|
1913 |
// --------------------------------------------------------------------------- |
|
1914 |
// |
|
1915 |
void CMmAppUi::OfferToolbarEventL( TInt aCommand ) |
|
1916 |
{ |
|
1917 |
TInt itemId = iCurrentSuiteModel->IdByIndex( iCurrentContainer->GetHighlight() ); |
|
1918 |
CHnItemModel* itemModel = iCurrentSuiteModel->GetItemModel( itemId ); |
|
1919 |
ASSERT( itemModel ); |
|
1920 |
const CHnToolbarModel* toolbarModel = itemModel->GetToolbarModel(); |
|
1921 |
ASSERT( toolbarModel ); |
|
1922 |
const CHnButtonModel* buttonModel = toolbarModel->GetButton( aCommand ); |
|
1923 |
ASSERT( buttonModel ); |
|
1924 |
||
1925 |
ForwardEventToHNL( buttonModel->GetEventId() ); |
|
1926 |
} |
|
1927 |
// --------------------------------------------------------------------------- |
|
1928 |
// |
|
1929 |
// --------------------------------------------------------------------------- |
|
1930 |
// |
|
1931 |
TInt CMmAppUi::ExecuteExtensionActionL( const TUid aUid , const TDesC& aCommand, |
|
1932 |
CLiwGenericParamList* aEventParamList ) |
|
1933 |
{ |
|
1934 |
iCurrentContainer->SetExDialogOpened( ETrue ); |
|
1935 |
return iMmExtManager->ExecuteActionL( aUid, aCommand, aEventParamList); |
|
1936 |
} |
|
1937 |
// --------------------------------------------------------------------------- |
|
1938 |
// |
|
1939 |
// --------------------------------------------------------------------------- |
|
1940 |
// |
|
1941 |
void CMmAppUi::HandleToolbarVisibilityL() |
|
1942 |
{ |
|
1943 |
TBool suiteModelHasToolbar = |
|
1944 |
iCurrentSuiteModel && iCurrentSuiteModel->HasToolbar(); |
|
1945 |
||
1946 |
if ( suiteModelHasToolbar ) |
|
1947 |
{ |
|
1948 |
if ( iToolbar ) |
|
1949 |
{ |
|
1950 |
// could have gotten hidden during view change |
|
1951 |
iToolbar->SetToolbarVisibility( ETrue ); |
|
1952 |
} |
|
1953 |
else |
|
1954 |
{ |
|
1955 |
iToolbar = CAknToolbar::NewL( R_GLOBAL_TOOLBAR ); |
|
1956 |
iToolbar->SetToolbarObserver( this ); |
|
1957 |
iToolbar->SetToolbarVisibility( ETrue ); |
|
1958 |
||
1959 |
// substract the toolbar from display's visible area |
|
1960 |
TRect remainingArea( ClientRect() ); |
|
1961 |
if ( !Layout_Meta_Data::IsLandscapeOrientation() ) |
|
1962 |
remainingArea.Resize( 0, -iToolbar->Size().iHeight ); |
|
1963 |
iCurrentContainer->SetRect( remainingArea ); |
|
1964 |
} |
|
1965 |
} |
|
1966 |
else if ( !suiteModelHasToolbar && iToolbar ) |
|
1967 |
{ |
|
1968 |
iToolbar->SetToolbarVisibility( EFalse ); |
|
1969 |
delete iToolbar; |
|
1970 |
iToolbar = NULL; |
|
1971 |
iCurrentContainer->SetRect( ClientRect() ); |
|
1972 |
} |
|
1973 |
} |
|
1974 |
||
1975 |
// --------------------------------------------------------------------------- |
|
1976 |
// |
|
1977 |
// --------------------------------------------------------------------------- |
|
1978 |
// |
|
1979 |
void CMmAppUi::UpdateToolbarL() |
|
1980 |
{ |
|
1981 |
// drop toolbar handling if there should be none |
|
1982 |
if ( iToolbar && iCurrentSuiteModel->HasToolbar() ) |
|
1983 |
{ |
|
1984 |
iToolbar->RemoveItem( EMmToolbarControl1 ); |
|
1985 |
iToolbar->RemoveItem( EMmToolbarControl2 ); |
|
1986 |
iToolbar->RemoveItem( EMmToolbarControl3 ); |
|
1987 |
||
1988 |
TInt itemId = iCurrentSuiteModel->IdByIndex( iCurrentContainer->Widget()->CurrentItemIndex() ); |
|
1989 |
CHnItemModel* itemModel = iCurrentSuiteModel->GetItemModel( itemId ); |
|
1990 |
if ( !itemModel ) |
|
1991 |
{ |
|
1992 |
return; |
|
1993 |
} |
|
1994 |
const CHnToolbarModel* toolbarModel = itemModel->GetToolbarModel(); |
|
1995 |
||
1996 |
CAknButton* button( NULL ); |
|
1997 |
for ( TInt i = 0; i < KNumOfButtonsInToolbar; ++i ) |
|
1998 |
{ |
|
1999 |
const CHnButtonModel* buttonModel = toolbarModel->GetButton( i ); |
|
2000 |
// get button icon and help text from model |
|
2001 |
if ( buttonModel ) |
|
2002 |
{ |
|
2003 |
CGulIcon* originalIcon = buttonModel->GetIcon(); |
|
2004 |
CGulIcon* iconCopy( NULL ); |
|
2005 |
if ( originalIcon && originalIcon->Bitmap() ) |
|
2006 |
{ |
|
2007 |
// create a copy of the icon if exists, |
|
2008 |
// CAknButton takes ownership of the icon but we |
|
2009 |
// want to reuse it, |
|
2010 |
// also duplicate bitmaps for proper scaling |
|
2011 |
CFbsBitmap* bitmap = new (ELeave) CFbsBitmap; |
|
2012 |
CleanupStack::PushL( bitmap ); |
|
2013 |
bitmap->Duplicate( originalIcon->Bitmap()->Handle() ); |
|
2014 |
||
2015 |
CFbsBitmap* mask( NULL ); |
|
2016 |
if ( originalIcon->Mask() ) |
|
2017 |
{ |
|
2018 |
mask = new (ELeave) CFbsBitmap; |
|
2019 |
CleanupStack::PushL( mask ); |
|
2020 |
mask->Duplicate( originalIcon->Mask()->Handle() ); |
|
2021 |
} |
|
2022 |
||
2023 |
iconCopy = CGulIcon::NewL( bitmap, mask ); |
|
2024 |
if ( mask ) |
|
2025 |
{ |
|
2026 |
CleanupStack::Pop( mask ); |
|
2027 |
} |
|
2028 |
CleanupStack::Pop( bitmap ); |
|
2029 |
CleanupStack::PushL( iconCopy ); |
|
2030 |
} |
|
2031 |
button = CAknButton::NewL( iconCopy, |
|
2032 |
NULL, |
|
2033 |
NULL, |
|
2034 |
NULL, |
|
2035 |
KNullDesC, |
|
2036 |
buttonModel->GetButtonText(), |
|
2037 |
0, |
|
2038 |
0 ); |
|
2039 |
if ( iconCopy ) |
|
2040 |
{ |
|
2041 |
CleanupStack::Pop( iconCopy ); |
|
2042 |
} |
|
2043 |
CleanupStack::PushL( button ); |
|
2044 |
button->SetDimmed( buttonModel->GetDimmed() ); |
|
2045 |
} |
|
2046 |
else |
|
2047 |
{ |
|
2048 |
button = CAknButton::NewLC(); |
|
2049 |
} |
|
2050 |
iToolbar->AddItemL( button, |
|
2051 |
EAknCtButton, |
|
2052 |
EMmToolbarControl1 + i, |
|
2053 |
0 ); |
|
2054 |
CleanupStack::Pop( button ); |
|
2055 |
} |
|
2056 |
} |
|
2057 |
} |
|
2058 |
||
2059 |
// --------------------------------------------------------------------------- |
|
2060 |
// |
|
2061 |
// --------------------------------------------------------------------------- |
|
2062 |
// |
|
2063 |
void CMmAppUi::SetEditModeL( TBool aIsEditMode ) |
|
2064 |
{ |
|
2065 |
MMPERF(("CMmAppUi::SetEditModeL %d - START",aIsEditMode)); |
|
2066 |
if ( IsEditMode() != aIsEditMode && iCurrentSuiteModel ) |
|
2067 |
{ |
|
2068 |
||
2069 |
// stops moving items. This must be called when leaving non-touch edit mode to save |
|
2070 |
// the current visible order of the items. In non-touch it is called only once when completing editing |
|
2071 |
||
2072 |
iHNInterface->SetEditModeL(aIsEditMode); |
|
2073 |
iCurrentContainer->StopMovingL(); |
|
2074 |
||
2075 |
if ( aIsEditMode ) |
|
2076 |
{ |
|
2077 |
iEditModeStatus = ETransitionToEditMode; |
|
2078 |
} |
|
2079 |
else |
|
2080 |
{ |
|
2081 |
if ( iEditModeStatus == ETransitionToEditMode ) |
|
2082 |
{ |
|
2083 |
iEditModeStatus = EFastTransitionFromEditMode; |
|
2084 |
} |
|
2085 |
else |
|
2086 |
{ |
|
2087 |
iEditModeStatus = ETransitionFromEditMode; |
|
2088 |
} |
|
2089 |
} |
|
2090 |
||
2091 |
HandleHighlightOffsetL( aIsEditMode ? EOffsetNext : EOffsetPrevious ); |
|
2092 |
iCurrentSuiteModel->SetSuiteHighlightL( |
|
2093 |
AdjustEditModeHighlightL( iCurrentSuiteModel->GetSuiteHighlight() ) ); |
|
2094 |
||
2095 |
// update the container at the end when highlight is proper, |
|
2096 |
// this will ensure correct focus/unfocus action handling |
|
2097 |
iCurrentContainer->CacheWidgetPosition(); |
|
2098 |
iCurrentContainer->SetEditModeL( IsEditMode() ); |
|
2099 |
||
2100 |
if ( iCurrentContainer->IsHighlightVisible() ) |
|
2101 |
{ |
|
2102 |
iMakeHightlightedItemFullyVisible = ETrue; |
|
2103 |
} |
|
2104 |
||
2105 |
RefreshUiPanesL(); |
|
2106 |
||
2107 |
//disable redraw so that no redrawing events coming from window server cause redrawing until |
|
2108 |
//everything is ready to draw. Then iCurrentContainer->DrawNow in HandlePresentationChangeL is called |
|
2109 |
if (IsEditMode()) |
|
2110 |
{ |
|
2111 |
iCurrentContainer->Widget()->View()->SetDisableRedraw(ETrue); |
|
2112 |
} |
|
2113 |
} |
|
2114 |
||
2115 |
MMPERF(("CMmAppUi::SetEditModeL - STOP")); |
|
2116 |
} |
|
2117 |
||
2118 |
// --------------------------------------------------------------------------- |
|
2119 |
// |
|
2120 |
// --------------------------------------------------------------------------- |
|
2121 |
// |
|
2122 |
void CMmAppUi::HandleWsEventL( const TWsEvent& aEvent, |
|
2123 |
CCoeControl* aDestination ) |
|
2124 |
{ |
|
2125 |
DEBUG(("_Mm_:CMmAppUi::HandleWsEventL %d - IN", aEvent.Type())); |
|
2126 |
||
2127 |
if ( aEvent.Type() == KAknUidValueEndKeyCloseEvent ) |
|
2128 |
{ |
|
2129 |
// return when the red key was pressed |
|
2130 |
MMPERF(("End key pressed")); |
|
2131 |
DEBUG(("_Mm_:CMmAppUi::HandleWsEventL - End key")); |
|
2132 |
ExitMatrix( EExitToIdle ); |
|
2133 |
return; |
|
2134 |
} |
|
2135 |
||
2136 |
TEventCode type = static_cast< TEventCode >( aEvent.Type() ); |
|
2137 |
||
2138 |
if ( ( type == EEventFocusLost || type == KAknFullOrPartialForegroundLost ) |
|
2139 |
&& iCurrentContainer ) |
|
2140 |
{ |
|
2141 |
iCurrentContainer->CacheWidgetPosition(); |
|
2142 |
} |
|
2143 |
||
2144 |
// base's HandleWsEventL needs to be called before foreground handling, |
|
2145 |
// otherwise the screen saver will be turned off |
|
2146 |
CAknAppUi::HandleWsEventL( aEvent, aDestination ); |
|
2147 |
||
2148 |
// refreshes toolbar when pen down event was invoked |
|
2149 |
if ( type == EEventPointer ) |
|
2150 |
{ |
|
2151 |
if ( iCurrentSuiteModel ) |
|
2152 |
{ |
|
2153 |
RefreshToolbarL(); |
|
2154 |
} |
|
2155 |
} |
|
2156 |
else if ( type == EEventFocusGained ) |
|
2157 |
{ |
|
2158 |
HandleFocusGainedL(); |
|
2159 |
} |
|
2160 |
else if ( type == EEventFocusLost ) |
|
2161 |
{ |
|
2162 |
HandleFocusLostL(); |
|
2163 |
} |
|
2164 |
else if ( type == KAknFullOrPartialForegroundGained ) |
|
2165 |
{ |
|
2166 |
HandleFullOrPartialForegroundGainedL(); |
|
2167 |
} |
|
2168 |
else if( type == KAknFullOrPartialForegroundLost ) |
|
2169 |
{ |
|
2170 |
HandleFullOrPartialForegroundLostL(); |
|
2171 |
} |
|
2172 |
} |
|
2173 |
||
2174 |
// --------------------------------------------------------------------------- |
|
2175 |
// |
|
2176 |
// --------------------------------------------------------------------------- |
|
2177 |
// |
|
2178 |
TErrorHandlerResponse CMmAppUi::HandleError(TInt aError, |
|
2179 |
const SExtendedError& /*aExtErr*/, |
|
2180 |
TDes& /*aErrorText*/, |
|
2181 |
TDes& /*aContextText*/ ) |
|
2182 |
{ |
|
2183 |
if( aError == KErrNoMemory ) |
|
2184 |
{ |
|
2185 |
TRAP_IGNORE( ResetToInitialStateL( ) ); |
|
2186 |
} |
|
2187 |
return EErrorNotHandled; |
|
2188 |
} |
|
2189 |
||
2190 |
// --------------------------------------------------------------------------- |
|
2191 |
// |
|
2192 |
// --------------------------------------------------------------------------- |
|
2193 |
// |
|
2194 |
void CMmAppUi::HandleSuiteEventL ( |
|
2195 |
THnCustomSuiteEvent aCustomSuiteEvent, CHnSuiteModel* aModel ) |
|
2196 |
{ |
|
2197 |
||
2198 |
DEBUG(("_Mm_:CMmAppUi::HandleSuiteEventL %d - IN",aCustomSuiteEvent)); |
|
2199 |
switch ( aCustomSuiteEvent ) |
|
2200 |
{ |
|
2201 |
case ESuitePushedToStack: |
|
2202 |
{ |
|
2203 |
aModel->RegisterSuiteObserverL( this, EPriorityMuchLess ); |
|
2204 |
} |
|
2205 |
break; |
|
2206 |
case ESuitePoppedFromStack: |
|
2207 |
{ |
|
2208 |
||
2209 |
} |
|
2210 |
break; |
|
2211 |
case ESuiteModelInitialized: |
|
2212 |
{ |
|
2213 |
HandleSuiteModelInitializedL( aModel ); |
|
2214 |
} |
|
2215 |
break; |
|
2216 |
default: |
|
2217 |
break; |
|
2218 |
} |
|
2219 |
||
2220 |
if ( iCurrentSuiteModel == aModel ) |
|
2221 |
{ |
|
2222 |
//We are interested in the following event |
|
2223 |
//only if they come from the current suite. |
|
2224 |
TBool redraw = (iScreenOn && IsForeground()) ? ETrue : EFalse; |
|
2225 |
switch (aCustomSuiteEvent) |
|
2226 |
{ |
|
2227 |
case ESuiteModelDestroyed: |
|
2228 |
{ |
|
2229 |
iCurrentContainer->PrepareForGarbage(); |
|
2230 |
iGarbage.AppendL(iCurrentContainer); |
|
2231 |
iContainerMap.Remove( |
|
2232 |
iCurrentSuiteModel->GetItemsOrder()->GetSuiteId()); |
|
2233 |
RemoveFromStack(iCurrentContainer); |
|
2234 |
iDummyContainer->MakeVisible( ETrue ); |
|
2235 |
iCurrentContainer->SetObserver(NULL); |
|
2236 |
iCurrentSuiteModel = NULL; |
|
2237 |
iCurrentContainer = NULL; |
|
2238 |
} |
|
2239 |
break; |
|
2240 |
case ESuiteItemsAdded: |
|
2241 |
{ |
|
2242 |
//we need consistent view/state before item is added |
|
2243 |
//so draggind should be cancelled |
|
2244 |
if( IsEditMode() && iCurrentContainer->IsDraggable() ) |
|
2245 |
{ |
|
2246 |
iCurrentContainer->CancelDragL( EFalse ); |
|
2247 |
iCurrentContainer->DrawNow(); |
|
2248 |
} |
|
2249 |
HandleNumberOfItemsChangedL( EItemsAdded ); |
|
2250 |
} |
|
2251 |
break; |
|
2252 |
case ESuiteItemsRemoved: |
|
2253 |
{ |
|
2254 |
//we need consistent view/state before item is removed |
|
2255 |
//so draggind should be cancelled |
|
2256 |
if( IsEditMode() && iCurrentContainer->IsDraggable() ) |
|
2257 |
{ |
|
2258 |
iCurrentContainer->CancelDragL( EFalse ); |
|
2259 |
iCurrentContainer->DrawNow(); |
|
2260 |
} |
|
2261 |
HandleNumberOfItemsChangedL( EItemsRemoved ); |
|
2262 |
} |
|
2263 |
break; |
|
2264 |
case ESuiteItemsUpdated: |
|
2265 |
{ |
|
2266 |
ClearTransitionFromEditModeFlag(); |
|
2267 |
iCurrentContainer->DrawView(); |
|
2268 |
} |
|
2269 |
break; |
|
2270 |
case ESuiteHighlightChanged: |
|
2271 |
{ |
|
2272 |
iCurrentContainer->SetManualHighlightL( |
|
2273 |
iCurrentSuiteModel->GetSuiteHighlight(), redraw ); |
|
2274 |
} |
|
2275 |
break; |
|
2276 |
default: |
|
2277 |
break; |
|
2278 |
} |
|
2279 |
} |
|
2280 |
DEBUG(("_Mm_:CMmAppUi::HandleSuiteEventL OUT")); |
|
2281 |
} |
|
2282 |
||
2283 |
// --------------------------------------------------------------------------- |
|
2284 |
// |
|
2285 |
// --------------------------------------------------------------------------- |
|
2286 |
// |
|
2287 |
void CMmAppUi::ClearTransitionFromEditModeFlag() |
|
2288 |
{ |
|
2289 |
if ( iEditModeStatus == ETransitionFromEditMode || |
|
2290 |
iEditModeStatus == EFastTransitionFromEditMode ) |
|
2291 |
{ |
|
2292 |
iEditModeStatus = ENoEditMode; |
|
2293 |
} |
|
2294 |
} |
|
2295 |
||
2296 |
// --------------------------------------------------------------------------- |
|
2297 |
// |
|
2298 |
// --------------------------------------------------------------------------- |
|
2299 |
// |
|
2300 |
TInt CMmAppUi::AdjustEditModeHighlightL( TInt aOriginalHighlight ) |
|
2301 |
{ |
|
2302 |
if ( AknLayoutUtils::PenEnabled() ) |
|
2303 |
{ |
|
2304 |
if ( !iCurrentContainer->IsHighlightVisible() |
|
2305 |
&& iEditModeStatus == ETransitionToEditMode ) |
|
2306 |
{ |
|
2307 |
aOriginalHighlight = KErrNotFound ; |
|
2308 |
} |
|
2309 |
} |
|
2310 |
return aOriginalHighlight; |
|
2311 |
} |
|
2312 |
||
2313 |
// --------------------------------------------------------------------------- |
|
2314 |
// |
|
2315 |
// --------------------------------------------------------------------------- |
|
2316 |
// |
|
2317 |
void CMmAppUi::HandleOutOfMemoryL() |
|
2318 |
{ |
|
2319 |
if( !iOutOfMemoryHandler ) |
|
2320 |
{ |
|
2321 |
iOutOfMemoryHandler = CMmNoMemory::NewL(); |
|
2322 |
} |
|
2323 |
iOutOfMemoryHandler->Start(); |
|
2324 |
} |
|
2325 |
||
2326 |
// --------------------------------------------------------------------------- |
|
2327 |
// |
|
2328 |
// --------------------------------------------------------------------------- |
|
2329 |
// |
|
2330 |
void CMmAppUi::ResetToInitialStateL() |
|
2331 |
{ |
|
2332 |
iDummyContainer->MakeVisible( ETrue ); |
|
2333 |
iDummyContainer->DrawNow(); |
|
2334 |
RefreshCbaL(); |
|
2335 |
||
2336 |
if (iCurrentSuiteModel) |
|
2337 |
{ |
|
2338 |
iCurrentSuiteModel->UnregisterSuiteObserver( this ); |
|
2339 |
} |
|
2340 |
RemoveFromStack( iCurrentContainer ); |
|
2341 |
ResetContainerMap(); |
|
2342 |
iGarbage.ResetAndDestroy(); |
|
2343 |
delete iHNInterface; |
|
2344 |
iHNInterface = NULL; |
|
2345 |
delete iMmExtManager; |
|
2346 |
iMmExtManager = NULL; |
|
2347 |
delete iTemplateLibrary; |
|
2348 |
iTemplateLibrary = NULL; |
|
2349 |
||
2350 |
iCurrentSuiteModel = NULL; |
|
2351 |
iCurrentContainer = NULL; |
|
2352 |
iContainerMap.Close(); |
|
2353 |
iEditModeStatus = ENoEditMode; |
|
2354 |
||
2355 |
GfxTransEffect::AbortFullScreen(); |
|
2356 |
iIsKastorEffectStarted = EFalse; |
|
2357 |
||
2358 |
RefreshUiPanesL(); |
|
2359 |
Cba()->MakeVisible( EFalse ); |
|
2360 |
StatusPane()->SwitchLayoutL( R_AVKON_STATUS_PANE_LAYOUT_USUAL ); |
|
2361 |
||
2362 |
iHNInterface = CHnEngine::NewL( *this ); |
|
2363 |
iTemplateLibrary = CMmTemplateLibrary::NewL(); |
|
2364 |
InitializeL(); |
|
2365 |
||
2366 |
iMmExtManager = CMMExtensionManager::NewL( *this ); |
|
2367 |
||
2368 |
iScreenOn = ETrue; |
|
2369 |
iSkinChangeNeeded = EFalse; |
|
2370 |
iSkinChangeInProgress = EFalse; |
|
2371 |
} |
|
2372 |
||
2373 |
// --------------------------------------------------------------------------- |
|
2374 |
// |
|
2375 |
// --------------------------------------------------------------------------- |
|
2376 |
// |
|
2377 |
void CMmAppUi::HandleSuiteModelInitializedL( CHnSuiteModel* aModel ) |
|
2378 |
{ |
|
2379 |
StatusPane()->MakeVisible( ETrue ); |
|
2380 |
Cba()->MakeVisible( ETrue ); |
|
2381 |
if ( aModel == iHNInterface->GetLastSuiteModelL() ) |
|
2382 |
{ |
|
2383 |
TBool showOpenFolderEffect(iCurrentSuiteModel |
|
2384 |
&& (iCurrentSuiteModel->CustomId() != aModel->CustomId() |
|
2385 |
|| iCurrentSuiteModel->WidgetType() |
|
2386 |
!= aModel->WidgetType())); |
|
2387 |
if( showOpenFolderEffect ) |
|
2388 |
{ |
|
2389 |
StartLayoutSwitchFullScreen( EMenuOpenFolderEffect ); |
|
2390 |
} |
|
2391 |
||
2392 |
iCurrentSuiteModel = aModel; |
|
2393 |
ShowSuiteL(); |
|
2394 |
iGarbage.ResetAndDestroy(); |
|
2395 |
||
2396 |
if ( iEditModeStatus == ETransitionToEditMode ) |
|
2397 |
{ |
|
2398 |
iEditModeStatus = EEditMode; |
|
2399 |
} |
|
2400 |
else if ( iEditModeStatus == ETransitionFromEditMode ) |
|
2401 |
{ |
|
2402 |
iEditModeStatus = ENoEditMode; |
|
2403 |
} |
|
2404 |
||
2405 |
HideMenuPaneIfVisibleL(); |
|
2406 |
EndFullScreen(); |
|
2407 |
} |
|
2408 |
else |
|
2409 |
{ |
|
2410 |
if( iHNInterface->SuiteModelLoadedL( |
|
2411 |
aModel->GetItemsOrder()->GetSuiteId() ) ) |
|
2412 |
{ |
|
2413 |
CMmWidgetContainer* containerToLoad = NULL; |
|
2414 |
TBool created( CreateNewContainerL( aModel, containerToLoad ) ); |
|
2415 |
if( created ) |
|
2416 |
{ |
|
2417 |
containerToLoad->Widget()->View()->SetDisableRedraw( ETrue ); |
|
2418 |
containerToLoad->SetEditModeL( IsEditMode() ); |
|
2419 |
containerToLoad->SetSuiteModelL( aModel ); |
|
2420 |
containerToLoad->SetEmptyTextL( aModel->EmptyText() ); |
|
2421 |
containerToLoad->SetObserver( this ); |
|
2422 |
containerToLoad->SetRect( ClientRect() ); |
|
2423 |
containerToLoad->MakeVisible( EFalse ); |
|
2424 |
} |
|
2425 |
} |
|
2426 |
} |
|
2427 |
} |
|
2428 |
||
2429 |
// --------------------------------------------------------------------------- |
|
2430 |
// |
|
2431 |
// --------------------------------------------------------------------------- |
|
2432 |
// |
|
2433 |
void CMmAppUi::HideMenuPaneIfVisibleL() |
|
2434 |
{ |
|
2435 |
if ( iEikonEnv->AppUiFactory()->MenuBar()->IsDisplayed() ) |
|
2436 |
{ |
|
2437 |
iEikonEnv->AppUiFactory()->MenuBar()->StopDisplayingMenuBar(); |
|
2438 |
} |
|
2439 |
} |
|
2440 |
||
2441 |
// --------------------------------------------------------------------------- |
|
2442 |
// |
|
2443 |
// --------------------------------------------------------------------------- |
|
2444 |
// |
|
2445 |
void CMmAppUi::ExitMatrix( TExitType aExitType ) |
|
2446 |
{ |
|
2447 |
DEBUG(("_Mm_:CMmAppUi::ExitMatrix - IN")); |
|
2448 |
DEBUG(("\t_Mm_:Exit type: %d",aExitType)); |
|
2449 |
||
2450 |
if ( aExitType == EExitReally ) |
|
2451 |
{ |
|
2452 |
// Calling PrepareHomescreenForMatrixExitL instead of ShowHomescreenL |
|
2453 |
// allows for avoiding a bug that would occur if appkey was pressed |
|
2454 |
// immediately after exiting the menu via Options->Exit. |
|
2455 |
// The bug would be that on pressing the appkey homescreen would be |
|
2456 |
// displayed and then the menu would appear again on the screen for |
|
2457 |
// a fraction of second causing an ugly and confusing flicker effect. |
|
2458 |
TRAP_IGNORE( PrepareHomescreenForMatrixExitL() ); |
|
2459 |
//ShowHomescreenL( aExitType ); |
|
2460 |
//if we got exit cmd from OS, let's really exit. |
|
2461 |
Exit(); |
|
2462 |
} |
|
2463 |
else |
|
2464 |
{ |
|
2465 |
GfxTransEffect::AbortFullScreen(); |
|
2466 |
iIsKastorEffectStarted = EFalse; |
|
2467 |
StartLayoutSwitchFullScreen( AknTransEffect::EApplicationExit ); |
|
2468 |
||
2469 |
TRAP_IGNORE( ShowHomescreenL( aExitType ) ); |
|
2470 |
TRAP_IGNORE( CleanupForExitL( EExitKeyRed ) ); |
|
2471 |
} |
|
2472 |
||
2473 |
DEBUG(("_Mm_:CMmAppUi::ExitMatrix - OUT")); |
|
2474 |
} |
|
2475 |
||
2476 |
// --------------------------------------------------------------------------- |
|
2477 |
// |
|
2478 |
// --------------------------------------------------------------------------- |
|
2479 |
// |
|
2480 |
void CMmAppUi::CleanupForExitL( TExitKeyType aExitKey ) |
|
2481 |
{ |
|
2482 |
DEBUG(("_Mm_:CMmAppUi::CleanupForExitL - IN")); |
|
2483 |
||
2484 |
// closing all dialogs opened in ui extensions before exit |
|
2485 |
iMmExtManager->ExecuteActionL( TUid::Null(), KCommandDeleteDialog, NULL ); |
|
2486 |
if( IsDisplayingDialog() ) |
|
2487 |
{ |
|
2488 |
AknDialogShutter::ShutDialogsL( *iEikonEnv ); |
|
2489 |
} |
|
2490 |
||
2491 |
if ( IsEditMode() && iCurrentContainer ) |
|
2492 |
{ |
|
2493 |
DEBUG(("\t_Mm_:Edit Mode turned off")); |
|
2494 |
iCurrentContainer->CancelDragL( EFalse ); |
|
2495 |
SetEditModeL( EFalse ); |
|
2496 |
} |
|
88
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
2497 |
|
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
2498 |
THnSuiteWidgetType widgetType = iCurrentContainer |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
2499 |
? iCurrentContainer->WidgetType() : EUnspecified; |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
2500 |
|
83 | 2501 |
// reset model - revert to root if current view is not a suite view |
2502 |
CHnSuiteModel* model = iHNInterface->GetLastSuiteModelL(); |
|
88
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
2503 |
|
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
2504 |
TBool commingFromBackground( aExitKey == ECommingFromBackground ); |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
2505 |
|
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
2506 |
if( model && ( aExitKey == EExitKeyApplication || commingFromBackground ) ) |
83 | 2507 |
{ |
2508 |
TBool topSuiteIsBeingEvaluated = |
|
2509 |
!model->GetItemsOrder()->IsSuiteReadyToShow(); |
|
2510 |
TBool topSuiteChanged = ResetToRootL(); |
|
2511 |
model = NULL; // ResetToRootL might have deleted the model |
|
2512 |
TBool presentationChangeExpected = topSuiteChanged || topSuiteIsBeingEvaluated; |
|
88
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
2513 |
|
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
2514 |
|
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
2515 |
TBool mustDrawImmediately = !presentationChangeExpected |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
2516 |
|| !iDummyContainer->IsVisible() || commingFromBackground; |
83 | 2517 |
|
88
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
2518 |
if( iCurrentContainer ) |
83 | 2519 |
{ |
88
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
2520 |
if( commingFromBackground ) |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
2521 |
{ |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
2522 |
//do not draw the widget if the previous widget type is diffenernt than the current one |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
2523 |
mustDrawImmediately &= ( widgetType |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
2524 |
== iCurrentContainer->WidgetType() ); |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
2525 |
|
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
2526 |
iCurrentContainer->SetWidgetCommingFromBackground( ETrue ); |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
2527 |
} |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
2528 |
|
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
2529 |
if( mustDrawImmediately ) |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
2530 |
{ |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
2531 |
DEBUG(("\t_Mm_:Top item index reset")); |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
2532 |
iCurrentContainer->ResetWidgetPosition(); |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
2533 |
iCurrentContainer->Widget()->UpdateScrollBarsL(); |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
2534 |
iCurrentContainer->MakeVisible( ETrue ); |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
2535 |
iCurrentContainer->DrawNow(); |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
2536 |
iCurrentContainer->SetWidgetCommingFromBackground( EFalse ); |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
2537 |
} |
83 | 2538 |
} |
2539 |
} |
|
2540 |
||
2541 |
DEBUG(("_Mm_:CMmAppUi::CleanupForExitL - OUT")); |
|
2542 |
} |
|
2543 |
||
2544 |
// --------------------------------------------------------------------------- |
|
2545 |
// |
|
2546 |
// --------------------------------------------------------------------------- |
|
2547 |
// |
|
2548 |
void CMmAppUi::ShowHomescreenL( TExitType aExitType ) |
|
2549 |
{ |
|
2550 |
TInt appToShowUid(0); |
|
2551 |
TInt idleid(0); |
|
2552 |
switch( aExitType ) |
|
2553 |
{ |
|
2554 |
case EExitToIdle: |
|
2555 |
{ |
|
2556 |
User::LeaveIfError( RProperty::Get( KPSUidAiInformation, |
|
2557 |
KActiveIdleUid, appToShowUid ) ); |
|
2558 |
OpenAppL( TUid::Uid( appToShowUid ) ); |
|
2559 |
} |
|
2560 |
break; |
|
2561 |
case EExitToPhone: |
|
2562 |
{ |
|
2563 |
if( !RProperty::Get( KPSUidUikon, KUikVideoCallTopApp, idleid ) ) |
|
2564 |
{ |
|
2565 |
// Possible error code not relevant, as we have valid id anyway |
|
2566 |
if( idleid == KVideoCallAppUid ) |
|
2567 |
{ |
|
2568 |
CreateActivateViewEventL( TVwsViewId( |
|
2569 |
TUid::Uid( idleid ), TUid::Uid( idleid ) ), |
|
2570 |
KNullUid, KNullDesC8() ); |
|
2571 |
break; |
|
2572 |
} |
|
2573 |
} |
|
2574 |
CAknTaskList* taskList = CAknTaskList::NewL( |
|
2575 |
iCoeEnv->WsSession() ); |
|
2576 |
TApaTask task = taskList->FindRootApp( TUid::Uid( KPhoneAppUid ) ); |
|
2577 |
delete taskList; |
|
2578 |
if( task.Exists() ) |
|
2579 |
{ |
|
2580 |
CApaWindowGroupName* windowName = CApaWindowGroupName::NewLC( |
|
2581 |
iCoeEnv->WsSession(), task.WgId() ); |
|
2582 |
TBool hidden = windowName->Hidden(); |
|
2583 |
CleanupStack::PopAndDestroy( windowName ); |
|
2584 |
if( !hidden ) |
|
2585 |
{ |
|
2586 |
OpenAppL( TUid::Uid( KPhoneAppUid ) ); |
|
2587 |
break; |
|
2588 |
} |
|
2589 |
} |
|
2590 |
ShowHomescreenL( EExitToIdle ); |
|
2591 |
} |
|
2592 |
break; |
|
2593 |
default: |
|
2594 |
ShowHomescreenL( EExitToPhone ); |
|
2595 |
} |
|
2596 |
} |
|
2597 |
||
2598 |
// --------------------------------------------------------------------------- |
|
2599 |
// |
|
2600 |
// --------------------------------------------------------------------------- |
|
2601 |
// |
|
2602 |
void CMmAppUi::PrepareHomescreenForMatrixExitL() |
|
2603 |
{ |
|
2604 |
TBool succeeded( EFalse ); |
|
2605 |
||
2606 |
CAknTaskList* taskList = CAknTaskList::NewL( iCoeEnv->WsSession() ); |
|
2607 |
TApaTask task = taskList->FindRootApp( TUid::Uid( KPhoneAppUid ) ); |
|
2608 |
delete taskList; |
|
2609 |
||
2610 |
if( task.Exists() ) |
|
2611 |
{ |
|
2612 |
CApaWindowGroupName* windowName = CApaWindowGroupName::NewLC( |
|
2613 |
iCoeEnv->WsSession(), task.WgId() ); |
|
2614 |
if( !windowName->Hidden() ) |
|
2615 |
{ |
|
2616 |
succeeded = !iCoeEnv->WsSession().SetWindowGroupOrdinalPosition( |
|
2617 |
task.WgId(), 1 ); |
|
2618 |
} |
|
2619 |
CleanupStack::PopAndDestroy( windowName ); |
|
2620 |
} |
|
2621 |
||
2622 |
if( !succeeded ) |
|
2623 |
{ |
|
88
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
2624 |
StartLayoutSwitchFullScreen( AknTransEffect::EApplicationExit ); |
83 | 2625 |
ShowHomescreenL( EExitReally ); |
2626 |
} |
|
2627 |
} |
|
2628 |
||
2629 |
// --------------------------------------------------------------------------- |
|
2630 |
// |
|
2631 |
// --------------------------------------------------------------------------- |
|
2632 |
// |
|
2633 |
void CMmAppUi::OpenAppL( const TUid aUid ) |
|
2634 |
{ |
|
2635 |
DEBUG(("_Mm_:CMmAppUi::OpenAppL - IN")); |
|
2636 |
DEBUG(("\t_Mm_:aUid: 0x%x",aUid.iUid)); |
|
2637 |
||
2638 |
// Get the correct application data |
|
2639 |
CAknTaskList* taskList = CAknTaskList::NewL( iCoeEnv->WsSession() ); |
|
2640 |
TApaTask task = taskList->FindRootApp( aUid ); |
|
2641 |
delete taskList; |
|
2642 |
||
2643 |
if ( task.Exists() ) |
|
2644 |
{ |
|
2645 |
CAknSgcClient::MoveApp( task.WgId(), ESgcMoveAppToForeground ); |
|
2646 |
} |
|
2647 |
else |
|
2648 |
{ |
|
2649 |
// Task doesn't exist, launch a new instance of an application |
|
2650 |
TApaAppInfo appInfo; |
|
2651 |
TApaAppCapabilityBuf capabilityBuf; |
|
2652 |
RApaLsSession lsSession; |
|
2653 |
User::LeaveIfError( lsSession.Connect() ); |
|
2654 |
CleanupClosePushL( lsSession ); |
|
2655 |
User::LeaveIfError( lsSession.GetAppInfo( appInfo, aUid ) ); |
|
2656 |
User::LeaveIfError( |
|
2657 |
lsSession.GetAppCapability( capabilityBuf, aUid ) ); |
|
2658 |
||
2659 |
TApaAppCapability& caps = capabilityBuf(); |
|
2660 |
TFileName appName = appInfo.iFullName; |
|
2661 |
CApaCommandLine* cmdLine = CApaCommandLine::NewLC(); |
|
2662 |
cmdLine->SetExecutableNameL( appName ); |
|
2663 |
||
2664 |
if ( caps.iLaunchInBackground ) |
|
2665 |
{ |
|
2666 |
cmdLine->SetCommandL( EApaCommandBackground ); |
|
2667 |
} |
|
2668 |
else |
|
2669 |
{ |
|
2670 |
cmdLine->SetCommandL( EApaCommandRun ); |
|
2671 |
} |
|
2672 |
||
2673 |
User::LeaveIfError( lsSession.StartApp( *cmdLine ) ); |
|
2674 |
||
2675 |
CleanupStack::PopAndDestroy( cmdLine ); |
|
2676 |
CleanupStack::PopAndDestroy( &lsSession ); |
|
2677 |
} |
|
2678 |
||
2679 |
DEBUG(("_Mm_:CMmAppUi::OpenAppL - OUT")); |
|
2680 |
} |
|
2681 |
// --------------------------------------------------------------------------- |
|
2682 |
// |
|
2683 |
// --------------------------------------------------------------------------- |
|
2684 |
// |
|
2685 |
void CMmAppUi::InitializeL() |
|
2686 |
{ |
|
2687 |
DEBUG(("_MM_:CMmAppUi::InitializeL IN")); |
|
2688 |
CLiwGenericParamList* paramList = CLiwGenericParamList::NewLC(); |
|
2689 |
CLiwDefaultMap* map = CLiwDefaultMap::NewLC(); |
|
2690 |
||
2691 |
HBufC* suiteName = StringLoader::LoadLC( R_MENU_TITLE ); |
|
2692 |
||
2693 |
paramList->AppendL( TLiwGenericParam( KParamSuiteName8, |
|
2694 |
TLiwVariant( KParamFolderSuite ) ) ); |
|
2695 |
map->InsertL( KParamSuiteName8, TLiwVariant( suiteName ) ); |
|
2696 |
map->InsertL( KParamFolderId8, TLiwVariant( KParamFolderId ) ); |
|
2697 |
map->InsertL( KParamRemoveLocked8, TLiwVariant( KParamFalse ) ); |
|
2698 |
map->InsertL( KParentFolderId8, TLiwVariant( KParamFolderId ) ); |
|
2699 |
map->InsertL( KTmpParentFolderId8, TLiwVariant( KParamFolderId ) ); |
|
2700 |
paramList->AppendL( TLiwGenericParam( KParams8, TLiwVariant( map ) ) ); |
|
2701 |
||
2702 |
iHNInterface->InitializeL( *paramList ); |
|
2703 |
||
2704 |
CleanupStack::PopAndDestroy( suiteName ); |
|
2705 |
CleanupStack::PopAndDestroy( map ); |
|
2706 |
CleanupStack::PopAndDestroy( paramList ); |
|
2707 |
DEBUG(("_MM_:CMmAppUi::InitializeL OUT")); |
|
2708 |
} |
|
2709 |
||
2710 |
// --------------------------------------------------------------------------- |
|
2711 |
// |
|
2712 |
// --------------------------------------------------------------------------- |
|
2713 |
// |
|
2714 |
void CMmAppUi::SetMiddleSoftKeyL() |
|
2715 |
{ |
|
2716 |
DEBUG(("_Mm_:CMmAppUi::SetMiddleSoftKeyL - IN")); |
|
2717 |
if ( iCurrentSuiteModel && !AknLayoutUtils::PenEnabled() && !IsEditMode() ) |
|
2718 |
{ |
|
2719 |
DEBUG(("\t_Mm_:suite highlight: %d", |
|
2720 |
iCurrentSuiteModel->GetSuiteHighlight())); |
|
2721 |
||
2722 |
TBool idByContainer = iCurrentContainer->IsHighlightVisible() && |
|
2723 |
iCurrentContainer->GetSuiteModelL()->GetItemModelsCount() > 1; |
|
2724 |
TInt itemId = idByContainer ? |
|
2725 |
iCurrentSuiteModel->IdByIndex( iCurrentContainer->GetHighlight() ) : |
|
2726 |
iCurrentSuiteModel->IdByIndex( KErrNotFound ); |
|
2727 |
CHnItemModel* itemModel = iCurrentSuiteModel->GetItemModel( itemId ); |
|
2728 |
||
2729 |
CHnButtonModel* mskModel = NULL; |
|
2730 |
||
2731 |
if ( itemModel ) |
|
2732 |
{ |
|
2733 |
mskModel = itemModel->GetMiddleSoftKey(); |
|
2734 |
} |
|
2735 |
||
2736 |
if ( mskModel ) |
|
2737 |
{ |
|
2738 |
TInt event = (mskModel->GetEventId() == KErrNotFound) ? |
|
2739 |
KKeyIdSelect : mskModel->GetEventId(); |
|
2740 |
Cba()->SetCommandL( CEikButtonGroupContainer::EMiddleSoftkeyPosition, |
|
2741 |
event, mskModel->GetButtonText()); |
|
2742 |
} |
|
2743 |
else |
|
2744 |
{ |
|
2745 |
// reset to default |
|
2746 |
RefreshCbaL(); |
|
2747 |
} |
|
2748 |
} |
|
2749 |
DEBUG(("_Mm_:CMmAppUi::SetMiddleSoftKeyL - OUT")); |
|
2750 |
} |
|
2751 |
||
2752 |
// --------------------------------------------------------------------------- |
|
2753 |
// |
|
2754 |
// --------------------------------------------------------------------------- |
|
2755 |
// |
|
2756 |
void CMmAppUi::StartLayoutSwitchFullScreen( TInt aKastorEffect ) |
|
2757 |
{ |
|
2758 |
if( ( !iIsKastorEffectStarted && iScreenOn && IsForeground() ) || |
|
2759 |
aKastorEffect == AknTransEffect::EApplicationStart || |
|
2760 |
aKastorEffect == AknTransEffect::EApplicationExit ) |
|
2761 |
{ |
|
2762 |
DEBUG(("_MM_:CMmAppUi::StartLayoutSwitchFullScreen Foreground")); |
|
2763 |
TUid uidNext( KUidMatrixMenuApp ); |
|
2764 |
TUid uidPrev( KUidMatrixMenuApp ); |
|
2765 |
||
2766 |
if( aKastorEffect == AknTransEffect::EApplicationExit ) |
|
2767 |
{ |
|
2768 |
uidPrev = TUid::Null(); |
|
2769 |
} |
|
2770 |
else if( aKastorEffect == AknTransEffect::EApplicationStart ) |
|
2771 |
{ |
|
2772 |
uidPrev = uidPrev.Uid( AI_UID3_AIFW_COMMON ); |
|
2773 |
} |
|
2774 |
||
2775 |
AknTransEffect::TParamBuffer params = AknTransEffect::GfxTransParam( |
|
2776 |
uidNext, uidPrev, AknTransEffect::TParameter::EFlagNone ); |
|
2777 |
||
2778 |
GfxTransEffect::BeginFullScreen( aKastorEffect, TRect(), |
|
2779 |
AknTransEffect::EParameterType, params ); |
|
2780 |
||
2781 |
iIsKastorEffectStarted = ETrue; |
|
2782 |
} |
|
2783 |
} |
|
2784 |
||
2785 |
// --------------------------------------------------------------------------- |
|
2786 |
// |
|
2787 |
// --------------------------------------------------------------------------- |
|
2788 |
// |
|
2789 |
void CMmAppUi::EndFullScreen() |
|
2790 |
{ |
|
2791 |
if( iIsKastorEffectStarted && iScreenOn ) |
|
2792 |
{ |
|
2793 |
DEBUG(("_MM_:CMmAppUi::EndFullScreen Foreground")); |
|
2794 |
GfxTransEffect::EndFullScreen(); |
|
2795 |
iIsKastorEffectStarted = EFalse; |
|
2796 |
} |
|
2797 |
} |
|
2798 |
// --------------------------------------------------------------------------- |
|
2799 |
// |
|
2800 |
// --------------------------------------------------------------------------- |
|
2801 |
// |
|
2802 |
void CMmAppUi::HandleRequestL( const CLiwGenericParamList& aParam, |
|
2803 |
CLiwGenericParamList* aOutput ) |
|
2804 |
{ |
|
2805 |
iHNInterface->HandleRequestL( aParam, aOutput ); |
|
2806 |
} |
|
2807 |
||
2808 |
// --------------------------------------------------------------------------- |
|
2809 |
// |
|
2810 |
// --------------------------------------------------------------------------- |
|
2811 |
// |
|
2812 |
TBool CMmAppUi::ResetToRootL() |
|
2813 |
{ |
|
2814 |
TBool resetConsumed( EFalse ); |
|
2815 |
if( iHNInterface && iCurrentSuiteModel && |
|
2816 |
!IsRootdisplayedL() ) |
|
2817 |
{ |
|
2818 |
RemoveFromStack( iCurrentContainer ); |
|
2819 |
iDummyContainer->MakeVisible( ETrue ); |
|
2820 |
iHNInterface->HandleBackEventL( |
|
2821 |
iCurrentSuiteModel->SuiteName(), |
|
2822 |
iHNInterface->GetSuiteModelsCountL() - 1 ); |
|
2823 |
ResetContainerMapToRootL(); |
|
2824 |
if( iCurrentContainer ) |
|
2825 |
{ |
|
88
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
2826 |
const TInt FirstItemIndex = 0; |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
2827 |
iCurrentContainer->GetSuiteModelL()->SetSuiteHighlightL( FirstItemIndex ); |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
2828 |
iMakeHightlightedItemFullyVisible = ETrue; |
83 | 2829 |
iCurrentContainer->ResetWidgetPosition(); |
88
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
2830 |
iCurrentContainer->SetEditModeL( EFalse ); |
83 | 2831 |
AddToStackL( iCurrentContainer ); |
2832 |
} |
|
2833 |
RefreshUiPanesL( ETrue ); |
|
2834 |
resetConsumed = ETrue; |
|
2835 |
} |
|
2836 |
return resetConsumed; |
|
2837 |
} |
|
2838 |
||
2839 |
// --------------------------------------------------------------------------- |
|
2840 |
// |
|
2841 |
// --------------------------------------------------------------------------- |
|
2842 |
// |
|
2843 |
void CMmAppUi::SkinContentChanged() |
|
2844 |
{ |
|
2845 |
iSkinChangeNeeded = ETrue; |
|
2846 |
iSkinChangeInProgress = ETrue; |
|
2847 |
} |
|
2848 |
// --------------------------------------------------------------------------- |
|
2849 |
// |
|
2850 |
// --------------------------------------------------------------------------- |
|
2851 |
// |
|
2852 |
void CMmAppUi::SkinConfigurationChanged( |
|
2853 |
const TAknsSkinStatusConfigurationChangeReason aReason) |
|
2854 |
{ |
|
2855 |
DEBUG(("_Mm_:CMmAppUi::SkinConfigurationChanged IN - aReason:%d iSkinChangeNeeded:%d iSkinChangeInProgress:%d", aReason, iSkinChangeNeeded, iSkinChangeInProgress)); |
|
2856 |
switch (aReason) |
|
2857 |
{ |
|
2858 |
case EAknsSkinStatusConfigurationMerged:// = 1, |
|
2859 |
{ |
|
2860 |
iSkinChangeNeeded = ETrue; |
|
2861 |
iSkinChangeInProgress = ETrue; |
|
2862 |
} |
|
2863 |
break; |
|
2864 |
case EAknsSkinStatusConfigurationDeployed:// = 2, |
|
2865 |
{ |
|
2866 |
iSkinChangeInProgress = EFalse; |
|
2867 |
if (IsForeground()) |
|
2868 |
{ |
|
2869 |
TRAPD( err, RefreshIconsL()); |
|
2870 |
if (!err) |
|
2871 |
{ |
|
2872 |
iSkinChangeNeeded = ETrue; |
|
2873 |
} |
|
2874 |
} |
|
2875 |
} |
|
2876 |
break; |
|
2877 |
default: |
|
2878 |
{ |
|
2879 |
||
2880 |
} |
|
2881 |
} |
|
2882 |
DEBUG(("_Mm_:CMmAppUi::SkinConfigurationChanged OUT - aReason:%d iSkinChangeNeeded:%d iSkinChangeInProgress:%d", aReason, iSkinChangeNeeded, iSkinChangeInProgress)); |
|
2883 |
} |
|
2884 |
||
2885 |
// --------------------------------------------------------------------------- |
|
2886 |
// |
|
2887 |
// --------------------------------------------------------------------------- |
|
2888 |
// |
|
2889 |
void CMmAppUi::SkinPackageChanged(const TAknsSkinStatusPackageChangeReason /*aReason*/) |
|
2890 |
{ |
|
2891 |
} |
|
2892 |
||
2893 |
// --------------------------------------------------------------------------- |
|
2894 |
// |
|
2895 |
// --------------------------------------------------------------------------- |
|
2896 |
// |
|
2897 |
void CMmAppUi::HandleTriggerMoveItemL( const TInt aRecipientId, |
|
2898 |
CLiwGenericParamList* aEventParameters) |
|
2899 |
{ |
|
2900 |
iHNInterface->TriggerHnEventL( KKeyIdMove, aRecipientId, aEventParameters); |
|
2901 |
} |
|
2902 |
||
2903 |
// --------------------------------------------------------------------------- |
|
2904 |
// |
|
2905 |
// --------------------------------------------------------------------------- |
|
2906 |
// |
|
2907 |
void CMmAppUi::RefreshIconsL() |
|
2908 |
{ |
|
2909 |
iSkinChangeNeeded = EFalse; |
|
2910 |
CLiwGenericParamList* paramList = CLiwGenericParamList::NewLC(); |
|
2911 |
TLiwGenericParam command(KHnRequest, TLiwVariant( KRefreshIcons)); |
|
2912 |
paramList->AppendL(command); |
|
2913 |
HandleRequestL(*paramList); |
|
2914 |
CleanupStack::PopAndDestroy(paramList); |
|
2915 |
if( iCurrentContainer ) |
|
2916 |
{ |
|
2917 |
iCurrentContainer->HandleResourceChange( KAknsMessageSkinChange ); |
|
2918 |
} |
|
2919 |
} |
|
2920 |
||
2921 |
// --------------------------------------------------------------------------- |
|
2922 |
// |
|
2923 |
// --------------------------------------------------------------------------- |
|
2924 |
// |
|
2925 |
void CMmAppUi::HandleHighlightOffsetL( TInt aOffset ) |
|
2926 |
{ |
|
2927 |
if( AknLayoutUtils::PenEnabled() ) |
|
2928 |
{ |
|
2929 |
iHNInterface->TriggerHnEventL( KKeyIdMoveHighlight, aOffset, NULL ); |
|
2930 |
} |
|
2931 |
} |
|
2932 |
||
2933 |
// --------------------------------------------------------------------------- |
|
2934 |
// |
|
2935 |
// --------------------------------------------------------------------------- |
|
2936 |
// |
|
2937 |
void CMmAppUi::HandleNumberOfItemsChangedL( TItemsChangeType aChange ) |
|
2938 |
{ |
|
2939 |
iCurrentContainer->NumberOfItemsChangedL( aChange ); |
|
2940 |
TBool scrollConsumed( EFalse ); |
|
2941 |
scrollConsumed = |
|
2942 |
iCurrentContainer->ScrollToItemL( iCurrentSuiteModel->GetSuiteHighlight() ); |
|
2943 |
if ( !scrollConsumed || !AknLayoutUtils::PenEnabled() ) |
|
2944 |
{ |
|
2945 |
iCurrentContainer->DrawNow(); |
|
2946 |
} |
|
2947 |
RefreshUiPanesL(); |
|
2948 |
} |
|
2949 |
||
2950 |
// --------------------------------------------------------------------------- |
|
2951 |
// |
|
2952 |
// --------------------------------------------------------------------------- |
|
2953 |
// |
|
2954 |
void CMmAppUi::ApplyHighlightFromModelL() |
|
2955 |
{ |
|
2956 |
if ( iCurrentSuiteModel && iCurrentContainer ) |
|
2957 |
{ |
|
2958 |
TInt highlightedItemIndex = iCurrentSuiteModel->GetSuiteHighlight(); |
|
2959 |
iCurrentContainer->RestoreWidgetPosition(); |
|
2960 |
||
2961 |
iCurrentContainer->SetManualHighlightL( |
|
2962 |
highlightedItemIndex, EFalse ); |
|
2963 |
if ( iMakeHightlightedItemFullyVisible && |
|
2964 |
!iCurrentContainer->ItemIsFullyVisible( highlightedItemIndex ) ) |
|
2965 |
{ |
|
2966 |
iCurrentContainer->ScrollToItemL( highlightedItemIndex ); |
|
2967 |
} |
|
2968 |
iCurrentContainer->CacheWidgetPosition(); |
|
2969 |
iMakeHightlightedItemFullyVisible = EFalse; |
|
2970 |
} |
|
2971 |
} |
|
2972 |
||
2973 |
// --------------------------------------------------------------------------- |
|
2974 |
// |
|
2975 |
// --------------------------------------------------------------------------- |
|
2976 |
// |
|
2977 |
void CMmAppUi::HandleFocusGainedL() |
|
2978 |
{ |
|
2979 |
DEBUG(("_Mm_:CMmAppUi::HandleWsEventL " |
|
2980 |
"- EEventFocusGained")); |
|
2981 |
||
2982 |
iHasFocus = ETrue; |
|
2983 |
||
2984 |
// Tricky: lack of iCurrentSuiteModel indicates that suite evaluation is in |
|
2985 |
// progress - do not call HandlePresentationChangeL if evalution has not |
|
2986 |
// finished. |
|
2987 |
if ( iCurrentContainer && !iCurrentContainer->IsVisible() && |
|
2988 |
iCurrentSuiteModel ) |
|
2989 |
{ |
|
2990 |
HandlePresentationChangeL( iCurrentContainer ); |
|
2991 |
} |
|
2992 |
||
2993 |
if ( iCurrentSuiteModel && iCurrentContainer ) |
|
2994 |
{ |
|
2995 |
iDummyContainer->MakeVisible( EFalse ); |
|
2996 |
iCurrentContainer->MakeVisible( ETrue ); |
|
2997 |
iCurrentContainer->DrawNow(); |
|
2998 |
} |
|
2999 |
if( IsForeground() ) |
|
3000 |
{ |
|
3001 |
RefreshUiPanesL(); |
|
3002 |
} |
|
3003 |
if ( iCurrentContainer ) |
|
3004 |
{ |
|
3005 |
iCurrentContainer->SetHasFocusL( ETrue ); |
|
3006 |
} |
|
3007 |
} |
|
3008 |
||
3009 |
// --------------------------------------------------------------------------- |
|
3010 |
// |
|
3011 |
// --------------------------------------------------------------------------- |
|
3012 |
// |
|
3013 |
void CMmAppUi::HandleFocusLostL() |
|
3014 |
{ |
|
3015 |
DEBUG(("_Mm_:CMmAppUi::HandleWsEventL " |
|
3016 |
"- EEventFocusLost")); |
|
3017 |
||
3018 |
iHasFocus = EFalse; |
|
3019 |
||
3020 |
if( iCurrentContainer ) |
|
3021 |
{ |
|
3022 |
//This is needed in case some popup is displayed |
|
3023 |
//while touching item in grid. Highlight |
|
3024 |
//should be reset to normal then. |
|
3025 |
if( AknLayoutUtils::PenEnabled() ) |
|
3026 |
{ |
|
3027 |
if( iCurrentContainer->WidgetType() == EGridWidget && !IsEditMode() ) |
|
3028 |
{ |
|
3029 |
iCurrentContainer->Widget()->View()->ItemDrawer()-> |
|
3030 |
SetFlags( CListItemDrawer::EDisableHighlight ); |
|
3031 |
} |
|
3032 |
iCurrentContainer->Widget()->View()-> |
|
3033 |
ItemDrawer()->ClearFlags( CListItemDrawer::EPressedDownState ); |
|
3034 |
iCurrentContainer->Widget()->View()->DrawItem( |
|
3035 |
iCurrentContainer->Widget()->CurrentItemIndex() ) ; |
|
3036 |
} |
|
3037 |
if( IsEditMode() && iCurrentContainer->IsDraggable() ) |
|
3038 |
{ |
|
3039 |
HandleDragStopL( iCurrentContainer->GetHighlight() ); |
|
3040 |
iCurrentContainer->DrawNow(); |
|
3041 |
} |
|
3042 |
iCurrentContainer->SetHasFocusL( EFalse ); |
|
3043 |
} |
|
3044 |
} |
|
3045 |
||
3046 |
// --------------------------------------------------------------------------- |
|
3047 |
// |
|
3048 |
// --------------------------------------------------------------------------- |
|
3049 |
// |
|
3050 |
void CMmAppUi::HandleFullOrPartialForegroundGainedL() |
|
3051 |
{ |
|
3052 |
DEBUG(("_Mm_:CMmAppUi::HandleWsEventL " |
|
3053 |
"- KAknFullOrPartialForegroundGained")); |
|
3054 |
//show Menu in TS when launched for the first time |
|
3055 |
if( isHiddenFromFS ) |
|
3056 |
{ |
|
3057 |
HideApplicationFromFSW( EFalse ); |
|
3058 |
isHiddenFromFS = EFalse; |
|
3059 |
} |
|
3060 |
||
88
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
3061 |
if( iCurrentContainer && iCurrentSuiteModel ) |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
3062 |
{ |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
3063 |
iCurrentContainer->HandleForegroundGainedL(); |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
3064 |
iDummyContainer->MakeVisible( EFalse ); |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
3065 |
iCurrentContainer->MakeVisible( ETrue ); |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
3066 |
RefreshUiPanesL(); |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
3067 |
} |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
3068 |
if( iSkinChangeNeeded && !iSkinChangeInProgress ) |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
3069 |
{ |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
3070 |
MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance(); |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
3071 |
if( skinInstance && !skinInstance->IsUpdateInProgress() ) |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
3072 |
{ |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
3073 |
RefreshIconsL(); |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
3074 |
} |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
83
diff
changeset
|
3075 |
} |
83 | 3076 |
} |
3077 |
||
3078 |
// --------------------------------------------------------------------------- |
|
3079 |
// |
|
3080 |
// --------------------------------------------------------------------------- |
|
3081 |
// |
|
3082 |
void CMmAppUi::HandleFullOrPartialForegroundLostL() |
|
3083 |
{ |
|
3084 |
DEBUG(("_Mm_:CMmAppUi::HandleWsEventL " |
|
3085 |
"- KAknFullOrPartialForegroundLost")); |
|
3086 |
if ( iCurrentContainer ) |
|
3087 |
{ |
|
3088 |
iCurrentContainer->HandleBackgroundGainedL(); |
|
3089 |
if ( IsRootdisplayedL() ) |
|
3090 |
{ |
|
3091 |
iCurrentContainer->RestoreWidgetPosition(); |
|
3092 |
iCurrentContainer->CacheWidgetPosition(); |
|
3093 |
} |
|
3094 |
} |
|
3095 |
} |
|
3096 |
||
3097 |
// End of File |