MCL/sf/mw/uiaccelerator: comparison uiacceltk/hitchcock/coretoolkit/src/HuiCanvasVisual.cpp

equal deleted inserted replaced

-:15bf7259bb7c
+:d8a3531bc6b8
 #include "Matrix.h"
 #include "HuiFxEffect.h"
 #include "HuiCmdBufferBrush.h"
+#include "huiextension.h"
+#include "huiwscanvascommands.h"
 /** Flag to convienintly disable/enable canvas render buffer usage if needed */
 /* Turned to EFalse as DFS77 was having booting problems in wk26 */
 /* Now checked dynamically from CHuiRenderer to allow different behaviour in DFS77 and DFS79 */
 //const TBool KHuiCanvasVisualUseRenderBuffer = EFalse;
 }
 void CHuiCanvasVisual::ConstructL()
 {
 CHuiLayout::ConstructL();
+SetFlags(EHuiVisualFlagWserv);
 iCanvasVisualData = new (ELeave) THuiCanvasVisualData;
 iCanvasVisualData->iCommandSetType = ECommandBufferWs;
 iCanvasVisualData->iCanvasFlags = 0;
 iCanvasVisualData->iExternalContentVisual = NULL;
 iCanvasVisualData->iParentCanvas = NULL;
 iCanvasVisualData->iBackground = NULL;
 iCanvasVisualData->iCanvasPainter = NULL;
+iCanvasVisualData->iStoredRenderBuffer = 0;
 iCanvasVisualData->iBackground = CHuiCanvasBackground::NewL();
 iCanvasVisualData->iBackground->SetVisual(this);
 iCanvasVisualData->iCanvasPainter = CHuiCanvasWsPainter::NewL();
 iCanvasVisualData->iCanvasPainter->SetVisual(this);
-iCanvasVisualData->iStoredRenderBuffer = 0;
 TBool useCanvasRenderBuffer = CHuiStatic::Renderer().Allows(EHuiRenderPluginAllowVisualPBufferSurfaces);
 iCanvasVisualData->iCanvasPainter->EnableRenderBuffer(useCanvasRenderBuffer);
 iCanvasVisualData->iLayerUsesAlphaFlag = EFalse;
 iCanvasVisualData->iLayerExtent = TRect();
 // subwindow effects
-EnableBrushesL(ETrue);
+//EnableBrushesL(ETrue);
 }
 CHuiCanvasVisual::~CHuiCanvasVisual()
 {
-FreeRenderBuffer();
-if(iCanvasVisualData->iExternalContentVisual)
+FreeRenderBuffer();
-	{
+if (iCanvasVisualData)
-	// Allow the external content visual to be drawn normally
+{
-	iCanvasVisualData->iExternalContentVisual->ClearFlag(EHuiVisualFlagDrawOnlyAsExternalContent);
+if(iCanvasVisualData->iExternalContentVisual)
-	}
+{
+// Allow the external content visual to be drawn normally
+iCanvasVisualData->iExternalContentVisual->ClearFlag(EHuiVisualFlagDrawOnlyAsExternalContent);
+}
+ClearCommandSet();
+if ( iCanvasVisualData->iBackground )
+{
+delete iCanvasVisualData->iBackground;
+iCanvasVisualData->iBackground = NULL;
+}
+if ( iCanvasVisualData->iCanvasPainter )
+{
+delete iCanvasVisualData->iCanvasPainter;
+iCanvasVisualData->iCanvasPainter = NULL;
+}
-if (iCanvasVisualData)
-{
-ClearCommandSet();
-delete iCanvasVisualData->iBackground;
-iCanvasVisualData->iBackground = NULL;
-delete iCanvasVisualData->iCanvasPainter;
-	iCanvasVisualData->iCanvasPainter = NULL;
 	iCanvasVisualData->iExternalContentVisual = NULL;
 	// Tell parent that we are destructed
 	if (iCanvasVisualData->iParentCanvas)
 	    {
 return;
 }
 if ((IsDelayedEffectSource() || Freezed()))
 {
+// Select right draw mode
+THuiCanvasDrawMode drawMode = (Flags() & EHuiVisualFlagOpaqueHint) ? EHuiCanvasDrawModeNormal : EHuiCanvasDrawModeBlend;
 if (StoredRenderBuffer())
 {
-DrawStoredFullScreenRenderBuffer(aGc);
+DrawStoredFullScreenRenderBuffer(drawMode, aGc);
 return;
 }
 else if (iCanvasVisualData->iStoredRenderBuffer)
 {
-DrawStoredVisualRenderBuffer();
+DrawStoredVisualRenderBuffer(drawMode);
 return;
 			}
 }
 // If this visual is completely under another visual, then this visual
 }
 }
 if ((IsDelayedEffectSource() || Freezed()))
 {
+// Select right draw mode
+THuiCanvasDrawMode drawMode = (Flags() & EHuiVisualFlagOpaqueHint) ? EHuiCanvasDrawModeNormal : EHuiCanvasDrawModeBlend;
 if (StoredRenderBuffer())
 {
-DrawStoredFullScreenRenderBuffer(aGc);
+DrawStoredFullScreenRenderBuffer(drawMode, aGc);
 			return;
 }
 else if (iCanvasVisualData->iStoredRenderBuffer)
 {
-DrawStoredVisualRenderBuffer();
+DrawStoredVisualRenderBuffer(drawMode);
 return;
 }
 }
 // Use 'under opaque' hint to optimize drawing.
 // Draw child windows, begin
 TBool afterOthers = EFalse;
 const TInt count = Count();
 for(TInt i = 0; i < count; ++i)
 {
-// This cast is not really safe, but dynamic cast is slow
+CHuiVisual* visual = iHuiLayoutPrivateData->iChildren[i];
-CHuiCanvasVisual* visual = (CHuiCanvasVisual*) iHuiLayoutPrivateData->iChildren[i];
 //Ignore inactive child visuals
 if ((visual->Flags()& EHuiVisualFlagInactive))
 {
 continue;
 }
-if (aIncludeCanvasFlags && !(visual->CanvasFlags()& aIncludeCanvasFlags))
+TInt canvasFlags = 0;
+if (aIncludeCanvasFlags || aExcludeCanvasFlags)
+{
+canvasFlags = visual->QueryCanvasFlags();
+}
+if (aIncludeCanvasFlags && !(canvasFlags & aIncludeCanvasFlags))
 {
 continue;
 }
-if (aExcludeCanvasFlags && (visual->CanvasFlags()& aExcludeCanvasFlags))
+if (aExcludeCanvasFlags && (canvasFlags & aExcludeCanvasFlags))
 {
 continue;
 }
 if(visual->Flags() & EHuiVisualFlagDrawAfterOthers)
 	}
 	return hasChanged;
 }
+// Goes through visual hierarchy and checks if any visual has changed.
+// This method does not modify any visuals. Parameter is not const
+// because of CanvasVisual method.
+TBool CHuiCanvasVisual::RecursiveChildTreeChanged(CHuiVisual* aVisual, TInt aExcludeCanvasFlags)
+{
+TBool changed = EFalse;
+// Check wheter we should include this visual or igonre it.
+if (aExcludeCanvasFlags)
+{
+if ( !(aVisual->Flags() & EHuiVisualFlagInactive) )
+{
+TInt canvasFlags = aVisual->QueryCanvasFlags();
+if ( !(canvasFlags & aExcludeCanvasFlags) )
+{
+changed |= aVisual->Changed();
+}
+}
+}
+if ( !changed )
+{
+const TInt count = aVisual->Count();
+for(TInt i = 0; i < count; ++i)
+{
+CHuiVisual* visual = &aVisual->Visual(i);
+changed |= RecursiveChildTreeChanged( visual, aExcludeCanvasFlags );
+if ( changed )
+{
+break;
+}
+}
+}
+return changed;
+}
 TBool CHuiCanvasVisual::ChildTreeChanged(TInt aExcludeCanvasFlags) const
 {
 // CHuiLayout::Changed() does not check children.
 // This utility method checks whole child tree below this visual.
-TBool changed = EFalse;
+return RecursiveChildTreeChanged(
+const_cast<CHuiCanvasVisual*>(this), aExcludeCanvasFlags);
-// Check wheter we should include this visual or igonre it.
+}
-if (aExcludeCanvasFlags)
-{
-if (!(iCanvasVisualData->iCanvasFlags & aExcludeCanvasFlags))
-{
-changed |= Changed();
-}
-}
-const TInt count = Count();
-for(TInt i = 0; i < count; ++i)
-{
-CHuiCanvasVisual* visual = (CHuiCanvasVisual*) iHuiLayoutPrivateData->iChildren[i];
-changed |= visual->ChildTreeChanged(aExcludeCanvasFlags);
-if (changed)
-{
-break;
-}
-}
-return changed;
-}
 EXPORT_C void CHuiCanvasVisual::ClearChanged()
 {
 iCanvasVisualData->iCanvasPainter->ClearAllBuffersChanged();
 CHuiLayout::ClearChanged();
 TRAP_IGNORE(SetCommandTypeL(aCommandType));
 }
 EXPORT_C void CHuiCanvasVisual::ClearCommandSet()
 {
-iCanvasVisualData->iCanvasPainter->ClearCommandSet();
+if ( iCanvasVisualData->iCanvasPainter )
-SetChanged();
+{
+iCanvasVisualData->iCanvasPainter->ClearCommandSet();
+SetChanged();
+}
 }
 #ifdef HUI_DEBUG_TRACK_DRAWING
 EXPORT_C void CHuiCanvasVisual::SetTrackCommandSet( TFileName& aFileName, TBool aTrack )
 {
 return;
 }
 	if (aCommandType == ECommandBufferAlf)
 	   	{
+	   	ClearFlags(EHuiVisualFlagWserv);
 	   	delete iCanvasVisualData->iCanvasPainter;
 	   	iCanvasVisualData->iCanvasPainter = NULL;
 iCanvasVisualData->iCommandSetType = ECommandBufferAlf;
 	   	iCanvasVisualData->iCanvasPainter = CHuiCanvasAlfPainter::NewL();
 iCanvasVisualData->iCanvasPainter->SetVisual(this);
 		}
 else if (aCommandType == ECommandBufferWs)
 	{
+	SetFlags(EHuiVisualFlagWserv);
 	delete iCanvasVisualData->iCanvasPainter;
 	   	iCanvasVisualData->iCanvasPainter = NULL;
 iCanvasVisualData->iCommandSetType = ECommandBufferWs;
 	   	iCanvasVisualData->iCanvasPainter = CHuiCanvasWsPainter::NewL();
 iCanvasVisualData->iCanvasPainter->SetVisual(this);
 drawContent = EFalse;
 }
 return drawContent;
 }
+// Goes through visual hierarchy and checks if any visual has external content drawing enabled.
+TBool CHuiCanvasVisual::RecursiveIsExternalContentDrawingEnabled(CHuiVisual* aVisual)
+{
+TBool drawExternalContent = EFalse;
+const TInt count = aVisual->Count();
+for(TInt i = 0; i < count; ++i)
+{
+CHuiVisual* visual = &aVisual->Visual(i);
+drawExternalContent |= visual->QueryExternalContentDrawingEnabled();
+if ( drawExternalContent )
+{
+break;
+}
+drawExternalContent |= RecursiveIsExternalContentDrawingEnabled( visual );
+if ( drawExternalContent )
+{
+break;
+}
+}
+return drawExternalContent;
+}
 TBool CHuiCanvasVisual::IsExternalContentDrawingEnabled(TBool aIncludeChildren) const
 {
 TBool drawExternalContent = EFalse;
 if (iCanvasVisualData->iExternalContentVisual)
 {
 drawExternalContent = ETrue;
 }
-if (aIncludeChildren)
+if (aIncludeChildren && !drawExternalContent)
 {
-for (TInt i=0; !drawExternalContent && i<Count(); i++)
+drawExternalContent |= RecursiveIsExternalContentDrawingEnabled(
-{
+const_cast<CHuiCanvasVisual*>(this));
-CHuiCanvasVisual* canvasVisual = (CHuiCanvasVisual*) &Visual(i);
-drawExternalContent |= canvasVisual->IsExternalContentDrawingEnabled(ETrue);
-}
 }
 return drawExternalContent;
 }
 EXPORT_C void CHuiCanvasVisual::SetParentCanvas(CHuiCanvasVisual* aParent)
 return iCanvasVisualData->iLayerUsesAlphaFlag;
 }
 EXPORT_C void CHuiCanvasVisual::SetLayerUsesAlphaFlag(TBool aEnabled)
 {
+if (aEnabled == KWindowIsDSAHost)
+{
+iCanvasVisualData->iCanvasFlags |= EHuiCanvasFlagDisableCanvasContent;
+return;
+}
 iCanvasVisualData->iLayerUsesAlphaFlag = aEnabled;
 }
 EXPORT_C TRect& CHuiCanvasVisual::LayerExtent()
 {
 translateback.iParams[EHuiTransformParamTranslateY] = hVisualHeigth;
 }
 }
 else // background surface was removed
 {
-EnableTransformationL(EFalse);
+iCanvasVisualData->iCanvasFlags &= (~EHuiCanvasFlagDisableCanvasContent);
+//EnableTransformationL(EFalse);
 }
 }
 TBool CHuiCanvasVisual::IsCanvasClippingEnabled() const
 iCanvasVisualData->iStoredRenderBuffer->InitializeL(content_rb->Size());
 iCanvasVisualData->iStoredRenderBuffer->Copy(*content_rb);
 }
 }
-void CHuiCanvasVisual::DrawStoredVisualRenderBuffer() const
+void CHuiCanvasVisual::DrawStoredVisualRenderBuffer(TInt aCanvasDrawMode) const
 {
 CHuiCanvasGc& gc = CanvasGc();
+CHuiCanvasVisual* visual = NULL;
+TBool transparent = EffectiveOpacity() < 1.0f;
+gc.SetDrawMode((THuiCanvasDrawMode)aCanvasDrawMode);
+if (transparent)
+{
+gc.EnableEffectiveOpacity(ETrue);
+visual = gc.Visual();
+gc.SetVisual(*this);
+gc.SetDrawMode(EHuiCanvasDrawModeBlend);
+}
 THuiRealPoint dest_point = DisplayRect().iTl;
 CHuiCanvasRenderBuffer *stored = iCanvasVisualData->iStoredRenderBuffer;
 gc.DrawImage(*stored, dest_point);
-}
+if (transparent)
+{
-void CHuiCanvasVisual::DrawStoredFullScreenRenderBuffer(CHuiGc& aGc) const
+gc.SetVisual(*visual);
+gc.EnableEffectiveOpacity(EFalse);
+}
+}
+void CHuiCanvasVisual::DrawStoredFullScreenRenderBuffer(TInt aCanvasDrawMode, CHuiGc& aGc) const
 {
 if (!Display()) return;
+if (!iHuiLayoutPrivateData->iGc)
+{
+CHuiRenderPlugin& renderplugin = CHuiStatic::Renderer();
+		// deleted in CHuiLayout destructor or CHuiCanvasVisual::FreeRenderBuffer when not needed anymore
+iHuiLayoutPrivateData->iGc = renderplugin.CreateCanvasGcL();
+}
 CHuiCanvasGc& gc = *iHuiLayoutPrivateData->iGc;
 gc.SetGc(aGc);
 gc.SetDefaults();
 gc.PushTransformationMatrix();
 gc.Scale(1.f, -1.f, 1.f);
 }
 THuiRealPoint dest_point = DisplayRect().iTl;
 CHuiCanvasRenderBuffer *stored = StoredRenderBuffer();
-gc.DrawImage(*stored, dest_point);
+TBool transparent = EffectiveOpacity() < 1.0f;
+CHuiCanvasVisual* visual = NULL;
+	gc.SetDrawMode((THuiCanvasDrawMode)aCanvasDrawMode);
+if (transparent)
+{
+gc.EnableEffectiveOpacity(ETrue);
+visual = gc.Visual();
+gc.SetVisual(*this);
+gc.SetDrawMode(EHuiCanvasDrawModeBlend);
+}
+gc.DrawImage(*stored, dest_point);
+if (transparent)
+{
+gc.SetVisual(*visual);
+gc.EnableEffectiveOpacity(EFalse);
+}
 gc.PopTransformationMatrix();
 }
 EXPORT_C void CHuiCanvasVisual::FreeRenderBuffer()
 {
 {
 if (iCanvasVisualData->iStoredRenderBuffer)
 {
 delete iCanvasVisualData->iStoredRenderBuffer;
 iCanvasVisualData->iStoredRenderBuffer = NULL;
-}
+delete iHuiLayoutPrivateData->iGc;
-}
+iHuiLayoutPrivateData->iGc = NULL;
+}
+}
+}
+// Goes through visual hierarchy and checks if any visual has command buffers
+// or other drawable content.
+TBool CHuiCanvasVisual::RecursiveHasCommandBuffers(CHuiVisual* aVisual)
+{
+TBool hasCommandBuffers = EFalse;
+const TInt count = aVisual->Count();
+for(TInt i = 0; i < count; ++i)
+{
+CHuiVisual* visual = &aVisual->Visual(i);
+// If visual is a canvas one, then QueryHasDrawableContent returns
+// HasCommandBuffers(EFalse)
+hasCommandBuffers |= visual->QueryHasDrawableContent();
+if ( hasCommandBuffers )
+{
+break;
+}
+hasCommandBuffers |= RecursiveHasCommandBuffers( visual );
+if ( hasCommandBuffers )
+{
+break;
+}
+}
+return hasCommandBuffers;
 }
 EXPORT_C TBool CHuiCanvasVisual::HasCommandBuffers(TBool aIncludeChildren) const
 {
 TBool hasCommandBuffers = iCanvasVisualData->iCanvasPainter->HasCommandBuffers();
-if (aIncludeChildren)
+if (aIncludeChildren && !hasCommandBuffers)
 {
-for (TInt i=0; i<Count(); i++)
+// Include children branch - just check if there is something to draw.
-{
+hasCommandBuffers |= RecursiveHasCommandBuffers(const_cast<CHuiCanvasVisual*>(this));
-CHuiCanvasVisual* canvasVisual = (CHuiCanvasVisual*) &Visual(i); // Dynamic cast is too slow for us ;)
-hasCommandBuffers |= canvasVisual->HasCommandBuffers(aIncludeChildren);
-if (hasCommandBuffers)
-{
-break;
-}
-}
 }
 return hasCommandBuffers;
 }
 aPos.iTl = InnerTopLeft();
 aPos.iBr = aPos.iTl + THuiRealPoint(innerSize.iWidth, innerSize.iHeight) ;
 return THuiLayoutChildRectLayoutUpdateNeeded;
 }
+void CHuiCanvasVisual::VisualExtension(const TUid& aExtensionUid, TAny** aExtensionParams)
+{
+if (aExtensionUid == KHuiVisualQueryUid && aExtensionParams && *aExtensionParams)
+{
+THuiVisualQueryParams* params = static_cast<THuiVisualQueryParams*>(*aExtensionParams);
+switch (params->iQueryType)
+{
+case THuiVisualQueryParams::EQueryCanvasFlags:
+params->iValue = CanvasFlags();
+params->iResult = KErrNone;
+break;
+case THuiVisualQueryParams::EQueryExternalContentDrawingEnabled:
+params->iValue = IsExternalContentDrawingEnabled(EFalse);
+params->iResult = KErrNone;
+break;
+case THuiVisualQueryParams::EQueryHasDrawableContent:
+params->iValue = HasCommandBuffers(EFalse);
+params->iResult = KErrNone;
+break;
+default:
+break;
+}
+}
+else
+	    {
+		CHuiVisual::VisualExtension(aExtensionUid, aExtensionParams);
+		}
+}

branch	RCL_3
changeset 3	d8a3531bc6b8
parent 0	15bf7259bb7c
child 5	433cbbb6a04b