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:  Xuikon control adapter header file

    15 *

    16 */

    17 

    18 

    19 #ifndef __XNCONTROLADAPTERIMPL_H__

    20 #define __XNCONTROLADAPTERIMPL_H__

    21 

    22 // System includes

    23 #include <e32base.h>

    24 #include <coecntrl.h>

    25 #include <AknIconUtils.h>

    26 #include <AknsEffectAnim.h>

    27 #include <AknsItemID.h>

    28 

    29 // User includes

    30 #include "xngesturehelper.h"

    31 

    32 // Forward declarations

    33 class CXnNodePluginIf;

    34 class CXnComponent;

    35 class CWindowGc;

    36 class CXnControlAdapter;

    37 class CXnNode;

    38 class CXnProperty;

    39 class CGulIcon;

    40 class CXnUiEngine;

    41 

    42 //Constants

    43 _LIT( KMif, "mif(" );

    44 _LIT8( KMenuBarNode, "menubar" );

    45 const TInt KSpaceChar = 32;

    46 const TInt KRightParenthesis = ')';

    47 

    48 /**

    49  * XnGestureHelper namespace

    50  * Used for the whole gesture family - Gesture recognizer, gesture helper, 

    51  * Point array

    52  */

    53 namespace XnGestureHelper

    54     {

    55     class CXnGestureHelper;

    56     }

    57 

    58 using XnGestureHelper::CXnGestureHelper;

    59 

    60 

    61 // Class declaration

    62 

    63 /**

    64 *  Control adapter class implementation.

    65 * 

    66 *  @ingroup group_xnlayoutengine 

    67 *  @lib xn3layoutengine.lib

    68 *  @since Series 60 3.1

    69 */

    70 NONSHARABLE_CLASS( CXnControlAdapterImpl ) : public CBase, 

    71     public MAknsEffectAnimObserver

    72     {

    73 public:

    74     

    75     /**

    76      * Response of property change handled/not handled

    77      */

    78     enum TPropertyChangeResponse

    79         {

    80         /** The property change was not handled. */

    81         EPropertyChangeNotConsumed,

    82         /** The property change was handled. */

    83         EPropertyChangeConsumed

    84         };

    85 

    86 public:

    87     

    88     /**

    89      *  Icon provider used by AknIconUtils

    90      *  

    91      *  @since Series 60 3.1

    92      */

    93     class TIconProvider : public MAknIconFileProvider

    94         {

    95     public:

    96         /**

    97          * Constructor

    98          * 

    99          * @param aFile File handle to use

   100          */

   101         TIconProvider( RFile& aFile );

   102         

   103     public:

   104         

   105         /**

   106          * Destructor.

   107          */

   108         virtual ~TIconProvider();

   109         

   110         // Functions from base classes

   111         /**

   112          * From MAknIconFileProvider Returns an open file handle to the icon 

   113          * file.

   114          * This method should leave if an icon file with specified type does

   115          * not exist. That may be the case e.g. with MBM file,

   116          * if there are no bitmap icons.

   117          *

   118          * Note! RFs::ShareProtected must be called to the RFs instance used

   119          * for opening the file.

   120          *

   121          * @param aFile Icon file should be opened in this file handle, which

   122          * is an empty file handle, when the AknIcon framework calls this 

   123          * method. The AknIcon framework takes care of closing the file handle 

   124          * after having used it.

   125          * 

   126          * @param aType Icon file type.

   127          */

   128         virtual void RetrieveIconFileHandleL( RFile& aFile,

   129             const TIconFileType /*aType*/);

   130         

   131         /**

   132          * From MAknIconFileProvider With this method, AknIcon framework 

   133          * informs that it does not use this MAknIconFileProvider instance 

   134          * any more. After this call,

   135          * it is ok to delete the object. This can be implemented simply

   136          * e.g. by deleting self in this callback.

   137          * Normally, this callback is invoked when the icon in question

   138          * is deleted.

   139          * Note, however, that if the same MAknIconFileProvider instance is

   140          * supplied in multiple CreateIcon calls, then it must be accessible

   141          * by AknIcon framework until it has signalled a matching amount

   142          * of these callbacks.

   143          */

   144         virtual void Finished();

   145         

   146     private:

   147         

   148         // file to use

   149         RFile iFile;

   150         };

   151 

   152 public:

   153     // Constructors and destructor

   154     

   155     /**

   156      * Two-phased constructor.

   157      * 

   158      * @param aNode 

   159      * @param aDadapter Control adapter

   160      * @param gc Window gc

   161      */

   162     static CXnControlAdapterImpl* NewL( CXnNodePluginIf& aNode,

   163         CXnControlAdapter& aAdapter, CWindowGc& gc );

   164 

   165     /**

   166      * Destructor.

   167      */

   168     virtual ~CXnControlAdapterImpl();

   169 

   170 public:

   171     // New functions

   172     

   173     /**

   174      * Sets component pointer.

   175      *

   176      * @since Series 60 3.1

   177      * @param aComponent Component pointer.

   178      */

   179     void SetComponent( CXnComponent* aComponent );

   180 

   181     /**

   182      * Gets the component pointer.

   183      *

   184      * @since Series 60 3.1

   185      * @return Component pointer.

   186      */

   187     CXnComponent* Component();

   188 

   189     /**

   190      * Const-version of getting the component pointer. 

   191      *

   192      * @since Series 60 3.1

   193      * @return Component pointer.

   194      */

   195     CXnComponent* Component() const;

   196 

   197     /**

   198      * Add a child adapter

   199      *

   200      * @since Series 60 3.1

   201      * @param aChild Child adapter

   202      */

   203     void AppendChildL(CXnControlAdapter& aChild, CXnNode& aNode);

   204        

   205     /**

   206      * Checks if the control should be drawn, according to visibility and 

   207      * display properties.

   208      *

   209      * @since Series 60 3.1

   210      * @return ETrue if drawing is ok, EFalse otherwise

   211      */

   212     TBool IsDrawingAllowed() const;

   213 

   214     /**

   215      * Gets content bitmaps. Ownership is not transferred.

   216      *

   217      * @since Series 60 3.1

   218      * @param aBitmap Bitmap to draw

   219      * @param aMask Mask to use

   220      */

   221     void ContentBitmaps( CFbsBitmap*& aBitmap, CFbsBitmap*& aMask );

   222 

   223     /**

   224      * Sets content bitmaps. Ownership is transferred.

   225      *

   226      * @since Series 60 3.1

   227      * @param aBitmap Bitmap to draw

   228      * @param aMask Mask to use

   229      */

   230     void SetContentBitmaps( CFbsBitmap* aBitmap, CFbsBitmap* aMask );

   231 

   232     /**

   233      * Sets content bitmaps. Ownership is transferred.

   234      *

   235      * @since Series 60 3.1

   236      * @param aBitmapUrl Url of the bitmap to draw

   237      * @param aMaskUrl Url of the bitmap mask to use

   238      */

   239     void SetContentBitmapsL( const TDesC& aBitmapUrl, const TDesC& aMaskUrl );

   240 

   241     /**

   242      * Load a bitmap from the server. Ownership is transferred.

   243      *

   244      * @since Series 60 3.1

   245      * @param aBitmapUrl Url of the bitmap to load

   246      * @return Bitmap

   247      */

   248     CFbsBitmap* LoadBitmap( const TDesC& aBitmapUrl );

   249 

   250     /**

   251      * Load a bitmap and mask from the server. Ownership is transferred.

   252      *

   253      * @since Series 60 3.1

   254      * @param aBitmapUrl Url of the bitmap to load

   255      * @param aMaskUrl Url of the mask to load, if any

   256      * @param aBitmap  Fetched bitmap

   257      * @param aMask Fetched mask

   258      * @return void

   259      */

   260     void GetBitmapAndMask( const TDesC& aBitmapUrl, const TDesC& aMaskUrl,

   261         CFbsBitmap*& aBitmap, CFbsBitmap*& aMask );

   262 

   263     /**

   264      * Handles pointer events

   265      * This method must always be called, even when it's overridden by derived

   266      * classes

   267      *

   268      * @param aPointerEvent pointer event

   269      */

   270     TBool HandlePointerEventL( const TPointerEvent& aPointerEvent );

   271     

   272     /**

   273      * Draws the control

   274      * This method must always be called, even when it's overridden by derived

   275      * classes

   276      *

   277      * @param aRect TRect to draw

   278      */

   279     void Draw( const TRect& aRect ) const;

   280     

   281     /**

   282      * Draws the control using a client-specified gc.

   283      *

   284      * @param aRect TRect to draw

   285      * @param aGc Gc used for drawing

   286      */

   287     void Draw( const TRect& aRect, CWindowGc& aGc ) const;

   288 

   289     /**

   290      * Return a child control by index

   291      * This method must not be overridden by derived classes

   292      *

   293      * @param aIndex Index of the child to return

   294      * @return Control at the given index

   295      */

   296     CCoeControl* ComponentControl( TInt aIndex ) const;

   297     

   298     /**

   299      * From CCoeControl Return count of children

   300      * This method must not be overridden by derived classes

   301      *

   302      * @return Count of children

   303      */

   304     TInt CountComponentControls() const;

   305 

   306     /**

   307      * Draws content image.

   308      *

   309      * @since Series 60 3.1

   310      */

   311     void DrawContentImage() const;

   312 

   313     /**

   314      * Draws content image.

   315      *

   316      * @param aGc Gc used for drawing

   317      * @since Series 60 3.1

   318      */

   319     void DrawContentImageL( CWindowGc& aGc ) const;

   320 

   321     /**

   322      * Size change notification

   323      */

   324     void SizeChanged();

   325 

   326     /**

   327      * Skin change notification

   328      */

   329     void SkinChanged();

   330 

   331     /**

   332      * Focus changed notification

   333      * 

   334      * @since S60 5.0

   335      * @param aFocused Control's current foucs state      

   336      */

   337     void FocusChangedL( TBool aFocused );

   338 

   339     /**

   340      * Initialize or refresh background and border bitmaps

   341      * This is called when for example the skin or control size is changed

   342      */

   343     void InitializeBackgroundAndBorderBitmapsL();

   344 

   345     /** 

   346      * This is called to measure adaptive content dimensions.

   347      *

   348      * @since 3.2

   349      * @param aAvailableSize Not used

   350      * @return For now it returns default size - zero

   351      */

   352     TSize MeasureAdaptiveContentL( const TSize& aAvailableSize );

   353 

   354     /** 

   355      * Sets the control blank

   356      * 

   357      * @since S60 5.1

   358      * @param aBlank, ETrue sets blank, EFalse resets blank

   359      */

   360     void SetBlank( TBool aBlank );

   361 

   362     /** 

   363      * Creates trigger node for swipe event

   364      * 

   365      * @since S60 5.1

   366      * @param aUiEngine reference to uiengine

   367      * @param aDirection Direction of swipe

   368      * @return trigger node for swipe

   369      */

   370     CXnNode* BuildSwipeTriggerNodeLC( CXnUiEngine& aUiEngine,

   371         const TDesC8& aDirection );

   372 

   373 public:

   374     // Functions from base classes

   375 

   376     /**

   377      * From CCoeControl Handles key events.

   378      *

   379      * @since Series 60 3.1

   380      * @param aKeyEvent Key event.

   381      * @param aType Event type.

   382      * @return Key response

   383      */

   384     TKeyResponse OfferKeyEventL( const TKeyEvent& aKeyEvent, 

   385         TEventCode aType );

   386 

   387     /**

   388      * From MAknLongTapDetectorCallBack. Handles the long tap events.

   389      *

   390      * @since Series 60 3.1

   391      * @param aPenEventLocation Long tap event location relative to parent 

   392      *        control.

   393      * @param aPenEventScreenLocation Long tap event location relative to 

   394      *        screen.

   395      */

   396     void HandleLongTapEventL( const TPoint& aPenEventLocation,

   397         const TPoint& aPenEventScreenLocation );

   398 

   399     /**

   400      * Creates highlight animation from a skin id when one is available.

   401      */

   402     void CreateAnimationL();

   403 

   404     /**

   405      * MAknsEffectAnimObserver callback. Draws the adapter again and renders

   406      * the animated area.

   407      * 

   408      * @param aError Error - zero if error, nonzero otherwise

   409      */

   410     virtual void AnimFrameReady( TInt aError, TInt );

   411 

   412     /**

   413      * Starts highlight animation.

   414      *

   415      * @param aAnimRestart When true, the animation is stopped and then 

   416      *        started again.

   417      */

   418     void StartHighlightAnimation( TBool aAnimRestart = EFalse );

   419 

   420     /**

   421      * Stops highlight animation.

   422      */

   423     void StopHighlightAnimation();

   424 

   425     /**

   426      * Handles property change

   427      */

   428     void DoHandlePropertyChangeL( CXnProperty* aProperty = NULL );

   429 

   430     /**

   431      * Handles change of device screen

   432      */

   433     void HandleScreenDeviceChangedL();

   434 

   435     /**

   436      * Updates background image

   437      * 

   438      * @param aProperty If it is background image, initializes background 

   439      *        bitmap

   440      * @return CXnControlAdapterImpl::TPropertyChangeResponse whether it was 

   441      *         consumed

   442      */

   443     CXnControlAdapterImpl::TPropertyChangeResponse UpdateBackgroundImageL(

   444         CXnProperty* aProperty );

   445 

   446     /**

   447      * Forwards event to gesture helper

   448      * 

   449      * @param aPointerEvent Event to be forwarded

   450      * @return ETrue when swipe took place, EFalse otherwise

   451      */

   452     TBool PassEventToGestureHelperL(

   453         const TPointerEvent& aPointerEvent );

   454 

   455     /*

   456      * Resets child adapters

   457      */

   458     void RemoveChildAdapters();

   459     

   460     /*

   461      * Returns Child adapters

   462      * 

   463      * @return Returns child adapters 

   464      */

   465     RPointerArray< CXnControlAdapter >& ChildAdapters();

   466 

   467 protected:

   468     // New functions

   469 

   470     /**

   471      * C++ default constructor.

   472      */

   473     CXnControlAdapterImpl( CXnNodePluginIf& aNode );

   474 

   475     /**

   476      * Two-phased constructor.

   477      */

   478     void ConstructL( CXnNodePluginIf& aNode, CXnControlAdapter& aAdapter,

   479         CWindowGc& gc );

   480 

   481 private:

   482     void DoDrawL( const TRect& aRect, CWindowGc& aGc ) const;

   483     void DrawBackgroundDataL( const TRect& aRect, CXnNode& aNode,

   484         CWindowGc& aGc );

   485     void DrawEditModeBgData( CXnNode& aNode, CWindowGc& aGc );

   486     void DrawTransparentColorL( CXnNode& aNode, CWindowGc& aGc,

   487         CFbsBitmap* aMask );

   488      void DrawBackgroundSkinL( CXnNode& aNode, CFbsBitmap* aMask, 

   489         CWindowGc& aGc,CXnProperty* aBgColor, TRect aRect = TRect::EUninitialized );

   490     void DrawBackgroundSkin(const TAknsItemID& aSkinId, CWindowGc& aGc, 

   491         TRect aRect );

   492     void DrawBackgroundImageL( const TRect& aRect, CXnNode& aNode,

   493         CWindowGc& aGc, CFbsBitmap* aBitmap, CFbsBitmap* aMask );

   494     RFs& FsSession();

   495 

   496 private:

   497     // Data 

   498     

   499     /** Node */

   500     CXnNodePluginIf& iNode;

   501     /** Pointer to component base object. */

   502     CXnComponent* iComponent;

   503     /** child controls */

   504     mutable RPointerArray< CXnControlAdapter > iChildren;

   505     /** content image */

   506     mutable CFbsBitmap* iContentBitmap;

   507     /** content bitmap index */

   508     mutable TInt iContentBitmapIndex;

   509     /** content mask */

   510     mutable CFbsBitmap* iContentMask;

   511     /** content mask index */

   512     mutable TInt iContentMaskIndex;

   513     /** background image */

   514     mutable CFbsBitmap* iBackgroundBitmap;

   515     /** background mask */

   516     mutable CFbsBitmap* iBackgroundMask;

   517     /** background image index */

   518     mutable TInt iBackgroundBitmapIndex;

   519     /** border image */

   520     mutable CFbsBitmap* iBorderBitmap;

   521     /** border image index */

   522     mutable TInt iBorderBitmapIndex;

   523     /** border image split value for top border */

   524     mutable TInt iBorderBitmapDividerTop;

   525     /** border image split value for right border */

   526     mutable TInt iBorderBitmapDividerRight;

   527     /** border image split value for bottom border */

   528     mutable TInt iBorderBitmapDividerBottom;

   529     /** border image split value for left border */

   530     mutable TInt iBorderBitmapDividerLeft;

   531     /** graphics context */

   532     mutable CWindowGc* iGc;

   533     /** control adapter */

   534     mutable CXnControlAdapter* iAdapter;

   535     /** icon provider, for AknIconUtils */

   536     mutable TIconProvider* iIconProvider;

   537     /** scaled content image */

   538     mutable CFbsBitmap* iScaledContentBitmap;

   539     /** scaled content mask */

   540     mutable CFbsBitmap* iScaledContentMask;

   541     /** scaled transparent color */

   542     mutable CGulIcon* iScaledTransparentColor;

   543     /** scaled background skin */

   544     mutable CGulIcon* iScaledBackgroundSkin;

   545     /** scaled background image */

   546     mutable CFbsBitmap* iScaledBackgroundImage;

   547     /** skin animation object for skin highlight animation */

   548     CAknsEffectAnim* iAnimation;

   549     /** skin animation identifier */

   550     TAknsItemID iAnimIID;

   551     /** flag: skin animation id is resolved from the CSS property */

   552     TBool iAnimIDResolved;

   553     /** pointer to gesturehelper */

   554     CXnGestureHelper* iGestureHelper;

   555     /** flag: for storing blank state */

   556     TBool iBlank;

   557     /** flag: to detect whether longtap occured */

   558     TBool iLongtap;    

   559     };

   560 

   561 #endif //__XNCONTROLADAPTERIMPL_H__