1 /*

     2 * Copyright (c) 2003-2009 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:  Implementation of the CMIDDisplayable class

    15 *

    16 */

    17 

    18 

    19 #include <bldvariant.hrh>

    20 

    21 #include <memory>

    22 #include <apgwgnam.h>

    23 #include <eikenv.h>

    24 #include <coecntrl.h>

    25 #include <uikon.hrh>

    26 // using BaflUtils::CopyWithTruncation in PopulateMenuItemsWithListL function

    27 #include <bautils.h>

    28 // using MMIDImage and MMIDBitmapImage

    29 #include <lcdgr.h>

    30 // macros definitions for resources

    31 #include <lcdui.rsg>

    32 // using TMifLcdui enumeration

    33 #include <lcdui.mbg>

    34 // Used for Avkon toolbar disabling

    35 #include <akntoolbar.h>

    36 // Layout data

    37 #include <layoutmetadata.cdl.h>

    38 #include <aknlayoutscalable_avkon.cdl.h>

    39 #include <e32property.h>

    40 //#include <SysStartup.h>

    41 #include <aknappui.h>

    42 // using CAknTitlePane in ShowTitleL() function

    43 #include <akntitle.h>

    44 // using CAknContextPane in SetMIDletIconL() function to show midlet icon

    45 #include <akncontext.h>

    46 // used for label converting for commands (in PopulateMenuItemsWithListL function)

    47 #include <AknBidiTextUtils.h>

    48 #include <avkon.hrh>

    49 #include <avkon.rsg>

    50 #include <AvkonInternalCRKeys.h>

    51 #include <aknstyluspopupmenu.h>

    52 #include <eiklabel.h>

    53 #ifdef RD_SCALABLE_UI_V2

    54 // For requiring available keyboards in the device

    55 #include <PtiEngine.h>

    56 #include <PtiDefs.h>

    57 #endif // RD_SCALABLE_UI_V2

    58 

    59 // OMJ storage

    60 #include <applicationinfo.h>

    61 #include <javastorageentry.h>

    62 #include <javastorage.h>

    63 #include <javastoragenames.h>

    64 #include <javauid.h>

    65 #include <javasymbianoslayer.h>

    66 

    67 #include "CMIDDisplayable.h"

    68 // API used in several places (iAppUi is member)

    69 #include "CMIDAppUi.h"

    70 #include "CMIDCanvas.h"

    71 // used in SetComponentL function

    72 #include "CMIDDefaultBackground.h"

    73 // API for ticker on displayable

    74 #include "CMIDTicker.h"

    75 #include "CMIDComponentFactory.h"

    76 // used for setting iMenuHandler from iUIManager (MenuHandler)

    77 #include "CMIDUIManager.h"

    78 #include "CMIDCommand.h"

    79 #include "CMIDForm.h"

    80 // using CMIDUtils::CopyBitmapL in SetMIDletIconL() function

    81 #include "CMIDUtils.h"

    82 // used in SetComponentL function

    83 // and used in several place for actions specific for Alert (SetTitleL, ContentSize, HandleCurrentL)

    84 #include "CMIDAlert.h"

    85 #include "CMIDAlertDialog.h"

    86 #include "CMIDEdwin.h"

    87 // used in SetComponentL function

    88 // used in HandleCurrentL function

    89 #include "CMIDTextBoxControl.h"

    90 #include "CMIDTextBoxDialogControl.h"

    91 // used in SetComponentL function

    92 #include "CMIDList.h"

    93 // using API for softkeys and their commands

    94 #include "CMIDSoftKey.h"

    95 #include "CMIDCanvasKeypad.h"

    96 #include "CMIDTicker.h"

    97 

    98 #include "coreuiavkonlcdui.h"

    99 #include "coreuiappui.h"

   100 

   101 #include <j2me/jdebug.h>

   102 

   103 /** This macro is executed each time a trapped call returns an error code different than KErrNone */

   104 #undef  TRAP_INSTRUMENTATION_LEAVE

   105 #define TRAP_INSTRUMENTATION_LEAVE(aResult) DEBUG_INT2("In CMIDDisplayable.cpp, trapped method was called at line %D and got exception %D", __LINE__, aResult);

   106 

   107 const TGulBorder::TBorderType KMIDLetBorder = TGulBorder::EThickDeepRaisedWithOutline;

   108 

   109 const TInt KCommandIdNotFound = -10000;

   110 const TInt KCommandIdBase = 7000;

   111 const TInt KItemCommandIdBase = 8000; // must be greater than KCommandIdBase

   112 // Special ID for built-in MSK commands. Handling of them is different because

   113 // built-in commands are not visible in menus, only in MSK. Built-in MSK commands

   114 // are commands that are set using SetMSKCommand method, but are not found in

   115 // command lists.

   116 const TInt KBuiltInMSKCommandId = 9000;

   117 

   118 // Index of the MSK in CBA, to be used when adding MSK command to CBA

   119 const TInt KMSKPositionInCBA = 3;

   120 

   121 /** The maximum number of softkeys on the device.

   122 */

   123 const TInt KMaxNumberOfSoftKeys = 2;

   124 const TInt KListLongTapAnimationDelay = 400000;

   125 const TInt KListLongTapDelay = 800000;

   126 

   127 

   128 /*

   129  * The allowed command types for softkeys,

   130  *   -1 means we have run out of allowed types.

   131  * More restrictive sks, eg the right sk, should come

   132  * before more permissive sks. This array is used to

   133  * initialise iSoftkeys.

   134  */

   135 const TInt KAllowedCommandTypesForSoftkeys[KMaxNumberOfSoftKeys][9] =

   136 {

   137     // Right softkey

   138     {

   139         MMIDCommand::EStop,

   140         MMIDCommand::ECancel,

   141         MMIDCommand::EBack,

   142         MMIDCommand::EExit,

   143         -1,

   144         -1,

   145         -1,

   146         -1,

   147         -1

   148     },

   149 

   150     // Left softkey

   151     {

   152         MMIDCommand::EStop,

   153         MMIDCommand::EOk,

   154         MMIDCommand::ECancel,

   155         MMIDCommand::EItem,

   156         MMIDCommand::EScreen,

   157         MMIDCommand::EBack,

   158         MMIDCommand::EHelp,

   159         MMIDCommand::EExit,

   160         -1

   161     }

   162 };

   163 

   164 /**

   165   The CBA that can have an options menu if commands are available.

   166   This is used as a zero-based index in iSoftkeys and must be

   167   less than KMaxNumberOfSoftKeys.

   168 */

   169 const TInt KOptionsMenuCBAIndex = 1; //left sk

   170 

   171 /**

   172   The sk position in the CBA. Must use the same ordering as

   173   KAllowedCommandTypesForSoftkeys and is used to initialise

   174   iSoftkeys.

   175 */

   176 const TInt KPositionsInCBAForSoftkeys[KMaxNumberOfSoftKeys] =

   177 {

   178     2, //Right softkey

   179     0 //Left softkey

   180 };

   181 

   182 // One ticker can be added more than one displayable. So keep track of all of them

   183 const TInt KAddDisplayable = 1; // add the displable to the list in ticker

   184 const TInt KRemoveDisplayable = 0; // Remove the displable from the list in ticker

   185 

   186 const TInt KSoftKeyLabelPropertyPositionsMSKIndex = 2;

   187 const TInt KSoftKeyLabelPropertyPositionsInCBA[ KSoftKeyLabelPropertyNumberOfSoftKeys ] =

   188 {

   189     0,  //LSK

   190     2,  //RSK

   191     3   //MSK

   192 };

   193 

   194 // class CMIDDisplayable

   195 

   196 CMIDDisplayable* CMIDDisplayable::NewL(MMIDEnv& aEnv,CMIDUIManager& aUIManager)

   197 {

   198     CMIDDisplayable* displayable = new(ELeave)CMIDDisplayable(aEnv,aUIManager);

   199     CleanupStack::PushL(displayable);

   200     displayable->ConstructL();

   201     CleanupStack::Pop(displayable);

   202     return displayable;

   203 }

   204 

   205 // ---------------------------------------------------------------------------

   206 //

   207 // ---------------------------------------------------------------------------

   208 //

   209 void CMIDDisplayable::ConstructL()

   210 {

   211     DEBUG("+ CMIDDisplayable::ConstructL");

   212 

   213     // Menu/commands

   214     // NOTE: Menu handler member variable has to be valid before

   215     // the <code>CCoeContol::MakeVisible</code> method is called

   216     // because the <code>CMIDDisplayable::MopSupplyObject</code> method

   217     // might be called because of that.

   218     iMenuHandler = iUIManager->OpenMenuHandlerL();

   219     iCommandList = new(ELeave) CMIDCommandList();

   220     iCommandList->SetCommandOffset(KCommandIdBase);

   221     iMSKCommand = NULL;

   222     iDisplayableBehindPopup = NULL;

   223 

   224     iEnv.AddObserverL(*this);

   225     CreateWindowL(&iEikonEnv->RootWin());

   226     SetMopParent(java::ui::CoreUiAvkonLcdui::getInstance().getJavaAknAppUi());

   227 

   228     //All windows are created invisible and then made visible

   229     //in SetComponentL(), except for Alerts (dialogs)

   230     MakeVisible(EFalse);

   231     Window().SetOrdinalPosition(-1);

   232 

   233     Window().EnableOnEvents(EEventControlOnlyWhenVisible);

   234     EnableDragEvents();

   235 

   236     // Long tap detection

   237     iLongTapDetector = CAknLongTapDetector::NewL(this);

   238 

   239     // SoftKeys

   240     for (TInt i = 0; i < KMaxNumberOfSoftKeys; i++)

   241     {

   242         CMIDSoftKey* softKey = CMIDSoftKey::NewLC(i, &(KAllowedCommandTypesForSoftkeys[i][0]),

   243                                KPositionsInCBAForSoftkeys[i]);

   244         User::LeaveIfError(iSoftKeys.Append(softKey));

   245         CleanupStack::Pop(softKey);

   246     }

   247 

   248     // CBA

   249     iCba = iMenuHandler->Cba();

   250 

   251     UpdateDisplayableRect();

   252     SetRect(iDisplayableRect);

   253 

   254     iBorder = TGulBorder::ENone;

   255 

   256     SetComponentsToInheritVisibility();

   257     // for Skin Support, Create background control context:

   258     iBackGroundControlContext = CAknsBasicBackgroundControlContext::NewL(

   259                                     KAknsIIDQsnBgAreaMain,  // Default mainpane skinning

   260                                     Rect(),                 // Layout to the entire client rect

   261                                     EFalse);

   262 

   263     iAppUi->Displayables().AppendL(this);

   264     iAppUi->SetEnv(iEnv);

   265     ActivateL();

   266 

   267     //Read JAD attribute value for On-Screen Keypad softkeys visual appearence with HW QWERTY keypad

   268     if (iEnv.MidletAttributeIsSetToVal(

   269                 LcduiMidletAttributes::KAttribOskSoftkeysInQwerty,

   270                 LcduiMidletAttributeValues::KPositionBottom))

   271     {

   272         iSKPositionWithQwerty = ESoftkeysBottom;

   273     }

   274     else

   275     {//default value

   276         iSKPositionWithQwerty = ESoftkeysRight;

   277     }

   278 

   279     DEBUG("- CMIDDisplayable::ConstructL");

   280 }

   281 

   282 

   283 

   284 CMIDDisplayable::CMIDDisplayable(MMIDEnv& aEnv,CMIDUIManager& aUIManager)

   285         :CEikBorderedControl(TGulBorder(KMIDLetBorder)),

   286         iUIManager(&aUIManager),iEnv(aEnv),

   287         iIsFullScreenMode(EFalse),iActive(EFalse), iSelectCommand(NULL), iSelectCommandEnabled(ETrue),

   288         iFullscreenCanvasLabelCacheIsValid(EFalse)

   289 #ifdef RD_TACTILE_FEEDBACK

   290         ,iPenInputServerConnected(EFalse)

   291 #endif //RD_TACTILE_FEEDBACK

   292         ,iIdOfMSKCommand(KErrNotFound)

   293 {

   294     iAppUi = (CMIDAppUi*)java::ui::CoreUiAvkonLcdui::getInstance().getJavaUiAppUi()->getLcduiChild();

   295 }

   296 

   297 CMIDDisplayable::~CMIDDisplayable()

   298 {

   299     DEBUG("+ CMIDDisplayable::CMIDDisplayable");

   300 

   301     // iPropertyWatch is CPropertyWatch object,

   302     // delete member call desctructor of CPropertyWatch

   303     // and remove active object form active scheduler

   304     if (iPropertyWatch)

   305     {

   306         delete iPropertyWatch;

   307         iPropertyWatch = NULL;

   308     }

   309 

   310     // Informing iEnv about deleting this

   311     iEnv.DisplayableIsDestructed(this);

   312 

   313     // Remove this from iEnv observer

   314     iEnv.RemoveObserver(*this);

   315 

   316     if (iAppUi)

   317     {

   318         iAppUi->RemoveFromStack(iContentControl);

   319         TInt index = iAppUi->Displayables().Find(this);

   320         if (index != KErrNotFound)

   321         {

   322             iAppUi->Displayables().Remove(index);

   323         }

   324     }

   325 

   326     delete iLongTapDetector;

   327     delete iStylusPopupMenu;

   328     delete iTitle;

   329 

   330 #ifdef RD_SCALABLE_UI_V2

   331     iUIManager->CloseCanvasKeypad(iCanvasKeypad);

   332     iCanvasKeypad = NULL;

   333 #endif //RD_SCALABLE_UI_V2

   334 

   335 #ifdef RD_TACTILE_FEEDBACK

   336     if (iPenInputServerConnected)

   337     {

   338         iPenInputServer.Close();

   339         iPenInputServerConnected = EFalse;

   340     }

   341 #endif //RD_TACTILE_FEEDBACK

   342 

   343     // if ticker is present in this displayable and displayable is

   344     // deleted but ticker is not, tell the ticker that displayable is

   345     // garbage collected.

   346     if (iTicker)

   347     {

   348         TRAP_IGNORE(iTicker->SetDisplayableL(this, KRemoveDisplayable));

   349     }

   350 

   351     delete iBackGroundControlContext;

   352     iBackGroundControlContext = NULL;

   353 

   354     iSoftKeys.ResetAndDestroy();

   355     delete iCommandList;

   356 

   357     if (iMenuHandler->GetDisplayable() == this)

   358     {//this may happen when the application is exiting

   359         iMenuHandler->SetDisplayable(NULL);

   360     }

   361 

   362     DEBUG("- CMIDDisplayable::CMIDDisplayable");

   363 }

   364 

   365 /**

   366  * This means we are being deleted java side. We delete ourselves.

   367  * However before doing this we call ReplaceBehindAlertIfNeeded().

   368  **/

   369 void CMIDDisplayable::Dispose()

   370 {

   371     if (iAppUi)

   372     {

   373         iAppUi->UnSetEnv();

   374     }

   375     ReplaceBehindAlertIfNeeded();

   376 

   377     delete this;

   378 }

   379 

   380 /**

   381  * This method is called when we are deleted java side, from Dispose().

   382  * This code should only execute when java side they decide to delete the

   383  * displayable immeditately behind a showing alert. We check if we are a

   384  * displayable behind an alert. If so we find another displayable (the

   385  * one with lowest ordinal position, ie the top most displayable except us

   386  * and the alert). If we find one we make it visible so that the alert will

   387  * not end up with a white background.

   388  **/

   389 void CMIDDisplayable::ReplaceBehindAlertIfNeeded()

   390 {

   391     if ((this != iUIManager->GetDefaultDisplayable())

   392             && IsVisible()

   393             && (iMenuHandler->GetDisplayable())

   394             && (iMenuHandler->GetDisplayable()->Component()->Type() == EAlert))

   395     {// In this case we are a faded displayable behind a dialog

   396         TInt numDisplayables = iAppUi->Displayables().Count();

   397         TInt index = -1;

   398         TInt currentPosition = 999;

   399         for (TInt i = 0; i < numDisplayables; i++)

   400         {

   401             CMIDDisplayable* disp = iAppUi->Displayables()[i];

   402             if ((disp != this) && (disp->DrawableWindow()->OrdinalPosition() < currentPosition)

   403                     && (disp->Component()->Type() != EAlert))

   404             {

   405                 currentPosition = disp->DrawableWindow()->OrdinalPosition();

   406                 index = i;

   407             }

   408         }

   409 

   410         if (index != -1)

   411         {

   412             CMIDDisplayable* disp = iAppUi->Displayables()[index];

   413             disp->MakeVisible(ETrue);

   414         }

   415     }

   416 }

   417 

   418 void CMIDDisplayable::Draw(const TRect& aRect) const

   419 {

   420     CWindowGc& gc = SystemGc();

   421 

   422     // Set up update region - preventing DSA to be destroyed by redrawing

   423     if (!iDirectContentsRegion.IsEmpty())

   424     {

   425         gc.CancelClippingRect();

   426         iUpdateRegion.Clear();

   427         iUpdateRegion.AddRect(aRect);

   428         // Remove occupied areas out from update region

   429         iUpdateRegion.SubRegion(iDirectContentsRegion);

   430         // Set the update region for the context

   431         gc.SetClippingRegion(iUpdateRegion);

   432     }

   433 

   434     if (iContent->Type() != ECanvas)

   435     {

   436         // Draw background

   437         MAknsSkinInstance* skin = AknsUtils::SkinInstance();

   438         AknsDrawUtils::Background(skin, iBackGroundControlContext, this, gc, aRect);

   439     }

   440     iBorder.Draw(gc, Rect());

   441 }

   442 

   443 TInt CMIDDisplayable::CountComponentControls() const

   444 {

   445     TInt count=0;

   446     if (iContentControl)

   447     {

   448         ++count;

   449     }

   450     return count;

   451 }

   452 

   453 CCoeControl* CMIDDisplayable::ComponentControl(TInt aIndex) const

   454 {

   455     switch (aIndex)

   456     {

   457     case 0:

   458         return iContentControl ? iContentControl: 0;

   459     default:

   460         return 0;

   461     }

   462 }

   463 

   464 void CMIDDisplayable::SizeChanged()

   465 {

   466     if (iBackGroundControlContext)

   467     {

   468         iBackGroundControlContext->SetRect(Rect());

   469     }

   470     Layout();

   471 }

   472 

   473 /**

   474  * Use the commands in aCommandList to create menu items and add them to aItems.

   475  */

   476 void CMIDDisplayable::PopulateMenuItemsWithListL

   477 (

   478     const CMIDMenuHandler::TMenuType& aMenuType, //The type of menu

   479     RArray<CEikMenuPaneItem::SData>& aItems, //The items that will be added to the menu

   480     CMIDCommandList* aCommandList, //The list of commands to be examined

   481     TBool aSeparator

   482 )

   483 {

   484     if (!aCommandList)

   485     {

   486         return;

   487     }

   488     const TBool isItemCommands = (aCommandList == iItemCommandList);

   489 

   490     CMIDCommandList* list = aCommandList;

   491     CEikMenuPaneItem::SData item;

   492 

   493 #ifdef RD_JAVA_S60_RELEASE_9_2

   494     // implicitList is used when creating options menu content.

   495     TBool implicitList = EFalse;

   496     if (iContent && iContent->Type() == EList && iContentControl)

   497     {

   498         CMIDList* list = static_cast<CMIDList*>(iContentControl);

   499         implicitList = list->ListChoiceType() == MMIDChoiceGroup::EImplicit;

   500     }

   501 #endif // RD_JAVA_S60_RELEASE_9_2

   502 

   503     const TInt count = list->Count();

   504     for (TInt ii=0; ii<count; ii++)

   505     {

   506         const CMIDCommand* command = (list->At(ii).iCommand);

   507 #ifdef RD_JAVA_S60_RELEASE_9_2

   508         // If command is mapped to any sk, do not add it to menu (pop-up menu is an exception).

   509         if (!iIsFullScreenMode && CommandIsMappedToSk(command) && aMenuType != CMIDMenuHandler::EPopUpMenu)

   510 #else

   511         // If command is mapped to any sk, do not add it to menu.

   512         if (!iIsFullScreenMode && CommandIsMappedToSk(command))

   513 #endif // RD_JAVA_S60_RELEASE_9_2               

   514         {

   515             continue;

   516         }

   517         // Only commands of type OK and ITEM are visible in context menu.

   518         // TextBox/TextField device-provided commands:

   519         // - "Fetch number"

   520         // - "Call"

   521         // - "Fetch e-mail address"

   522         // are exception. Those are visible ONLY in Options menu so here

   523         // they are not added to context menu.

   524 #ifdef RD_JAVA_S60_RELEASE_9_2

   525         if (aMenuType == CMIDMenuHandler::EOkMenu || aMenuType == CMIDMenuHandler::EPopUpMenu)

   526 #else

   527         if (aMenuType == CMIDMenuHandler::EOkMenu)

   528 #endif // RD_JAVA_S60_RELEASE_9_2            

   529         {

   530             if ((!isItemCommands &&

   531             (command->CommandType() != MMIDCommand::EOk) &&

   532             (command->CommandType() != MMIDCommand::EItem)) ||

   533             (command->Id() == CMIDEdwinUtils::EMenuCommandFetchPhoneNumber) ||

   534             (command->Id() == CMIDEdwinUtils::EMenuCommandFetchEmailAddress) ||

   535             (command->Id() == CMIDEdwinUtils::EMenuCommandCreatePhoneCall))

   536             {

   537                 continue;

   538             }

   539         }

   540 

   541         if (aMenuType == CMIDMenuHandler::EHelpMenu)

   542         {

   543             if (command->CommandType() != MMIDCommand::EHelp)

   544             {

   545                 continue;

   546             }

   547         }

   548 

   549         TPtrC shortLabel = const_cast<CMIDCommand*>(command)->ShortLabel();

   550         TPtrC longLabel  = const_cast<CMIDCommand*>(command)->Label();

   551 

   552         item.iCommandId = ii + list->CommandOffset();

   553         item.iCascadeId = 0;

   554 

   555         if (ii == (count-1) && aSeparator)

   556         {

   557             item.iFlags = EEikMenuItemSeparatorAfter;

   558         }

   559         else

   560         {

   561             item.iFlags = 0;

   562         }

   563 

   564         // Find out whether the long label fits into the menu without clipping,

   565         // and use the long label if it fits; otherwise use short label.

   566         //

   567         // In some scripts the visual presentation may differ from the logical text,

   568         // so we need to convert the text to visual presentation first.

   569         // The clipped clipped string is not used, only the return value is.

   570         //

   571         const CFont& font =

   572             *AknLayoutUtils::FontFromId(AKN_LAYOUT_TEXT_List_pane_texts__menu_single__Line_1(0).iFont);

   573         TInt maxMenuItemLength = CEikMenuPaneItem::SData::ENominalTextLength;

   574 

   575         TRect parentRect = Rect();

   576         TAknLayoutText prompt1;

   577         prompt1.LayoutText(parentRect, AKN_LAYOUT_TEXT_Data_query_pop_up_window_texts_Line_1(0));

   578         TInt layoutWidth = prompt1.TextRect().Width();

   579 

   580         HBufC* visual = HBufC::NewMaxLC(maxMenuItemLength + KAknBidiExtraSpacePerLine);

   581         TPtr visualPtr = visual->Des();

   582         TBool clip = AknBidiTextUtils::ConvertToVisualAndClip(

   583                          longLabel,

   584                          visualPtr,

   585                          font,

   586                          layoutWidth,

   587                          layoutWidth,

   588                          AknBidiTextUtils::EImplicit,

   589                          0xFFFF);

   590         CleanupStack::PopAndDestroy(visual);

   591 

   592         if (clip)

   593         {

   594             BaflUtils::CopyWithTruncation(item.iText, shortLabel);

   595         }

   596         else

   597         {

   598             BaflUtils::CopyWithTruncation(item.iText, longLabel);

   599         }

   600 

   601         if ((iMSKCommand) && (iMSKCommand == list->At(ii).iCommand))

   602         {

   603             User::LeaveIfError(aItems.Insert(item, 0));

   604         }

   605         else

   606         {

   607 #ifdef RD_JAVA_S60_RELEASE_9_2

   608             if (aMenuType == CMIDMenuHandler::EOptionsMenu)

   609             {

   610                 TBool implicitCmd = (implicitList && (command->CommandType() == MMIDCommand::EOk ||

   611                                                       command->CommandType() == MMIDCommand::EItem));

   612 

   613                 if (!implicitCmd)

   614                 {

   615                     User::LeaveIfError(aItems.Append(item));

   616                 }

   617                 else if (implicitCmd && iContentControl &&

   618                          static_cast<CMIDList*>(iContentControl)->IsHighlighted())

   619                 {

   620                     // If highlight in implicit list is False then there is no focus

   621                     // Item/Ok should be visible in options menu only when there is focus on item

   622                     User::LeaveIfError(aItems.Append(item));

   623                 }

   624             }

   625             else

   626             {

   627                 User::LeaveIfError(aItems.Append(item));

   628             }

   629 #else

   630             User::LeaveIfError(aItems.Append(item));

   631 #endif // RD_JAVA_S60_RELEASE_9_2        

   632         }

   633     }

   634 }

   635 

   636 

   637 /**

   638  * Create a list of menu items based on the type of menu and the

   639  * existing command lists.

   640  *

   641  * This method is executed each time the menu is displayed to the user.

   642  * There are two types of menus that can be displayed: context sensitive

   643  * - activated by the select key also known as ok-options menu -

   644  * or standard options menu - activated by the LSK. In the standard options

   645  * menu we display item and standard commands.In the context menu we display

   646  * item commands (if there are any) and standard commands if they are

   647  * of type OK or ITEM, this is taken care of by PopulateMenuItemsWithListL().

   648  *

   649  * @see PopulateMenuItemsWithListL(), CMIDMenuHandler::ShowMenuL()

   650  **/

   651 void CMIDDisplayable::CreateMenuItemsL

   652 (

   653     const CMIDMenuHandler::TMenuType& aMenuType, // the type of menu

   654     RArray<CEikMenuPaneItem::SData>& aMenuItems // the list of menu items

   655 )

   656 {

   657     aMenuItems.Reset();

   658 

   659     if (aMenuType == CMIDMenuHandler::EOkMenu)

   660     {

   661         if (iItemCommandList && iItemCommandList->Count() > 0)

   662         {

   663             PopulateMenuItemsWithListL(aMenuType, aMenuItems, iItemCommandList, EFalse);

   664         }

   665 

   666         // Add form commands always

   667         PopulateMenuItemsWithListL(aMenuType, aMenuItems, iCommandList, EFalse);

   668     }

   669     else if (aMenuType == CMIDMenuHandler::EHelpMenu)

   670     { // Add the Help commands only

   671         PopulateMenuItemsWithListL(aMenuType, aMenuItems, iCommandList, EFalse);

   672     }

   673     else if (aMenuType == CMIDMenuHandler::EOptionsMenu)

   674     {

   675         PopulateMenuItemsWithListL(aMenuType, aMenuItems, iItemCommandList, EFalse);

   676         PopulateMenuItemsWithListL(aMenuType, aMenuItems, iCommandList, ETrue);

   677     }

   678 }

   679 

   680 /**

   681  * iMenuHandler gets the commands first and handles the default ones (exit, options...).

   682  * The rest of the commands are passed here.

   683  **/

   684 void CMIDDisplayable::ProcessCommandL(TInt aCommandId)

   685 {

   686     if (!iActive)

   687     {

   688         return;

   689     }

   690 

   691     if (aCommandId == EAknSoftkeyContextOptions)

   692     { // MSK command to show context sensitive menu -> open it

   693         ShowOkOptionsMenuL();

   694     }

   695     else if (aCommandId == KBuiltInMSKCommandId)

   696     {

   697         // Handle built-in command that is not accessible from menus, only in MSK.

   698         // Send a notification to the observer; there always should be one in built-in

   699         // commands, if not it is considered to be an error.

   700         ASSERT(iMSKCommand->Observer());

   701         iMSKCommand->Observer()->ProcessCommandL(iMSKCommand);

   702     }

   703     else if (aCommandId >= KItemCommandIdBase

   704              && iItemCommandList->IsValidIndex(aCommandId-KItemCommandIdBase))

   705     {

   706         HandleItemCommandL(iItemCommandList->At(aCommandId-KItemCommandIdBase));

   707     }

   708     else if (aCommandId >= KCommandIdBase

   709              && iCommandList->IsValidIndex(aCommandId-KCommandIdBase))

   710     {

   711         HandleStandardCommandL(iCommandList->At(aCommandId-KCommandIdBase));

   712     }

   713 #ifdef RD_JAVA_S60_RELEASE_9_2

   714     // If command has come from pop-up menu, ensure that

   715     // possible pending up event is forwarded to the UI component.

   716     if (iContent && iContentControl)

   717     {

   718         if (iContent->Type() == EList)

   719         {

   720             CMIDList* list = static_cast<CMIDList*>(iContentControl);

   721             list->PostPendingUpEventL();

   722         }

   723         else if (iContent->Type() == EForm)

   724         {

   725             CMIDForm* form = static_cast<CMIDForm*>(iContentControl);

   726             form->PostPendingUpEventL();

   727         }

   728     }

   729 #endif // RD_JAVA_S60_RELEASE_9_2    

   730 }

   731 

   732 #ifdef RD_SCALABLE_UI_V2

   733 /** */

   734 // This function can be moved out from RD_SCALABLE_UI_V2 flag if needed.

   735 // It is behind this flag because currently it is used only by Touch.

   736 void CMIDDisplayable::ProcessCommandL(CMIDCommand* aCommand)

   737 {

   738     TInt internalID = GetInternalCommandIdFor(aCommand);

   739     if (internalID != KCommandIdNotFound)

   740     {

   741         ProcessCommandL(internalID);

   742     }

   743 }

   744 #endif //RD_SCALABLE_UI_V2

   745 

   746 /** */

   747 void CMIDDisplayable::HandleStandardCommandL(const TCommandEntry& aCmdEntry)

   748 {

   749     TBool postJavaEvent = ETrue;

   750     if (aCmdEntry.iCommand->Id() < 0)

   751     { //non-midlet command, see if there is an observer

   752         if (aCmdEntry.iCommand->Observer())

   753         {

   754             postJavaEvent = !(aCmdEntry.iCommand->Observer()->ProcessCommandL(aCmdEntry.iCommand));

   755         }

   756     }

   757 

   758     if (postJavaEvent)

   759     {

   760         iEnv.PostJavaEvent(*this, EDisplayable, ECommand, aCmdEntry.iKey);

   761     }

   762 }

   763 

   764 /** */

   765 void CMIDDisplayable::HandleItemCommandL(const TCommandEntry& aCmdEntry)

   766 {

   767     TBool postJavaEvent = ETrue;

   768     if (aCmdEntry.iCommand->Id() < 0)

   769     { //non-midlet command, see if there is an observer

   770         if (aCmdEntry.iCommand->Observer())

   771         {

   772             postJavaEvent = !(aCmdEntry.iCommand->Observer()->ProcessCommandL(aCmdEntry.iCommand));

   773         }

   774     }

   775 

   776     if (postJavaEvent && iContent->Type() == EForm)

   777     {

   778         CMIDForm* form = static_cast<CMIDForm*>(iContentControl);

   779         ASSERT(form);

   780 

   781         MMIDItem* item = form->CurrentItem();

   782         if (item)

   783         {

   784             iEnv.PostJavaEvent(*item, EItem, ECommand, aCmdEntry.iKey);

   785         }

   786     }

   787 }

   788 

   789 void CMIDDisplayable::HandleHelpCommandL()

   790 {

   791     // Get how many java help commands is registered

   792     TInt numCommands = NumCommandsForHelpOptionsMenu();

   793 

   794     // If there is only one help command, invoke the Java help event directly

   795     if (numCommands == 1)

   796     {

   797         TCommandEntry cmdEntry;

   798         cmdEntry.iCommand = NULL;

   799 

   800         if (iCommandList)

   801         {

   802             TInt index = iCommandList->HighestPriorityCommand(MMIDCommand::EHelp);

   803             if (index != KErrNotFound)

   804             {

   805                 cmdEntry = iCommandList->At(index);

   806                 iEnv.PostJavaEvent(*this, EDisplayable, ECommand, cmdEntry.iKey);

   807             }

   808         }

   809     }

   810     // If there is two or more help commands, let display the menu with these commands

   811     else if (numCommands > 0)

   812     {

   813         iMenuHandler->ShowMenuL(CMIDMenuHandler::EHelpMenu);

   814     }

   815 }

   816 

   817 TInt CMIDDisplayable::NumCommandsForHelpOptionsMenu() const

   818 {

   819     TInt ret = 0;

   820 

   821     // Add always HELP commands from form

   822     TInt numCommands = iCommandList->Count();

   823     for (TInt i = 0; i < numCommands; i++)

   824     {

   825         const CMIDCommand& command = *(iCommandList->At(i).iCommand);

   826         if (command.CommandType() == MMIDCommand::EHelp)

   827         {

   828             ret++;

   829         }

   830     }

   831     return ret;

   832 }

   833 

   834 /**

   835  * Find the screen or help command with highest priority

   836  * and if exists invokes it

   837  **/

   838 void CMIDDisplayable::HandleHighestPriorityScreenOrHelpCommandL()

   839 {

   840     // Find the highest priority screen or help command

   841     TInt screenOrHelpCmdIndex = GetHighestPriorityScreenOrHelpCommand();

   842     if (screenOrHelpCmdIndex != KErrNotFound)

   843     {

   844         HandleStandardCommandL(iCommandList->At(screenOrHelpCmdIndex));

   845     }

   846 }

   847 

   848 //

   849 // From MMIDDisplayable

   850 //

   851 void CMIDDisplayable::SetTitleL(const TDesC* aTitle)

   852 {

   853     delete iTitle;

   854     iTitle = NULL;

   855 

   856     if (aTitle)

   857     {

   858         iTitle = aTitle->AllocL();

   859     }

   860 

   861     if (iTitle)

   862     {

   863         iHasTitle = ETrue;

   864     }

   865     else

   866     {

   867         iHasTitle = EFalse;

   868     }

   869 

   870     if (iActive)

   871     {

   872         ShowTitleL();

   873     }

   874 

   875     if (iContent && iContent->Type() == EAlert)

   876     {

   877         CMIDAlert* alert = (CMIDAlert*) iContent;

   878         alert->SetTitleL(iTitle);

   879     }

   880     // Title must be forwarded to Pop-up TextBox

   881     else if (iContent && iContent->Type() == ETextBox && iIsPopupTextBox)

   882     {

   883         CMIDTextBoxDialogControl* textbox = (CMIDTextBoxDialogControl*) iContent;

   884         textbox->SetTitleL(iTitle);

   885     }

   886 }

   887 

   888 /**

   889  * Sets the Ticker

   890  *

   891  * StartL is called on the current displayable's ticker in these circumstances:

   892  * - When the MIDlet is brought to the foreground (in HandleForegroundL(ETrue))

   893  * - When the device is switched on (in HandleSwitchOnL(ETrue))

   894  * - If the MIDlet has been paused due to a CSaveNotifier event, StartL is

   895  *   called when the MIDlet is next brought to the foreground.(in HandleSwitchOnL(ETrue))

   896  * - When the displayable is made current (StartL called by framework)

   897  *

   898  * Stop is called on the current displayable's ticker in these circumstances:

   899  * - When the MIDlet is placed in the background.(in HandleForegroundL(EFalse) )

   900  * - The implementation uses the CSaveNotifier framework to provide MIDLet state changes.

   901  *   When the following events are received ESaveAll,ESaveQuick,ESaveData,EReleaseRAM

   902  *   the MIDlet is paused and the ticker is stopped.(in HandleSwitchOnL(EFalse))

   903  * - When the Displayable is no longer current. (Stop is called by framework)

   904  **/

   905 void CMIDDisplayable::SetTickerL(MMIDTicker* aTicker)

   906 {

   907     CMIDTicker* newTicker = static_cast< CMIDTicker* >(aTicker);

   908     // if it is the same do nothing

   909     if (iTicker == aTicker)

   910     {

   911         return;

   912     }

   913 

   914     if (iTicker)

   915     {

   916         // Tell the current Ticker that it has no displayable

   917         iTicker->SetDisplayableL(this, KRemoveDisplayable);

   918     }

   919 

   920     iTicker = newTicker;

   921     if (iTicker)

   922     {

   923         iTicker->SetDisplayableL(this, KAddDisplayable);

   924     }

   925 

   926     // Request ticker timer if a valid ticker has been set and

   927     // this is the current displayable.

   928     UpdateTickerL();

   929 }

   930 

   931 // ---------------------------------------------------------------------------

   932 //

   933 // ---------------------------------------------------------------------------

   934 //

   935 MMIDTicker* CMIDDisplayable::Ticker() const

   936 {

   937     return iTicker;

   938 }

   939 

   940 // ---------------------------------------------------------------------------

   941 // Ensures that ticker update events are generated when appropriate

   942 // (e.g. when active) and that this displayables ticker control is notified

   943 // whenever it needs to redraw.

   944 //

   945 // ResumeTicker() and SuspendTicker() deal with the ticker timer whereas

   946 // PauseTicker() is actually sending the ticker to the background makeing it

   947 // disappear.

   948 // ---------------------------------------------------------------------------

   949 void CMIDDisplayable::UpdateTickerL()

   950 {

   951     if (iActive)

   952     {

   953         iUIManager->OpenNaviPaneControllerL()->SetTickerL(iTicker);

   954         if (iIsFullScreenMode || iIsPopupTextBox)

   955         {

   956             iUIManager->OpenNaviPaneControllerL()->ShowTickerL(EFalse);

   957         }

   958         else

   959         {

   960             iUIManager->OpenNaviPaneControllerL()->ShowTickerL(ETrue);

   961         }

   962     }

   963 }

   964 

   965 // ---------------------------------------------------------------------------

   966 //

   967 // ---------------------------------------------------------------------------

   968 //

   969 void CMIDDisplayable::HandleSwitchOnL(TBool /*aSwitchOn*/)

   970 {

   971 }

   972 

   973 // ---------------------------------------------------------------------------

   974 //

   975 // ---------------------------------------------------------------------------

   976 //

   977 void CMIDDisplayable::HandleForegroundL(TBool aForeground)

   978 {

   979     DEBUG("+ CMIDDisplayable::HandleForegroundL");

   980 

   981     // send HandleForegroundL notification to Form

   982     if (iContent && (iContent->Type() == MMIDComponent::EForm) && iContentControl)

   983     {

   984         CMIDForm* form = static_cast<CMIDForm*>(iContentControl);

   985         ASSERT(form);

   986         form->HandleForegroundL(aForeground);

   987     }

   988 

   989 #ifdef RD_JAVA_NGA_ENABLED

   990     HandleCanvasForeground(aForeground);

   991 #endif // RD_JAVA_NGA_ENABLED    

   992 

   993     if (aForeground)

   994     {

   995         //If MIDlet is sent to foreground and JAD-attribute BackgroundEvent=Pause,

   996         //then call startApp() method for the MIDlet.

   997 

   998         if (iEnv.MidletAttributeIsSetToVal(LcduiMidletAttributes::KAttribBackgroundEvent,

   999                                            LcduiMidletAttributeValues::KPauseValue))

  1000 

  1001         {

  1002             iEnv.PostMidletEvent(EStart);

  1003         }

  1004     }

  1005     else //to background

  1006     {

  1007 

  1008         //If MIDlet is sent to background and JAD-attribute BackgroundEvent=Pause,

  1009         //then call pauseApp() method for the MIDlet.

  1010 

  1011         if (iEnv.MidletAttributeIsSetToVal(LcduiMidletAttributes::KAttribBackgroundEvent,

  1012                                            LcduiMidletAttributeValues::KPauseValue) &&

  1013                 !this->DrawableWindow()->IsFaded())

  1014 

  1015         {

  1016             iEnv.PostMidletEvent(EPause);

  1017         }

  1018     }

  1019     DEBUG("- CMIDDisplayable::HandleForegroundL");

  1020 }

  1021 

  1022 // ---------------------------------------------------------------------------

  1023 //

  1024 // ---------------------------------------------------------------------------

  1025 //

  1026 void CMIDDisplayable::HandleResourceChangeL(TInt aType)

  1027 {

  1028     DEBUG("+ CMIDDisplayable::HandleResourceChangeL");

  1029 

  1030     if (aType == KEikDynamicLayoutVariantSwitch)

  1031     { // dynamic orientation change

  1032 

  1033         // Correct rect is set for displayable

  1034         if (iActive && iCanvasKeypad)

  1035         { //Update correct On-Screen Keypad type

  1036             UpdateOnScreenKeypadSettings();

  1037         }

  1038         UpdateDisplayableRect();

  1039         SetRect(iDisplayableRect);

  1040 

  1041         // MIDlet icon is resized in cpane SizeChanged()

  1042 

  1043         if (!iActive && iContentControl)

  1044         {//The active displayable already gets this call by the CONE framework but

  1045             //background displayables don't, so for example a background form won't be

  1046             //re-laid-out if we don't call this here

  1047             iContentControl->HandleResourceChange(aType);

  1048         }

  1049 #ifdef RD_SCALABLE_UI_V2

  1050         if (iUseOnScreenKeypad && iCanvasKeypad && (iActive || this->DrawableWindow()->IsFaded()))

  1051         {

  1052             iCanvasKeypad->UpdateVisualAppearanceL(*iCanvas, iOnScreenKeyboardType, *this);

  1053         }

  1054 #endif // RD_SCALABLE_UI_V2

  1055         iFullscreenCanvasLabelCacheIsValid = EFalse;

  1056     }

  1057     else if (aType == KEikColorResourceChange ||

  1058              aType == KAknsMessageSkinChange  ||

  1059              aType == KUidValueCoeColorSchemeChangeEvent)

  1060     { //skin or color change, may need to recreate ctx icon

  1061         // send skin change event to non-active controls so they can also

  1062         // reload graphics

  1063         if (!iActive && iContentControl)

  1064         {

  1065             iContentControl->HandleResourceChange(aType);

  1066         }

  1067 #ifdef RD_SCALABLE_UI_V2

  1068         if (iUseOnScreenKeypad && iCanvasKeypad && iActive)

  1069         {

  1070             iCanvasKeypad->UpdateVisualAppearanceL(*iCanvas, iOnScreenKeyboardType, *this);

  1071         }

  1072 #endif // RD_SCALABLE_UI_V2

  1073         iFullscreenCanvasLabelCacheIsValid = EFalse;

  1074     }

  1075 

  1076     DEBUG("- CMIDDisplayable::HandleResourceChangeL");

  1077 

  1078     // Language input change, needed by TextEditor.

  1079     if ((aType == KEikInputLanguageChange) && iContentControl)

  1080     {

  1081         iContentControl->HandleResourceChange(aType);

  1082     }

  1083 }

  1084 

  1085 /**

  1086  * The container has changed it available drawing space, so resize

  1087  * the displayable to fit and post a size changed event.

  1088  **/

  1089 void CMIDDisplayable::Layout()

  1090 {

  1091     TBool changed(EFalse);

  1092 

  1093     //

  1094     // Get client area of window (within border).

  1095     //

  1096     TRect rect(iBorder.InnerRect(Rect()));

  1097 

  1098     if (iContentControl)

  1099     {

  1100         if (iContentControl->Rect() != rect)

  1101         {

  1102             // Anything left in rect is space for the content.

  1103             // It is arguable that the content should post the resize event as

  1104             // it knows its true size. Certainly that is required for Canvas.

  1105             iContentControl->SetRect(rect);

  1106             changed = ETrue;

  1107             TRAP_IGNORE(iUIManager->OpenNaviPaneControllerL()->LayoutTickerL());

  1108         }

  1109 

  1110         MMIDComponent::TType type = iContent->Type();

  1111         //

  1112         // We assume that the content width/height == control width height

  1113         // arguably not a valid assumption for any content - but especially

  1114         // invalid for Canvas when the JAD specifies an assumed size.

  1115         //

  1116         // Let Canvas's post their own size, but

  1117         // use the content rect size for all other displayables.

  1118         //

  1119         if (type != ECanvas && type != EGameCanvas)

  1120         {

  1121             //

  1122             // Only post this event for non-canvas components.

  1123             //

  1124             TSize size(rect.Size());

  1125             iEnv.PostJavaEvent(*this, EDisplayable, ESizeChanged, size.iWidth, size.iHeight, 0);

  1126         }

  1127     }

  1128 

  1129     if (changed)

  1130     {

  1131         DrawDeferred();

  1132     }

  1133 }

  1134