diff -r 000000000000 -r 15bf7259bb7c uiacceltk/hitchcock/coretoolkit/src/huicanvaswsswgc.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/uiacceltk/hitchcock/coretoolkit/src/huicanvaswsswgc.cpp	Tue Feb 02 07:56:43 2010 +0200
@@ -0,0 +1,1519 @@
+/*
+* Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies). 
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:   Definition of CHuiCanvasWsSwGc.
+*
+*/
+
+
+
+#include "huicanvaswsswgc.h"
+#include "uiacceltk/HuiCanvasVisual.h"
+#include <graphics/wsgraphicscontext.h>
+#include <e32cmn.h>
+#include <AknLayoutFont.h>
+#include <gdi.h>
+
+
+
+CHuiCanvasWsSwGc* CHuiCanvasWsSwGc::NewL()
+	{
+	CHuiCanvasWsSwGc* self    = new ( ELeave ) CHuiCanvasWsSwGc;
+    CleanupStack::PushL( self );
+    self->ConstructL();
+    CleanupStack::Pop();
+
+    return self;
+    }
+
+
+CHuiCanvasWsSwGc::CHuiCanvasWsSwGc()
+    {
+    
+    }
+
+void CHuiCanvasWsSwGc::ConstructL()
+	{
+    iCanvasGc = CHuiStatic::Renderer().CreateCanvasGcL();
+
+	// There is no need to do clipping at canvas gc so lets disable it
+	iCanvasGc->SetClippingMode(EHuiCanvasClipModeNone);
+	}
+
+CHuiCanvasWsSwGc::~CHuiCanvasWsSwGc()
+    {
+    iTempRegion.Close();
+    iWsClipRegion.Close();
+    iDefaultClipRegion.Close();
+    
+    delete iCanvasGc;
+    iCanvasGc = NULL;
+    
+    delete iBitBitmap;
+    iBitBitmap = NULL;
+    
+	delete iBitDevice;
+	iBitDevice = NULL;
+	
+	delete iBitGc;
+	iBitGc = NULL;
+	
+    delete iCapturingBitGc;
+    iCapturingBitGc = NULL;
+    
+    delete iCapturingBitBitmap;
+    iCapturingBitBitmap = NULL;
+    
+    delete iCapturingBitDevice;
+    iCapturingBitDevice = NULL;
+    }
+    
+void CHuiCanvasWsSwGc::WsBitBltL(TInt aBitmapHandle, TPoint aPoint)
+	{
+	iIsReallyDirty = ETrue;
+			
+	if (!IsRenderingEnabled())
+	    {
+	    return;
+	    }
+	
+    TPoint point = AdjustCoordinates(aPoint);	
+    // Draw            
+	CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;
+    CleanupStack::PushL(bitmap);
+    
+	TInt error = bitmap->Duplicate(aBitmapHandle);
+	if ( error == KErrNone  )
+	    {
+	    iBitGc->BitBlt(point,bitmap);
+	    }
+	    CleanupStack::PopAndDestroy();
+	}
+
+
+
+
+void CHuiCanvasWsSwGc::WsBitBltRectL(TInt aBitmapHandle, TPoint aPoint, TRect aRect)
+	{
+	iIsReallyDirty = ETrue;
+
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+	
+	TPoint point = AdjustCoordinates(aPoint);	
+    // Draw            
+	CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;
+    CleanupStack::PushL(bitmap);
+    
+	TInt error = bitmap->Duplicate(aBitmapHandle);
+	
+	if ( error == KErrNone  )
+        {
+        iBitGc->BitBlt(point,bitmap,aRect);
+        }
+        CleanupStack::PopAndDestroy();
+
+	}
+
+
+
+void CHuiCanvasWsSwGc::WsBitBltMaskedL(TInt aBitmapHandle, TInt aMaskHandle, TInt aInvertMask, TPoint aPoint, TRect aRect)
+	{
+	iIsReallyDirty = ETrue;
+
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+	
+	TPoint point = AdjustCoordinates(aPoint);	
+    // Draw            
+	CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;
+    CleanupStack::PushL(bitmap);
+    TInt error = bitmap->Duplicate(aBitmapHandle);
+	if (error == KErrNone)
+	    {
+	    CFbsBitmap* bitmapMask = new (ELeave) CFbsBitmap;
+	    CleanupStack::PushL(bitmapMask);
+	    error = bitmapMask->Duplicate(aMaskHandle);
+	    if (error == KErrNone)
+	        {
+	        iBitGc->BitBltMasked(point,bitmap,aRect,bitmapMask,aInvertMask);
+	        }
+	    CleanupStack::PopAndDestroy(2);
+	    }
+	else
+        {
+        CleanupStack::PopAndDestroy();
+        }
+	
+	}
+
+void CHuiCanvasWsSwGc::WsBitBltMaskedPointL(TInt aBitmapHandle, TInt aMaskHandle, TPoint aPoint1, TPoint aPoint2, TRect aRect)
+	{
+	iIsReallyDirty = ETrue;
+
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+	
+	TPoint point1 = AdjustCoordinates(aPoint1);	
+
+     // Draw            
+	CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;
+    CleanupStack::PushL(bitmap);
+    TInt error = bitmap->Duplicate(aBitmapHandle);
+    if (error == KErrNone)
+        {
+        CFbsBitmap* bitmapMask = new (ELeave) CFbsBitmap;
+        CleanupStack::PushL(bitmapMask);
+        error = bitmapMask->Duplicate(aMaskHandle);
+        if (error == KErrNone)
+            {
+            if (aPoint2 != TPoint(0,0))
+                {
+                CFbsBitmap* movedMask = CreateMovedMaskL(*bitmapMask, aPoint2);
+                iBitGc->BitBltMasked(point1,bitmap,aRect, movedMask ,ETrue);    
+                delete movedMask;    
+                }
+            else
+                {
+                iBitGc->BitBltMasked(point1,bitmap,aRect, bitmapMask ,ETrue);            
+                }        
+            }
+        CleanupStack::PopAndDestroy(2);
+        }
+    else
+        {
+        CleanupStack::PopAndDestroy();
+        }    
+	}
+
+void CHuiCanvasWsSwGc::WsCombinedBitBltMaskedL(TRect aDestinationRect, const RArray<THuiCachedCombinedImageParams>& aBlits)
+    {
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+    
+    TRect adjustedDestinationRect(aDestinationRect);
+           
+    for (TInt i=0; i<aBlits.Count(); i++)
+        {
+      	CFbsBitmap* bitmap = NULL;
+    	CFbsBitmap* bitmapMask = NULL;
+      	TPoint point = aBlits[i].iCombinedBitmapPoint;
+      	TPoint adjustedPoint =AdjustCoordinates(point);
+        
+        if (aBlits[i].iBitmapHandle)
+            {
+        	bitmap = new (ELeave) CFbsBitmap;
+            CleanupStack::PushL(bitmap);
+            bitmap->Duplicate(aBlits[i].iBitmapHandle);                                        
+            }
+        
+        if (aBlits[i].iMaskHandle)
+            {
+    	    bitmapMask = new (ELeave) CFbsBitmap;
+            CleanupStack::PushL(bitmapMask);
+            bitmapMask->Duplicate(aBlits[i].iMaskHandle);                
+            }        
+        
+        TRect sourceRect = TRect(TPoint(0,0), bitmap->SizeInPixels());
+        if (bitmapMask)
+            {
+            TBool invertMask = (bitmapMask->DisplayMode() == EGray256);                       
+            iBitGc->BitBltMasked(adjustedPoint, bitmap, sourceRect, bitmapMask, invertMask);                       
+            }
+        else
+            {
+            iBitGc->BitBlt(adjustedPoint, bitmap);                                           
+            }                                                    
+        
+        if (bitmapMask)
+            {
+            CleanupStack::PopAndDestroy(bitmapMask);    
+            bitmapMask = NULL;
+            }
+        
+        if (bitmap)
+            {
+            CleanupStack::PopAndDestroy(bitmap);                    
+            bitmap = NULL;
+            }        
+        }
+    }
+
+void CHuiCanvasWsSwGc::WsResetClippingRegionL()
+	{
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+
+    // Reset clip region in our own region
+    iWsClipRegion.Clear();
+
+	// Reset clip region in iBitGc to default one
+    if (iDefaultClipRegion.Count())
+        {
+        iBitGc->SetClippingRegion(iDefaultClipRegion);
+        }
+    else
+        {
+        iBitGc->CancelClippingRegion();
+        }
+	}
+
+void CHuiCanvasWsSwGc::WsClearL()
+	{		
+	iIsReallyDirty = ETrue;
+	
+	if (!IsRenderingEnabled())
+        {
+        return;
+        }
+
+   	iBitGc->Clear();
+	}
+
+void CHuiCanvasWsSwGc::WsClearRectL(TRect& aRect)
+	{		
+	iIsReallyDirty = ETrue;
+	
+	if (!IsRenderingEnabled())
+        {
+        return;
+        }
+
+    iBitGc->Clear(AdjustCoordinates(aRect));
+	}
+
+void CHuiCanvasWsSwGc::WsResetBrushPatternL()
+	{
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+
+    iBitGc->DiscardBrushPattern();
+	}
+
+void CHuiCanvasWsSwGc::WsResetFontL()
+	{
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+    
+	iBitGc->DiscardFont();
+	}
+
+void CHuiCanvasWsSwGc::WsDrawArcL(TPoint aPoint1, TPoint aPoint2, TRect aRect)
+	{
+	iIsReallyDirty = ETrue;
+
+	if (!IsRenderingEnabled())
+        {
+        return;
+        }
+
+	TPoint point1 = AdjustCoordinates(aPoint1);
+	TPoint point2 = AdjustCoordinates(aPoint2);
+	TRect rect = AdjustCoordinates(aRect);
+	iBitGc->DrawArc(rect,point1,point2);
+	}
+
+void CHuiCanvasWsSwGc::WsDrawPieL(TPoint aPoint1, TPoint aPoint2, TRect aRect)
+	{
+	iIsReallyDirty = ETrue;
+
+	if (!IsRenderingEnabled())
+        {
+        return;
+        }
+
+	TPoint point1 = AdjustCoordinates(aPoint1);
+	TPoint point2 = AdjustCoordinates(aPoint2);
+	TRect rect = AdjustCoordinates( aRect );
+	iBitGc->DrawPie(rect,point1,point2);
+	}
+
+void CHuiCanvasWsSwGc::WsDrawBitmap1L(TInt aBitmapHandle, TRect aRect)
+	{
+	iIsReallyDirty = ETrue;
+
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+	
+    // Draw            
+	CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;
+    CleanupStack::PushL(bitmap);
+    
+	TInt error = bitmap->Duplicate(aBitmapHandle);
+	if ( error == KErrNone )
+	    {
+	    iBitGc->DrawBitmap(AdjustCoordinates(aRect),bitmap);
+	    }
+	CleanupStack::PopAndDestroy();
+	}
+
+void CHuiCanvasWsSwGc::WsDrawBitmap2L(TInt aBitmapHandle, TRect aRect1, TRect aRect2)
+	{
+	iIsReallyDirty = ETrue;
+
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+	
+     // Draw            
+	CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;
+    CleanupStack::PushL(bitmap);
+    
+	TInt error = bitmap->Duplicate(aBitmapHandle);
+	if ( error == KErrNone )
+	    {
+	    iBitGc->DrawBitmap(AdjustCoordinates(aRect1),bitmap,aRect2);
+	    }
+	CleanupStack::PopAndDestroy();   
+	}
+
+void CHuiCanvasWsSwGc::WsDrawBitmap3L(TInt aBitmapHandle, TPoint aPoint)
+	{
+	iIsReallyDirty = ETrue;
+
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+	
+	TPoint point = AdjustCoordinates(aPoint);
+    // Draw            
+	CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;
+    CleanupStack::PushL(bitmap);
+    
+	TInt error = bitmap->Duplicate(aBitmapHandle);
+	if ( error == KErrNone )
+	    {
+	    iBitGc->DrawBitmap(point,bitmap);
+	    }
+	CleanupStack::PopAndDestroy();
+	}
+
+void CHuiCanvasWsSwGc::WsDrawBitmapMaskedL(TInt aBitmapHandle, TInt aMaskHandle, TInt aInvertMask, TRect& aRect1, TRect& aRect2)
+	{
+	iIsReallyDirty = ETrue;
+
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+	
+    // Draw            
+	CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;
+    CleanupStack::PushL(bitmap);
+    TInt error = bitmap->Duplicate(aBitmapHandle);
+    if ( error == KErrNone )
+        {
+        // Draw            
+        CFbsBitmap* bitmapMask = new (ELeave) CFbsBitmap;
+        CleanupStack::PushL(bitmapMask);
+        error = bitmapMask->Duplicate(aMaskHandle);
+        if ( error == KErrNone )
+            {
+            iBitGc->DrawBitmapMasked(AdjustCoordinates(aRect1),bitmap,aRect2,bitmapMask,aInvertMask);    
+            }
+        CleanupStack::PopAndDestroy(2);
+        }
+    else
+        {
+        CleanupStack::PopAndDestroy();
+        }
+          
+	}
+
+void CHuiCanvasWsSwGc::WsDrawRoundRectL(TPoint aPoint, TRect& aRect)
+	{
+	iIsReallyDirty = ETrue;
+
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+
+    iBitGc->DrawRoundRect(AdjustCoordinates(aRect),TSize(aPoint.iX,aPoint.iY));
+	}
+
+void CHuiCanvasWsSwGc::WsDrawPolyLineL(CArrayFix<TPoint>* aPointerArray)
+	{
+	iIsReallyDirty = ETrue;
+
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+	
+	if(aPointerArray)
+		{
+		for(int i=0; i<aPointerArray->Count();i++)
+			{
+			aPointerArray->At(i) = AdjustCoordinates(aPointerArray->At(i));
+			}
+		iBitGc->DrawPolyLine(aPointerArray);
+		}
+	}
+
+void CHuiCanvasWsSwGc::WsDrawPolyLineNoEndPointL(TPoint* aPointerArray, TInt aCount)
+	{
+	iIsReallyDirty = ETrue;
+
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+	
+	if ( aPointerArray )
+        {
+        for(int i=0; i<aCount;i++)
+			{
+			aPointerArray[i] = AdjustCoordinates(aPointerArray[i]);
+			}
+		iBitGc->DrawPolyLineNoEndPoint(aPointerArray,aCount);
+        } 
+    }
+
+void CHuiCanvasWsSwGc::WsDrawPolygonL(CArrayFix<TPoint>* aPointerArray, TInt aFillRule)
+	{
+	iIsReallyDirty = ETrue;
+
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+	
+	if ( aPointerArray )
+        {
+        for(int i=0; i<aPointerArray->Count();i++)
+        	{
+        	aPointerArray->At(i) = AdjustCoordinates(aPointerArray->At(i));	
+        	}
+        iBitGc->DrawPolygon( aPointerArray,(CFbsBitGc ::TFillRule)aFillRule );	
+        }
+	}	
+
+void CHuiCanvasWsSwGc::WsDrawEllipseL(TRect& aRect)
+	{
+	iIsReallyDirty = ETrue;
+
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+	
+    iBitGc->DrawEllipse(AdjustCoordinates(aRect));
+	}
+
+void CHuiCanvasWsSwGc::WsDrawLineL(TPoint& aStart, TPoint& aEnd)
+	{
+	iIsReallyDirty = ETrue;
+
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+	
+	TPoint startPoint = AdjustCoordinates(aStart);
+	TPoint endPoint = AdjustCoordinates(aEnd);
+    iBitGc->DrawLine( startPoint,endPoint );
+	}
+
+void CHuiCanvasWsSwGc::WsDrawLineToL(TPoint& aPoint)
+	{
+	iIsReallyDirty = ETrue;
+
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+	
+	TPoint point = AdjustCoordinates(aPoint);
+    iBitGc->DrawLineTo(point);
+	}
+
+void CHuiCanvasWsSwGc::WsDrawLineByL(TPoint& aPoint)
+	{
+	iIsReallyDirty = ETrue;
+
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+	
+	TPoint point = AdjustCoordinates(aPoint);
+    iBitGc->DrawLineBy(point);
+	}
+
+void CHuiCanvasWsSwGc::WsDrawRectL(TRect& aRect)
+	{
+	iIsReallyDirty = ETrue;
+
+	if (!IsRenderingEnabled())
+        {
+        return;
+        }
+
+    iBitGc->DrawRect(AdjustCoordinates(aRect));
+	}
+
+void CHuiCanvasWsSwGc::WsDrawText1L(TPtr& aTextValue, THuiCanvasTextParameters& aTextParameters)
+	{
+	if (iBitGc && !iBitGc->IsFontUsed())
+	    {
+	    return;    
+	    }
+
+	iIsReallyDirty = ETrue;
+	
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+	
+#ifdef SYMBIAN_BUILD_GCE            
+    CGraphicsContext::TTextParameters gcTextParams = *(CGraphicsContext::TTextParameters*)&aTextParameters;
+	iBitGc->DrawText(aTextValue, &gcTextParams);
+#else			
+	iBitGc->DrawText(aTextValue);
+#endif            
+    }
+
+void CHuiCanvasWsSwGc::WsDrawText2L(TPtr& aTextValue, TPoint& aPoint,THuiCanvasTextParameters& aTextParameters)
+	{
+	if (iBitGc && !iBitGc->IsFontUsed())
+	    {
+	    return;    
+	    }
+
+	iIsReallyDirty = ETrue;
+
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+	
+	TPoint point = AdjustCoordinates(aPoint);
+
+#ifdef SYMBIAN_BUILD_GCE            
+    CGraphicsContext::TTextParameters gcTextParams = *(CGraphicsContext::TTextParameters*)&aTextParameters;
+	iBitGc->DrawText(aTextValue, &gcTextParams, point);
+#else			
+    iBitGc->DrawText(aTextValue, point);
+#endif
+    }
+
+void CHuiCanvasWsSwGc::WsDrawText3L(TPtr& aTextValue, TRect& aRect, THuiCanvasTextParameters& aTextParameters)
+	{
+	if (iBitGc && !iBitGc->IsFontUsed())
+	    {
+	    return;    
+	    }
+	
+	iIsReallyDirty = ETrue;
+
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+	
+#ifdef SYMBIAN_BUILD_GCE            
+    CGraphicsContext::TTextParameters gcTextParams = *(CGraphicsContext::TTextParameters*)&aTextParameters;
+	iBitGc->DrawText(aTextValue, &gcTextParams, AdjustCoordinates(aRect));
+#else			
+	iBitGc->DrawText(aTextValue, AdjustCoordinates(aRect));
+#endif
+    }
+
+
+void CHuiCanvasWsSwGc::WsDrawText4L(TPtr& aTextValue, TRect& aRect, TInt aBaselineOffset, TInt aTextAlign, TInt aTextMargin,THuiCanvasTextParameters& aTextParameters)
+	{
+	if (iBitGc && !iBitGc->IsFontUsed())
+	    {
+	    return;    
+	    }
+	
+	iIsReallyDirty = ETrue;
+
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+		
+#ifdef SYMBIAN_BUILD_GCE            
+    CGraphicsContext::TTextParameters gcTextParams = *(CGraphicsContext::TTextParameters*)&aTextParameters;
+	iBitGc->DrawText(aTextValue, &gcTextParams, AdjustCoordinates(aRect), aBaselineOffset,(CFbsBitGc::TTextAlign )aTextAlign,aTextMargin);
+#else			
+    iBitGc->DrawText(aTextValue, AdjustCoordinates(aRect), aBaselineOffset,(CFbsBitGc::TTextAlign )aTextAlign,aTextMargin);
+#endif
+    }
+
+void CHuiCanvasWsSwGc::WsDrawText5L( TPtr& aTextValue, TRect& aRect, TInt aBaselineOffset, TInt aTextAlign, TInt aTextMargin,TInt aTextWidth, THuiCanvasTextParameters& aTextParameters)
+	{
+	if (iBitGc && !iBitGc->IsFontUsed())
+	    {
+	    return;    
+	    }
+	
+	iIsReallyDirty = ETrue;
+
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+	
+#ifdef SYMBIAN_BUILD_GCE            
+    CGraphicsContext::TTextParameters gcTextParams = *(CGraphicsContext::TTextParameters*)&aTextParameters;
+    iBitGc->DrawText(aTextValue, &gcTextParams, AdjustCoordinates(aRect), aBaselineOffset,aTextWidth,(CFbsBitGc::TTextAlign )aTextAlign,aTextMargin);
+#else
+    iBitGc->DrawText(aTextValue, AdjustCoordinates(aRect), aBaselineOffset,aTextWidth,(CFbsBitGc::TTextAlign )aTextAlign,aTextMargin);
+#endif
+    }
+	
+void CHuiCanvasWsSwGc::WsDrawTextVertical1L(TPtr& aTextValue, TInt aTextUp, THuiCanvasTextParameters& aTextParameters)	
+    {
+	if (iBitGc && !iBitGc->IsFontUsed())
+	    {
+	    return;    
+	    }
+    
+	iIsReallyDirty = ETrue;
+
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+	
+#ifdef SYMBIAN_BUILD_GCE            
+    CGraphicsContext::TTextParameters gcTextParams = *(CGraphicsContext::TTextParameters*)&aTextParameters;
+    iBitGc->DrawTextVertical(aTextValue, &gcTextParams, aTextUp);
+#else
+    iBitGc->DrawTextVertical(aTextValue, aTextUp);
+#endif
+    }
+
+void CHuiCanvasWsSwGc::WsDrawTextVertical2L(TPtr& aTextValue, TInt aTextUp,TPoint& aPoint, THuiCanvasTextParameters& aTextParameters)	
+    {
+	if (iBitGc && !iBitGc->IsFontUsed())
+	    {
+	    return;    
+	    }
+    
+	iIsReallyDirty = ETrue;
+
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+	
+    TPoint point = AdjustCoordinates(aPoint);	 	                                       	
+#ifdef SYMBIAN_BUILD_GCE            
+    CGraphicsContext::TTextParameters gcTextParams = *(CGraphicsContext::TTextParameters*)&aTextParameters;
+    iBitGc->DrawTextVertical(aTextValue, &gcTextParams, point,aTextUp);
+#else
+    iBitGc->DrawTextVertical(aTextValue,point,aTextUp);
+#endif
+    }
+
+void CHuiCanvasWsSwGc::WsDrawTextVertical3L(TPtr& aTextValue, TInt aTextUp, TRect& aRect, THuiCanvasTextParameters& aTextParameters)	
+    {
+	if (iBitGc && !iBitGc->IsFontUsed())
+	    {
+	    return;    
+	    }
+    
+	iIsReallyDirty = ETrue;
+
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+	
+#ifdef SYMBIAN_BUILD_GCE            
+    CGraphicsContext::TTextParameters gcTextParams = *(CGraphicsContext::TTextParameters*)&aTextParameters;
+    iBitGc->DrawTextVertical(aTextValue, &gcTextParams, AdjustCoordinates(aRect),aTextUp);
+#else
+    iBitGc->DrawTextVertical(aTextValue,AdjustCoordinates(aRect),aTextUp);
+#endif
+    }
+
+void CHuiCanvasWsSwGc::WsDrawTextVertical4L(TPtr& aTextValue, TRect& aRect, TInt aBaselineOffset, TInt aTextUp, TInt aTextAlign, TInt aTextMargin,THuiCanvasTextParameters& aTextParameters)
+    {
+	if (iBitGc && !iBitGc->IsFontUsed())
+	    {
+	    return;    
+	    }
+    
+	iIsReallyDirty = ETrue;
+
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+	
+#ifdef SYMBIAN_BUILD_GCE            
+    CGraphicsContext::TTextParameters gcTextParams = *(CGraphicsContext::TTextParameters*)&aTextParameters;
+    iBitGc->DrawTextVertical(aTextValue, &gcTextParams, AdjustCoordinates(aRect),aBaselineOffset,aTextUp,(CFbsBitGc::TTextAlign )aTextAlign,aTextMargin);
+#else
+    iBitGc->DrawTextVertical(aTextValue,AdjustCoordinates(aRect),aBaselineOffset,aTextUp,(CFbsBitGc::TTextAlign )aTextAlign,aTextMargin);
+#endif
+    }
+
+void CHuiCanvasWsSwGc::WsDrawTextVertical5L(TPtr& aTextValue, TRect& aRect, TInt aBaselineOffset, TInt aTextUp, TInt aTextAlign, TInt aTextMargin, TInt aTextWidth, THuiCanvasTextParameters& aTextParameters)
+    {
+	if (iBitGc && !iBitGc->IsFontUsed())
+	    {
+	    return;    
+	    }
+    
+	iIsReallyDirty = ETrue;
+
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+	
+#ifdef SYMBIAN_BUILD_GCE            
+    CGraphicsContext::TTextParameters gcTextParams = *(CGraphicsContext::TTextParameters*)&aTextParameters;
+    iBitGc->DrawTextVertical(aTextValue, &gcTextParams, AdjustCoordinates(aRect),aBaselineOffset,aTextWidth,aTextUp,(CFbsBitGc::TTextAlign )aTextAlign,aTextMargin);
+#else
+    iBitGc->DrawTextVertical(aTextValue,AdjustCoordinates(aRect),aBaselineOffset,aTextWidth,aTextUp,(CFbsBitGc::TTextAlign )aTextAlign,aTextMargin);
+#endif
+    }
+
+void CHuiCanvasWsSwGc::WsMoveToL( TPoint& aPoint)
+    {
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+
+    TPoint point = AdjustCoordinates(aPoint);
+    iBitGc->MoveTo(point);
+    }
+
+void CHuiCanvasWsSwGc::WsMoveByL( TPoint& aPoint)
+    {
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+
+    TPoint point = AdjustCoordinates(aPoint);
+    iBitGc->MoveBy(point);
+    }
+    
+void CHuiCanvasWsSwGc::WsPlotL(TPoint& aPoint)
+	{
+	iIsReallyDirty = ETrue;
+
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+	
+	TPoint point = AdjustCoordinates(aPoint);
+    // Draw  
+    iBitGc->Plot(point);
+	}
+
+void CHuiCanvasWsSwGc::WsResetL()
+	{
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+
+    iWsClipRect = RoundedDisplayRect();            
+	iWsOrigin = TPoint(0,0);	
+	iBitGc->Reset();
+    WsResetClippingRegionL();   
+	}
+
+void CHuiCanvasWsSwGc::WsSetBrushColorL( TRgb aColor)
+    {
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+
+    iBitGc->SetBrushColor(aColor);
+    }
+
+void CHuiCanvasWsSwGc::WsSetBrushOriginL( TPoint& aPoint)
+    {
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+
+    TPoint point = AdjustCoordinates(aPoint);
+    iBitGc->SetBrushOrigin(point);
+    }
+
+void CHuiCanvasWsSwGc::WsSetBrushStyleL( TInt aStyle)
+    {
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+
+    iBitGc->SetBrushStyle((CFbsBitGc::TBrushStyle)aStyle);
+    }
+
+void CHuiCanvasWsSwGc::WsSetClippingRegionL( RRegion& aRegion)
+    {        
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+
+    // Store first
+    iWsClipRegion.Clear();    
+    for (TInt i=0;i<aRegion.Count();i++)
+        {
+        iWsClipRegion.AddRect(aRegion[i]);
+        }    
+
+    // Area is in screen coordinates so we must convert it 
+    iTempRegion.Clear();
+    for (TInt i=0; i < aRegion.Count(); i++)
+        {
+        iTempRegion.AddRect(AdjustCoordinates(aRegion[i]));   
+        }
+    
+    iTempRegion.Intersect(iDefaultClipRegion); // MNA: Koe
+    
+    iBitGc->SetClippingRegion(iTempRegion);
+    }
+    
+void CHuiCanvasWsSwGc::WsSetDrawModeL( TInt aDrawMode)
+	{
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+
+    iBitGc->SetDrawMode((CFbsBitGc::TDrawMode)aDrawMode);
+	}
+
+void CHuiCanvasWsSwGc::WsSetOriginL( TPoint& aOrigin)
+	{
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+	
+	iWsOrigin = aOrigin;
+ 	iBitGc->SetOrigin(aOrigin);
+	}
+
+void CHuiCanvasWsSwGc::WsSetPenColorL( TRgb aColor)
+	{
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+
+    iBitGc->SetPenColor(aColor);
+	}
+
+void CHuiCanvasWsSwGc::WsSetPenStyleL( TInt aStyle)
+	{
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+
+	iBitGc->SetPenStyle((CFbsBitGc::TPenStyle)aStyle);
+	}
+
+void CHuiCanvasWsSwGc::WsSetPenSizeL( TInt aWidth, TInt aHeight)
+	{
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+
+	TSize lSize(aWidth,aHeight);
+	iBitGc->SetPenSize(lSize);
+	}
+
+void CHuiCanvasWsSwGc::WsSetTextShadowColorL( TRgb /*aColor*/)
+	{
+ 	// N/A
+	}
+
+void CHuiCanvasWsSwGc::WsSetCharJustificationL( TInt aExcessiveWidth, TInt aNumGap)
+	{
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+
+	iBitGc->SetCharJustification(aExcessiveWidth,aNumGap);
+	}
+
+void CHuiCanvasWsSwGc::WsSetWordJustificationL( TInt aExcessiveWidth, TInt aNumGap)
+	{
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+
+    iBitGc->SetWordJustification(aExcessiveWidth,aNumGap);
+	}
+
+void CHuiCanvasWsSwGc::WsSetUnderlineStyleL( TInt aValue )
+	{
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+	
+	if (aValue < 1000) // magic, we recycle the same function for both underline and strike through
+	    {
+	    iBitGc->SetUnderlineStyle((TFontUnderline)aValue);	
+	    }
+	else
+	    {
+	    iBitGc->SetStrikethroughStyle((TFontStrikethrough)(aValue-1000));
+	    }
+	}
+
+void CHuiCanvasWsSwGc::WsSetBrushPatternL( TInt aValue)
+	{
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+
+	iBitGc->UseBrushPattern(aValue);
+	}
+
+void CHuiCanvasWsSwGc::WsSetFontL( TInt aFontId)
+	{
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+
+	iBitGc->UseFont(aFontId);
+	}
+
+void CHuiCanvasWsSwGc::WsCopyRectL( TPoint& aPoint, TRect& aRect)
+	{
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+
+	iBitGc->CopyRect(AdjustCoordinates(aPoint),AdjustCoordinates(aRect));
+	}
+
+void CHuiCanvasWsSwGc::WsUpdateJustificationL( TPtr& aTextValue)
+	{
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+
+	iBitGc->UpdateJustification(aTextValue);
+	}
+
+void CHuiCanvasWsSwGc::WsUpdateJustificationVerticalL( TInt aValue, TPtr& aTextValue )
+	{
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+
+	if(aValue)
+    	iBitGc->UpdateJustificationVertical(aTextValue,ETrue);
+	else
+		iBitGc->UpdateJustificationVertical(aTextValue,EFalse);
+	}
+
+void CHuiCanvasWsSwGc::WsSetFontNoDuplicateL( TInt aCurrentFont)
+	{
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+
+	iBitGc->UseFont(aCurrentFont);	
+	}
+
+void CHuiCanvasWsSwGc::WsCopySettingsL()
+	{
+    }
+
+void CHuiCanvasWsSwGc::WsSetClippingRectL( TRect& aRect)
+    {
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+
+    // Symbian SetClippingRect takes ws origin into account, 
+    // but SetClippingRegion does not.
+ 	iWsClipRect = aRect;
+    iBitGc->SetClippingRect(AdjustCoordinates(aRect));                
+    return;
+    }
+
+void CHuiCanvasWsSwGc::WsCancelClippingRectL()
+    {
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+
+    iWsClipRect = AdjustCoordinates(RoundedDisplayRect());        
+    iBitGc->CancelClippingRect();
+    }
+
+void CHuiCanvasWsSwGc::WsSetFadedL( TInt& aFaded)
+    {
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+
+    iBitGc->SetFaded(aFaded);
+    }
+
+void CHuiCanvasWsSwGc::WsSetFadingParametersL( TInt aBlackMap, TInt aWhiteMap)
+    {
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+
+    iBitGc->SetFadingParameters(aBlackMap, aWhiteMap);    
+	}
+
+void CHuiCanvasWsSwGc::WsFadeAreaL( RRegion& /*aRegion */)
+    {
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+
+    return; // TODO: Fading does not work, somebody fix it please
+    
+/*    
+	iIsReallyDirty = ETrue;
+
+    // Area is in screen coordinates so we must convert it ?
+    RRegion adjustedRegion;
+
+    for (TInt i=0; i < aRegion.Count(); i++)
+        {
+        adjustedRegion.AddRect(AdjustCoordinates(aRegion[i]));   
+        }
+        
+   	iBitGc->FadeArea(&adjustedRegion);    
+    adjustedRegion.Close();    
+*/
+    }
+
+void CHuiCanvasWsSwGc::WsMapColorsL()
+    {
+    // N/A
+    }
+
+void CHuiCanvasWsSwGc::WsSetUserDisplayModeL( TInt /*aMode*/ )
+    {
+    // N/A
+    }
+
+void CHuiCanvasWsSwGc::WsUseFontL(TInt aCurrentFont)
+    {
+    if (!IsRenderingEnabled())
+        {
+        return;
+        }
+
+    iBitGc->UseFont(aCurrentFont);    
+    }       
+
+void CHuiCanvasWsSwGc::BeginActionL(TInt aAction, TRect /*aDisplayRect*/, const CHuiCanvasVisual& aUser, TBool aIsCachePrepared, const TRegion& aUpdateRegion)
+	{
+	iAction = aAction;
+	iVisual = &aUser;
+
+    if (!iVisual)
+        {
+        return;    
+        }        
+
+    // Update area is in screen coordinates so we must convert it 
+    iDefaultClipRegion.Clear();
+    for (TInt i=0; i < aUpdateRegion.Count(); i++)
+        {
+        iDefaultClipRegion.AddRect(AdjustCoordinates(aUpdateRegion[i]));   
+        }
+    
+    TSize size = RoundedDisplayRect().Size();	
+
+    TBool recreateBackbuffer = (!iBitGc || (iBitBitmap && iBitBitmap->SizeInPixels() != size));
+    
+    // If this is first draw or size has changed, re-create backbuffer
+	if (recreateBackbuffer)
+		{				    	
+        // Release old cached backbuffer image
+        iVisual->Env().CanvasTextureCache().ReleaseAllCachedEntries(*iVisual);		        
+
+        iBitmapInitialized = EFalse;
+		
+        if (!iBitBitmap)
+            {
+            iBitBitmap = new (ELeave) CFbsBitmap;
+            iBitBitmap->Create(size, SelectDisplayMode());  
+            }
+        else
+            {
+            iBitBitmap->Resize(size);    
+            }    
+	    
+        if (!iBitDevice)
+            {
+            iBitDevice = CFbsBitmapDevice::NewL(iBitBitmap);        
+            }
+        else
+            {
+            iBitDevice->Resize(size);    
+            }    
+
+	    delete iBitGc;
+	    iBitGc = NULL;
+	    User::LeaveIfError(iBitDevice->CreateContext(iBitGc));             
+        
+        TRgb clearColor = KRgbWhite;
+        clearColor.SetAlpha(0x00);
+        
+	    iBitGc->SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha);
+        iBitGc->SetPenColor(clearColor);
+        iBitGc->SetBrushColor(clearColor);
+        iBitGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
+  	    iBitGc->Clear();
+  	    iBitGc->Reset();    	  
+  	    
+  	    iIsReallyDirty = EFalse;
+		}
+	
+	if (iBitGc)
+	    {
+	    iBitGc->Reset();
+	    }
+	
+	iBitmapPrepared = aIsCachePrepared && iBitmapInitialized;
+	}
+
+// Note that for perfomance reasons we keep iBitBitmap alive in this method   
+void CHuiCanvasWsSwGc::EndActionL(const TRegion& /*aUpdateRegion*/, TBool aUpdateDisplay)
+	{
+    if (!iBitBitmap || !iVisual)
+        {
+        return;    
+        }        
+        
+    if ( iAction == EDrawBuffer )
+        {
+        iBitmapInitialized = ETrue;
+        iBitmapPrepared = ETrue;
+        }
+        
+    // If capturing is used, then copy content from bitmap.
+    // TODO: We could use capturing bitmap directly to get better performance if the window content changes a lot 
+    // TODO: Is this actually a bug ? We should not copy to iCapturingBitGc EVERYTIME !??!
+    if (iCapturingBitGc)
+        {
+        iCapturingBitGc->SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha);
+        iCapturingBitGc->BitBlt(TPoint(0,0), iBitBitmap);    
+        }
+
+    if (iAction == EDrawBuffer && aUpdateDisplay && iIsReallyDirty && RoundedDisplayRect().Size() != TSize(0,0))
+        {
+        // Texture cache creates new cached (hw accelerated) image from backbuffer bitmap if needed
+        // However, we must enable touch count check for the duration of cached image creation.
+        // In addition, we must perform CreateCachedImageL only after we have really updated bitmap,
+        // so we want touch count check to be used.
+        
+        THuiCachedImageParams cachedImageParams;
+        cachedImageParams.iBitmapHandle = iBitBitmap->Handle();
+         
+        TBool wasTouchCountEnabled = iVisual->Env().CanvasTextureCache().IsTouchCountCheckEnabled();
+        iVisual->Env().CanvasTextureCache().EnableTouchCountCheck(ETrue);
+        iVisual->Env().CanvasTextureCache().ReleaseAllCachedEntries(*iVisual);
+        
+        const CHuiCanvasGraphicImage* cachedImage = NULL;
+        TRAPD(err, cachedImage = iVisual->Env().CanvasTextureCache().CreateCachedImageL(cachedImageParams, *iVisual));
+        
+        iVisual->Env().CanvasTextureCache().EnableTouchCountCheck(wasTouchCountEnabled);
+        if (err)
+            {
+            User::Leave(err);
+            }
+
+        const CHuiTexture* texture = NULL;
+        if (cachedImage)
+            {
+            texture = cachedImage->Texture();
+            }
+        if (texture)
+            {
+            // Draw backbuffer to screen            
+            THuiRealRect destinationRect(iVisual->DisplayRect().iTl, texture->Size());                
+            CanvasGc().DrawImage(*texture, destinationRect);        
+            }
+        else
+            {
+    #ifdef _DEBUG
+            RDebug::Print(_L("CHuiCanvasWsSwGc::EndActionL: No cached image !"));
+    #endif
+            }
+        }
+	}
+
+CHuiCanvasGc& CHuiCanvasWsSwGc::CanvasGc() const
+	{
+	return *iCanvasGc;
+	}	  	
+    
+    
+TPoint CHuiCanvasWsSwGc::AdjustCoordinates(TPoint aPoint)
+	{
+	TPoint adjustment = RoundedDisplayRect().iTl;
+	TPoint lPoint(aPoint.iX-adjustment.iX + iPosDelta.iX,aPoint.iY-adjustment.iY + iPosDelta.iY );	
+	return lPoint;
+	}
+
+TRect CHuiCanvasWsSwGc::AdjustCoordinates(TRect aRect)
+	{
+	TRect rect = aRect;
+	TPoint adjustment = -RoundedDisplayRect().iTl;
+	    
+	rect.Move(adjustment.iX + iPosDelta.iX, adjustment.iY  + iPosDelta.iY);
+	return rect;
+	}
+	
+TDisplayMode CHuiCanvasWsSwGc::SelectDisplayMode()
+    {
+    TDisplayMode mode = EColor16MA;
+        
+    // Note 64K mode cannot be used until separate mask is supported. It might be
+    // possible to generate according to dirty region ?
+    
+    /*
+    // NOTE: EHuiRendererGles10 and EHuiRendererGles11 temporarely use EColor64K
+    // beacuse it looks as there are some problems with uploading 16MA 
+    // mode bitmaps into multisegmented textures.
+    //
+    if (CHuiStatic::Env().Renderer() == EHuiRendererBitgdi || 
+        CHuiStatic::Env().Renderer() == EHuiRendererGles10 || 
+        CHuiStatic::Env().Renderer() == EHuiRendererGles11)
+        {        
+        mode = EColor64K;           
+        }
+    */    
+    return mode;    
+    }
+	
+TInt CHuiCanvasWsSwGc::SetCapturingBufferL(CFbsBitmap* aTarget)
+    {
+    if (iCapturingBitBitmap)
+        {
+        delete iCapturingBitBitmap;
+        iCapturingBitBitmap = NULL;    
+        }
+    
+    if (iCapturingBitGc)
+        {
+        delete iCapturingBitGc;
+        iCapturingBitGc = NULL;    
+        }
+
+    if (iCapturingBitDevice)
+        {
+        delete iCapturingBitDevice;
+        iCapturingBitDevice = NULL;    
+        }
+
+    if (aTarget)
+        {
+        iCapturingBitBitmap = new (ELeave) CFbsBitmap;
+        iCapturingBitBitmap->Duplicate(aTarget->Handle());                        
+        }
+                   
+    if (iCapturingBitBitmap)
+        {
+	    iCapturingBitDevice = CFbsBitmapDevice::NewL(iCapturingBitBitmap);
+	    User::LeaveIfError(iCapturingBitDevice->CreateContext(iCapturingBitGc));                         
+        }    
+    
+    return KErrNone;
+    }
+
+TRect CHuiCanvasWsSwGc::RoundedDisplayRect() const
+    {
+    if (iVisual)
+        {
+        return iVisual->DisplayRect().Round();    
+        }
+    else
+        {
+        return TRect(0,0,0,0);    
+        }    
+        
+    }
+
+void CHuiCanvasWsSwGc::SetPositionDelta( TPoint& aPoint )
+    {
+    iPosDelta = aPoint;
+    }
+
+CFbsBitmap* CHuiCanvasWsSwGc::CreateMovedMaskL(CFbsBitmap& aOriginalMask, TPoint aNewTopLeftCorner)
+    {
+    TSize size = aOriginalMask.SizeInPixels();
+    
+    CFbsBitmap* newMask = new(ELeave)CFbsBitmap;                       
+    CleanupStack::PushL(newMask);
+            
+    newMask->Create(size, aOriginalMask.DisplayMode());       
+    
+    CFbsDevice* newMaskdevice = NULL;
+    CFbsBitGc* newMaskGc = NULL;
+
+    newMaskdevice = CFbsBitmapDevice::NewL(newMask);
+    CleanupStack::PushL(newMaskdevice);
+    User::LeaveIfError(newMaskdevice->CreateContext(newMaskGc));
+
+    newMaskGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
+    newMaskGc->SetPenStyle(CGraphicsContext::ESolidPen);
+    newMaskGc->SetPenColor(KRgbWhite);
+    newMaskGc->SetBrushColor(KRgbWhite);
+    newMaskGc->DrawRect(TRect(TPoint(0,0), size));
+    newMaskGc->BitBlt(TPoint(0,0), &aOriginalMask, TRect(aNewTopLeftCorner, size));
+    newMaskGc->BitBlt(aNewTopLeftCorner, &aOriginalMask, TRect(TPoint(0,0), size));
+    
+    delete newMaskGc;    
+    CleanupStack::PopAndDestroy(newMaskdevice);
+    CleanupStack::Pop(newMask);
+    
+    return newMask;
+    }
+
+void CHuiCanvasWsSwGc::ClearCache()
+    {
+    // Nothing to do..
+    }
+
+TBool CHuiCanvasWsSwGc::IsRenderBufferEnabled() const
+    {
+    return (iBitBitmap != NULL);
+    }
+
+TBool CHuiCanvasWsSwGc::IsRenderBufferPrepared() const
+    {
+    return (iBitBitmap != NULL) && iIsReallyDirty && 
+           (RoundedDisplayRect().Size() != TSize(0,0)) && iBitmapPrepared;       
+    }
+
+TBool CHuiCanvasWsSwGc::IsRenderBufferInitialized() const
+    {
+    // always initialized
+    return (iBitBitmap != NULL) && iBitmapInitialized;
+    }
+
+TInt CHuiCanvasWsSwGc::EnableRenderbuffer(TBool /*aEnable*/)
+    {
+    // Enabled by default
+    return KErrNone;
+    }
+
+THuiCanvasWsGcType CHuiCanvasWsSwGc::Type() const
+    {
+    return EHuiCanvasWsSw;
+    }
+
+
+void CHuiCanvasWsSwGc::EnableUpdateRegion(const TRegion& aUpdateRegion, TBool aClear)
+    {
+    // Area is in screen coordinates so we must convert it 
+    iDefaultClipRegion.Clear();
+    for (TInt i=0; i < aUpdateRegion.Count(); i++)
+        {
+        iDefaultClipRegion.AddRect(AdjustCoordinates(aUpdateRegion[i]));   
+        }
+
+    if (!iBitGc)
+        {
+        return;
+        }
+    
+    if (aClear)
+        {
+        if (iDefaultClipRegion.Count())
+            {
+            iBitGc->SetClippingRegion(iDefaultClipRegion);
+            }
+
+        TRgb clearColor = KRgbWhite;
+        clearColor.SetAlpha(0x0);
+        iBitGc->SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha);
+        iBitGc->SetPenColor(clearColor);
+        iBitGc->SetBrushColor(clearColor);
+        iBitGc->SetBrushStyle(CGraphicsContext::ESolidBrush);        
+        iBitGc->Clear(); 
+        iBitGc->Reset();
+        }    
+
+    if (iDefaultClipRegion.Count())
+        {
+        iBitGc->SetClippingRegion(iDefaultClipRegion);
+        }
+    }
+
+void CHuiCanvasWsSwGc::DisableUpdateRegion()
+    {
+    if (iBitGc)
+        {
+        iBitGc->CancelClippingRegion();
+        }
+    }
+
+void CHuiCanvasWsSwGc::SetRelativeOrientation(CHuiGc::TOrientation /*aOrientation*/)
+    {
+    // Not supported yet
+    }
+
+TBool CHuiCanvasWsSwGc::IsRenderingEnabled() const
+    {
+    return iAction == EDrawBuffer;
+    }