/**************************************************************
 * 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/




// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_canvas.hxx"
// This code strongly inspired by Miguel / Federico's Gnome Canvas demo code.

#include <comphelper/processfactory.hxx>
#include <comphelper/regpathhelper.hxx>
#include <cppuhelper/servicefactory.hxx>
#include <cppuhelper/bootstrap.hxx>
#include <com/sun/star/lang/XMultiServiceFactory.hpp>
#include <com/sun/star/lang/XInitialization.hpp>
#include <com/sun/star/registry/XSimpleRegistry.hpp>

#include <ucbhelper/contentbroker.hxx>
#include <ucbhelper/configurationkeys.hxx>

#include <basegfx/polygon/b2dpolygon.hxx>
#include <basegfx/polygon/b2dpolygontools.hxx>
#include <basegfx/tools/canvastools.hxx>

#include <vcl/window.hxx>
#include <vcl/virdev.hxx>
#include <vcl/svapp.hxx>
#include <vcl/msgbox.hxx>
#include <vcl/unowrap.hxx>
#include <vcl/canvastools.hxx>

#include <rtl/bootstrap.hxx>

#include <com/sun/star/rendering/XCanvas.hpp>
#include <com/sun/star/rendering/FillRule.hpp>
#include <com/sun/star/rendering/ViewState.hpp>
#include <com/sun/star/rendering/RenderState.hpp>
#include <com/sun/star/rendering/PathCapType.hpp>
#include <com/sun/star/rendering/PathJoinType.hpp>
#include <com/sun/star/rendering/XSpriteCanvas.hpp>
#include <com/sun/star/rendering/XGraphicDevice.hpp>
#include <com/sun/star/rendering/CompositeOperation.hpp>
#include <com/sun/star/rendering/XBitmap.hpp>

#include <stdio.h>
#include <unistd.h>


// never import whole leaf namespaces, since this will result in
// absolutely weird effects during (Koenig) name lookup
using namespace ::com::sun::star;


class DemoApp : public Application
{
public:
	virtual void Main();
	virtual USHORT	Exception( USHORT nError );
};

static void PrintHelp()
{
	fprintf( stdout, "canvasdemo - Exercise the new canvas impl\n" );
}

class TestWindow : public Dialog
{
	public:
		TestWindow() : Dialog( (Window *) NULL )
		{
			SetText( rtl::OUString::createFromAscii( "Canvas test" ) );
			SetSizePixel( Size( 600, 450 ) );
			EnablePaint( true );
			Show();
		}
		virtual ~TestWindow() {}
        virtual void MouseButtonUp( const MouseEvent& /*rMEvt*/ )
		{ 
			//TODO: do something cool
            EndDialog(); 
        }
		virtual void Paint( const Rectangle& rRect );
};

class DemoRenderer
{
	public:
		Size maSize;
		Size maBox;
		rendering::ViewState   maViewState;
		rendering::RenderState maRenderState;
    	uno::Sequence< double > maColorBlack;
		uno::Sequence< double > maColorWhite;
		uno::Sequence< double > maColorRed;
		uno::Reference< rendering::XCanvas > mxCanvas;
		uno::Reference< rendering::XCanvasFont > mxDefaultFont;
		uno::Reference< rendering::XGraphicDevice > mxDevice;

		DemoRenderer( uno::Reference< rendering::XGraphicDevice > xDevice,
					  uno::Reference< rendering::XCanvas > xCanvas,
					  Size aSize ) :
            maSize(aSize),
            maBox(),
            maViewState(),
            maRenderState(),
            maColorBlack( vcl::unotools::colorToStdColorSpaceSequence( Color(COL_BLACK)) ),
            maColorWhite( vcl::unotools::colorToStdColorSpaceSequence( Color(COL_WHITE)) ),
            maColorRed( vcl::unotools::colorToStdColorSpaceSequence( Color(COL_RED)) ),
            mxCanvas(xCanvas),
            mxDefaultFont(),
            mxDevice( xDevice )
		{
			// Geometry init
			geometry::AffineMatrix2D aUnit( 1,0, 0,
											0,1, 0 );
			maViewState.AffineTransform = aUnit;
			maRenderState.AffineTransform = aUnit;
			maRenderState.DeviceColor = maColorBlack;

			//I can't figure out what the compsiteoperation stuff does
			//it doesn't seem to do anything in either VCL or cairocanvas
			//I was hoping that CLEAR would clear the canvas before we paint,
			//but nothing changes
			maRenderState.CompositeOperation = rendering::CompositeOperation::OVER; 

			maBox.Width() = aSize.Width() / 3;
			maBox.Height() = aSize.Height() / 3;

			lang::Locale aLocale;
			rendering::FontInfo aFontInfo;
			aFontInfo.FamilyName = ::rtl::OUString::createFromAscii( "Swiss" );
			aFontInfo.StyleName = ::rtl::OUString::createFromAscii( "SansSerif" );
			geometry::Matrix2D aFontMatrix( 1, 0,
											0, 1 );
			rendering::FontRequest aFontRequest( aFontInfo, 12.0, 0.0, aLocale );
			uno::Sequence< beans::PropertyValue > aExtraFontProperties;
 			mxDefaultFont = xCanvas->createFont( aFontRequest, aExtraFontProperties, aFontMatrix );
			if( !mxDefaultFont.is() )
				fprintf( stderr, "Failed to create font\n" );
		}

		void drawGrid()
		{
			double d, dIncr = maSize.Width() / 3;
			for ( d = 0; d <= maSize.Width(); d += dIncr )
				mxCanvas->drawLine( geometry::RealPoint2D( d, 0 ),
									geometry::RealPoint2D( d, maSize.Height() ),
									maViewState, maRenderState );
			dIncr = maSize.Height() / 3;
			for ( d = 0; d <= maSize.Height(); d += dIncr )
				mxCanvas->drawLine( geometry::RealPoint2D( 0, d ),
									geometry::RealPoint2D( maSize.Width(), d ),
									maViewState, maRenderState );
		}

    	void drawStringAt( ::rtl::OString aString, double x, double y )
		{
			rendering::StringContext aText;
			aText.Text = ::rtl::OStringToOUString( aString, RTL_TEXTENCODING_UTF8 );
			aText.StartPosition = 0;
			aText.Length = aString.getLength();
			rendering::RenderState aRenderState( maRenderState );
			aRenderState.AffineTransform.m02 += x;
			aRenderState.AffineTransform.m12 += y;

			mxCanvas->drawText( aText, mxDefaultFont, maViewState, aRenderState, 0);
		}

        void drawRect( Rectangle rRect, uno::Sequence< double > &aColor, int /*nWidth*/ )
		{
			uno::Sequence< geometry::RealPoint2D > aPoints(4);
			uno::Reference< rendering::XLinePolyPolygon2D > xPoly;

			aPoints[0] = geometry::RealPoint2D( rRect.Left(),  rRect.Top() );
			aPoints[1] = geometry::RealPoint2D( rRect.Left(),  rRect.Bottom() );
			aPoints[2] = geometry::RealPoint2D( rRect.Right(), rRect.Bottom() );
			aPoints[3] = geometry::RealPoint2D( rRect.Right(), rRect.Top() );

			uno::Sequence< uno::Sequence< geometry::RealPoint2D > > aPolys(1);
			aPolys[0] = aPoints;
			xPoly = mxDevice->createCompatibleLinePolyPolygon( aPolys );
			xPoly->setClosed( 0, true );
			uno::Reference< rendering::XPolyPolygon2D> xPP( xPoly, uno::UNO_QUERY );
			
			rendering::RenderState aRenderState( maRenderState );
			aRenderState.DeviceColor = aColor;
			mxCanvas->drawPolyPolygon( xPP, maViewState, aRenderState );
		}

		void translate( double x, double y)
		{
			maRenderState.AffineTransform.m02 += x;
			maRenderState.AffineTransform.m12 += y;
		}

		void drawPolishDiamond( double center_x, double center_y)
		{
			const int    VERTICES = 10;
			const double RADIUS = 60.0;
			int i, j;
			double a;

			rendering::RenderState maOldRenderState = maRenderState; // push
			translate( center_x, center_y );

			for (i = 0; i < VERTICES; i++)
			{
				a = 2.0 * M_PI * i / VERTICES;
				geometry::RealPoint2D aSrc( RADIUS * cos (a), RADIUS * sin (a) );

				for (j = i + 1; j < VERTICES; j++)
				{
					a = 2.0 * M_PI * j / VERTICES;

//					FIXME: set cap_style to 'ROUND'
					mxCanvas->drawLine( aSrc,
										geometry::RealPoint2D( RADIUS * cos (a),
															   RADIUS * sin (a) ),
										maViewState, maRenderState );
				}
			}

			maRenderState = maOldRenderState; // pop
		}

		void drawHilbert( double anchor_x, double anchor_y )
		{
			const double SCALE=7.0;
			const char hilbert[] = "urdrrulurulldluuruluurdrurddldrrruluurdrurddldrddlulldrdldrrurd";
			int nLength = sizeof( hilbert ) / sizeof (hilbert [0]);

			uno::Sequence< geometry::RealPoint2D > aPoints( nLength );
			uno::Reference< rendering::XLinePolyPolygon2D > xPoly;
		
			aPoints[0] = geometry::RealPoint2D( anchor_x, anchor_y );
			for (int i = 0; i < nLength; i++ )
			{
				switch( hilbert[i] )
				{
					case 'u':
						aPoints[i+1] = geometry::RealPoint2D( aPoints[i].X,
															aPoints[i].Y - SCALE );
						break;
					case 'd':
						aPoints[i+1] = geometry::RealPoint2D( aPoints[i].X,
															aPoints[i].Y + SCALE );
						break;
					case 'l':
						aPoints[i+1] = geometry::RealPoint2D( aPoints[i].X - SCALE,
															aPoints[i].Y );
						break;
					case 'r':
						aPoints[i+1] = geometry::RealPoint2D( aPoints[i].X + SCALE,
															aPoints[i].Y );
						break;
				}
			}

			uno::Sequence< uno::Sequence< geometry::RealPoint2D > > aPolys(1);
			aPolys[0] = aPoints;

			xPoly = mxDevice->createCompatibleLinePolyPolygon( aPolys );
			xPoly->setClosed( 0, false );
			uno::Reference< rendering::XPolyPolygon2D> xPP( xPoly, uno::UNO_QUERY );

			rendering::RenderState aRenderState( maRenderState );
			aRenderState.DeviceColor = maColorRed;
//			aRenderState.DeviceColor[3] = 0.5;
			rendering::StrokeAttributes aStrokeAttrs;
			aStrokeAttrs.StrokeWidth = 4.0;
			aStrokeAttrs.MiterLimit = 2.0; // ?
			aStrokeAttrs.StartCapType = rendering::PathCapType::BUTT;
			aStrokeAttrs.EndCapType = rendering::PathCapType::BUTT;
			aStrokeAttrs.JoinType = rendering::PathJoinType::MITER;
			//fprintf( stderr, "FIXME: stroking a PolyPolygon doesn't show up\n" );
			//yes it does
			mxCanvas->strokePolyPolygon( xPP, maViewState, aRenderState, aStrokeAttrs );
			// FIXME: do this instead:
			//mxCanvas->drawPolyPolygon( xPP, maViewState, aRenderState );
		}

		void drawTitle( rtl::OString aTitle )
		{
			// FIXME: text anchoring to be done
			double nStringWidth = aTitle.getLength() * 8.0;
			drawStringAt ( aTitle, (maBox.Width() - nStringWidth) / 2, 15 );
		}

		void drawRectangles()
		{
			rendering::RenderState maOldRenderState = maRenderState; // push

			drawTitle( ::rtl::OString( "Rectangles" ) );
			
			drawRect( Rectangle( 20, 30, 70, 60 ), maColorRed, 8 );
			// color mediumseagreen, stipple fill, outline black
			drawRect( Rectangle( 90, 40, 180, 100 ), maColorBlack, 4 );
			// color steelblue, filled, no outline
			drawRect( Rectangle( 10, 80, 80, 140 ), maColorBlack, 1 );

			maRenderState = maOldRenderState; // pop
		}

		void drawEllipses()
		{
			rendering::RenderState maOldRenderState = maRenderState; // push
			translate( maBox.Width(), 0.0 );

			drawTitle( ::rtl::OString( "Ellipses" ) );

            const basegfx::B2DPoint aCenter( maBox.Width()*.5, 
                                             maBox.Height()*.5 );
            const basegfx::B2DPoint aRadii( maBox.Width()*.3, 
                                            maBox.Height()*.3 );
            const basegfx::B2DPolygon& rEllipse( 
                basegfx::tools::createPolygonFromEllipse( aCenter, 
                                                          aRadii.getX(),
                                                          aRadii.getY() ));

			uno::Reference< rendering::XPolyPolygon2D > xPoly( 
                basegfx::unotools::xPolyPolygonFromB2DPolygon(mxDevice,
                                                              rEllipse) );

			rendering::StrokeAttributes aStrokeAttrs;
			aStrokeAttrs.StrokeWidth = 4.0;
			aStrokeAttrs.MiterLimit = 2.0; // ?
			aStrokeAttrs.StartCapType = rendering::PathCapType::BUTT;
			aStrokeAttrs.EndCapType = rendering::PathCapType::BUTT;
			aStrokeAttrs.JoinType = rendering::PathJoinType::MITER;
			mxCanvas->strokePolyPolygon( xPoly, maViewState, maRenderState, aStrokeAttrs );

			maRenderState = maOldRenderState; // pop
		}

		void drawText()
		{
			rendering::RenderState maOldRenderState = maRenderState; // push
			translate( maBox.Width() * 2.0, 0.0 );

			drawTitle( ::rtl::OString( "Text" ) );

			translate( 0.0,
                       maBox.Height() * .5 );
			drawTitle( ::rtl::OString( "This is lame" ) );

			maRenderState = maOldRenderState; // pop
		}

		void drawImages()
		{
			rendering::RenderState maOldRenderState = maRenderState; // push
			translate( 0.0, maBox.Height() );

			drawTitle( ::rtl::OString( "Images" ) );

			uno::Reference< rendering::XBitmap > xBitmap(mxCanvas, uno::UNO_QUERY);

            if( !xBitmap.is() )
                return;

			translate( maBox.Width()*0.1, maBox.Height()*0.2 );
			maRenderState.AffineTransform.m00 *= 4.0/15;
			maRenderState.AffineTransform.m11 *= 3.0/15;
            
			mxCanvas->drawBitmap(xBitmap, maViewState, maRenderState);

			// uno::Reference< rendering::XBitmap > xBitmap2( xBitmap->getScaledBitmap(geometry::RealSize2D(48, 48), false) );
			// mxCanvas->drawBitmap(xBitmap2, maViewState, maRenderState); //yes, but where?
			//cairo-canvas says:
			//called CanvasHelper::getScaledBitmap, we return NULL, TODO
            //Exception 'BitmapEx vclcanvas::tools::bitmapExFromXBitmap(const com::sun::star::uno::Reference<com::sun::star::rendering::XBitmap>&),
            //bitmapExFromXBitmap(): could not extract BitmapEx' thrown
			//
            //vcl-canvas says:
			//Exception 'BitmapEx vclcanvas::tools::bitmapExFromXBitmap(const com::sun::star::uno::Reference<com::sun::star::rendering::XBitmap>&),
			//bitmapExFromXBitmap(): could not extract bitmap' thrown
			//  Thorsten says that this is a bug, and Thorsten never lies.

			maRenderState = maOldRenderState; // pop
		}

		void drawLines()
		{
			rendering::RenderState maOldRenderState = maRenderState; // push
			translate( maBox.Width(), maBox.Height() );

			drawTitle( ::rtl::OString( "Lines" ) );

			drawPolishDiamond( 70.0, 80.0 );
			drawHilbert( 140.0, 140.0 );

			maRenderState = maOldRenderState; // pop
		}

		void drawCurves()
		{
			rendering::RenderState maOldRenderState = maRenderState; // push
			translate( maBox.Width() * 2.0, maBox.Height() );

			drawTitle( ::rtl::OString( "Curves" ) );

			translate( maBox.Width() * .5, maBox.Height() * .5 );

			const double r= 30.0;
			const int num_curves = 3;
		  
			//hacky hack hack
			uno::Sequence< geometry::RealBezierSegment2D > aBeziers (num_curves);
			uno::Reference< rendering::XBezierPolyPolygon2D > xPoly;

			for (int i= 0; i < num_curves; i++)
				aBeziers[i]= geometry::RealBezierSegment2D( r * cos(i*2*M_PI/num_curves), //Px
															r * sin(i*2*M_PI/num_curves), //py
															r * 2 * cos((i*2*M_PI + 2*M_PI)/num_curves),  //C1x
															r * 2 * sin((i*2*M_PI + 2*M_PI)/num_curves),  //C1y
															r * 2 * cos((i*2*M_PI + 2*M_PI)/num_curves),  //C2x
															r * 2 * sin((i*2*M_PI + 2*M_PI)/num_curves)); //C2y
			uno::Sequence< uno::Sequence< geometry::RealBezierSegment2D > > aPolys(1);
			aPolys[0] = aBeziers;
			xPoly = mxDevice->createCompatibleBezierPolyPolygon(aPolys);
			xPoly->setClosed( 0, true );
			//uno::Reference< rendering::XBezierPolyPolygon2D> xPP( xPoly, uno::UNO_QUERY );
			//compiles, but totally screws up.  I think it is interpretting the bezier as a line
			uno::Reference< rendering::XPolyPolygon2D> xPP( xPoly, uno::UNO_QUERY );
		
			rendering::StrokeAttributes aStrokeAttrs;
			aStrokeAttrs.StrokeWidth = 4.0;
			aStrokeAttrs.MiterLimit = 2.0; // ?
			aStrokeAttrs.StartCapType = rendering::PathCapType::BUTT;
			aStrokeAttrs.EndCapType = rendering::PathCapType::BUTT;
			aStrokeAttrs.JoinType = rendering::PathJoinType::MITER;
			mxCanvas->strokePolyPolygon( xPP, maViewState, maRenderState, aStrokeAttrs );
			//you can't draw a BezierPolyPolygon2D with this, even though it is derived from it
			//mxCanvas->drawPolyPolygon( xPP, maViewState, maRenderState );
					   
			maRenderState = maOldRenderState; // pop
		}

	double gimmerand()
		{
			return (double)(rand()) / RAND_MAX * 100 + 50;
		}

		void drawArcs()
		{
			rendering::RenderState maOldRenderState = maRenderState; // push
			translate( 0.0, maBox.Height() * 2.0 );

			drawTitle( ::rtl::OString( "Arcs" ) );
			

			//begin hacks
			//This stuff doesn't belong here, but probably in curves
			//This stuff doesn't work in VCL b/c vcl doesn't do beziers
			//Hah!  Every time the window redraws, we do this
			double ax;
			double ay;
			double bx;
			double by;
			bx= gimmerand();
			by= gimmerand();
				
			for (int i= 0; i < 1; i++)
			{
				//point a= point b;
				ax= bx;
				ay= by;
				//point b= rand;
				bx= gimmerand();
				by= gimmerand();
				double c1x= gimmerand();
				double c1y= gimmerand();
				double c2x= gimmerand();
				double c2y= gimmerand();
				maRenderState.DeviceColor = maColorRed;
				mxCanvas->drawLine(geometry::RealPoint2D(ax, ay), geometry::RealPoint2D(c1x, c1y), maViewState, maRenderState);
				mxCanvas->drawLine(geometry::RealPoint2D(c1x, c1y), geometry::RealPoint2D(c2x, c2y), maViewState, maRenderState);
				mxCanvas->drawLine(geometry::RealPoint2D(bx, by), geometry::RealPoint2D(c2x, c2y), maViewState, maRenderState);
 				//draw from a to b
				geometry::RealBezierSegment2D aBezierSegment(
					ax, //Px
					ay, //Py
					c1x,
					c1x,
					c2x,
					c2y
					);
				geometry::RealPoint2D aEndPoint(bx, by);
				maRenderState.DeviceColor = maColorBlack;
				mxCanvas->drawBezier( 
					aBezierSegment,
					aEndPoint,
					maViewState, maRenderState );
			}
			maRenderState = maOldRenderState; // pop
		}


	void drawRegularPolygon(double centerx, double centery, int sides, double r)
		{
			//hacky hack hack
			uno::Sequence< geometry::RealPoint2D > aPoints (sides);
			uno::Reference< rendering::XLinePolyPolygon2D > xPoly;

			for (int i= 0; i < sides; i++)
			{
				aPoints[i]= geometry::RealPoint2D( centerx + r * cos(i*2 * M_PI/sides), 
												   centery + r * sin(i*2 * M_PI/sides));
			}
			uno::Sequence< uno::Sequence< geometry::RealPoint2D > > aPolys(1);
			aPolys[0] = aPoints;
			xPoly = mxDevice->createCompatibleLinePolyPolygon( aPolys );
			xPoly->setClosed( 0, true );
			rendering::RenderState aRenderState( maRenderState );
			aRenderState.DeviceColor = maColorRed;
			uno::Reference< rendering::XPolyPolygon2D> xPP( xPoly, uno::UNO_QUERY );
			mxCanvas->drawPolyPolygon( xPP, maViewState, aRenderState);
			mxCanvas->fillPolyPolygon( xPP,
									   maViewState,
									   aRenderState );
		}

		void drawPolygons()
		{
			rendering::RenderState maOldRenderState = maRenderState; // push
			translate( maBox.Width() * 1.0, maBox.Height() * 2.0 );

			drawTitle( ::rtl::OString( "Polgyons" ) );

			int sides= 3;
			for (int i= 1; i <= 4; i++)
			{
				drawRegularPolygon(35*i, 35, sides, 15);
				sides++;
			}
	
			maRenderState = maOldRenderState; // pop
		}

		void drawWidgets() // FIXME: prolly makes no sense
		{
			rendering::RenderState maOldRenderState = maRenderState; // push
			translate( maBox.Width() * 2.0, maBox.Height() * 2.0 );

			drawTitle( ::rtl::OString( "Widgets" ) );

			maRenderState = maOldRenderState; // pop
		}
};


void TestWindow::Paint( const Rectangle& /*rRect*/ )
{
	try
	{
        const Size aVDevSize(300,300);
        VirtualDevice aVDev(*this);
        aVDev.SetOutputSizePixel(aVDevSize);
		uno::Reference< rendering::XCanvas > xVDevCanvas( aVDev.GetCanvas(),
                                                          uno::UNO_QUERY_THROW );
		uno::Reference< rendering::XGraphicDevice > xVDevDevice( xVDevCanvas->getDevice(),
                                                                 uno::UNO_QUERY_THROW );
		DemoRenderer aVDevRenderer( xVDevDevice, xVDevCanvas, aVDevSize);
        xVDevCanvas->clear();
		aVDevRenderer.drawGrid();
        aVDevRenderer.drawRectangles();
		aVDevRenderer.drawEllipses();
		aVDevRenderer.drawText();
        aVDevRenderer.drawLines();
        aVDevRenderer.drawCurves();
        aVDevRenderer.drawArcs();
        aVDevRenderer.drawPolygons();

		uno::Reference< rendering::XCanvas > xCanvas( GetSpriteCanvas(),
	                                                      uno::UNO_QUERY_THROW );
		uno::Reference< rendering::XGraphicDevice > xDevice( xCanvas->getDevice(),
                                                             uno::UNO_QUERY_THROW );

		DemoRenderer aRenderer( xDevice, xCanvas, GetSizePixel() );
        xCanvas->clear();
		aRenderer.drawGrid();
        aRenderer.drawRectangles();
		aRenderer.drawEllipses();
		aRenderer.drawText();
        aRenderer.drawLines();
        aRenderer.drawCurves();
        aRenderer.drawArcs();
        aRenderer.drawPolygons();
        aRenderer.drawWidgets();
		aRenderer.drawImages();

        // check whether virdev actually contained something
        uno::Reference< rendering::XBitmap > xBitmap(xVDevCanvas, uno::UNO_QUERY);        
        if( !xBitmap.is() )
            return;
        
        aRenderer.maRenderState.AffineTransform.m02 += 100;
        aRenderer.maRenderState.AffineTransform.m12 += 100;
        xCanvas->drawBitmap(xBitmap, aRenderer.maViewState, aRenderer.maRenderState);

		uno::Reference< rendering::XSpriteCanvas > xSpriteCanvas( xCanvas, 
                                                                  uno::UNO_QUERY );
        if( xSpriteCanvas.is() )
            xSpriteCanvas->updateScreen( sal_True ); // without
                                                     // updateScreen(),
                                                     // nothing is
                                                     // visible
	}
	catch (const uno::Exception &e)
	{
		fprintf( stderr, "Exception '%s' thrown\n" ,
				 (const sal_Char *) ::rtl::OUStringToOString( e.Message, RTL_TEXTENCODING_UTF8 ) );
	}
}

USHORT DemoApp::Exception( USHORT nError )
{
	switch( nError & EXC_MAJORTYPE )
	{
		case EXC_RSCNOTLOADED:
			Abort( String::CreateFromAscii( "Error: could not load language resources.\nPlease check your installation.\n" ) );
			break;
	}
	return 0;
}

void DemoApp::Main()
{
	bool bHelp = false;

	for( USHORT i = 0; i < GetCommandLineParamCount(); i++ )
	{
		::rtl::OUString aParam = GetCommandLineParam( i );

		if( aParam.equalsAscii( "--help" ) ||
			aParam.equalsAscii( "-h" ) )
				bHelp = true;
	}

	if( bHelp )
	{
		PrintHelp();
		return;
	}

	//-------------------------------------------------
	// create the global service-manager
	//-------------------------------------------------
    uno::Reference< lang::XMultiServiceFactory > xFactory;
    try
    {
        uno::Reference< uno::XComponentContext > xCtx = ::cppu::defaultBootstrap_InitialComponentContext();
        xFactory = uno::Reference< lang::XMultiServiceFactory >(  xCtx->getServiceManager(), 
                                                                  uno::UNO_QUERY );
        if( xFactory.is() )
            ::comphelper::setProcessServiceFactory( xFactory );
    }
    catch( uno::Exception& )
    {
    }

    if( !xFactory.is() )
    {
        fprintf( stderr, "Could not bootstrap UNO, installation must be in disorder. Exiting.\n" );
        exit( 1 );
    }

    // Create UCB.
    uno::Sequence< uno::Any > aArgs( 2 );
	aArgs[ 0 ] <<= rtl::OUString::createFromAscii( UCB_CONFIGURATION_KEY1_LOCAL );
	aArgs[ 1 ] <<= rtl::OUString::createFromAscii( UCB_CONFIGURATION_KEY2_OFFICE );
    ::ucbhelper::ContentBroker::initialize( xFactory, aArgs );

	InitVCL( xFactory );
	TestWindow pWindow;
	pWindow.Execute();
    DeInitVCL();

    // clean up UCB
	::ucbhelper::ContentBroker::deinitialize();
}

DemoApp aDemoApp;

// TODO
//   - bouncing clip-rectangle mode - bounce a clip-rect around the window ...
//   - complete all of pre-existing canvas bits
//   - affine transform tweakage ...