1 /*

     2 * Copyright (c) 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:  Layout calculation and UI rendering mechanism implementations.

    15 *

    16 */

    17 

    18 

    19 #ifndef _CXNUIENGINEIMPL_H

    20 #define _CXNUIENGINEIMPL_H

    21 

    22 // System includes

    23 

    24 // User includes

    25 #include "xnuistatelistener.h"

    26 #include "xnviewmanager.h"

    27 #include "xnmenu.h"

    28 

    29 // Forward declarations

    30 class CCoeControl;

    31 class CXnControlAdapter;

    32 class CXnNode;

    33 class CXnPointerArray;

    34 class CXnODT;

    35 class CGraphicsDevice;

    36 class CXnUiEngine;

    37 class CXnKeyEventDispatcher;

    38 class CXnEditor;

    39 class CXnResource;

    40 class CXnEditMode;

    41 class CXnViewManager;

    42 class CXnViewData;

    43 class CXnPluginData;

    44 

    45 // Constants

    46 namespace XnLayoutPhase

    47     {

    48     const TInt ENone = 0x00;

    49     const TInt ELayout = 0x01;

    50     const TInt EMeasure = 0x02;

    51     }

    52 

    53 namespace XnLayoutControl

    54     {

    55     const TInt ELayoutUI = 0x01;

    56     const TInt ERenderUI = 0x02;

    57     const TInt ERefreshMenu = 0x04;

    58     const TInt EIgnoreState = 0x08;

    59     const TInt EViewDirty = 0x10;

    60     const TInt EEffectStarted = 0x20;    

    61     }

    62 	

    63 NONSHARABLE_STRUCT( TXnDirtyRegion )

    64     {

    65     RRegion         iRegion;      

    66     CCoeControl*    iControl; // Not own.

    67     

    68     ~TXnDirtyRegion()

    69         {

    70         iRegion.Close();

    71         }

    72     };

    73 

    74 

    75 NONSHARABLE_STRUCT( TXnSplitScreenState )

    76     {

    77     /** Partial screen editor node. Not own */

    78     CXnNode* iPartialScreenEditorNode;

    79     /** Is partial screen input open */

    80     TBool iPartialScreenOpen;

    81     /** Partial screen block progression. Own. */

    82     const TDesC8* iPartialScreenBlock;

    83     

    84     // ctor

    85     TXnSplitScreenState() : 

    86         iPartialScreenEditorNode( NULL ),

    87         iPartialScreenOpen( EFalse ),

    88         iPartialScreenBlock( NULL ) {}

    89     };

    90 

    91 

    92 // Class declaration

    93 

    94 /**

    95  *  Layout calculation and UI rendering mechanism

    96  *  implementations.

    97  *  

    98  *  @ingroup group_xnlayoutengine

    99  *  @lib xn3layoutengine.lib

   100  *  @since Series 60 3.1

   101  */

   102 NONSHARABLE_CLASS( CXnUiEngineImpl ) : public CBase,     

   103     public MXnViewObserver, 

   104     public MXnUiResourceChangeObserver,

   105     public XnMenuInterface::MXnMenuObserver

   106     {

   107     

   108 public:

   109     // Constructors and destructor

   110 

   111     /**

   112      * Two-phased constructor.

   113      * 

   114      * @param aUiEngine Ui engine

   115      * @param aViewManager View manager

   116      */

   117     static CXnUiEngineImpl* NewL( CXnUiEngine& aUiEngine,

   118         CXnAppUiAdapter& aAdapter );

   119 

   120     /**

   121      * 2nd phase constructor 

   122      */

   123     void ConstructL();

   124 

   125     /**

   126      * Destructor.

   127      */

   128     virtual ~CXnUiEngineImpl();

   129 

   130 public:

   131     // New functions

   132 

   133     /**

   134      * Gets AppUi

   135      *

   136      * @since S60 5.0     

   137      * @return AppUi

   138      */    

   139     CXnAppUiAdapter& AppUiAdapter() const;

   140     

   141     /**

   142      * Lays out the UI

   143      * 

   144      * @since Series 60 3.1

   145      * @param aNode Starting point of the layout

   146      */

   147     void LayoutUIL( CXnNode* aNode = NULL );

   148 

   149     /**

   150      * Creates UI implementations for the UI, adjusts control coordinates 

   151      * according to the layout

   152      * 

   153      * @since Series 60 3.1

   154      * @param aNode Starting point

   155      */

   156     void RenderUIL( CXnNode* aNode = NULL );

   157     

   158     /**

   159      * Gets the root node of the UI

   160      * 

   161      * @since Series 60 3.1

   162      * @return Root node

   163      */

   164     CXnNode* RootNode();

   165     

   166     /**

   167      * Gets the ODT

   168      * 

   169      * @since Series 60 3.1

   170      * @return ODT

   171      */

   172     CXnODT* ODT();

   173     

   174     /**

   175      * Finds a node by id

   176      * 

   177      * @since Series 60 3.1

   178      * @param aNode Node id

   179      * @param aNamespace Namespace

   180      * @return Node with given id

   181      */

   182     CXnNode* FindNodeByIdL( const TDesC& aNodeId,

   183         const TDesC& aNamespace = KNullDesC );

   184     /**

   185      * Finds a node by id, b-bit version

   186      * 

   187      * @since Series 60 3.1

   188      * @param aNode Node id

   189      * @param aNamespace Namespace

   190      * @return Node with given id

   191      */

   192     CXnNode* FindNodeByIdL( const TDesC8& aNodeId, 

   193         const TDesC8& aNamespace = KNullDesC8 );

   194     /**

   195      * Finds nodes by class

   196      * 

   197      * @since Series 60 3.1

   198      * @param aClassId Class id

   199      * @return Nodes with given class id

   200      */

   201     CXnPointerArray* FindNodeByClassL( const TDesC& aClassId,

   202         const TDesC& aNamespace = KNullDesC );

   203     

   204     /**

   205      * Finds nodes by class

   206      * 

   207      * @since Series 60 3.1

   208      * @param aClassId Class id

   209      * @return Nodes with given class id

   210      */

   211     CXnPointerArray* FindNodeByClassL( const TDesC8& aClassId,

   212         const TDesC8& aNamespace = KNullDesC8 );

   213     

   214     /**

   215      * Find content source nodes from namespace. Ownership is not transferred.

   216      *

   217      * @since S60 5.2

   218      * @param aNamespace Namespace

   219      * @return Content source nodes from namespace

   220      */    

   221     CXnPointerArray* CXnUiEngineImpl::FindContentSourceNodesL(

   222         const TDesC8& aNamespace );

   223     

   224     /**

   225      * Gets resources of the UI

   226      * 

   227      * @since Series 60 3.1

   228      * @return List of resources

   229      */

   230     CArrayPtrSeg< CXnResource >& Resources();

   231     

   232     /**

   233      * Sets currently focused node

   234      * 

   235      * @since Series 60 3.1

   236      * @param aFocusedNode Currently focused node

   237      * @param aSource A source of event that triggered focus change.

   238      */

   239     void SetFocusedNodeL( CXnNode* aFocusedNode, TInt aSource = 0 );

   240     

   241     /**

   242      * Get currently focused node

   243      * 

   244      * @since Series 60 3.1

   245      * @return Focused node.

   246      */

   247     CXnNode* FocusedNode();

   248 

   249     /**

   250      * Checks if the UI is in Edit mode.

   251      * 

   252      * @since Series 60 5.0        

   253      * @return ETrue if the current mode is edit, otherwise EFalse.

   254      */

   255     TBool IsEditMode();

   256            

   257     /**

   258      * Get a numeric value of a property in vertical pixels

   259      * 

   260      * @since Series 60 3.1

   261      * @param aValue Property

   262      * @param aReferenceValue Value used for percentage calculation

   263      * @return Value in vertical pixels

   264      */

   265     TInt VerticalPixelValueL( CXnProperty* aValue, TInt aReferenceValue );

   266     

   267     /**

   268      * Get a numeric value of a property in horizontal pixels

   269      * 

   270      * @since Series 60 3.1

   271      * @param aValue Property

   272      * @param aReferenceValue Value used for percentage calculation

   273      * @return Value in horizontal pixels

   274      */

   275     TInt HorizontalPixelValueL( CXnProperty* aValue, TInt aReferenceValue );

   276     

   277     /**

   278      * Get a numeric value of a property in vertical twips

   279      * 

   280      * @since Series 60 3.1

   281      * @param aValue Property

   282      * @param aReferenceValue Value used for percentage calculation

   283      * @return Value in vertical twips

   284      */

   285     TInt VerticalTwipValueL( CXnProperty* aValue, TInt aReferenceValue );

   286     

   287     /**

   288      * Get a numeric value of a property in horizontal twips

   289      * 

   290      * @since Series 60 3.1

   291      * @param aValue Property

   292      * @param aReferenceValue Value used for percentage calculation

   293      * @return Value in horizontal pixels

   294      */

   295     TInt HorizontalTwipValueL( CXnProperty* aValue, TInt aReferenceValue );

   296 

   297     /**

   298      * Refresh current menu

   299      *

   300      * @since Series 60 3.1

   301      */

   302     void RefreshMenuL();

   303 

   304     /**

   305      * Returns view manager

   306      *

   307      * @since S60 5.0

   308      * @return view manager

   309      */

   310     CXnViewManager* ViewManager();

   311 

   312     /**

   313      * Returns the active view

   314      

   315      * @since Series 60 3.1

   316      * @return Active view node

   317      */

   318     CXnNode* ActiveView();

   319 

   320     /**

   321      * Add a dirty node. LayoutUiL and RenderUiL will only perform operations

   322      * on the set of dirty nodes.

   323      *

   324      * @since Series 60 3.1

   325      * @param aNode Dirty node.

   326      * @param aLayoutPhaseHint, a hint where to start next layout phase

   327      */

   328     void AddDirtyNodeL( CXnNode* aNode, TInt aLevel );

   329 

   330     /**

   331      * Get the size of the current screen device

   332      *

   333      * @since Series 60 3.1

   334      * @return Size of the current screen device

   335      */

   336     TSize ScreenDeviceSize() const;

   337 

   338     /**

   339      * Checks whether the dialog is displaying.

   340      *

   341      * @since Series 60 3.1

   342      * @return ETrue if dialog is displaying.

   343      */

   344     TBool IsDialogDisplaying();

   345 

   346     /**

   347      * Handles a change to the control's resources of type aType

   348      *

   349      * @since Series 60 3.1

   350      * @param aType Changed resource type

   351      */

   352     void HandleResourceChangeL( TInt aType );

   353 

   354     /**

   355      * Checks whether the menu is displaying.

   356      * 

   357      * @since Series 60 3.1

   358      * @return ETrue if menu is displaying.

   359      */

   360     TBool IsMenuDisplaying();

   361 

   362     /**

   363      * Returns menubar node

   364      * 

   365      * @since Series 60 3.2

   366      * @return Menubar node

   367      */

   368     CXnNode* MenuBarNode() const;

   369 

   370     /**

   371      * Returns stylus popup node

   372      * 

   373      * @since S60 60 5.0

   374      * @return stylus popup node

   375      */    

   376     CXnNode* StylusPopupNode() const;

   377     

   378     /**

   379      * Set node as passive, and add it to the passive focused node array.

   380      * 

   381      * @since Series 60 3.2

   382      * @param aNode Node to use.

   383      */

   384     void AddPassiveFocusedNodeL( CXnNode* aNode );

   385 

   386     /**

   387      * Unset the passive focus from the node, and remove it from the passive 

   388      * focused node array.

   389      * 

   390      * @since Series 60 3.2

   391      * @param aNode Node to use.

   392      */

   393     void RemovePassiveFocusedNodeL( CXnNode* aNode );

   394 

   395     /**

   396      * Clear the passive focused node array, and unset the passive focus 

   397      * states.

   398      * 

   399      * @since Series 60 3.2

   400      */

   401     void ClearPassiveFocusedNodesL();

   402 

   403     /**

   404      * Sets node's dropped state

   405      * 

   406      * @since Series 60 3.2

   407      * @param aNode Node

   408      * @param aDropped Dropped

   409      */

   410     void SetNodeDroppedL( CXnNode& aNode, TInt aDropped ) const;

   411 

   412     /**

   413      * Checks if node is adaptive, but doesn't have any content

   414      * 

   415      * @since Series 60 3.2

   416      * @param aNode node

   417      * @param aAvailableSize size to be checked

   418      */

   419     void CheckAdaptiveContentL( CXnNode& aNode, TSize aAvailableSize ) const;

   420 

   421     /**

   422      * Adds a node which can be focused

   423      * 

   424      * @since Series 60 3.2

   425      * @param aNode Node

   426      */

   427     void AddFocusCandidateL( CXnNode* aNode );

   428 

   429     /**

   430      * Sets client rect

   431      * 

   432      * @since Series 60 3.2

   433      * @param aRect area to be set

   434      * @param aDrawNow Call rendering routines if ETrue

   435      */

   436     void SetClientRectL( TRect aRect, TBool aDrawNow = ETrue );

   437     

   438     /**

   439      * Fetch editor to operate on AI3 widgets.

   440      * 

   441      * @since Series 60 5.0

   442      * @return Pointer to Editor

   443      */

   444     CXnEditor* Editor() const;

   445     

   446     /**

   447      * Gets client rect

   448      * 

   449      * @since Series 60 3.2

   450      * @return client rect

   451      */

   452     TRect ClientRect() const;

   453 

   454     /**

   455      * Gets pointer to edit mode storage.

   456      * 

   457      * @since Series 60 5.0

   458      * @return edit mode storage

   459      */

   460     CXnEditMode* EditMode();

   461 

   462     /**

   463      * Get current view plugins nodes.

   464      * 

   465      * @since Series 60 5.0

   466      * @return Pointer to plugin node array

   467      */

   468     RPointerArray< CXnNode >* Plugins();

   469 

   470     /**

   471      * Gets theme resource file

   472      * 

   473      * @since S60 5.1         

   474      * @param aPath path from which file is found

   475      * @param aFile file to which resource is set

   476      * @return errorcode

   477      */

   478     TInt GetThemeResource( const TDesC& aPath, RFile& aFile );

   479 

   480     /**

   481      * Analyse added widget

   482      * 

   483      * @since S60 5.1

   484      * @param aNode Widget to be analyzed

   485      * @return ETrue if fits, EFalse otherwise

   486      */

   487     TBool AnalyseAddedWidgetL( CXnNode& aNode );

   488         

   489     /**

   490      * Disables layoyt and redraw, places cleanup item to cleanup stack

   491      * for enabling layot and redraw

   492      * 

   493      * @since Series 60 5.0     

   494      */                        

   495     void DisableRenderUiLC();

   496     

   497     /**

   498      * Set event dispatcher

   499      * 

   500      * @since Series 60 5.0

   501      * @param aDispather Event dispatcher     

   502      */                    

   503     void SetEventDispatcher( CXnKeyEventDispatcher* aDispatcher );

   504 

   505     /**

   506      * Enables partial touch input

   507      * 

   508      * @since Series 60 5.2

   509      * @param aNode Editor Node

   510      * @param TBool Partial input is enabled      

   511      */      

   512     void EnablePartialTouchInput( CXnNode& aNode, TBool aEnable );

   513 

   514     /**

   515      * Is partial input active

   516      * 

   517      * @since Series 60 5.2

   518      * @return TBool is partial input active      

   519      */      

   520     TBool IsPartialInputActive();

   521 

   522     /**

   523       * Checks if text editor is focused or partioal touch input open.

   524       * 

   525       * @since Series 60 5.2

   526       * @return TBool True if partial input is open or editor focused

   527       */      

   528     TBool IsTextEditorActive();

   529 

   530 private:

   531     

   532     IMPORT_C static void EnableRenderUi( TAny* aAny );

   533         

   534 private:

   535     // constructors

   536 

   537     /**

   538      * C++ default constructor.

   539      */

   540     CXnUiEngineImpl( CXnUiEngine& aUiEngine, CXnAppUiAdapter& aAdapter );

   541 

   542 private:

   543     // new functions

   544     

   545     /**

   546      * Prepares to the layout algorithm run

   547      * 

   548      * @since Series 60 3.2

   549      */

   550     void PrepareRunLayoutL();

   551 

   552     /**

   553      * Runs the layout algorithm        

   554      * 

   555      * @since Series 60 3.2

   556      */

   557     TInt RunLayoutL( CXnNode* aNode );

   558 

   559     /**

   560      * Checks if layout is currently disabled

   561      * 

   562      * @since Series 60 3.2

   563      */

   564     TBool IsLayoutDisabled();

   565 

   566     void AddToRedrawListL( CXnNode* aNode, TRect aRect =

   567         TRect::EUninitialized );

   568 

   569     void AddToDirtyListL( CXnNode* aNode );

   570 

   571     /**

   572      * Finds a node where to start layout

   573      *

   574      * @since Series 60 5.0

   575      */

   576     CXnNode* StartLayoutFromL();

   577 

   578     void ForceRenderUIL( TBool aLayoutOnly = EFalse );

   579 

   580     CCoeControl* WindowOwningControl( CXnNode& aNode );

   581     

   582     TXnDirtyRegion* FindDirtyRegionL( CXnNode& aNode );

   583 

   584     void AddRedrawRectL( TRect aRect, CXnNode& aNode );

   585 

   586     void ReportScreenDeviceChangeL();

   587     

   588     /**

   589       * Handle partial touch input

   590       * 

   591       * @since Series 60 5.2

   592       * @param TInt aType 

   593       */ 

   594     void HandlePartialTouchInputL( CXnNode& aNode, TBool aEnable );

   595 

   596     /**

   597       * Set node visible

   598       * 

   599       * @since Series 60 5.2

   600       * @param aNode node to hide/show

   601       * @param TBool aVisible boolean to set node visible      

   602       */      

   603     void SetNodeVisibleL( CXnNode* aNode, TBool aVisible );

   604 

   605     /**

   606       * Set partial screen block

   607       * 

   608       * @since Series 60 5.2

   609       * @param CXnNode aParent parent node 

   610       * @param TDesC8 aBlockProgression set layout direction

   611       */     

   612     void SetPartialScreenBlockProgressionL( 

   613             CXnNode* aParent, const TDesC8& aBlockProgression );

   614    

   615     /**

   616       * Handles skin change resource change

   617       * 

   618       * @since Series 60 5.2

   619       */

   620     void HandleSkinChangeL();

   621 

   622     /**

   623       * Handles KEikDynamicLayoutVariantSwitch resource change

   624       * 

   625       * @since Series 60 5.2

   626       */

   627     void HandleDynamicLayoutVariantSwitchL();

   628 	

   629 private:

   630     //Derived functions

   631     

   632     /** 

   633      * from MXnViewObserver 

   634      */

   635     void NotifyViewActivatedL( const CXnViewData& aViewData );

   636 

   637     /** 

   638      * from MXnViewObserver

   639      */

   640     void NotifyViewDeactivatedL( const CXnViewData& /*aViewData*/ );

   641 

   642     /**

   643      * from MXnViewObserver 

   644      */

   645     void NotifyConfigureWidgetL( const CHsContentInfo& /*aContentInfo*/,

   646         CXnPluginData& /*aPluginData*/ );

   647     

   648     /** 

   649      * from MXnViewObserver 

   650      */

   651     void NotifyWidgetAdditionL( const CXnPluginData& aPluginData );

   652 

   653     /** 

   654      * from MXnViewObserver

   655      */

   656     void NotifyWidgetRemovalL( const CXnPluginData& /*aPluginData*/ );

   657 

   658     /** 

   659      * from MXnViewObserver 

   660      */

   661     void NotifyViewAdditionL( const CXnPluginData& /*aPluginData*/ ){};

   662 

   663     /** 

   664      * from MXnViewObserver

   665      */

   666     void NotifyViewRemovalL( const CXnPluginData& /*aPluginData*/ ){};

   667 

   668     /** 

   669      * from MXnViewObserver

   670      */

   671     void NotifyAllViewsLoadedL(){};

   672 

   673     /** 

   674      * from MXnViewObserver

   675      */

   676     void NotifyContainerActivatedL( const CXnViewData& /*aViewData*/ ){};

   677 

   678 private:

   679     // from MXnMenuObserver

   680 

   681     TBool DynInitMenuItemL( CXnNodeAppIf& aMenuItem, CXnNodeAppIf* aPlugin = NULL );

   682 

   683 private:

   684     // from MXnPropertyChangeObserver

   685 

   686     /**

   687      * Property changed

   688      * 

   689      * @since S60 5.1         

   690      * @param aKey key value

   691      * @param aValue property value         

   692      */

   693     void PropertyChangedL( const TUint32 aKey, const TInt aValue );

   694 

   695 private:

   696     // from MXnUiResourceChangeObserver

   697     

   698     /**

   699      * @see MXnUiResourceChangeObserver

   700      */

   701     void NotifyStatusPaneSizeChanged();

   702 

   703     /**

   704      * @see MXnUiResourceChangeObserver

   705      */

   706     void NotifyResourceChanged( TInt aType );

   707     

   708 private:

   709     // Data               

   710     

   711     /** Current screen device, Owned */

   712     CGraphicsDevice* iCurrentGraphicsDevice;

   713     /** UI engine - received from constructor's input parameters, Not owned */

   714     CXnUiEngine* iUiEngine;

   715     /** AppUi, Not owned */

   716     CXnAppUiAdapter& iAppUiAdapter;    

   717     /** Not owned. View manager */

   718     CXnViewManager& iViewManager;

   719     /** Key event dispatcher, Not owned */

   720     CXnKeyEventDispatcher* iKeyEventDispatcher;

   721     /** ControlAdapters, not owned */

   722     const RPointerArray< CXnControlAdapter >* iControlAdapterList;

   723     /** Region pending redraw */

   724     RPointerArray<TXnDirtyRegion> iRedrawRegions;

   725     /** List of currently dirty nodes */

   726     RPointerArray< CXnNode > iDirtyList;

   727     /** Array of nodes which can be focused */

   728     RPointerArray< CXnNode > iFocusCandidateList;

   729     /** current view */

   730     CXnNode* iCurrentView;

   731     /** current view control adapter, not owned */

   732     CXnControlAdapter* iCurrentViewControlAdapter;

   733     /** Controls layouting */

   734     TInt iLayoutControl;

   735     /** Layout algo phase */

   736     TInt iLayoutPhase;

   737     /** Unit in pixels (width). */

   738     TReal iHorizontalUnitInPixels;

   739     /** Unit in pixels (height). */

   740     TReal iVerticalUnitInPixels;

   741     /** Cached menu node	*/	

   742     CXnNode* iMenuNode;

   743     /** Cached styluspopup node */

   744     CXnNode* iStylusPopupNode;

   745     /** Drawing area */

   746     TRect iClientRect;

   747     /** Owned. Edit mode storage; */

   748     CXnEditMode* iEditMode;

   749     /** Disable count */

   750     TInt iDisableCount;   

   751 	/**Split screen states*/

   752     TXnSplitScreenState iSplitScreenState;

   753     };

   754 

   755 #endif      // _CXNUIENGINEIMPL_H