1 /*

     2 * Copyright (c) 2006-2007 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:   Implements CHuiVisual class. Visuals are graphical entities 

    15 *                visible on a display.

    16 *

    17 */

    18 

    19 

    20 

    21 #include "uiacceltk/HuiVisual.h"  // Class definition

    22 #include "uiacceltk/HuiLayout.h"

    23 #include "uiacceltk/HuiControl.h"

    24 #include "uiacceltk/HuiControlGroup.h"

    25 #include "uiacceltk/HuiEnv.h"

    26 #include "uiacceltk/HuiDisplay.h"

    27 #include "uiacceltk/HuiRoster.h"

    28 #include "uiacceltk/HuiTransformation.h"

    29 #include "uiacceltk/HuiDrawing.h"

    30 #include "HuiRenderPlugin.h"

    31 #include "uiacceltk/HuiUtil.h"

    32 #include "uiacceltk/HuiStatic.h"

    33 #include "uiacceltk/HuiProbe.h"

    34 #include "uiacceltk/huidropshadow.h"

    35 #include "HuiRosterImpl.h"

    36 #include "HuiFxEffect.h"

    37 #include "HuiFxEffectParser.h"

    38 #include "alflogger.h"

    39 #include "HuiCmdBufferBrush.h"

    40 #include "huicanvasrenderbuffer.h"

    41 

    42 struct CHuiVisual::THuiVisualPrivateData

    43     {

    44 public: // Functions

    45     // Constructor: initialize the data

    46     THuiVisualPrivateData() : iTacticons(), iDropShadow(NULL)

    47         {

    48         iEffect = NULL;

    49         iEffectParser = NULL;

    50         }

    51         

    52     // Destructor: destruct the data

    53     ~THuiVisualPrivateData()

    54         {

    55         iTacticons.Close();

    56         delete iDropShadow;

    57         delete iEffectParser;

    58         delete iEffect;

    59         }

    60     

    61     // structs

    62     struct TTacticon

    63         {

    64         TInt iFeedbackType;

    65         TInt iEventType;

    66         };

    67     

    68     // Data

    69     RArray<TTacticon> iTacticons;

    70     CHuiDropShadow* iDropShadow;

    71     TRect iPreviousDrawnTvOut; 

    72     CHuiFxEffect* iEffect;

    73     CHuiFxEffectParser* iEffectParser;

    74     MHuiEffectable *iEffectable;

    75     CHuiCanvasRenderBuffer* iStoredRenderBuffer;

    76     TBool iStoredRenderBufferModificationsEnabled;

    77     TBool iFreezed;

    78     };

    79 class CHuiEffectable : public CBase, public MHuiEffectable

    80     {

    81 public: // from MHuiEffectable

    82     CHuiEffectable(CHuiVisual *aVisual) : iVisual(aVisual) { }

    83     void EffectSetEffect(CHuiFxEffect* aEffect);

    84     TReal32 EffectOpacityTarget() const;

    85     void EffectSetOpacity(TReal32 aOpacity);

    86     void EffectDrawSelf( CHuiGc &aGc, const TRect & aDisplayRect) const;

    87     THuiRealRect EffectDisplayRect() const __SOFTFP;

    88     void SetLoadingEffect(TBool aLoading);    

    89     void EffectSetSource( TBool aIsInput1 );

    90     TBool EffectGetSource() const;

    91 

    92 private:

    93     CHuiVisual *iVisual;

    94     TBool iIsInput1;

    95     };

    96 void CHuiEffectable::EffectSetEffect(CHuiFxEffect* aEffect)

    97     {

    98     iVisual->SetEffect(aEffect);

    99     }

   100 void CHuiEffectable::EffectSetSource( TBool aIsInput1 )

   101     {

   102     iIsInput1 = aIsInput1;

   103     }

   104 TBool CHuiEffectable::EffectGetSource() const

   105     {

   106     return iIsInput1;

   107     }

   108 

   109 TReal32 CHuiEffectable::EffectOpacityTarget() const

   110     {

   111     return iVisual->iOpacity.Target();

   112     }

   113 

   114 void CHuiEffectable::EffectSetOpacity(TReal32 aOpacity)

   115     {

   116     iVisual->iOpacity.Set( aOpacity );

   117     }

   118 

   119 void CHuiEffectable::EffectDrawSelf( CHuiGc &aGc, const TRect & aDisplayRect) const

   120     {

   121     iVisual->DrawSelf(aGc, aDisplayRect);

   122     }

   123 

   124 THuiRealRect CHuiEffectable::EffectDisplayRect() const __SOFTFP

   125     {

   126     return iVisual->DisplayRect();

   127     }

   128 

   129 void CHuiEffectable::SetLoadingEffect(TBool aLoading)

   130     {

   131     iVisual->SetLoadingEffect(aLoading);

   132     }

   133 

   134 

   135 /// Descriptor that is returned when the tag is queried and no tag has been

   136 /// been defined for a visual.

   137 _LIT8(KHuiVisualUndefinedTag, "");

   138 

   139 EXPORT_C MHuiVisualOwner::~MHuiVisualOwner()

   140     {

   141     }

   142 

   143 EXPORT_C CHuiCanvasRenderBuffer *CHuiVisual::StoredRenderBuffer() const

   144     {

   145     return iVisualData->iStoredRenderBuffer;

   146     }

   147 EXPORT_C void CHuiVisual::SetStoredRenderBuffer(CHuiCanvasRenderBuffer *aRenderBuffer)

   148     {

   149     if (iVisualData->iStoredRenderBufferModificationsEnabled)

   150         {

   151         if (iVisualData->iStoredRenderBuffer)

   152             {

   153             iVisualData->iStoredRenderBuffer->UnInitialize();

   154             }

   155         delete iVisualData->iStoredRenderBuffer;

   156         iVisualData->iStoredRenderBuffer = aRenderBuffer;

   157         }

   158     }

   159 EXPORT_C void CHuiVisual::SetStoredRenderBufferModificationsEnabled(TBool aEnabled)

   160     {

   161     iVisualData->iStoredRenderBufferModificationsEnabled = aEnabled;

   162     }

   163 

   164 EXPORT_C void CHuiVisual::SetFreezeState(TBool aEnabled)

   165     {

   166     iVisualData->iFreezed = aEnabled;

   167     }

   168 TBool CHuiVisual::Freezed() const

   169 {

   170     return iVisualData->iFreezed;

   171 }

   172 

   173 EXPORT_C CHuiVisual* CHuiVisual::AddNewL(CHuiControl& aOwnerControl,

   174                                          CHuiLayout* aParentLayout)

   175     {

   176     CHuiVisual* visual = STATIC_CAST(CHuiVisual*,

   177         aOwnerControl.AppendVisualL(EHuiVisualTypeVisual, aParentLayout));

   178     return visual;

   179     }

   180 

   181 

   182 EXPORT_C CHuiVisual::CHuiVisual(MHuiVisualOwner& aOwner)

   183         : iOpacity(1.f),

   184           iOwner(&aOwner), 

   185           // Set the maximum size to unlimited.

   186           iMaxSize(TSize(KMaxTInt, KMaxTInt)),

   187           iPadding(0), 

   188           iDisplayRectFrameNumber(KMaxTUint),

   189           iDisplayRectTargetFrameNumber(KMaxTUint)

   190     {

   191     HUI_PROBE_ASSOCIATE_WITH_CURRENT_SESSION

   192     HUI_PROBE_REPORT_CONSTRUCTED

   193     iOpacity.SetStyle(EHuiTimedValueStyleLinear);

   194     }

   195 

   196 

   197 EXPORT_C void CHuiVisual::ConstructL()

   198     {

   199     iVisualData = new (ELeave) THuiVisualPrivateData;

   200     iVisualData->iEffectable = new CHuiEffectable(this);

   201     iVisualData->iStoredRenderBuffer = NULL;

   202     }

   203 

   204 

   205 EXPORT_C CHuiVisual::~CHuiVisual()

   206     {

   207     // Cancel scheduled commands for this visual.

   208     Env().CancelCommands(this);

   209 

   210 	// Update previous dirty rect to relevant displays so that the visual can be erased

   211     if(Display())

   212         {        

   213         CHuiRoster& roster = Display()->Roster();

   214 		// Check if this roster is shared between several displays and add previous dirty to all 

   215 		// of them

   216     	for(TInt i = 0; i < Env().Displays().Count(); ++i)

   217         	{ 

   218         	CHuiDisplay* display = &Env().Display(i);

   219         	if (&(display->Roster()) == &roster)

   220         		{

   221 				const TRect& previousDirtyRect = display->IsDisplayTypeTvOut() ? iVisualData->iPreviousDrawnTvOut : iPreviousDrawn;

   222 				TRect empty;

   223         		display->CombineAndAddDirtyRegion(previousDirtyRect, empty);

   224         		}

   225         	}	

   226         }

   227 

   228     // If this is a root-level visual, it must be hidden on the display.

   229     if(iDisplay)

   230         {

   231         iDisplay->Roster().HideVisual(this);

   232         }

   233 

   234     // If the visual is still attached to a layout, it is time to remove it.

   235     if(iLayout)

   236         {

   237         iLayout->Remove(this);

   238         }

   239         

   240     // If the visual is attached to some visual as external content visual,

   241     // remove the link from the parent visual

   242     if (Flags() & EHuiVisualFlagDrawOnlyAsExternalContent)

   243     	{

   244     	TRAP_IGNORE(CHuiStatic::Env().Display(0).RosterImpl().RemoveExternalContentVisualFromParentL(this));

   245     	}

   246 

   247     delete iBrushes;

   248     delete iTag;

   249     delete iTransform;

   250     delete iVisualData->iEffectable;

   251     if (iVisualData->iStoredRenderBuffer)

   252         {

   253         iVisualData->iStoredRenderBuffer->UnInitialize();

   254         }

   255     delete iVisualData->iStoredRenderBuffer;

   256     delete iVisualData;

   257     

   258     iOwner = NULL;

   259     iDisplay = NULL;

   260     iLayout = NULL;

   261 

   262     HUI_PROBE_REPORT_DESTRUCTED

   263     }

   264 

   265 

   266 EXPORT_C void CHuiVisual::RemoveAndDestroyAllD()

   267     {

   268     ASSERT(iOwner != NULL);

   269     iOwner->VisualDestroyed(*this);

   270     delete this;

   271     }

   272 

   273 

   274 EXPORT_C CHuiLayout* CHuiVisual::Layout() const

   275     {

   276     return iLayout;

   277     }

   278 

   279 

   280 void CHuiVisual::SetLayout(CHuiLayout* aLayout)

   281     {

   282     iLayout = aLayout;

   283     }

   284 

   285 

   286 EXPORT_C CHuiEnv& CHuiVisual::Env() const

   287     {

   288     return Owner().Env();

   289     }

   290 

   291 

   292 EXPORT_C CHuiSkin& CHuiVisual::Skin() const

   293     {

   294     return Owner().Env().Skin();

   295     }

   296 

   297 

   298 EXPORT_C CHuiDisplay* CHuiVisual::Display() const

   299     {

   300     const CHuiVisual* iter = this;

   301 

   302     while(iter)

   303         {

   304         if(iter->iDisplay)

   305             {

   306             return iter->iDisplay;

   307             }

   308         iter = iter->Layout();

   309         }

   310 

   311     // Not shown on any display.

   312     return NULL;

   313     }

   314 

   315 

   316 void CHuiVisual::SetDisplay(CHuiDisplay* aDisplay)

   317     {

   318     iDisplay = aDisplay;

   319     }

   320 

   321 

   322 EXPORT_C void CHuiVisual::SetFlag(THuiVisualFlags aFlag)

   323     {

   324     SetFlags(aFlag);

   325     }

   326 

   327 

   328 EXPORT_C void CHuiVisual::SetFlags(TInt aAnyFlags)

   329     {

   330     const TInt oldFlags = iFlags;

   331     iFlags |= aAnyFlags;

   332 

   333     if(!CHuiStatic::Renderer().Allows(EHuiRenderPluginAllow3DProjection))

   334         {

   335         // The rendering plugin does not support 3D projection.

   336         ClearFlag(EHuiVisualFlag3DProjection);

   337         }

   338         

   339     HandleFlagsChanged( oldFlags );

   340     }

   341 

   342 

   343 EXPORT_C void CHuiVisual::ClearFlag(THuiVisualFlags aFlag)

   344     {

   345     ClearFlags( aFlag );

   346     }

   347 

   348 

   349 EXPORT_C void CHuiVisual::ClearFlags(TInt aAnyFlags)

   350     {

   351     const TInt oldFlags = iFlags;

   352     iFlags &= ~aAnyFlags;

   353     

   354     HandleFlagsChanged( oldFlags );

   355     }

   356 

   357 

   358 EXPORT_C MHuiVisualOwner& CHuiVisual::Owner() const

   359     {

   360     ASSERT(iOwner != NULL);

   361     return *iOwner;

   362     }

   363     

   364     

   365 EXPORT_C void CHuiVisual::SetOwner(MHuiVisualOwner& aOwner)

   366     {

   367     iOwner = &aOwner;

   368     }

   369     

   370     

   371 EXPORT_C TInt CHuiVisual::Count() const

   372     {

   373     return 0;

   374     }

   375 

   376 

   377 EXPORT_C CHuiVisual& CHuiVisual::Visual(TInt /*aIndex*/) const

   378     {

   379     USER_INVARIANT();

   380     return *(CHuiVisual*)this; // never reached

   381     }

   382 

   383 

   384 EXPORT_C void CHuiVisual::SetOrigin(THuiVisualHOrigin aHoriz, THuiVisualVOrigin aVert)

   385     {

   386     ClearFlags(EHuiVisualFlagHOriginCenter | EHuiVisualFlagHOriginRight);

   387     switch(aHoriz)

   388         {

   389         case EHuiVisualHOriginCenter:

   390             SetFlag(EHuiVisualFlagHOriginCenter);

   391             break;

   392 

   393         case EHuiVisualHOriginRight:

   394             SetFlag(EHuiVisualFlagHOriginRight);

   395             break;

   396 

   397         default:

   398             break;

   399         }

   400 

   401     ClearFlags(EHuiVisualFlagVOriginCenter | EHuiVisualFlagVOriginBottom);

   402     switch(aVert)

   403         {

   404         case EHuiVisualVOriginCenter:

   405             SetFlag(EHuiVisualFlagVOriginCenter);

   406             break;

   407 

   408         case EHuiVisualVOriginBottom:

   409             SetFlag(EHuiVisualFlagVOriginBottom);

   410             break;

   411 

   412         default:

   413             break;

   414         }

   415     }

   416 

   417 

   418 EXPORT_C THuiVisualHOrigin CHuiVisual::HorizontalOrigin() const

   419     {

   420     if(iFlags & EHuiVisualFlagHOriginCenter)

   421         {

   422         return EHuiVisualHOriginCenter;

   423         }

   424     if(iFlags & EHuiVisualFlagHOriginRight)

   425         {

   426         return EHuiVisualHOriginRight;

   427         }

   428     return EHuiVisualHOriginLeft;

   429     }

   430 

   431 

   432 EXPORT_C THuiVisualVOrigin CHuiVisual::VerticalOrigin() const

   433     {

   434     if(iFlags & EHuiVisualFlagVOriginCenter)

   435         {

   436         return EHuiVisualVOriginCenter;

   437         }

   438     if(iFlags & EHuiVisualFlagVOriginBottom)

   439         {

   440         return EHuiVisualVOriginBottom;

   441         }

   442     return EHuiVisualVOriginTop;

   443     }

   444 

   445 

   446 EXPORT_C void CHuiVisual::AlignByOrigin(THuiRealPoint& aPointInPixels, TBool aUndo) const

   447     {

   448     TInt factor = (aUndo? -1 : 1);

   449     THuiRealPoint itemSize(0.f, 0.f); 

   450     

   451     TInt horizOrig = HorizontalOrigin();

   452     TInt vertOrig = VerticalOrigin();

   453 

   454     // The position of the origin depends whether the coordinates are mirrored.    

   455     if(LocalBaseUnit().iX.iMagnitude < 0)

   456         {

   457         if(horizOrig == EHuiVisualHOriginLeft)

   458             {

   459             horizOrig = EHuiVisualHOriginRight;

   460             }

   461         else if(horizOrig == EHuiVisualHOriginRight)

   462             {

   463             horizOrig = EHuiVisualHOriginLeft;

   464             }

   465         else

   466             {

   467             // For PC-lint

   468             }

   469         }

   470     if(LocalBaseUnit().iY.iMagnitude < 0)

   471         {

   472         if(vertOrig == EHuiVisualVOriginTop)

   473             {

   474             vertOrig = EHuiVisualVOriginBottom;

   475             }

   476         else if(vertOrig == EHuiVisualVOriginBottom)

   477             {

   478             vertOrig = EHuiVisualVOriginTop;

   479             }

   480         else

   481             {

   482             // For PC-lint

   483             }

   484         }

   485     

   486     if(horizOrig != EHuiVisualHOriginLeft ||

   487         vertOrig != EHuiVisualVOriginTop)

   488         {

   489         // Need the size of the visual for aligning to non-top/left corner.

   490         itemSize = LocalPointInPixels(Size().RealNow());

   491         }

   492     

   493     switch(horizOrig)

   494         {

   495         case EHuiVisualHOriginCenter:

   496             aPointInPixels.iX -= factor * itemSize.iX / 2.f;

   497             break;

   498 

   499         case EHuiVisualHOriginRight:

   500             aPointInPixels.iX -= factor * itemSize.iX;

   501             break;

   502 

   503         default:

   504             break;

   505         }

   506 

   507     switch(vertOrig)

   508         {

   509         case EHuiVisualVOriginCenter:

   510             aPointInPixels.iY -= factor * itemSize.iY / 2.f;

   511             break;

   512 

   513         case EHuiVisualVOriginBottom:

   514             aPointInPixels.iY -= factor * itemSize.iY;

   515             break;

   516 

   517         default:

   518             break;

   519         }

   520     }

   521 

   522 

   523 EXPORT_C const THuiTimedPoint& CHuiVisual::Pos() const

   524     {

   525     return iPos;

   526     }

   527 

   528 

   529 EXPORT_C const THuiTimedPoint& CHuiVisual::Size() const

   530     {

   531     return iSize;

   532     }

   533 

   534 

   535 EXPORT_C void CHuiVisual::SetPos(const THuiRealPoint& aPos, TInt aTransitionTime)

   536     {

   537     iPos.iX.Set(aPos.iX, aTransitionTime);

   538     iPos.iY.Set(aPos.iY, aTransitionTime);

   539     }

   540 

   541 

   542 EXPORT_C void CHuiVisual::SetSize(const THuiRealSize& aSize, TInt aTransitionTime)

   543     {

   544     iSize.iX.Set(aSize.iWidth < 0 ? aSize.iWidth *-1 : aSize.iWidth, aTransitionTime);

   545     iSize.iY.Set(aSize.iHeight < 0 ? aSize.iHeight *-1 : aSize.iHeight, aTransitionTime);

   546     }

   547 

   548 

   549 EXPORT_C void CHuiVisual::SetRect(const THuiRealRect& aRect, TInt aTransitionTime)

   550     {

   551     SetPos(aRect.iTl, aTransitionTime);

   552     SetSize(aRect.Size(), aTransitionTime);

   553     }

   554 

   555 

   556 // deprecated

   557 EXPORT_C void CHuiVisual::Move(const TPoint& aOffset, TInt aTransitionTime)

   558     {

   559 	Move(PixelPointInLocal(THuiRealPoint(aOffset), EHuiReferenceStateNow), aTransitionTime);  

   560 	}

   561 

   562 

   563 EXPORT_C void CHuiVisual::Move(const THuiRealPoint& aOffset, TInt aTransitionTime)

   564     {

   565     iPos.iX.Set(iPos.iX.Target() + aOffset.iX, aTransitionTime);

   566     iPos.iY.Set(iPos.iY.Target() + aOffset.iY, aTransitionTime);

   567     }

   568 

   569 

   570 EXPORT_C void CHuiVisual::Mimic(const CHuiVisual& aVisual, TInt aTransitionTime)

   571     {

   572     SetPos(aVisual.iPos.RealTarget(), aTransitionTime);

   573     SetSize(aVisual.iSize.RealTarget().AsSize(), aTransitionTime);

   574     }

   575 

   576 

   577 // deprecated

   578 EXPORT_C void CHuiVisual::SetCenteredPosAndSize(const TPoint& aCenterPoint,

   579                                                 const TSize& aSize,

   580                                                 TInt aTransitionTime)

   581     {

   582     THuiRealPoint visualSize = PixelPointInLocal(THuiRealPoint(aSize.iWidth, aSize.iHeight),

   583     	EHuiReferenceStateNow);

   584     SetCenteredPosAndSize(PixelPointInLocal(THuiRealPoint(aCenterPoint), EHuiReferenceStateNow), 

   585     	visualSize.AsSize(), aTransitionTime);

   586     }

   587 

   588 

   589 EXPORT_C void CHuiVisual::SetCenteredPosAndSize(const THuiRealPoint& aCenterPoint,

   590                                                 const THuiRealSize& aSize,

   591                                                 TInt aTransitionTime)

   592     {

   593     SetPos(THuiRealPoint(aCenterPoint.iX - aSize.iWidth/2,

   594     	aCenterPoint.iY - aSize.iHeight/2), aTransitionTime);

   595     SetSize(aSize, aTransitionTime);

   596     }

   597 

   598 

   599 EXPORT_C void CHuiVisual::UpdateChildrenLayout(TInt /*aTransitionTime*/)

   600     {

   601     }

   602 

   603 

   604 void CHuiVisual::ReportLayoutUpdate()

   605     {

   606     // Notify owner, if requested.

   607     if(iFlags & EHuiVisualFlagLayoutUpdateNotification)

   608         {

   609         Owner().VisualLayoutUpdated(*this);

   610         }

   611     }

   612 

   613 // deprecated

   614 EXPORT_C void CHuiVisual::SetMinSize(const TSize& aMinSize)

   615     {

   616     THuiRealPoint minPoint = PixelPointInLocal(THuiRealPoint(aMinSize.iWidth, aMinSize.iHeight),

   617     	EHuiReferenceStateNow);

   618     SetMinSize(minPoint.AsSize());

   619     }

   620 

   621 EXPORT_C void CHuiVisual::SetMinSize(const THuiRealSize& aMinSize)

   622     {

   623     iMinSize = aMinSize;

   624     }

   625     

   626 // deprecated

   627 EXPORT_C TSize CHuiVisual::MinSize() const

   628     {

   629     THuiRealSize minSize = MinSizeInBaseUnits();

   630     THuiRealPoint minPoint = LocalPointInPixels(THuiRealPoint(minSize.iWidth, minSize.iHeight),

   631     	EHuiReferenceStateNow);

   632     // @todo: Should we round this value?

   633     return (TSize(minPoint.AsSize()));

   634     }

   635 

   636 EXPORT_C THuiRealSize CHuiVisual::MinSizeInBaseUnits() const __SOFTFP 

   637     {

   638     return iMinSize;

   639     }

   640 

   641 

   642 // deprecated

   643 EXPORT_C void CHuiVisual::SetMaxSize(const TSize& aMaxSize)

   644     {

   645     THuiRealPoint maxPoint = PixelPointInLocal(THuiRealPoint(aMaxSize.iWidth, aMaxSize.iHeight),

   646     	EHuiReferenceStateNow);

   647     SetMaxSize(maxPoint.AsSize());

   648     }

   649 

   650 EXPORT_C void CHuiVisual::SetMaxSize(const THuiRealSize& aMaxSize)

   651     {

   652     iMaxSize = aMaxSize;

   653     }

   654 

   655 

   656 // deprecated

   657 EXPORT_C TSize CHuiVisual::MaxSize() const

   658     {

   659     THuiRealSize maxSize = MaxSizeInBaseUnits();

   660     THuiRealPoint maxPoint = LocalPointInPixels(THuiRealPoint(maxSize.iWidth, maxSize.iHeight),

   661     	EHuiReferenceStateNow);

   662     // @todo: Should we round this value?

   663     return (TSize(maxPoint.AsSize()));

   664     }

   665 

   666 EXPORT_C THuiRealSize CHuiVisual::MaxSizeInBaseUnits() const __SOFTFP

   667     {

   668     return iMaxSize;

   669     }

   670 

   671 

   672 EXPORT_C void CHuiVisual::SetClipping(TBool aClipping)

   673     {

   674     if(aClipping)

   675         {

   676         SetFlag(EHuiVisualFlagClipping);

   677         }

   678     else

   679         {

   680         ClearFlag(EHuiVisualFlagClipping);

   681         }

   682     }

   683 

   684 

   685 EXPORT_C TBool CHuiVisual::Clipping() const

   686     {

   687     return (iFlags & EHuiVisualFlagClipping) != 0;

   688     }

   689 

   690 

   691 EXPORT_C THuiRealRect CHuiVisual::DisplayRect() const __SOFTFP

   692     {

   693     // Recalculate and cache as necessary. 

   694     TBool recalculationNeeded = ETrue;

   695     

   696     TUint frameno = 0; // CHuiStatic::FrameCount() is called before used

   697     const TBool calledDuringDraw = Env().CurrentDisplay() ? ETrue : EFalse;

   698     

   699     if ( calledDuringDraw ) // before the draw, the cache is not updated

   700         {

   701         frameno = CHuiStatic::FrameCount();

   702         if ( frameno == iDisplayRectFrameNumber )

   703             {

   704             recalculationNeeded = EFalse;

   705             }

   706         }

   707     

   708     if( recalculationNeeded )

   709 	    {

   710 	    THuiRealRect rect(LocalToDisplay(Pos().RealNow()),

   711 	                      LocalPointInPixels(Size().RealNow()).AsSize());

   712 

   713         if (rect.iTl.iX > rect.iBr.iX)

   714             {

   715             TReal tempX = rect.iTl.iX;

   716             rect.iTl.iX = rect.iBr.iX;

   717             rect.iBr.iX = tempX;

   718             }

   719   

   720         if (rect.iTl.iY > rect.iBr.iY)

   721             {

   722             TReal tempY = rect.iTl.iY;

   723             rect.iTl.iY = rect.iBr.iY;

   724             rect.iBr.iY = tempY;

   725             }

   726 	                      

   727 	    iDisplayRect = rect;

   728 	    

   729 	    if ( calledDuringDraw ) // update frame number only during draw

   730             {

   731 	        iDisplayRectFrameNumber = frameno;

   732             }

   733 	    }

   734     return iDisplayRect;

   735     }

   736 

   737 THuiRealRect CHuiVisual::CachedDisplayRect() const

   738     {

   739     return iDisplayRect;    

   740     }

   741 

   742 

   743 EXPORT_C THuiRealRect CHuiVisual::DisplayRectTarget() const __SOFTFP

   744     {

   745     // Calculate effect display area if the visual has an attached effect

   746     // For OpenVG nothing is needed as the area is the final position,

   747     // not something that happens during transition.

   748     // Recalculate and cache as necessary. 

   749     TBool recalculationNeeded = ETrue;

   750     

   751     TUint frameno = 0; // CHuiStatic::FrameCount() is called before used

   752     const TBool calledDuringDraw = Env().CurrentDisplay() ? ETrue : EFalse;

   753     

   754     if ( calledDuringDraw ) // before the draw, the cache is not updated

   755         {

   756         frameno = CHuiStatic::FrameCount();

   757         if ( frameno == iDisplayRectTargetFrameNumber )

   758             {

   759             recalculationNeeded = EFalse;

   760             }

   761         }

   762 

   763     if( recalculationNeeded )

   764 	    {

   765 		THuiRealRect rect(LocalToDisplay(Pos().RealTarget(), EHuiReferenceStateTarget),

   766 		                  LocalPointInPixels(Size().RealTarget(), EHuiReferenceStateTarget).AsSize());

   767 

   768         if (rect.iTl.iX > rect.iBr.iX)

   769             {

   770             TReal32 tempX = rect.iTl.iX;

   771             rect.iTl.iX = rect.iBr.iX;

   772             rect.iBr.iX = tempX;

   773             }

   774   

   775         if (rect.iTl.iY > rect.iBr.iY)

   776             {

   777             TReal32 tempY = rect.iTl.iY;

   778             rect.iTl.iY = rect.iBr.iY;

   779             rect.iBr.iY = tempY;

   780             }

   781         

   782         iDisplayRectTarget = rect;

   783         

   784         if ( calledDuringDraw ) // update frame number only during draw

   785             {

   786 	        iDisplayRectTargetFrameNumber = frameno;

   787             }

   788 	    }

   789 	return iDisplayRectTarget;

   790     }

   791 

   792 

   793 EXPORT_C TReal32 CHuiVisual::EffectiveOpacity() const __SOFTFP

   794     {

   795     TReal32 opacity = iOpacity.Now();

   796 

   797     // Controls in control groups (i.e., normally all controls)

   798     // get a common opacity from the group.

   799     if(Owner().ControlGroup())

   800         {

   801         opacity *= Owner().ControlGroup()->iOpacity.Now();

   802         }

   803 

   804     CHuiVisual* iter = Layout();

   805 

   806     // Factor in all the opacities of the parent visuals.

   807     while(iter)

   808         {

   809         opacity *= iter->iOpacity.Now();

   810         if(opacity <= 0)

   811             {

   812             // Fully transparent;

   813             return 0;

   814             }

   815         iter = iter->Layout();

   816         }

   817 

   818     return opacity;

   819     }

   820 

   821 

   822 EXPORT_C TBool CHuiVisual::PrepareDrawL()

   823     {

   824     // The visual base class doesn't prepare anything.	

   825     return ETrue;

   826     }

   827 

   828 

   829 EXPORT_C void CHuiVisual::Draw(CHuiGc& aGc) const

   830     {

   831     if (Flags() & EHuiVisualFlagDrawOnlyAsExternalContent)

   832     	{

   833    	    // This is used only as external content visual. Return now if we are not currently drawing

   834    	    // external content.

   835     	if (!Display() || !Display()->RosterImpl().IsDrawingExternalContent())

   836     		{

   837 			return;

   838     		}

   839     	}

   840 

   841     TReal32 opacity = EffectiveOpacity();

   842     if(opacity <= 0)

   843         {

   844         // The visual is invisible because it's fully transparent.

   845         return;

   846         }

   847 

   848     // This is the currently effective area on the display used

   849     // by the visual.

   850     THuiRealRect displayRect = DisplayRect();

   851 

   852     EnterLocalProjection(aGc, ETrue, 0.f, &displayRect);

   853 

   854     // Apply local transformation.

   855     Transform(aGc, ETrue, &displayRect);

   856 

   857     // Draw background brushes (under the content).

   858     DrawBrushes(aGc, EHuiBrushLayerBackground);

   859 

   860     // Clip contents to visual rectangle.

   861     if(Clipping())

   862         {

   863         // Visual content clipping is affected by transformation.

   864         aGc.PushClip();

   865         aGc.Clip(displayRect);

   866         aGc.Enable(CHuiGc::EFeatureClipping);

   867         }

   868     if( iVisualData->iEffect )

   869         {

   870         // Can we draw effect

   871         TBool canUseEffectDrawing = Effect() && !LoadingEffect();

   872         

   873         // Flag to know what we did

   874         TBool didDrawEffect = EFalse;

   875         

   876         if (canUseEffectDrawing)

   877             {

   878             // Note that EHuiVisualFlagOpaqueHint improves performance a lot in cached effect drawing 

   879             TBool transparent = !(Flags() & EHuiVisualFlagOpaqueHint);

   880             TBool refreshCache = Changed();                

   881             didDrawEffect = iVisualData->iEffect->CachedDraw(aGc, displayRect, refreshCache, !transparent);

   882             }

   883 

   884         if (!didDrawEffect) 

   885             {

   886             // Draw the visual instead if the effect failed

   887             DrawSelf(aGc, displayRect);

   888             }

   889         else

   890             {

   891             // Effect was drawn, OpenGLES/OpenVG may be in different state than what Gc thinks so we restore it.

   892             aGc.RestoreState();

   893             }

   894         }

   895     else if ( !LoadingEffect() )

   896         {

   897         // Draw the visual itself.

   898         // But don't draw if we are just building the effect - 

   899         // We may get a view of the visual with its default values though it may

   900         // want to start from size 0 or whatever

   901         DrawSelf(aGc, displayRect);

   902         }

   903     else

   904         {

   905         // just to keep codescanners and other stupid tools happy

   906         }

   907 

   908     if(Clipping())

   909         {

   910         aGc.PopClip();

   911         }

   912 

   913     // Draw foreground brushes (over the content).

   914     DrawBrushes(aGc, EHuiBrushLayerForeground);

   915 

   916     // Undo local transformation.

   917     Transform(aGc, EFalse);

   918     EnterLocalProjection(aGc, EFalse);

   919 

   920     }

   921 

   922 

   923 EXPORT_C void CHuiVisual::DrawBrushes(CHuiGc& aGc, THuiBrushLayer aLayer) const

   924     {

   925     if(iBrushes)

   926         {

   927         iBrushes->ActivateBrushGuide(this);

   928         iBrushes->Draw(aLayer, aGc, *this);

   929         iBrushes->ActivateBrushGuide(NULL);        

   930         }

   931     }

   932 

   933 

   934 EXPORT_C void CHuiVisual::DrawSelf(CHuiGc& /*aGc*/,

   935                                    const TRect& /*aDisplayRect*/) const

   936     {

   937     // The visual base class doesn't draw a3nything.

   938     }

   939     

   940     

   941 EXPORT_C void CHuiVisual::BoxMetricToPixelRect(const THuiBoxMetric& aBox, 

   942         THuiRealRect& aRectInPixels) const

   943     {

   944     aRectInPixels.iTl = MetricToPixels(THuiXYMetric(aBox.iLeft, aBox.iTop));

   945     aRectInPixels.iBr = MetricToPixels(THuiXYMetric(aBox.iRight, aBox.iBottom));

   946     }

   947     

   948     

   949 /*EXPORT_C void CHuiVisual::BoxMetricToLocalRect(const THuiBoxMetric& aBox,

   950         THuiRealRect& aLocalRect) const

   951     {

   952     THuiRealRect pixelRect;

   953     BoxMetricToPixelRect(aBox, pixelRect);

   954     aLocalRect.iTl = PixelPointInLocal(pixelRect.iTl);

   955     aLocalRect.iBr = PixelPointInLocal(pixelRect.iBr);

   956     }*/

   957 

   958 

   959 EXPORT_C THuiRealPoint CHuiVisual::LocalPointInPixels(const THuiRealPoint& aLocalPoint) const __SOFTFP

   960     {

   961     return LocalPointInPixels(aLocalPoint, EHuiReferenceStateNow);

   962     }

   963     

   964     

   965 EXPORT_C THuiRealPoint CHuiVisual::PixelPointInLocal(const THuiRealPoint& aPixelPoint) const __SOFTFP

   966     {

   967     return PixelPointInLocal(aPixelPoint, EHuiReferenceStateNow);

   968     }

   969     

   970     

   971 THuiRealPoint CHuiVisual::PixelPointInUnits(const THuiRealPoint& aPixelPoint, 

   972     const THuiXYMetric& aUnit, THuiReferenceState aReferenceState ) const __SOFTFP

   973     {

   974     THuiRealPoint result(0.f, 0.f);

   975     THuiXYMetric metric = aUnit;

   976     PixelsToMetric(aPixelPoint, metric, aReferenceState); // sets X and Y lengths

   977 

   978     if(aUnit.iX.iMagnitude != 0)

   979         {

   980         result.iX = metric.iX.iMagnitude / aUnit.iX.iMagnitude;

   981         }

   982     else

   983         {

   984         result.iX = 0;

   985         }

   986 

   987     if(aUnit.iY.iMagnitude != 0)

   988         {

   989         result.iY = metric.iY.iMagnitude / aUnit.iY.iMagnitude;

   990         }

   991     else

   992         {

   993         result.iY = 0;

   994         }

   995 

   996     return result;

   997     }

   998 

   999 EXPORT_C THuiRealPoint CHuiVisual::MetricReferenceInPixels(const THuiXYMetric& aMetric) const __SOFTFP

  1000     {

  1001     return MetricReferenceInPixels(aMetric, EHuiReferenceStateNow);

  1002     }

  1003 

  1004 

  1005 EXPORT_C THuiRealPoint CHuiVisual::MetricReferenceInPixels(const THuiXYMetric& aMetric, 

  1006                                                            THuiReferenceState aReferenceState) const __SOFTFP

  1007     {

  1008     THuiRealPoint refSizePx(0.f, 0.f);

  1009     

  1010     // if weights are used in this context, treat them as normalized units

  1011     TInt xUnit = (aMetric.iX.iUnit == EHuiUnitWeight) ? EHuiUnitNormalized : aMetric.iX.iUnit;

  1012     TInt yUnit = (aMetric.iY.iUnit == EHuiUnitWeight) ? EHuiUnitNormalized : aMetric.iY.iUnit;

  1013         

  1014     // For normalized units, the reference is the parent size in pixels.

  1015     if(xUnit == EHuiUnitNormalized || yUnit == EHuiUnitNormalized ||

  1016        xUnit == EHuiUnitParentWidth || yUnit == EHuiUnitParentWidth ||

  1017        xUnit == EHuiUnitParentHeight || yUnit == EHuiUnitParentHeight)        

  1018        {

  1019         THuiRealPoint sizePx(0.f, 0.f);

  1020         

  1021         // Determine parent size in pixels.

  1022         if(iLayout)

  1023             {

  1024             // Recursive fun. We don't want to do this more than once.

  1025             // (LocalPointInPixels => MetricsToPixels => MetricReferenceInPixels)

  1026             sizePx = iLayout->LocalPointInPixels(

  1027                             aReferenceState == EHuiReferenceStateTarget? iLayout->Size().RealTarget() :

  1028                             iLayout->Size().RealNow(), aReferenceState);

  1029   	        }

  1030         else if(Display())

  1031             {

  1032             // @todo Jaakko please code review this change!

  1033 //            sizePx = Display()->Size().AsPoint();

  1034             sizePx = Display()->VisibleArea().Size().AsPoint();

  1035             }

  1036         else

  1037             {

  1038             // For PC-lint

  1039             }

  1040             

  1041         if(xUnit == EHuiUnitNormalized || xUnit == EHuiUnitParentWidth)

  1042             {

  1043             refSizePx.iX = sizePx.iX;

  1044             }

  1045         else if(xUnit == EHuiUnitParentHeight)

  1046             {

  1047             refSizePx.iX = sizePx.iY;

  1048             }

  1049         else

  1050             {

  1051             // For PC-lint

  1052             }

  1053 

  1054         if(yUnit == EHuiUnitNormalized || yUnit == EHuiUnitParentHeight)

  1055             {

  1056             refSizePx.iY = sizePx.iY;

  1057             }

  1058         else if(yUnit == EHuiUnitParentWidth)

  1059             {

  1060             refSizePx.iY = sizePx.iX;

  1061             }

  1062         else

  1063             {

  1064             // For PC-lint

  1065             }

  1066         }

  1067 

  1068     // Display-relative units are always relative to the display where the visual is on.

  1069     if(xUnit == EHuiUnitRelativeToDisplay && Display())

  1070         {

  1071         refSizePx.iX = Display()->VisibleArea().Width();

  1072         }

  1073     if(yUnit == EHuiUnitRelativeToDisplay && Display())

  1074         {

  1075         refSizePx.iY = Display()->VisibleArea().Height();

  1076         }        

  1077 

  1078     // For relative to my size units, the reference is the size of this visual in pixels.

  1079     if(xUnit == EHuiUnitRelativeToMySize || yUnit == EHuiUnitRelativeToMySize ||

  1080         xUnit == EHuiUnitMyWidth || yUnit == EHuiUnitMyWidth ||

  1081         xUnit == EHuiUnitMyHeight || yUnit == EHuiUnitMyHeight ||

  1082         xUnit == EHuiUnitMyDimensionAverage || yUnit == EHuiUnitMyDimensionAverage)

  1083         {

  1084         THuiRealPoint sizePx(0.f, 0.f);

  1085         if(iLayout)

  1086             {

  1087             // Recursive fun. We don't want to do this more than once.

  1088             // (MetricsToPixels => MetricReferenceInPixels)

  1089             sizePx = iLayout->MetricToPixels(LocalBaseUnit().Abs() * 

  1090                 ((aReferenceState == EHuiReferenceStateTarget) ? iSize.RealTarget() : iSize.RealNow()));

  1091             }

  1092         else if(Display())

  1093             {

  1094             sizePx = Display()->VisibleArea().Size().AsPoint();

  1095             }

  1096         else

  1097             {

  1098             // For PC-lint

  1099             }

  1100         

  1101         if(xUnit == EHuiUnitRelativeToMySize || xUnit == EHuiUnitMyWidth)

  1102             {

  1103             refSizePx.iX = sizePx.iX;

  1104             }

  1105         else if(xUnit == EHuiUnitMyHeight)

  1106             {

  1107             refSizePx.iX = sizePx.iY;

  1108             }

  1109         else

  1110             {

  1111             // For PC-lint

  1112             }

  1113         

  1114         if(yUnit == EHuiUnitRelativeToMySize || yUnit == EHuiUnitMyHeight)

  1115             {

  1116             refSizePx.iY = sizePx.iY;

  1117             }

  1118         else if(yUnit == EHuiUnitMyWidth)

  1119             {

  1120             refSizePx.iY = sizePx.iX;

  1121             }

  1122         else

  1123             {

  1124             // For PC-lint

  1125             }

  1126 

  1127         if( xUnit == EHuiUnitMyDimensionAverage ||

  1128       	    yUnit == EHuiUnitMyDimensionAverage )

  1129             {

  1130             TReal32 average = (sizePx.iX + sizePx.iY) / 2;

  1131             if(xUnit == EHuiUnitMyDimensionAverage)

  1132       	        {

  1133                 refSizePx.iX = average;

  1134                 }