diff options
Diffstat (limited to 'canvas/workben/canvasdemo.cxx')
-rw-r--r-- | canvas/workben/canvasdemo.cxx | 712 |
1 files changed, 712 insertions, 0 deletions
diff --git a/canvas/workben/canvasdemo.cxx b/canvas/workben/canvasdemo.cxx new file mode 100644 index 000000000000..6cb2afa82d7b --- /dev/null +++ b/canvas/workben/canvasdemo.cxx @@ -0,0 +1,712 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 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! Everytime 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 ... + |