1 /*

     2 * Copyright (c) 2003-2008 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:  ?Description

    15 *

    16 */

    17 

    18 

    19 #ifndef CMIDDISPLAYABLE_H

    20 #define CMIDDISPLAYABLE_H

    21 

    22 // CEikBorderedControl inheritance in class declaration

    23 #include <eikbctrl.h>

    24 #include <eikmobs.h>

    25 // needed for calling function SupplyMopObject in CMIDControlItem.cpp, CMIDDisplayable.cpp, CMIDForm.cpp

    26 #include <eikmop.h>

    27 #include <lcdui.h>

    28 #include <eikmenub.h>

    29 // used MAknLongTapDetectorCallBack interface in class declaration

    30 // using CAknLongTapDetector* iLongTapDetector member

    31 #include <aknlongtapdetector.h>

    32 

    33 // Skin

    34 // using API for icons in CMIDCanvas.cpp

    35 // using API for skin in CMIDDisplayable.cpp

    36 // using API for icons and skin in CMIDChoiceGroupModel.cpp

    37 #include <AknsDrawUtils.h>// skin

    38 // for backgroud control context (iBackGroundControlContext)

    39 #include <AknsBasicBackgroundControlContext.h> //skin

    40 

    41 #include "CMIDCommand.h"

    42 // API needed for working with commands and command list (setting, getting, handling)

    43 #include "CMIDCommandList.h"

    44 // using CMIDMenuHandler::TMenuType

    45 #include "CMIDMenuHandler.h"

    46 // using TMidpCustomEvents enumeration

    47 #include "S60LCDUICustomEvents.h"

    48 #include "CMIDCanvasKeypad.h"

    49 #include <e32property.h>

    50 

    51 #ifdef RD_TACTILE_FEEDBACK

    52 #include <touchfeedback.h>

    53 #include <peninputclient.h>

    54 #endif //RD_TACTILE_FEEDBACK

    55 

    56 // Constants

    57 const TInt KSoftKeyLabelPropertyNumberOfSoftKeys = 3;

    58 

    59 // Forward declarations

    60 class CMIDAppUi;

    61 class CMIDSoftKey;

    62 class CMIDUIManager;

    63 class CAknAppUi;

    64 class CMIDTicker;

    65 class CCommandList;

    66 class MMIDDisplayableObserver;

    67 class CEikButtonGroupContainer;

    68 class CAknStylusPopUpMenu;

    69 class CPropertyWatch;

    70 

    71 // Container for MIDlet Displayables.

    72 NONSHARABLE_CLASS(CMIDDisplayable) : public CEikBorderedControl, public MMIDDisplayable,

    73         public MMIDEnvObserver, public MAknLongTapDetectorCallBack, public MEikMenuObserver

    74 {

    75 public:

    76 

    77 #ifdef RD_SCALABLE_UI_V2

    78     /**

    79      * On screen keypad options for devices that do not have physical keypads.

    80      */

    81     enum TOnScreenKeypadValue

    82     {

    83         EOnScreenKeypadValueUndefined = 0,

    84         EOnScreenKeypadValueNo,

    85         EOnScreenKeypadValueNavigationKeys,

    86         EOnScreenKeypadValueGameActions,

    87         EOnScreenKeypadValueLskRsk

    88     };

    89 

    90     // is VKB on screen

    91     TBool IsVKBOnScreen();

    92 #endif // RD_SCALABLE_UI_V2

    93 

    94     /**

    95      * On-Screen Keypad SoftKey positions(used when hw-qwerty does not have LSK&RSK)

    96      */

    97     enum TOnScreenKeypadSoftKeysPosition

    98     {

    99         ESoftkeysBottom = 0,//default value

   100         ESoftkeysRight

   101     };

   102 

   103     /**

   104      * Returns SoftKey position defined by JAD parameter(default position is bottom)

   105      */

   106     TInt GetSKPositionForOSK();

   107 

   108     // Construction

   109     static CMIDDisplayable* NewL(MMIDEnv& aEnv,CMIDUIManager& aUIManager);

   110 

   111     // From MMIDDisplayable

   112     void SetTitleL(const TDesC* aTitle);

   113     void SetTickerL(MMIDTicker* aTicker);

   114     MMIDTicker* Ticker() const;

   115     void AddCommandL(MMIDCommand* aCommand);

   116     void RemoveCommand(MMIDCommand* aCommand);

   117     TSize ContentSize() const;

   118     void HandleCurrentL(TBool aCurrent);

   119     void SetComponentL(MMIDComponent& aComponent);

   120     MMIDComponent* Component() const;

   121     void SetFullScreenModeL(TBool aFullScreen);

   122     CCoeControl& ContentWindow();

   123     TBool SoftKeyLabelLocation(TInt aSoftKeyId, TPoint& aPosition, TSize& aSize);

   124     TInt SoftKeyLabelAnchor(TInt aSoftKeyId);

   125     void DrawNow();

   126     void ChangeOSKBackgroundState(TBool aOSKBackgroundState);

   127 

   128     /**

   129      * Sets a command listener existence info.

   130      * @since Series S60 3.2

   131      * @param aExistence ETrue if command listener is set

   132      */

   133     void SetCommandListenerExistence(TBool aExistence);

   134 

   135     // From MMIDComponent

   136     void Dispose();

   137 

   138     // From MMIDEnvObserver

   139     void HandleSwitchOnL(TBool aSwitchOn);

   140     void HandleForegroundL(TBool aForeground);

   141     void HandleResourceChangeL(TInt aType);

   142 

   143     // Title handling

   144     TBool HasTitle() const;

   145     void ShowTitleL();

   146     HBufC*  Title();

   147     void ClearTitleL();

   148 

   149     // Command handling

   150     CMIDCommandList* MainCommandList() const;

   151     CMIDCommand* FindCommandWithId(TInt aCommandId) const;

   152 

   153     /**

   154      * Find the correct softkey commands, if any,  and draw the CBA.

   155      * Finally draw the CBA.

   156      *

   157      * @see RestoreMenuL()

   158      **/

   159     void InitializeCbasL();

   160     void SetCba(CEikButtonGroupContainer* aCba);

   161     TBool ShowOkOptionsMenuL();

   162     TInt NumCommandsForOkOptionsMenu() const;

   163     TInt GetHighestPriorityScreenOrHelpCommand() const;

   164     void SetItemCommandList(CMIDCommandList* aList, CMIDCommand* aMSKCommand);

   165     void SetMSKCommand(CMIDCommand* aMSKCommand);

   166     /**

   167      * Stores select command to Displayable

   168      * @param aSelectCommand a command used in MSK and in menu

   169      */

   170     void SetSelectCommand(CMIDCommand* aSelectCommand);

   171     /**

   172      * Disables or enables select command

   173      * @aEnableSelectCommand ETrue enables select command and EFalse disables select command

   174      */

   175     void SetSelectCommandState(TBool aEnableSelectCommand);

   176 

   177     TInt CommandCount();

   178     void ProcessCommandL(TInt aCommandId);

   179     void DisplayableBehindPopupIsDestroyed();

   180     // Processes native Help command event to java

   181     void HandleHelpCommandL();

   182     // Get number of inserted help commands

   183     TInt NumCommandsForHelpOptionsMenu() const;

   184     void HandleHighestPriorityScreenOrHelpCommandL();

   185 

   186 #ifdef RD_SCALABLE_UI_V2

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

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

   189     /**

   190      * Passes call to ProcessCommandL (TInt aCommandId) function.

   191      * This is useful in situations in which the internal Command ID is not available.

   192      *

   193      * @param aCommand to be executed.

   194      * @since S60 5.0

   195      */

   196     void ProcessCommandL(CMIDCommand* aCommand);

   197 #endif // RD_SCALABLE_UI_V2

   198 

   199     void CreateMenuItemsL(const CMIDMenuHandler::TMenuType& aMenuType,

   200                           RArray<CEikMenuPaneItem::SData>& aMenuItems);

   201     // Skin

   202     MAknsControlContext* BackGroundControlContext();

   203 

   204     /** From MAknLongTapDetectorCallBack */

   205     void HandleLongTapEventL(const TPoint& /*aPenEventLocation*/, const TPoint& /*aPenEventScreenLocation*/);

   206 

   207     /**

   208      * Way to report pointer event to displayable so that the component will get the

   209      * default long tap functionality. This method should be called when ever a pointer

   210      * event occurs in an ui component. Returns true if the event is consumed and should

   211      * not be forwarded any more (e.g. pointer up event after a detected long tap).

   212      **/

   213     TBool TryDetectLongTapL(const TPointerEvent& aPointerEvent);

   214 

   215     // Misc.

   216     TBool IsFullScreenMode() const;

   217     CMIDMenuHandler* MenuHandler() const;

   218     TBool IsActive() const;

   219 

   220     /**

   221      * Content component notifies Displayable about its deletion.

   222      *

   223      * @note It might happen that content is destroyed before displayable

   224      * and that's why we need to notify displayable about its content deletion.

   225      * @see Displayable.java: registeredFinalize()

   226      **/

   227     void NotifyContentDestroyed();

   228 

   229     /**

   230      * Gets a command listener existence info.

   231      * @since Series S60 3.2

   232      * @return ETrue if a command listener is set

   233      */

   234     TBool IsCommandListenerSet() const;

   235     /**

   236      * Get UI manager

   237      * @return CMIDUIManager instance

   238      *

   239      * @since s60

   240      */

   241     virtual CMIDUIManager* GetUIManager() const;

   242 

   243     /**

   244      * Sets S60 Selection Key Compatibility

   245      */

   246     void SetS60SelectionKeyCompatibility(TBool aS60SelectionKeyCompatibility);

   247 

   248     /**

   249     Adds a rectangle which is excluded from redrawing (for DSA)

   250     @param "aRect" Rentangle to be exluded from redrawing.

   251     */

   252     void AddDirectContentArea(const TRect& aRect);

   253 

   254     /**

   255     Removes a rectangle which is excluded from redrawing (for DSA)

   256     @param "aRect" Rentangle to be removed from exclusion list.

   257     */

   258     void RemoveDirectContentArea(const TRect& aRect);

   259 

   260     /**

   261     Checks if there were some direct content area added

   262     @return ETrue if there no DC Area has been added

   263     */

   264     TBool NoDirectContentAreaDefined();

   265 

   266     /**

   267      * Sets popup style TextBox boolean value. Called by CMIDTextBoxDialogControl when

   268      * TextBox presentation is pop-up.

   269      *

   270      * @param "aPopup" boolean value indicating whether the textbox is popup or not.

   271      *

   272      * @since S60 5.0

   273      */

   274     void SetPopupTextBox(TBool aPopup);

   275 

   276     /**

   277      * Returns boolean value indicating whether this displayable is pop-up TextBox.

   278      *

   279      * @return TBool

   280      *

   281      * @since S60 5.0

   282      */

   283     virtual TBool IsPopupTextBox();

   284 

   285     /**

   286     * Handles the On-Screen Keypad visual appearance.

   287     *

   288     * @return void

   289     *

   290     * @since S60 5.0

   291     */

   292     void HandleOnScreenKeypadVisual();

   293 

   294     /**

   295     * Notify a CMIDDisplayable then application is switch to background.

   296     *

   297     * @return void

   298     *

   299     * @since S60 5.0

   300     */

   301     void HandleApplicationBackground();

   302 

   303     /**

   304      * Function process command which is mapped to MSK

   305      *

   306      * @return void

   307      *

   308      * @since S60 5.0

   309      */

   310     void ProcessMSKCommandL();

   311 

   312 private:

   313     // Construction and destruction

   314     CMIDDisplayable(MMIDEnv& aEnv,CMIDUIManager& aUIManager);

   315     void ConstructL();

   316     ~CMIDDisplayable();

   317 

   318     // From CCoeControl

   319     void Draw(const TRect& aRect) const;

   320     virtual TInt CountComponentControls() const;

   321     CCoeControl* ComponentControl(TInt aIndex) const;

   322     void SizeChanged();

   323     TTypeUid::Ptr MopSupplyObject(TTypeUid aId);

   324 

   325     // Private command handling

   326     void PopulateMenuItemsWithListL(const CMIDMenuHandler::TMenuType& aMenuType,

   327                                     RArray<CEikMenuPaneItem::SData>& aItems, CMIDCommandList* aCommandList, TBool aSeparator);

   328     TBool CommandIsMappedToSk(const CMIDCommand* aCommand) const;

   329     void HandleStandardCommandL(const TCommandEntry& aCmdEntry);

   330     void HandleItemCommandL(const TCommandEntry& aCmdEntry);

   331     TInt GetInternalCommandIdFor(CMIDCommand* aCommand) const;

   332     void GetOkOptionsMenuCommands(RPointerArray<CMIDCommand>& aCommands) const;

   333     void ResetSoftKeysAndCommands(const RArray<CMIDCommandList*>& aLists);

   334 

   335     // Visual layouting and updating

   336     void UpdateVisualAppearanceL();

   337     void UpdateTickerL();

   338     void Layout();

   339     void SizeWindowAndToolBar();

   340     void ReplaceBehindAlertIfNeeded();

   341     void UpdateDisplayableRect();

   342 

   343     // Activation handling

   344     void HandleActivatedL();

   345     void HandleDeactivated();

   346 

   347 

   348     // The structure to store the Direct content bounds and its identification number

   349     struct TDirectContentsRect

   350     {

   351         /**

   352          * Default ctor

   353          */

   354         TDirectContentsRect()

   355                 : iRefCount(0) {}

   356 

   357         /**

   358          * Ctor

   359          * @param aRect Rectangle

   360          */

   361         TDirectContentsRect(const TRect& aRect)

   362                 : iRect(aRect), iRefCount(1) {}

   363 

   364         TRect iRect;

   365         TInt iRefCount;

   366     };

   367 

   368     /**

   369      * Determines whether two TDirectContentsRect type objects match

   370      * @param aLhs First object

   371      * @param aRhs Second object

   372      * @return True if matched

   373      * @see RArray::Find

   374      */

   375     static TBool MatchDirectContentsRects(

   376         const TDirectContentsRect& aLhs, const TDirectContentsRect& aRhs);

   377 

   378     /**

   379      * Updates <code>iDirectContentsRegion</code> according to

   380      * the <code>iDirectContentsRects</code> array.

   381      */

   382     void UpdateDirectContentsRegion();

   383 

   384 

   385     // From MEikMenuObserver

   386     void SetEmphasis(CCoeControl* aMenuControl,TBool aEmphasis);

   387     /**

   388      * OnScreenKeypad

   389      * Returns canvas rect from LAF when using OnScreenKeypad.

   390      *

   391      * @return TRect                    Canvas Rect

   392      *

   393      * @since S60 5.0

   394      */

   395     TRect GetCanvasRectFromLaf();

   396 

   397     /**

   398     * Set correct On-Screen keyboard type.

   399     *

   400     * @return void

   401     *

   402     * @since S60 5.0

   403     */

   404     void UpdateOnScreenKeypadSettings();

   405 

   406     /**

   407     * Read On-Screen keyboard MIDlet suite settings

   408     *

   409     * @return void

   410     *

   411     * @since S60 5.0

   412     */

   413     void ReadOnScreenKeypadTypeFromSuiteSettings();

   414 

   415 #ifdef RD_SCALABLE_UI_V2

   416     /**

   417      * Returns midlet suite setting for on screen keypad.

   418      * The setting is retrieved from the User preferences API and it requires file accessing, thus

   419      * this function should not be called repeatedly because of performance issues.

   420      *

   421      * @return TOnScreenKeypadValue     Current setting value.

   422      *                                  Returns EOnScreenKeypadValueUndefined if reading of the setting fails.

   423      *

   424      * @since S60 5.0

   425      */

   426     TUint OnScreenKeypadL();

   427 #endif // RD_SCALABLE_UI_V2

   428 

   429     void RenewFullscreenCanvasLabelCacheL();

   430 

   431 #ifdef RD_JAVA_NGA_ENABLED

   432     /**

   433      * In case content is Canvas, notifies it about changed

   434      * foreground status.

   435      *

   436      * @param aForeground   ETrue, if displayable is on foreground,

   437      *                      EFalse otherwise.

   438      * @since S60 9.2

   439      */

   440     void HandleCanvasForeground(TBool aForeground);

   441 #endif // RD_JAVA_NGA_ENABLED

   442 

   443     void HideIndicator(CEikStatusPane* aSp, TInt aId);

   444     void HideIndicators();

   445 

   446 private:

   447     CMIDAppUi* iAppUi;

   448     CMIDUIManager* iUIManager;

   449     MMIDEnv& iEnv;

   450     CAknLongTapDetector* iLongTapDetector;

   451     TBool iLongTapDetected;

   452     CAknStylusPopUpMenu* iStylusPopupMenu;

   453 

   454     // Controls

   455     CCoeControl* iContentControl;

   456     CEikButtonGroupContainer* iCba;

   457     // Peers

   458     CMIDTicker* iTicker;

   459     MMIDComponent* iContent;

   460 

   461     //The main displayable commands

   462     CMIDCommandList* iCommandList;

   463 

   464     //Displayable behind Alert and PopupTextBox

   465     CMIDDisplayable* iDisplayableBehindPopup;

   466 

   467     //The commands associated with form items

   468     CMIDCommandList* iItemCommandList;

   469 

   470     // The command associated with middle soft key, may be NULL

   471     CMIDCommand* iMSKCommand;

   472 

   473     //Sofkey information. For each softkey on the device it

   474     //stores the allowed commands types, the mapped command

   475     //or default CBA button

   476     RPointerArray<CMIDSoftKey> iSoftKeys;

   477 

   478     CMIDMenuHandler* iMenuHandler;

   479     HBufC* iTitle;

   480     TBool iHasTitle;

   481 

   482     //Skin

   483     CAknsBasicBackgroundControlContext* iBackGroundControlContext;

   484 

   485     // State

   486     TBool iIsFullScreenMode;

   487     TBool iActive;

   488     TBool iCommandListenerExistence;

   489     TRect iDisplayableRect;

   490     // current number of item commands

   491     TInt  iItemCommandsCount;

   492 

   493     CMIDCommand* iSelectCommand;

   494     TBool iSelectCommandEnabled;

   495 

   496     TBool iS60SelectionKeyCompatibility;

   497 

   498     //OnScreenKeypad specific members

   499     CMIDCanvasKeypad*    iCanvasKeypad;

   500     CMIDCanvas* iCanvas;

   501     TBool iUseOnScreenKeypad;

   502     TInt iOnScreenKeyboardType;

   503     TInt iSKPositionWithQwerty;

   504 

   505     mutable RRegion iUpdateRegion;

   506     RRegion iDirectContentsRegion;

   507     // Direct content bounds list

   508     RArray< TDirectContentsRect > iDirectContentsRects;

   509 

   510     // Structure to store the softkey label position and anchor

   511     struct TSoftkeyLabel

   512     {

   513         TPoint iPosition;

   514         TSize  iSize;

   515         // Java anchor constant as defined in class Graphics

   516         enum TJavaAnchor

   517         {

   518             EJavaHCenter = 1,

   519             EJavaVCenter = 2,

   520             EJavaLeft    = 4,

   521             EJavaRight   = 8,

   522             EJavaTop     = 16,

   523             EJavaBottom  = 32

   524         };

   525         TInt  iAnchor;

   526         // Shows if the sk is used

   527         TBool iIsOn;

   528     };

   529 

   530     // The storage of softkey labels data

   531     // This is used for the increasing of the performace of getting SK properties

   532     // The data validity is stored in iFullscreenCanvasLabelCacheIsValid

   533     // The data are renewed/revalidated by RenewFullscreenCanvasLabelCache()

   534     TSoftkeyLabel iFullscreenCanvasLabelCache[ KSoftKeyLabelPropertyNumberOfSoftKeys ];

   535 

   536     // Shows if the data in iFullscreenCanvasLabelCache are valid

   537     TBool iFullscreenCanvasLabelCacheIsValid;

   538 

   539     // VKB status

   540 #ifdef RD_TACTILE_FEEDBACK

   541     RPeninputServer iPenInputServer;

   542     TBool iPenInputServerConnected;

   543 #endif

   544 

   545     // Used by TextBox indicating whether the textbox is popup or not.

   546     TBool iIsPopupTextBox;

   547 

   548     /**

   549      *  Initialize iPropertyWatch as CPropertyWatch. Active Object will be

   550      *  removed from Active Scheduler in CMIDDisplayable (destructor).

   551      */

   552     CPropertyWatch* iPropertyWatch;

   553 

   554     //stores id of command mapped to the MSK

   555     TInt iIdOfMSKCommand;

   556 

   557 };

   558 

   559 

   560 

   561 

   562 // Timer delay

   563 const TInt KTimerDelayValue = 200000;//0.2s

   564 

   565 /**

   566 An active object that tracks changes to the active keyboard properties

   567 */

   568 NONSHARABLE_CLASS(CPropertyWatch) : public CActive

   569 {

   570 public:

   571     static CPropertyWatch* NewL(MMIDDisplayable* aDisplayable);

   572     ~CPropertyWatch();

   573 private:

   574     CPropertyWatch();

   575     void ConstructL(MMIDDisplayable* aDisplayable);

   576     void RunL();

   577     void DoCancel();

   578     void HandleDelayTimerEventL();

   579     static TInt DelayTimerCallbackL(TAny* aThis);

   580 

   581     CMIDDisplayable* iDisplayable;

   582     RProperty iProperty;

   583 

   584     /**

   585     * Timer delay for reacting to keypad opening/closing.

   586     */

   587     CPeriodic*     iDelayTimer;

   588 

   589 };

   590 

   591 

   592 

   593 #endif // CMIDDISPLAYABLE_H

   594 

   595 // End of File