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:   

    15 *

    16 */

    17 

    18 #include "HuiCmdBufferBrush.h"

    19 #include "HuiFxEffect.h"

    20 #include <uiacceltk/HuiBrushArray.h>

    21 #include "huicanvasgc.h"

    22 #include "huicanvaswsgc.h"

    23 #include "huicanvaswshwgc.h"

    24 #include "huicanvaspainter.h"

    25 #include "huicanvaswspainter.h"

    26 CHuiCmdBufferBrush *CHuiCmdBufferBrush::NewL(TInt aLayerId, CHuiCanvasGc &aGc, CHuiCanvasWsGc &aWsGc, CHuiCanvasVisual &aVisual, CHuiCanvasPainter &aPainter)

    27     {

    28     CHuiCmdBufferBrush *brush = new (ELeave) CHuiCmdBufferBrush(aGc, aWsGc);

    29     CleanupStack::PushL(brush);

    30     brush->ConstructL(aLayerId, aVisual, aPainter);

    31     CleanupStack::Pop(brush);

    32     return brush;

    33     }

    34 CHuiCmdBufferBrush::CHuiCmdBufferBrush( CHuiCanvasGc &aGc, CHuiCanvasWsGc &aWsGc )

    35     : iCanvasGc(aGc), iCanvasWsGc(aWsGc)

    36     {

    37     }

    38 

    39 

    40 void CHuiCmdBufferBrush::ConstructL(TInt aLayerId, CHuiCanvasVisual &aVisual, CHuiCanvasPainter &aPainter)

    41     {

    42     iLayerId = aLayerId;

    43     iVisual = &aVisual;

    44     iCanvasPainter = &aPainter;

    45     }

    46 CHuiCmdBufferBrush::~CHuiCmdBufferBrush()

    47     {

    48     TInt count = iBuffers.Count();

    49     for(int i=0;i<count;i++)

    50         {

    51         CHuiCanvasCommandBuffer *buf = iBuffers[i].iCommandBuffer;

    52         buf->RemoveDestroyObserver(this);

    53         }

    54     }

    55 TInt CHuiCmdBufferBrush::Type2() const { return ECmdBufferBrush; }

    56 

    57 void CHuiCmdBufferBrush::AddBufferL(TLayeredBuffer aBuffer)

    58     {

    59     iBuffers.AppendL(aBuffer);

    60     }

    61 

    62 

    63 void CHuiCmdBufferBrush::Draw(CHuiGc& aGc, const MHuiBrushGuide& aGuide) const

    64     {

    65     THuiRealRect brushRect = aGuide.BrushRect();

    66     DrawSelf(aGc, brushRect);

    67     }

    68 void CHuiCmdBufferBrush::DrawSelf(CHuiGc &aGc, THuiRealRect brushRect) const

    69 {    

    70     iCanvasGc.SetVisual(*iVisual);

    71     iCanvasGc.SetGc(aGc);

    72     iCanvasGc.SetDefaults();   

    73     //iCanvasPainter->EnableRenderBuffer(ETrue);

    74     //static_cast<CHuiCanvasWsPainter*>(iCanvasPainter)->EnableRenderBufferIfNeeded(ETrue);

    75 

    76     TRect displayRect = brushRect.Round();

    77     

    78     RRegion reg;

    79     TInt size = iBuffers.Count();

    80     for(int i=0;i<size;i++)

    81         {

    82         TRect rect = iBuffers[i].iBoundingRectangle;

    83 

    84         RDebug::Print(_L("TP: ClearBackground %d"), iLayerId);

    85         ClearBackground(aGc, rect);

    86 

    87         rect.iTl.iX += brushRect.iTl.iX;

    88         rect.iTl.iY += brushRect.iTl.iY;

    89         rect.iBr.iX += brushRect.iTl.iX;

    90         rect.iBr.iY += brushRect.iTl.iY;

    91         reg.AddRect(rect);

    92         }

    93     iCanvasWsGc.BeginActionL(EDrawBuffer,reg.BoundingRect() /*displayRect*/,*iVisual,EFalse,reg);                   

    94 

    95     for(int i2=0;i2<size;i2++)

    96         {

    97         TRect rect = iBuffers[i2].iBoundingRectangle;

    98 

    99         rect.iTl.iX += brushRect.iTl.iX;

   100         rect.iTl.iY += brushRect.iTl.iY;

   101         rect.iBr.iX += brushRect.iTl.iX;

   102         rect.iBr.iY += brushRect.iTl.iY;

   103 

   104         RRegion region;

   105         region.AddRect(rect);

   106         for(int ii2 = i2+1;ii2<size; ii2++)

   107             {

   108             TRect rect2 = iBuffers[ii2].iBoundingRectangle;

   109 

   110             rect2.iTl.iX += brushRect.iTl.iX;

   111             rect2.iTl.iY += brushRect.iTl.iY;

   112             rect2.iBr.iX += brushRect.iTl.iX;

   113             rect2.iBr.iY += brushRect.iTl.iY;

   114             if (iBuffers[i2].iCommandBuffer != iBuffers[ii2].iCommandBuffer)

   115                 {

   116                 region.SubRect(rect2);

   117                 }

   118             }

   119         region.Intersect(iBuffers[i2].iCommandBuffer->iUpdateRegion);

   120             

   121         if (!region.IsEmpty())

   122             {

   123             

   124             //iCanvasWsGc.BeginActionL(EScanBuffer,rect /*displayRect*/,*iVisual,EFalse,region);                   

   125             //DrawDrawingCommands(EScanBuffer, aGc, rect, iBuffers[i2].iBufferPart, iBuffers[i2].iCommandBuffer, region);

   126             //iCanvasWsGc.EndActionL(region);                 

   127 

   128             DrawDrawingCommands(EDrawBuffer, aGc, rect, iBuffers[i2].iBufferPart, iBuffers[i2].iCommandBuffer, region);

   129             }

   130         region.Close();

   131         }

   132     {

   133     TInt flags = iVisual->Flags();

   134     iVisual->ClearFlag(EHuiVisualFlagOpaqueHint);

   135     iCanvasWsGc.EndActionL(reg, ETrue);                     

   136     iVisual->SetFlags(flags);

   137     }

   138 

   139     reg.Close();

   140     

   141 #if 0

   142     for(int i3=0;i3<size;i3++)

   143         {

   144         TRect rect = iBuffers[i3].iBoundingRectangle;

   145         rect.iTl.iX += brushRect.iTl.iX;

   146         rect.iTl.iY += brushRect.iTl.iY;

   147         rect.iBr.iX += brushRect.iTl.iX;

   148         rect.iBr.iY += brushRect.iTl.iY;

   149         CopyBuffer(aGc, rect);

   150         }

   151 #endif

   152 

   153     }

   154 

   155 void CHuiCmdBufferBrush::ClearBackground(CHuiGc &aGc, TRect aRectangle) const

   156     {

   157     //void DrawRects(RArray<THuiRealRect>& aRects);

   158 #if 0

   159     THuiRealPoint tl(aRectangle.iTl.iX, aRectangle.iTl.iY);

   160     THuiRealPoint br(aRectangle.iBr.iX, aRectangle.iBr.iY);

   161     THuiRealRect rect(tl, br);

   162     TReal32 opacity = iCanvasGc.Opacity();

   163     iCanvasGc.SetOpacity(0.0f);

   164     iCanvasGc.Clear(rect);

   165     iCanvasGc.SetOpacity(opacity);

   166 #endif

   167 

   168     CHuiCanvasRenderBuffer* renderbuffer = NULL;

   169     renderbuffer = iVisual->Env().CanvasTextureCache().FindCachedRenderBuffer(*iVisual);

   170     iCanvasGc.ClearRenderBuffer(*renderbuffer, aRectangle /*TRect(0,0,iVisual->DisplayRect().Size().iWidth, iVisual->DisplayRect().Size().iHeight)*/);

   171     }

   172 void CHuiCmdBufferBrush::DrawDrawingCommands(TInt aAction, CHuiGc &aGc, TRect aClippingRectangle, 

   173                                              TPtrC8 aCommands, CHuiCanvasCommandBuffer *buf, const TRegion &reg) const

   174     {

   175     TRect rect = aClippingRectangle;

   176     RDebug::Print(_L("TP: DrawDrawingCommands (%d,%d)-(%d,%d)"), rect.iTl.iX, rect.iTl.iY, rect.iBr.iX, rect.iBr.iY);    

   177 

   178     //iCanvasWsGc.EnableUpdateRegion(reg /*buf->iUpdateRegion*/, EFalse /*aClearBeforeHandlingBuffers*/);

   179 

   180     TRAP_IGNORE(iCanvasPainter->HandleBufferL(rect, aAction, *iVisual, &aGc, TPoint(0,0), aCommands, buf));  

   181     //iCanvasWsGc.DisableUpdateRegion();

   182 

   183     }

   184 void CHuiCmdBufferBrush::CopyBuffer(CHuiGc &aGc, TRect aRectangle) const

   185     {

   186     RDebug::Print(_L("TP: CopyBuffer"));    

   187     }

   188 

   189 void CHuiCmdBufferBrush::Flush() const

   190     {

   191     

   192     }

   193 

   194 void CHuiCmdBufferBrush::EffectSetEffect(CHuiFxEffect* aEffect)

   195     {

   196     if (iEffect)

   197         {

   198         iEffect->SetEffectEndObserver( NULL, 0 );

   199         }

   200     delete iEffect;

   201     iEffect = aEffect;

   202     }

   203 

   204 TReal32 CHuiCmdBufferBrush::EffectOpacityTarget() const

   205     {

   206     return 1.0;

   207     }

   208 void CHuiCmdBufferBrush::EffectSetOpacity(TReal32 aOpacity)

   209     {

   210     // empty

   211     }

   212 void CHuiCmdBufferBrush::EffectDrawSelf( CHuiGc &aGc, const TRect & aDisplayRect) const

   213     {

   214     DrawSelf(aGc, aDisplayRect);

   215     }

   216 

   217 THuiRealRect CHuiCmdBufferBrush::EffectDisplayRect() const __SOFTFP

   218     {

   219     RRegion reg;

   220     TInt size = iBuffers.Count();

   221     for(int i=0;i<size;i++)

   222         {

   223         TRect rect = iBuffers[i].iBoundingRectangle;

   224         reg.AddRect(rect);

   225         }

   226     

   227     THuiRealRect r(reg.BoundingRect());

   228     reg.Close();

   229     return r;

   230     }

   231 

   232 void CHuiCmdBufferBrush::SetLoadingEffect(TBool /*aLoading*/)

   233     {

   234     // TODO

   235     }

   236 void CHuiCmdBufferBrush::EffectSetSource( TBool /*aIsInput1*/ )

   237     {

   238     }

   239 TBool CHuiCmdBufferBrush::EffectGetSource() const

   240     {

   241     return EFalse;

   242     }

   243 

   244 void CHuiCmdBufferBrush::DestroyBuffer(CHuiCanvasCommandBuffer *aBuffer)

   245     {

   246     TInt count = iBuffers.Count();

   247     for(int i=count-1;i>=0;i--)

   248         {

   249         CHuiCanvasCommandBuffer *buf = iBuffers[i].iCommandBuffer;

   250         if (buf == aBuffer)

   251             {

   252             iBuffers.Remove(i);

   253             }

   254         }

   255     }

   256 

   257 struct TIndexTableElement

   258     {

   259     TInt32 iOffset;

   260     TInt32 iSize;

   261     TInt32 iLayerId;

   262     //TRect iBoundingRect;

   263     TInt iTliX;

   264     TInt iTliY;

   265     TInt iBriX;

   266     TInt iBriY;

   267     //TInt32 iBufferId;

   268     };

   269 

   270 void ReplaceBufferL(RArray<CHuiCmdBufferBrush::TLayeredBuffer> &aBuffers, const CHuiCmdBufferBrush::TLayeredBuffer &buf);

   271 TInt FindBuffer(CHuiBrushArray &aBrushes, TInt aLayerId);

   272 

   273 

   274 void ParseCmdBufferL(CHuiBrushArray &aBrushes, TPtrC8 aBuffer, TPtrC8 aIndexTable, CHuiCanvasGc &aGc, CHuiCanvasWsGc &aWsGc, CHuiCanvasVisual &aVisual, CHuiCanvasPainter &aPainter)

   275     {

   276     TInt32 numIndexes = aIndexTable.Length() / sizeof(TIndexTableElement);

   277     for(TInt i=0;i<numIndexes;i++)

   278         {

   279         TInt32 offset = i * sizeof(TIndexTableElement);

   280         TInt32 size = sizeof(TIndexTableElement);

   281         TPtrC8 ptr;

   282         ptr.Set(aIndexTable.Mid(offset, size));

   283         TIndexTableElement *elem = (TIndexTableElement*)ptr.Ptr();

   284         //RDebug::Print(_L("Layer: %d: ID: %d, offset=%d, size = %d"), i, elem->iLayerId, elem->iOffset, elem->iSize);

   285         //RDebug::Print(_L("aBuffer.Length()=%d"), aBuffer.Length());

   286         TPtrC8 ptr2(aBuffer.Ptr()+elem->iOffset, elem->iSize) ; // aBuffer.Mid(elem->iOffset, elem->iSize));

   287         //ptr2.Set();

   288 	

   289         TInt index = FindBuffer(aBrushes, elem->iLayerId);

   290         if (index == -1)

   291             {

   292             CHuiCmdBufferBrush *brush2 = CHuiCmdBufferBrush::NewL(elem->iLayerId, aGc, aWsGc, aVisual, aPainter);

   293             CleanupStack::PushL(brush2);

   294             aBrushes.AppendL(brush2, EHuiHasOwnership);

   295             CleanupStack::Pop();

   296             brush2->SetLayer(EHuiBrushLayerForeground);

   297             index = aBrushes.Count() - 1;

   298             }

   299         CHuiCmdBufferBrush &brush = (CHuiCmdBufferBrush&)aBrushes[index];

   300         CHuiCmdBufferBrush::TLayeredBuffer buf;

   301         //buf.iBufferId = elem->iBufferId;

   302         //TODO buf.iUpdateRegion = ...

   303         TInt count = aPainter.NumBuffers();

   304         CHuiCanvasCommandBuffer *buffer = count ? aPainter.At(count-1) : NULL;

   305         if (buffer)

   306             {

   307             buffer->AddDestroyObserver(&brush);

   308             }

   309         buf.iBoundingRectangle.SetRect(elem->iTliX, elem->iTliY, elem->iBriX, elem->iBriY);

   310         if (buf.iBoundingRectangle == TRect(0,0,0,0))

   311             {

   312             buf.iBoundingRectangle = TRect(0,0,aVisual.BrushRect().Size().iWidth, aVisual.BrushRect().Size().iHeight);

   313             }

   314         buf.iBufferPart.Set(ptr2);

   315         buf.iCommandBuffer = buffer;

   316         ReplaceBufferL(brush.iBuffers, buf);

   317         }

   318     }

   319 

   320 void ReplaceBufferL(RArray<CHuiCmdBufferBrush::TLayeredBuffer> &aBuffers, const CHuiCmdBufferBrush::TLayeredBuffer &aBuf)

   321     {

   322     aBuffers.AppendL(aBuf);

   323 #if 0

   324     // TODO: Dunno if iBufferId can be used or whether we need to use regions to

   325     // identify buffers.

   326     TInt size = aBuffers.Count();

   327     TInt index = -1;

   328     for(int i=0;i<size;i++)

   329         { // this loop might be able to optimize away if it becomes performance problem.

   330           // but would need to notice that ParseCmdBuffer always goes layers in order.

   331           // current code has no such assumption.

   332         CHuiCmdBufferBrush::TLayeredBuffer &buffer= aBuffers[i];

   333         if (buffer.iBufferId == buf.iBufferId)

   334             {

   335             index = i;

   336             break;

   337             }

   338         }

   339     if (index != -1)

   340         {

   341         aBuffers[index] = buf;

   342         }

   343     else

   344         {

   345         aBuffers.AppendL(buf);

   346         }

   347 #endif

   348     }

   349 

   350 TInt FindBuffer(CHuiBrushArray &aBrushes, TInt aLayerId)

   351     {

   352     TInt size = aBrushes.Count();

   353     for(int i=0;i<size;i++)

   354         {

   355         CHuiCmdBufferBrush *brush = dynamic_cast<CHuiCmdBufferBrush*>(&aBrushes[i]);

   356         if (brush && brush->LayerId() == aLayerId)

   357             {

   358             return i;

   359             }

   360         }

   361     return -1;

   362     }

   363 

   364 // wspainter needs to be able to skip the index table command

   365 void SkipCommand()

   366     {

   367     

   368     }