/*
* Copyright (c) 2002 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:  Graphics Extension Library source file
*
*/
#include "Gfx2dGcInterface.h"

// --------------------------------------------------------------------------
// CGfx2dGcVGR::CGfx2dGcVGR() : iScale( 1 ),
// ---------------------------------------------------------------------------
CGfx2dGcVGR::CGfx2dGcVGR() 
    {
    }

//
// ==========================================================================
// Create a new instance.
// ==========================================================================
// --------------------------------------------------------------------------
//  CGfx2dGcVGR* CGfx2dGcVGR::NewL( CFbsBitmap* aFrameBuffer, TFontSpec& aFontSpec )
// ---------------------------------------------------------------------------
 CGfx2dGcVGR* CGfx2dGcVGR::NewL( const TSize /*aBufferSize*/, TFontSpec& /*aFontSpec*/, CSvgBitmapFontProvider */*aSvgBitmapFontProvider*/ )
    {
    return NULL;
    }

// --------------------------------------------------------------------------
// void CGfx2dGcVGR::ConstructL( CFbsBitmap* aFrameBuffer, TFontSpec& aFontSpec )
// ---------------------------------------------------------------------------
void CGfx2dGcVGR::ConstructL( const TSize /*aBufferSize*/, TFontSpec& /*aFontSpec*/, CSvgBitmapFontProvider* /*aSvgBitmapFontProvider*/ )
    {
    }

// ==========================================================================
// Destructor.
// ==========================================================================
// --------------------------------------------------------------------------
//  CGfx2dGcVGR::~CGfx2dGcVGR()
// ---------------------------------------------------------------------------
CGfx2dGcVGR::~CGfx2dGcVGR()
    {
    }


// --------------------------------------------------------------------------
// void CGfx2dGcVGR::SetFrameBufferL( CFbsBitmap* aFrameBuffer )
// ---------------------------------------------------------------------------
void CGfx2dGcVGR::ChangeBufferSizeL( const TSize /*aSize */)
{
    }

// --------------------------------------------------------------------------
// void CGfx2dGcVGR::ActivateL()
// ---------------------------------------------------------------------------
void CGfx2dGcVGR::ActivateL()
    {
    }

// void CGfx2dGcVGR::AdjustShapeComplexityL( TInt32 /*aVertexSize*/ )
// ---------------------------------------------------------------------------
void CGfx2dGcVGR::AdjustShapeComplexityL( TInt32 /*aVertexSize*/ )
    {
    }


void CGfx2dGcVGR::DoDrawL( MGfxShape* /*aShape*/ )
    {
    }

void CGfx2dGcVGR::PostDraw()
{
}

// --------------------------------------------------------------------------
// void CGfx2dGcVGR::SetWindingRule( TGfxWindingRule aRule )
// ---------------------------------------------------------------------------
void CGfx2dGcVGR::SetWindingRule( TGfxWindingRule /*aRule*/ )
    {
    }

// --------------------------------------------------------------------------
// void CGfx2dGcVGR::Draw( MGfxShape* aShape )
// ---------------------------------------------------------------------------
void CGfx2dGcVGR::DrawL( MGfxShape* /*aShape*/ )
    {
    }


// --------------------------------------------------------------------------
// TUint8 CGfx2dGcVGR::Composite()
// ---------------------------------------------------------------------------
TUint8 CGfx2dGcVGR::Composite()
    {
    return 0;
    }

// --------------------------------------------------------------------------
// TGfxColor CGfx2dGcVGR::ForegroundColor()
// ---------------------------------------------------------------------------
TGfxColor CGfx2dGcVGR::ForegroundColor()
    {
    return TGfxColor(0);
    }

// --------------------------------------------------------------------------
// TGfxColor CGfx2dGcVGR::BackgroundColor()
// ---------------------------------------------------------------------------
TGfxColor CGfx2dGcVGR::BackgroundColor()
    {
    return TGfxColor(0);
    }

// --------------------------------------------------------------------------
// MGfxPaint* CGfx2dGcVGR::Paint()
// ---------------------------------------------------------------------------
MGfxPaint* CGfx2dGcVGR::Paint()
    {
    return NULL;
    }

// --------------------------------------------------------------------------
// TGfxRenderingHints* CGfx2dGcVGR::RenderingHints()
// ---------------------------------------------------------------------------
TGfxRenderingHints* CGfx2dGcVGR::RenderingHints()
    {
    return NULL;
    }

// --------------------------------------------------------------------------
// TGfxStroke CGfx2dGcVGR::Stroke()
// ---------------------------------------------------------------------------
TGfxStroke CGfx2dGcVGR::Stroke()
    {
    return TGfxStroke();
    }

// --------------------------------------------------------------------------
// TGfxAffineTransform CGfx2dGcVGR::Transform()
// ---------------------------------------------------------------------------
TGfxAffineTransform CGfx2dGcVGR::Transform()
    {
    return TGfxAffineTransform();
    }


// --------------------------------------------------------------------------
// MGfxShape* CGfx2dGcVGR::Clip()
// ---------------------------------------------------------------------------
MGfxShape* CGfx2dGcVGR::Clip()
    {
    return NULL;
    }


// --------------------------------------------------------------------------
// void CGfx2dGcVGR::GetDashArray( CArrayFix<TFixPt>*& aArray,
// ---------------------------------------------------------------------------
void CGfx2dGcVGR::GetDashArray( CArrayFix<TFloatFixPt>*& /*aArray*/,
                                      TFloatFixPt& /*aOffset*/ )
    {
    }

// --------------------------------------------------------------------------
// void CGfx2dGcVGR::SetDashOffset( TFixPt aDashOffset )
// ---------------------------------------------------------------------------
void CGfx2dGcVGR::SetDashOffset( TFloatFixPt /*aDashOffset*/ )
{
}

// --------------------------------------------------------------------------
// void CGfx2dGcVGR::SetComposite( const TUint8 aComposite )
// ---------------------------------------------------------------------------
void CGfx2dGcVGR::SetComposite( const TUint8 /*aComposite*/ )
    {
    }

// --------------------------------------------------------------------------
// void CGfx2dGcVGR::SetForegroundColor( const TGfxColor& aColor )
// ---------------------------------------------------------------------------
void CGfx2dGcVGR::SetForegroundColor( const TGfxColor& /*aColor*/ )
    {
    }

// --------------------------------------------------------------------------
// void CGfx2dGcVGR::SetBackgroundColor( const TGfxColor& aColor )
// ---------------------------------------------------------------------------
void CGfx2dGcVGR::SetBackgroundColor( const TGfxColor& /*aColor*/ )
    {
    }

// --------------------------------------------------------------------------
// void CGfx2dGcVGR::SetPaint( MGfxPaint* aPaint )
// ---------------------------------------------------------------------------
void CGfx2dGcVGR::SetPaint( MGfxPaint* /* aPaint*/ )
    {
    }

// --------------------------------------------------------------------------
// void CGfx2dGcVGR::SetStroke( TGfxStroke aStroke )
// ---------------------------------------------------------------------------
void CGfx2dGcVGR::SetStroke( TGfxStroke /*aStroke*/ )
    {
    }

// --------------------------------------------------------------------------
// void CGfx2dGcVGR::SetRenderingHints( const TGfxRenderingHints& aRenderingHints )
// ---------------------------------------------------------------------------
void CGfx2dGcVGR::SetRenderingHints( const TGfxRenderingHints& /*aRenderingHints*/ )
    {
    }

// --------------------------------------------------------------------------
// void CGfx2dGcVGR::SetTransform( const TGfxAffineTransform& aTransform )
// ---------------------------------------------------------------------------
void CGfx2dGcVGR::SetTransform( const TGfxAffineTransform& /*aTransform*/ )
    {
    }

// --------------------------------------------------------------------------
// void CGfx2dGcVGR::SetClip( const TGfxRectangle2D& aClip )
// ---------------------------------------------------------------------------
void CGfx2dGcVGR::SetClip( const TGfxRectangle2D& /*aClip*/ )
    {
    }

// --------------------------------------------------------------------------
// void CGfx2dGcVGR::SetDashArrayL( CArrayFix<TFloatFixPt>* aArray )
// ---------------------------------------------------------------------------
void CGfx2dGcVGR::SetDashArrayL( CArrayFix<TFloatFixPt>* /*aArray*/ )
    {
    }


// --------------------------------------------------------------------------
// TSize CGfx2dGcVGR::DeviceBounds()
// ---------------------------------------------------------------------------
TSize CGfx2dGcVGR::DeviceBounds()
    {
    return TSize();
    }

// --------------------------------------------------------------------------
// void CGfx2dGcVGR::SetAntialiasingMode( const TInt32 /*aAntialiasingEnable*/)
// ---------------------------------------------------------------------------
void CGfx2dGcVGR::SetAntialiasingMode( const TInt32 /*aAntialiasingEnable*/)
    {
    }

// --------------------------------------------------------------------------
// void CGfx2dGcVGR::SetFont( const CFont* aFont )
// ---------------------------------------------------------------------------
void CGfx2dGcVGR::SetFont( const CFont* /*aFont*/ )
    {
    }
// --------------------------------------------------------------------------
// CFont* CGfx2dGcVGR::Font()
// ---------------------------------------------------------------------------
CFont* CGfx2dGcVGR::Font()
    {
    return NULL;
    }

// --------------------------------------------------------------------------
// void CGfx2dGcVGR::GetSystemFontScaled(TFloatFixPt aHeight, 
//                                     const TDesC& aTypefaceName,
//                                     CFont*& aFont,
//                                     TFontSpec& aFontSpec )
// ---------------------------------------------------------------------------
void CGfx2dGcVGR::GetFontScaled( TFloatFixPt /*aHeight*/, 
                             const TDesC& /*aTypefaceName*/,
                             CFont*& /*aFont*/,
                             TFontSpec& /*aFontSpec */)
{
}

// --------------------------------------------------------------------------
// void CGfx2dGcVGR::SetFontSize( const TFloatFixPt aFontSize )
// ---------------------------------------------------------------------------
void CGfx2dGcVGR::SetFontSize( const TFloatFixPt /* aFontSize */)
    {
    }

// --------------------------------------------------------------------------
// void CGfx2dGcVGR::SetFontWeight( const TInt32 aFontWeight )
// ---------------------------------------------------------------------------
void CGfx2dGcVGR::SetFontWeight( const TInt32 /* aFontWeight */)
    {
    }

// --------------------------------------------------------------------------
// void CGfx2dGcVGR::SetFontStyle( const TInt32 aFontStyle )
// ---------------------------------------------------------------------------
void CGfx2dGcVGR::SetFontStyle( const TInt32 /*aFontStyle*/ )
    {
    }

// --------------------------------------------------------------------------
// void CGfx2dGcVGR::SetFontFamily( CDesCArrayFlat* aFamilies )
// ---------------------------------------------------------------------------
void CGfx2dGcVGR::SetFontFamily( CDesCArrayFlat* /*aFamilies*/ )
    {
    }

// --------------------------------------------------------------------------
// void CGfx2dGcVGR::SetTextanchor( const TInt32 aTextAnchor )
// ---------------------------------------------------------------------------
void CGfx2dGcVGR::SetTextanchor( const TInt32 /*aTextAnchor*/ )
    {
    }

// --------------------------------------------------------------------------
// void CGfx2dGcVGR::SetTextDecoration( const TInt32 aTextDecoration )
// ---------------------------------------------------------------------------
void CGfx2dGcVGR::SetTextDecoration( const TInt32 /*aTextDecoration*/ )
    {
    }


// Text Drawing
// --------------------------------------------------------------------------
// void CGfx2dGcVGR::DrawStringL( const TDesC& aDesc,
// ---------------------------------------------------------------------------
void CGfx2dGcVGR::DrawStringL( const TDesC& /*aDesc*/,
                                     TFloatFixPt /*aX*/,
                                     TFloatFixPt /*aY*/,
                                     TInt8 /* aTextAnchor */,
                                     TInt8 /* aTextDecoration */,
                                     CDesCArrayFlat* /* aFamilies */,
                                     TReal /*aWordSpacing*/,
                                     TReal /*aLetterSpacing*/,
                                     CArrayFix<TReal32>* /*aArrayRotate*/,
                                     CArrayFix<TFloatFixPt>* /*aArrayX*/,
                                     CArrayFix<TFloatFixPt>* /*aArrayY*/,
                                     TSize& /*aBboxSizeResult*/, 
				     CFont*& /*aFont*/, 
				     TFontSpec& /*aFontSpec*/ )
    {
    }



// Raster image drawing
// --------------------------------------------------------------------------
// void CGfx2dGcVGR::DrawImage( CFbsBitmap* aImage,
// ---------------------------------------------------------------------------
void CGfx2dGcVGR::DrawImage( CFbsBitmap* /*aImage*/,
                                      const TGfxRectangle2D& /*aImageRect*/,
                                      TBool /*aHasAlpha*/ )
    {
    }


// ==========================================================================
// Clear the whole graphics context with the background color
// ==========================================================================
// --------------------------------------------------------------------------
// void CGfx2dGcVGR::Clear(TUint32 aRGBA8888Color)
// ---------------------------------------------------------------------------
void CGfx2dGcVGR::Clear(TUint32 /*aRGBA8888Color*/)
    {
    }

// ==========================================================================
// This method copies the internal RGBA8888 framebuffer to CfbsBitmap that
// is specified in constructor. The CfbsBitmap could be 4k color (RGB0444),
// 64k color (RGB565), or 16M color (RGB888).
// ==========================================================================
// --------------------------------------------------------------------------
//  void CGfx2dGcVGR::UpdateFramebufferL()
// ---------------------------------------------------------------------------
void CGfx2dGcVGR::UpdateFramebufferL( CFbsBitmap* /*aBitmap*/, CFbsBitmap* /*aMask*/ )
    {
    }

void CGfx2dGcVGR::UpdateFramebufferL( CFbsBitmap* /*aBitmap*/, CFbsBitmap* /*aMask*/,TSize /*BitmapSize*/,TDisplayMode /*aBitmapDspMode*/,TDisplayMode /*aMaskDspMode*/ )

    {



    }
// ====================================================================================
// Blend bitmap with background according to group opacity
// This function gets called with the opacity framebuffer and the group opacity value
// The opacity buffer is initialized with the 0xAA55AA55 value. The pixels not matching
// ====================================================================================

// --------------------------------------------------------------------------
// void CGfx2dGcVGR::BlendWithBackground(TUint32* aFrameBuffer, TReal32 aOpacity)
// ---------------------------------------------------------------------------
void CGfx2dGcVGR::BlendWithBackground(TUint32* /*aColorBuffer*/, TReal32 /*aOpacity*/)
{
}

// ====================================================================================
// return iBuffer
// ==========================================================================
// Generate 8 bit gray or 1bit B/W mask from internal ARGB8888 frame buffer.
// ==========================================================================
// --------------------------------------------------------------------------
// void CGfx2dGcVGR::GenerateMask(CFbsBitmap* aMask)
// ---------------------------------------------------------------------------
void CGfx2dGcVGR::GenerateMask(CFbsBitmap* /*aMask*/)
    {
    }

// ==========================================================================
//  This function calls the low level function to set fill opacity value
// ==========================================================================

// --------------------------------------------------------------------------
// void CGfx2dGcVGR::SetFillOpacity(TFixPt aFillOpacity)
// ---------------------------------------------------------------------------
void CGfx2dGcVGR::SetFillOpacity(TFloatFixPt /*aFillOpacity*/)
    {
    }
// ==========================================================================
//  This function calls the low level function to set stroke opacity value
// ==========================================================================

// --------------------------------------------------------------------------
// void CGfx2dGcVGR::SetStrokeOpacity(TFixPt aStrokeOpacity)
// ---------------------------------------------------------------------------
void CGfx2dGcVGR::SetStrokeOpacity(TFloatFixPt /*aStrokeOpacity*/)
    {
    }
// ==========================================================================
//  This function is called to set the dithering flag
// ==========================================================================

// --------------------------------------------------------------------------
// void CGfx2dGcVGR::SetDoDithering( TBool aDoDithering )
// ---------------------------------------------------------------------------
void CGfx2dGcVGR::SetDoDithering( TBool /*aDoDithering*/ )
    {
    }

TUint32* CGfx2dGcVGR::ColorBuffer()
{
		return NULL;
}

// --------------------------------------------------------------------------
// void CGfx2dGcVGR::ColorConvertTo64K
// ---------------------------------------------------------------------------
void CGfx2dGcVGR::ColorConvertTo64K( TUint32* /*aDestAddress*/, const TSize& /*aSize*/ )
    {
}

void CGfx2dGcVGR::UpdateColorBuffer()
    {
    }