FCL/sf/app/jrt: comparison javauis/lcdui_akn/lcdui/src/CMIDDisplayable.cpp

equal deleted inserted replaced

-:e5618cc85d74
+:6c158198356e
 LcduiMidletAttributeValues::KPositionBottom))
 {
 iSKPositionWithQwerty = ESoftkeysBottom;
 }
 else
-{//default value
+{
+//default value
 iSKPositionWithQwerty = ESoftkeysRight;
 }
 // initialization of keypad information
 ReadOnScreenKeypadTypeFromSuiteSettings();
 iFullscreenCanvasLabelCacheIsValid(EFalse)
 #ifdef RD_TACTILE_FEEDBACK
 ,iPenInputServerConnected(EFalse)
 #endif //RD_TACTILE_FEEDBACK
 ,iIdOfMSKCommand(KErrNotFound)
+,iRestoreOrientation(EFalse)
+,iReleaseCnt(0)
 {
 #ifdef RD_JAVA_S60_RELEASE_9_2
 iSplitScreenKeyboard = EFalse;
 #endif // RD_JAVA_S60_RELEASE_9_2
 iAppUi = (CMIDAppUi*)java::ui::CoreUiAvkonLcdui::getInstance().getJavaUiAppUi()->getLcduiChild();
 iSoftKeys.ResetAndDestroy();
 delete iCommandList;
 if (iMenuHandler->GetDisplayable() == this)
-{//this may happen when the application is exiting
+{
+//this may happen when the application is exiting
 iMenuHandler->SetDisplayable(NULL);
 }
 DEBUG("- CMIDDisplayable::CMIDDisplayable");
 }
 * This means we are being deleted java side. We delete ourselves.
 * However before doing this we call ReplaceBehindAlertIfNeeded().
 **/
 void CMIDDisplayable::Dispose()
 {
-if (iAppUi)
-{
-iAppUi->UnSetEnv();
-}
 ReplaceBehindAlertIfNeeded();
 delete this;
 }
 {
 if ((this != iUIManager->GetDefaultDisplayable())
 && IsVisible()
 && (iMenuHandler->GetDisplayable())
 && (iMenuHandler->GetDisplayable()->Component()->Type() == EAlert))
-{// In this case we are a faded displayable behind a dialog
+{
+// In this case we are a faded displayable behind a dialog
 TInt numDisplayables = iAppUi->Displayables().Count();
 TInt index = -1;
 TInt currentPosition = 999;
 for (TInt i = 0; i < numDisplayables; i++)
 {
 {
 User::LeaveIfError(aItems.Append(item));
 }
 #else
 User::LeaveIfError(aItems.Append(item));
 #endif // RD_JAVA_S60_RELEASE_9_2
 }
 }
 }
 // Add form commands always
 PopulateMenuItemsWithListL(aMenuType, aMenuItems, iCommandList, EFalse);
 }
 else if (aMenuType == CMIDMenuHandler::EHelpMenu)
-{ // Add the Help commands only
+{
+// Add the Help commands only
 PopulateMenuItemsWithListL(aMenuType, aMenuItems, iCommandList, EFalse);
 }
 else if (aMenuType == CMIDMenuHandler::EOptionsMenu)
 {
 PopulateMenuItemsWithListL(aMenuType, aMenuItems, iItemCommandList, EFalse);
 {
 return;
 }
 if (aCommandId == EAknSoftkeyContextOptions)
-{ // MSK command to show context sensitive menu -> open it
+{
+// MSK command to show context sensitive menu -> open it
 ShowOkOptionsMenuL();
 }
 else if (aCommandId == KBuiltInMSKCommandId)
 {
 // Handle built-in command that is not accessible from menus, only in MSK.
 {
 CMIDForm* form = static_cast<CMIDForm*>(iContentControl);
 form->PostPendingUpEventL();
 }
 }
 #endif // RD_JAVA_S60_RELEASE_9_2
 }
 #ifdef RD_SCALABLE_UI_V2
 /** */
 // This function can be moved out from RD_SCALABLE_UI_V2 flag if needed.
 /** */
 void CMIDDisplayable::HandleStandardCommandL(const TCommandEntry& aCmdEntry)
 {
 TBool postJavaEvent = ETrue;
 if (aCmdEntry.iCommand->Id() < 0)
-{ //non-midlet command, see if there is an observer
+{
+//non-midlet command, see if there is an observer
 if (aCmdEntry.iCommand->Observer())
 {
 postJavaEvent = !(aCmdEntry.iCommand->Observer()->ProcessCommandL(aCmdEntry.iCommand));
 }
 }
 /** */
 void CMIDDisplayable::HandleItemCommandL(const TCommandEntry& aCmdEntry)
 {
 TBool postJavaEvent = ETrue;
 if (aCmdEntry.iCommand->Id() < 0)
-{ //non-midlet command, see if there is an observer
+{
+//non-midlet command, see if there is an observer
 if (aCmdEntry.iCommand->Observer())
 {
 postJavaEvent = !(aCmdEntry.iCommand->Observer()->ProcessCommandL(aCmdEntry.iCommand));
 }
 }
 CMIDForm* form = static_cast<CMIDForm*>(iContentControl);
 ASSERT(form);
 form->HandleForegroundL(aForeground);
 }
-HandleCanvasForeground(aForeground);
+// Notify canvas about gained foreground only if it is the current displayable
+if (!aForeground || iActive)
+{
+HandleCanvasForeground(aForeground);
+}
 if (aForeground)
 {
-//If MIDlet is sent to foreground and JAD-attribute BackgroundEvent=Pause,
+// If MIDlet is sent to foreground and JAD-attribute BackgroundEvent=Pause,
-//then call startApp() method for the MIDlet.
+// then call startApp() method for the MIDlet.
 if (iEnv.MidletAttributeIsSetToVal(LcduiMidletAttributes::KAttribBackgroundEvent,
 LcduiMidletAttributeValues::KPauseValue))
 {
 iEnv.PostMidletEvent(EStart);
+iAppUi->SetPauseAppState(EFalse);
 }
 }
 else //to background
 {
-//If MIDlet is sent to background and JAD-attribute BackgroundEvent=Pause,
+// If MIDlet is sent to background and JAD-attribute BackgroundEvent=Pause,
-//then call pauseApp() method for the MIDlet.
+// and window is not faded yet or window is already faded but pauseApp was not called yet,
+// then call pauseApp() method for the MIDlet.
+TBool isfaded = this->DrawableWindow()->IsFaded();
 if (iEnv.MidletAttributeIsSetToVal(LcduiMidletAttributes::KAttribBackgroundEvent,
-LcduiMidletAttributeValues::KPauseValue) &&
+LcduiMidletAttributeValues::KPauseValue) && (!isfaded ||
-!this->DrawableWindow()->IsFaded())
+(isfaded && !iAppUi->GetPauseAppState())))
 {
 iEnv.PostMidletEvent(EPause);
+iAppUi->SetPauseAppState(ETrue);
 }
 }
 DEBUG("- CMIDDisplayable::HandleForegroundL");
 }
 void CMIDDisplayable::HandleResourceChangeL(TInt aType)
 {
 DEBUG("+ CMIDDisplayable::HandleResourceChangeL");
 if (aType == KEikDynamicLayoutVariantSwitch)
-{ // dynamic orientation change
+{
+// dynamic orientation change
 // Correct rect is set for displayable
 if (iActive && iCanvasKeypad)
-{ //Update correct On-Screen Keypad type
+{
+//Update correct On-Screen Keypad type
 UpdateOnScreenKeypadSettings();
 }
 UpdateDisplayableRect();
 SetRect(iDisplayableRect);
 // MIDlet icon is resized in cpane SizeChanged()
 if (!iActive && iContentControl)
-{//The active displayable already gets this call by the CONE framework but
+{
+//The active displayable already gets this call by the CONE framework but
 //background displayables don't, so for example a background form won't be
 //re-laid-out if we don't call this here
 iContentControl->HandleResourceChange(aType);
 }
 #ifdef RD_SCALABLE_UI_V2
+// When current Displayble is Canvas or popup Displayable and the last
+// Displayble was Canvas, then OSK visual appearance is needed
+//  to be change.
 if (iUseOnScreenKeypad && iCanvasKeypad && (iActive || this->DrawableWindow()->IsFaded()))
 {
-iCanvasKeypad->UpdateVisualAppearanceL(*iCanvas, iOnScreenKeyboardType, *this);
+if (iActive)
+{
+// Current is Canvas.
+iCanvasKeypad->UpdateVisualAppearanceL(*iCanvas, iOnScreenKeyboardType, *this);
+}
+else
+{
+// Get current Displayable and the last fullscreen Displayble.
+MMIDDisplayable* current = iEnv.Current();
+const MMIDDisplayable* last = iEnv.LastFullscreenDisplayable();
+if (current && last && current->Component()
+&& last->Component())
+{
+// Get types of Displayables.
+MMIDComponent::TType lastType = last->Component()->Type();
+MMIDComponent::TType currentType = current->Component()->Type();
+if (lastType == ECanvas)
+{
+if (currentType == EAlert)
+{
+// Current is Alert and the last fullscreen
+// Displayable was Canvas.
+iCanvasKeypad->UpdateVisualAppearanceL(
+*iCanvas, iOnScreenKeyboardType, *this);
+}
+else if (currentType == ETextBox && current->IsPopupTextBox())
+{
+// Current is popup TextBox and the last fullscreen
+// Displayable was Canvas.
+iCanvasKeypad->UpdateVisualAppearanceL(
+*iCanvas, iOnScreenKeyboardType, *this);
+}
+}
+}
+}
 }
 #endif // RD_SCALABLE_UI_V2
 iFullscreenCanvasLabelCacheIsValid = EFalse;
 }
 else if (aType == KEikColorResourceChange ||
 aType == KAknsMessageSkinChange  ||
 aType == KUidValueCoeColorSchemeChangeEvent)
-{ //skin or color change, may need to recreate ctx icon
+{
+//skin or color change, may need to recreate ctx icon
 // send skin change event to non-active controls so they can also
 // reload graphics
 if (!iActive && iContentControl)
 {
 iContentControl->HandleResourceChange(aType);
 if ((aType == KEikInputLanguageChange) && iContentControl)
 {
 iContentControl->HandleResourceChange(aType);
 }
 }
+#ifdef RD_JAVA_NGA_ENABLED
+void CMIDDisplayable::HandleFullOrPartialForegroundL(TBool aFullOrPartialFg)
+{
+CMIDCanvas* canvas = GetContentCanvas();
+if (canvas)
+{
+canvas->HandleFullOrPartialForegroundL(aFullOrPartialFg, iActive);
+}
+}
+void CMIDDisplayable::HandleFreeGraphicsMemory()
+{
+CMIDCanvas* canvas = GetContentCanvas();
+if (canvas)
+{
+canvas->FreeGraphicsMemory(ETrue);
+}
+}
+#endif // RD_JAVA_NGA_ENABLED
 /**
 * The container has changed it available drawing space, so resize
 * the displayable to fit and post a size changed event.
 **/
 //
 TRect CMIDDisplayable::GetCanvasRectFromLaf()
 {
 DEBUG("+ CMIDDisplayable::GetCanvasRectFromLaf");
-TRect resultRect;
+TRect resultRect = TRect(0,0,0,0);
 AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EScreen, resultRect);
 TAknLayoutRect canvasRect;
 TAknLayoutRect mainPane;
 TAknLayoutRect mainMidpPane;
-//Read canvasRect from LAF depending on keyboard type
+#ifdef RD_JAVA_S60_RELEASE_9_2
-switch (iOnScreenKeyboardType)
+// If split screen is open, then it is needed return current size of Canvas.
-{
+if (iSplitScreenKeyboard)
-case EOnScreenKeypadValueNo:
+{
-break;
+CMIDCanvas* canvas = GetContentCanvas();
-case EOnScreenKeypadValueNavigationKeys:
+if (canvas)
 {
-if (iIsFullScreenMode)
+resultRect = canvas->ViewRect();
-{
+}
-if (!Layout_Meta_Data::IsLandscapeOrientation())  //portrait
+}
-{
+else
-canvasRect.LayoutRect(resultRect, AknLayoutScalable_Avkon::midp_canvas_pane(1).LayoutLine());
+{
-}
+#endif // RD_JAVA_S60_RELEASE_9_2
-else //landscape
+//Read canvasRect from LAF depending on keyboard type
-{
+switch (iOnScreenKeyboardType)
-canvasRect.LayoutRect(resultRect, AknLayoutScalable_Avkon::midp_canvas_pane(8).LayoutLine());
+{
-}
+case EOnScreenKeypadValueNo:
-}
+break;
-else //normal mode
+case EOnScreenKeypadValueNavigationKeys:
 {
-if (!Layout_Meta_Data::IsLandscapeOrientation())  //portrait
+if (iIsFullScreenMode)
 {
-mainPane.LayoutRect(resultRect, AknLayoutScalable_Avkon::main_pane(3).LayoutLine());
+if (!Layout_Meta_Data::IsLandscapeOrientation())  //portrait
-mainMidpPane.LayoutRect(mainPane.Rect(), AknLayoutScalable_Avkon::main_midp_pane(0).LayoutLine());
-canvasRect.LayoutRect(mainMidpPane.Rect(), AknLayoutScalable_Avkon::midp_canvas_pane(4).LayoutLine());
-}
-else //landscape
-{
-mainPane.LayoutRect(resultRect, AknLayoutScalable_Avkon::main_pane(4).LayoutLine());
-mainMidpPane.LayoutRect(mainPane.Rect(), AknLayoutScalable_Avkon::main_midp_pane(1).LayoutLine());
-canvasRect.LayoutRect(mainMidpPane.Rect(), AknLayoutScalable_Avkon::midp_canvas_pane(7).LayoutLine());
-}
-}
-resultRect = canvasRect.Rect();
-break;
-}
-case EOnScreenKeypadValueGameActions:
-{
-if (iIsFullScreenMode)
-{
-if (!Layout_Meta_Data::IsLandscapeOrientation())  //portrait
-{
-canvasRect.LayoutRect(resultRect, AknLayoutScalable_Avkon::midp_canvas_pane(2).LayoutLine());
-}
-else //landscape
-{
-canvasRect.LayoutRect(resultRect, AknLayoutScalable_Avkon::midp_canvas_pane(3).LayoutLine());
-}
-}
-else //normal mode
-{
-if (!Layout_Meta_Data::IsLandscapeOrientation())  //portrait
-{
-mainPane.LayoutRect(resultRect, AknLayoutScalable_Avkon::main_pane(3).LayoutLine());
-mainMidpPane.LayoutRect(mainPane.Rect(), AknLayoutScalable_Avkon::main_midp_pane(0).LayoutLine());
-canvasRect.LayoutRect(mainMidpPane.Rect(), AknLayoutScalable_Avkon::midp_canvas_pane(5).LayoutLine());
-}
-else//landscape
-{
-mainPane.LayoutRect(resultRect, AknLayoutScalable_Avkon::main_pane(4).LayoutLine());
-mainMidpPane.LayoutRect(mainPane.Rect(), AknLayoutScalable_Avkon::main_midp_pane(1).LayoutLine());
-canvasRect.LayoutRect(mainMidpPane.Rect(), AknLayoutScalable_Avkon::midp_canvas_pane(6).LayoutLine());
-}
-}
-resultRect = canvasRect.Rect();
-break;
-}
-case EOnScreenKeypadValueLskRsk:
-{
-if (iIsFullScreenMode)
-{
-if (!Layout_Meta_Data::IsLandscapeOrientation())  //portrait
-{
-canvasRect.LayoutRect(resultRect, AknLayoutScalable_Avkon::midp_canvas_pane(11).LayoutLine());
-}
-else //landscape
-{
-if (iSKPositionWithQwerty == ESoftkeysRight)
 {
-canvasRect.LayoutRect(resultRect, AknLayoutScalable_Avkon::midp_canvas_pane(10).LayoutLine());
+canvasRect.LayoutRect(resultRect, AknLayoutScalable_Avkon::midp_canvas_pane(1).LayoutLine());
 }
-else
+else //landscape
 {
+canvasRect.LayoutRect(resultRect, AknLayoutScalable_Avkon::midp_canvas_pane(8).LayoutLine());
+}
+}
+else //normal mode
+{
+if (!Layout_Meta_Data::IsLandscapeOrientation())  //portrait
+{
+mainPane.LayoutRect(resultRect, AknLayoutScalable_Avkon::main_pane(3).LayoutLine());
+mainMidpPane.LayoutRect(mainPane.Rect(), AknLayoutScalable_Avkon::main_midp_pane(0).LayoutLine());
+canvasRect.LayoutRect(mainMidpPane.Rect(), AknLayoutScalable_Avkon::midp_canvas_pane(4).LayoutLine());
+}
+else //landscape
+{
+mainPane.LayoutRect(resultRect, AknLayoutScalable_Avkon::main_pane(4).LayoutLine());
+mainMidpPane.LayoutRect(mainPane.Rect(), AknLayoutScalable_Avkon::main_midp_pane(1).LayoutLine());
+canvasRect.LayoutRect(mainMidpPane.Rect(), AknLayoutScalable_Avkon::midp_canvas_pane(7).LayoutLine());
+}
+}
+resultRect = canvasRect.Rect();
+break;
+}
+case EOnScreenKeypadValueGameActions:
+{
+if (iIsFullScreenMode)
+{
+if (!Layout_Meta_Data::IsLandscapeOrientation())  //portrait
+{
+canvasRect.LayoutRect(resultRect, AknLayoutScalable_Avkon::midp_canvas_pane(2).LayoutLine());
+}
+else //landscape
+{
+canvasRect.LayoutRect(resultRect, AknLayoutScalable_Avkon::midp_canvas_pane(3).LayoutLine());
+}
+}
+else //normal mode
+{
+if (!Layout_Meta_Data::IsLandscapeOrientation())  //portrait
+{
+mainPane.LayoutRect(resultRect, AknLayoutScalable_Avkon::main_pane(3).LayoutLine());
+mainMidpPane.LayoutRect(mainPane.Rect(), AknLayoutScalable_Avkon::main_midp_pane(0).LayoutLine());
+canvasRect.LayoutRect(mainMidpPane.Rect(), AknLayoutScalable_Avkon::midp_canvas_pane(5).LayoutLine());
+}
+else//landscape
+{
+mainPane.LayoutRect(resultRect, AknLayoutScalable_Avkon::main_pane(4).LayoutLine());
+mainMidpPane.LayoutRect(mainPane.Rect(), AknLayoutScalable_Avkon::main_midp_pane(1).LayoutLine());
+canvasRect.LayoutRect(mainMidpPane.Rect(), AknLayoutScalable_Avkon::midp_canvas_pane(6).LayoutLine());
+}
+}
+resultRect = canvasRect.Rect();
+break;
+}
+case EOnScreenKeypadValueLskRsk:
+{
+if (iIsFullScreenMode)
+{
+if (!Layout_Meta_Data::IsLandscapeOrientation())  //portrait
+{
+canvasRect.LayoutRect(resultRect, AknLayoutScalable_Avkon::midp_canvas_pane(11).LayoutLine());
+}
+else //landscape
+{
+if (iSKPositionWithQwerty == ESoftkeysRight)
+{
+canvasRect.LayoutRect(resultRect, AknLayoutScalable_Avkon::midp_canvas_pane(10).LayoutLine());
+}
+else
+{
 #ifdef RD_JAVA_S60_RELEASE_9_2
 canvasRect.LayoutRect(resultRect, AknLayoutScalable_Avkon::midp_canvas_pane(9).LayoutLine());
 #else
 resultRect = TRect(80,0,560,360); // Layout data not defined in older releases.
 DEBUG("- CMIDDisplayable::GetCanvasRectFromLaf");
 return resultRect;
 #endif // RD_JAVA_S60_RELEASE_9_2
+}
 }
 }
-}
+else//normal mode
-else//normal mode
+{
-{
+//no need to present LSK&RSK in OSK when in normal mode Canvas
-//no need to present LSK&RSK in OSK when in normal mode Canvas
+resultRect = TRect(0,0,0,0);
-resultRect = TRect(0,0,0,0);
+DEBUG("- CMIDDisplayable::GetCanvasRectFromLaf");
-DEBUG("- CMIDDisplayable::GetCanvasRectFromLaf");
+return resultRect;
-return resultRect;
+}
-}
+resultRect = canvasRect.Rect();
-resultRect = canvasRect.Rect();
+break;
-break;
+}
 }
-default:
+#ifdef RD_JAVA_S60_RELEASE_9_2
-{
+}
-resultRect = TRect(0,0,0,0);
+#endif // RD_JAVA_S60_RELEASE_9_2
-break;
-}
-}
 DEBUG("- CMIDDisplayable::GetCanvasRectFromLaf");
 return resultRect;
 }
 ASSERT(iContent);
 iActive = aCurrent;
 const TType type = iContent->Type();
-HandleCanvasForeground(aCurrent);
 if (aCurrent)
 {
+HandleCanvasForeground(aCurrent);
 // when setting displayable as current remember to deactivate
 // the default displayable if it has not been done yet
 CMIDDisplayable* defaultDisplayable =
 iUIManager->GetDefaultDisplayable();
 if (defaultDisplayable &&
 {
 HandleDeactivated();
 }
 if (type == EAlert)
-{// alerts do their on thing, they rely on sleeping dialogs in fact
+{
+// alerts do their on thing, they rely on sleeping dialogs in fact
 CMIDAlert* alert = static_cast<CMIDAlert*>(iContentControl);
 TRAP_IGNORE(alert->HandleCurrentL(aCurrent));
 UpdateTickerL();
 }
 else if (type == ETextBox && iIsPopupTextBox)
-{// Pop-up TextBox do their on thing, they rely on sleeping dialogs in fact
+{
+// Pop-up TextBox do their on thing, they rely on sleeping dialogs in fact
 CMIDTextBoxDialogControl* textBoxDialogControl =
 static_cast<CMIDTextBoxDialogControl*>(iContentControl);
 TRAP_IGNORE(textBoxDialogControl->HandleCurrentL(aCurrent));
 }
 else
 !(iMenuHandler->GetDisplayable()->Component()->Type() == ETextBox &&
 iMenuHandler->GetDisplayable()->IsPopupTextBox()))
 {
 MakeVisible(EFalse);
 }
+// Notify canvas after changing the visibility
+HandleCanvasForeground(aCurrent);
 }
 iContentControl->SetFocus(aCurrent);
 switch (type)
 {
 iDisplayableRect = canvasRect;
 }
 #endif //RD_SCALABLE_UI_V2
 if (!iActive)
-{ // Restore pane visibility. There is one pane for all displayables.
+{
+// Restore pane visibility. There is one pane for all displayables.
 // Only active displayable can decide about the pane visibility.
 // Others should not change it.
 pane->MakeVisible(paneVisible);
 }
 iCba->SetBoundingRect(iDisplayableRect);
 // Control pane area has to be reduced
 iCba->ReduceRect(iDisplayableRect);
 if (!iActive)
-{ // Restore cba visibility. There is one cba for all displayables.
+{
+// Restore cba visibility. There is one cba for all displayables.
 // Only active displayable can decide about the cba visibility.
 // Others should not change it.
 iCba->MakeVisible(cbaVisible);
 }
 }
 // Displayable rect is updated and set
 UpdateDisplayableRect();
 SetRect(iDisplayableRect);
 if (iActive)
-{ //this means we are the active displayable
+{
+//this means we are the active displayable
 UpdateVisualAppearanceL();
 }
 if (aFullScreen)
 {
 void CMIDDisplayable::SetMSKCommand(CMIDCommand* aMSKCommand)
 {
 CMIDCommand* oldMSKCommand = iMSKCommand;
 iMSKCommand = aMSKCommand;
 if (oldMSKCommand != iMSKCommand)
-{ // avoid unnecessary updating to avoid flickering
+{
+// avoid unnecessary updating to avoid flickering
 TRAP_IGNORE(InitializeCbasL());
 }
 }
 void CMIDDisplayable::SetSelectCommand(CMIDCommand* aSelectCommand)
 {
 if (aSelectCommand != iSelectCommand)
-{ // avoid unnecessary updating to avoid flickering
+{
+// avoid unnecessary updating to avoid flickering
 iSelectCommand = aSelectCommand;
 TRAP_IGNORE(InitializeCbasL());
 }
 }
 #ifdef RD_JAVA_S60_RELEASE_9_2
 if (iSelectCommand)
 #else
 if (!iSelectCommandEnabled && iSelectCommand)
 #endif // RD_JAVA_S60_RELEASE_9_2
 {
 // remove the select command
 for (TInt j = 0; j < lists.Count(); j++)
 {
 if (lists[j])
 if (iMSKCommand)
 {
 // There is a explicitly set MSK command -> it takes the precedence and gets MSK
 TInt commandId = GetInternalCommandIdFor(iMSKCommand);
 if (commandId == KCommandIdNotFound)
-{// it must be a built-in command, it is the only command not contained in the command lists
+{
+// it must be a built-in command, it is the only command not contained in the command lists
 commandId = KBuiltInMSKCommandId;
 }
 iCba->SetCommandL(KMSKPositionInCBA, commandId, iMSKCommand->ShortLabel());
 iIdOfMSKCommand = commandId;
 }
 else if (!iMSKCommand && (contextMenuSize == 1))
 {
 // There is no explicitly set MSK command and just one for the context menu.
 // Instead of a menu, put the command to MSK directly.
 RPointerArray<CMIDCommand> commands;
-GetOkOptionsMenuCommands(commands);
+GetOkOptionsMenuCommandsL(commands);
 ASSERT(commands.Count() == 1);
 CMIDCommand* command = commands[0];
 commands.Close();
 iCba->SetCommandL(KMSKPositionInCBA,
 GetInternalCommandIdFor(command),
 {
 TCommandEntry cmd;
 cmd.iCommand = NULL;
 if (iItemCommandList && iItemCommandList->Count() > 0)
-{// there can only be one so pick the first one
+{
+// there can only be one so pick the first one
 cmd = iItemCommandList->At(0);
 if (cmd.iCommand->IsMappedToSoftKey())
 {
 HandleItemCommandL(cmd);
 }
 else if (iCommandList && iCommandList->Count() > 0)
 {
 TInt index = iCommandList->HighestPriorityCommand(MMIDCommand::EOk);
 if (index == KErrNotFound)
-{// there can only be one so if the other one was KErrNotFound, this must be it
+{
+// there can only be one so if the other one was KErrNotFound, this must be it
 index = iCommandList->HighestPriorityCommand(MMIDCommand::EItem);
 }
 cmd = iCommandList->At(index);
 if (cmd.iCommand->IsMappedToSoftKey())
 }
 return EFalse;
 }
+// ---------------------------------------------------------------------------
+// See how many commands eligible for the screen or help - optins menu we have.
+// If we have only one command call ProcessCommandL. Otherwise show
+// options menu. In these two cases return ETrue. If zero or negative
+// commands do nothing and return EFalse.
+// ---------------------------------------------------------------------------
+TBool CMIDDisplayable::ShowScreenOrHelpOptionsMenuL()
+{
+TBool ret = EFalse;
+TInt numOkCommands = NumCommandsForOkOptionsMenu();
+TInt numScreenOrHelpCommands = NumCommandsForScreenOrHelpOptionsMenu();
+TInt screenOrHelpCmdIndex = GetHighestPriorityScreenOrHelpCommand();
+// There is no OK or ITEM command defined on form
+// There are SCREEN or HELP commands
+if (iCommandList && screenOrHelpCmdIndex != KErrNotFound && numOkCommands == 0)
+{
+CMIDCommand *command = NULL;
+if (iCommandList->IsValidIndex(screenOrHelpCmdIndex))
+{
+command = iCommandList->At(screenOrHelpCmdIndex).iCommand;
+}
+if (command && (command->CommandType() == MMIDCommand::EScreen ||
+command->CommandType() == MMIDCommand::EHelp) && iMenuHandler)
+{
+if (numScreenOrHelpCommands > 1)
+{
+iMenuHandler->ShowMenuL(CMIDMenuHandler::EOptionsMenu);
+ret = ETrue;
+}
+else if (numScreenOrHelpCommands == 1)
+{
+ProcessCommandL(iCommandList->CommandOffset());
+ret = ETrue;
+}
+}
+}
+return ret;
+}
 // ---------------------------------------------------------------------------
 // Return the number of commands that can be displayed in the ok-options menu.
 // If form has set any item commands in iItemCommandList this means that there is
 // a form item focused and the commands for this item should be displayed in
 }
 ret++;
 }
 }
+return ret;
+}
+// ---------------------------------------------------------------------------
+// Return the number of commands that can be displayed in the screen or help - options menu.
+// Form item screen or help commands are ignored
+//
+// TextBox/TextField device-provided commands:
+// - "Fetch number"
+// - "Call"
+// - "Fetch e-mail address"
+// are exception. Those are visible ONLY in Options menu so here they are
+// removed from context menu commands count.
+// ---------------------------------------------------------------------------
+TInt CMIDDisplayable::NumCommandsForScreenOrHelpOptionsMenu() const
+{
+TInt ret = 0;
+// Add SCREEN and HELP commands from form
+if (iCommandList)
+{
+TInt numCommands = iCommandList->Count();
+for (TInt i = 0; i < numCommands; i++)
+{
+const CMIDCommand& command = *(iCommandList->At(i).iCommand);
+if (((command.CommandType() == MMIDCommand::EScreen) ||
+(command.CommandType() == MMIDCommand::EHelp)) &&
+(command.Id() != CMIDEdwinUtils::EMenuCommandFetchPhoneNumber) &&
+(command.Id() != CMIDEdwinUtils::EMenuCommandFetchEmailAddress) &&
+(command.Id() != CMIDEdwinUtils::EMenuCommandCreatePhoneCall))
+{
+TBool selectCommand = (&command == iSelectCommand);
+if (selectCommand && !iSelectCommandEnabled)
+{
+continue;
+}
+ret++;
+}
+}
+}
 return ret;
 }
 // ---------------------------------------------------------------------------
 // Returns a pointer to the command in the iCommandList with the specified
 // they are not added to context menu commands array.
 //
 // If there are item commands, there are placed first. Form commands of ITEM
 // and OK type are then included always.
 // ---------------------------------------------------------------------------
-void CMIDDisplayable::GetOkOptionsMenuCommands(RPointerArray<CMIDCommand>& aCommands) const
+void CMIDDisplayable::GetOkOptionsMenuCommandsL(RPointerArray<CMIDCommand>& aCommands) const
 {
 aCommands.Reset();
 if (iItemCommandList && iItemCommandList->Count() > 0)
 {
 for (TInt i = 0; i < iItemCommandList->Count(); i++)
 const CMIDCommand* command = iItemCommandList->At(i).iCommand;
 if ((command->Id() != CMIDEdwinUtils::EMenuCommandFetchPhoneNumber) &&
 (command->Id() != CMIDEdwinUtils::EMenuCommandFetchEmailAddress) &&
 (command->Id() != CMIDEdwinUtils::EMenuCommandCreatePhoneCall))
 {
-aCommands.Append(command);
+aCommands.AppendL(command);
 }
 }
 }
 // add Form commands always
 {
 if (!iSelectCommandEnabled && command == iSelectCommand)
 {
 continue;
 }
-aCommands.Append(command);
+aCommands.AppendL(command);
 }
 }
 }
 /**
 // If there is a context menu available, forward events to long tap detector
 #ifdef RD_JAVA_S60_RELEASE_9_2
 if (NumCommandsForOkOptionsMenu() > 0)
 #else
 if (NumCommandsForOkOptionsMenu() > 1)
 #endif // RD_JAVA_S60_RELEASE_9_2
 {
 iLongTapDetector->PointerEventL(aPointerEvent);
 }
 if (aPointerEvent.iType == TPointerEvent::EButton1Up && iLongTapDetected)
 {
 {
 #ifdef RD_JAVA_S60_RELEASE_9_2
 PopulateMenuItemsWithListL(CMIDMenuHandler::EPopUpMenu, menuItems, iItemCommandList, EFalse);
 #else
 PopulateMenuItemsWithListL(CMIDMenuHandler::EOkMenu, menuItems, iItemCommandList, EFalse);
 #endif // RD_JAVA_S60_RELEASE_9_2
 }
 // Add form commands always
 #ifdef RD_JAVA_S60_RELEASE_9_2
 PopulateMenuItemsWithListL(CMIDMenuHandler::EPopUpMenu, menuItems, iCommandList, EFalse);
 #else
 PopulateMenuItemsWithListL(CMIDMenuHandler::EOkMenu, menuItems, iCommandList, EFalse);
 #endif // RD_JAVA_S60_RELEASE_9_2
 #ifdef RD_JAVA_S60_RELEASE_9_2
 if (menuItems.Count() > 0)
 #else
 if (menuItems.Count() > 1)
 #endif // RD_JAVA_S60_RELEASE_9_2
 {
 // recreate stylus popup menu because it does not have method
 // for clearing the menu items
 delete iStylusPopupMenu;
 iStylusPopupMenu = NULL;
 TDirectContentsRect rect(aRect);
 TInt index = iDirectContentsRects.Find(
 rect, TIdentityRelation< TDirectContentsRect >(CMIDDisplayable::MatchDirectContentsRects));
 if (index == KErrNotFound)
 {
-iDirectContentsRects.Append(rect);
+TInt err = iDirectContentsRects.Append(rect);
-UpdateDirectContentsRegion();
+if (KErrNone == err)
+{
+UpdateDirectContentsRegion();
+}
+else
+{
+DEBUG_INT("CMIDDisplayable::AddDirectContentArea - RArray append error %d", err);
+}
 }
 else
 {
 iDirectContentsRects[ index ].iRefCount++;
 }
 DEBUG("- CMIDDisplayable::RenewFullscreenCanvasLabelCacheL");
 }
 void CMIDDisplayable::HandleCanvasForeground(TBool aForeground)
 {
-if (iContent && iContentControl &&
+CMIDCanvas* canvas = GetContentCanvas();
-(iContent->Type() == MMIDComponent::ECanvas ||
+if (canvas)
-iContent->Type() == MMIDComponent::EGameCanvas))
+{
-{
-CMIDCanvas* canvas = static_cast<CMIDCanvas*>(iContentControl);
 canvas->HandleForeground(aForeground);
 }
 }
 void CMIDDisplayable::HandleApplicationBackground()
 HideIndicator(pane, EEikStatusPaneUidMessage);
 HideIndicator(pane, EEikStatusPaneUidClock);
 HideIndicator(pane, EEikStatusPaneUidDigitalClock);
 }
+CMIDCanvas* CMIDDisplayable::GetContentCanvas()
+{
+CMIDCanvas* ret = NULL;
+if (iContent && iContentControl &&
+(iContent->Type() == MMIDComponent::ECanvas ||
+iContent->Type() == MMIDComponent::EGameCanvas))
+{
+ret = static_cast<CMIDCanvas*>(iContentControl);
+}
+return ret;
+}
 CPropertyWatch* CPropertyWatch::NewL(MMIDDisplayable* aDisplayable)
 {
 DEBUG("+ CPropertyWatch::NewL");
 CPropertyWatch* self = new(ELeave) CPropertyWatch;
 CleanupStack::Pop(self);
 DEBUG("- CPropertyWatch::NewL");
 return self;
+}
+void CMIDDisplayable::FixOrientation()
+{
+TBool tmpRestoreOrientation;
+if (!iAvkonAppUi)
+{
+return;
+}
+iOldUiOrientation = iAvkonAppUi->Orientation();
+tmpRestoreOrientation = (iOldUiOrientation == CAknAppUiBase::EAppUiOrientationUnspecified) ? ETrue : EFalse;
+// Fix the orientation when was set to unspecified only
+if (tmpRestoreOrientation)
+{
+TRAP_IGNORE(iAvkonAppUi->SetOrientationL(CAknAppUiBase::EAppUiOrientationLandscape));
+iRestoreOrientation = ETrue;
+++iReleaseCnt;
+}
+}
+void CMIDDisplayable::ReleaseOrientation()
+{
+if (!iAvkonAppUi)
+{
+return;
+}
+if (iReleaseCnt > 0)
+{
+--iReleaseCnt;
+if (iReleaseCnt == 0 && iRestoreOrientation)
+{
+TRAP_IGNORE(iAvkonAppUi->SetOrientationL(iOldUiOrientation));
+iRestoreOrientation = EFalse;
+}
+}
 }
 CPropertyWatch::CPropertyWatch()
 : CActive(0)
 {

branch	RCL_3
changeset 60	6c158198356e
parent 59	e5618cc85d74