canvas/workben/canvasdemo.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 // This code strongly inspired by Miguel / Federico's Gnome Canvas demo code.
  21
  22 #include <sal/config.h>
  23
  24 #include <basegfx/polygon/b2dpolygon.hxx>
  25 #include <basegfx/polygon/b2dpolygontools.hxx>
  26 #include <basegfx/utils/canvastools.hxx>
  27 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  28 #include <com/sun/star/rendering/CompositeOperation.hpp>
  29 #include <com/sun/star/rendering/FillRule.hpp>
  30 #include <com/sun/star/rendering/PathCapType.hpp>
  31 #include <com/sun/star/rendering/PathJoinType.hpp>
  32 #include <com/sun/star/rendering/RenderState.hpp>
  33 #include <com/sun/star/rendering/ViewState.hpp>
  34 #include <com/sun/star/rendering/XBitmap.hpp>
  35 #include <com/sun/star/rendering/XCanvas.hpp>
  36 #include <com/sun/star/rendering/XGraphicDevice.hpp>
  37 #include <com/sun/star/rendering/XSpriteCanvas.hpp>
  38 #include <com/sun/star/ucb/UniversalContentBroker.hpp>
  39 #include <comphelper/processfactory.hxx>
  40 #include <cppuhelper/bootstrap.hxx>
  41 #include <vcl/canvastools.hxx>
  42 #include <vcl/svapp.hxx>
  43 #include <vcl/vclmain.hxx>
  44 #include <vcl/virdev.hxx>
  45 #include <vcl/window.hxx>
  46 #include <vcl/wrkwin.hxx>
  47
  48 using namespace ::com::sun::star;
  49
  50 static void PrintHelp()
  51 {
  52     fprintf( stdout, "canvasdemo - Exercise the new canvas impl\n" );
  53 }
  54
  55 class TestWindow : public WorkWindow
  56 {
  57     public:
  58         TestWindow() : WorkWindow(nullptr, WB_APP | WB_STDWORK)
  59         {
  60             SetText("Canvas test");
  61             SetSizePixel( Size( 600, 450 ) );
  62             EnablePaint( true );
  63             Show();
  64         }
  65         virtual ~TestWindow() override {}
  66         virtual void MouseButtonUp( const MouseEvent& /*rMEvt*/ ) override
  67         {
  68             //TODO: do something cool
  69             Application::Quit();
  70         }
  71         virtual void Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect) override;
  72 };
  73
  74 class DemoRenderer
  75 {
  76     public:
  77         Size maSize;
  78         Size maBox;
  79         rendering::ViewState   maViewState;
  80         rendering::RenderState maRenderState;
  81         uno::Sequence< double > maColorBlack;
  82         uno::Sequence< double > maColorWhite;
  83         uno::Sequence< double > maColorRed;
  84         uno::Reference< rendering::XCanvas > mxCanvas;
  85         uno::Reference< rendering::XCanvasFont > mxDefaultFont;
  86         uno::Reference< rendering::XGraphicDevice > mxDevice;
  87
  88         DemoRenderer( uno::Reference< rendering::XGraphicDevice > xDevice,
  89                       uno::Reference< rendering::XCanvas > xCanvas,
  90                       Size aSize ) :
  91             maSize(aSize),
  92             maBox(),
  93             maViewState(),
  94             maRenderState(),
  95             maColorBlack( vcl::unotools::colorToStdColorSpaceSequence( COL_BLACK) ),
  96             maColorWhite( vcl::unotools::colorToStdColorSpaceSequence( COL_WHITE) ),
  97             maColorRed( vcl::unotools::colorToStdColorSpaceSequence( COL_RED) ),
  98             mxCanvas(xCanvas),
  99             mxDefaultFont(),
 100             mxDevice( xDevice )
 101         {
 102             // Geometry init
 103             geometry::AffineMatrix2D aUnit( 1,0, 0,
 104                                             0,1, 0 );
 105             maViewState.AffineTransform = aUnit;
 106             maRenderState.AffineTransform = aUnit;
 107             maRenderState.DeviceColor = maColorBlack;
 108
 109             //I can't figure out what the compositeoperation stuff does
 110             //it doesn't seem to do anything in either VCL or cairocanvas
 111             //I was hoping that CLEAR would clear the canvas before we paint,
 112             //but nothing changes
 113             maRenderState.CompositeOperation = rendering::CompositeOperation::OVER;
 114
 115             maBox.setWidth(aSize.Width() / 3);
 116             maBox.setHeight(aSize.Height() / 3);
 117
 118             lang::Locale aLocale;
 119             rendering::FontInfo aFontInfo;
 120             aFontInfo.FamilyName = "Swiss";
 121             aFontInfo.StyleName = "SansSerif";
 122             geometry::Matrix2D aFontMatrix( 1, 0,
 123                                             0, 1 );
 124             rendering::FontRequest aFontRequest( aFontInfo, 12.0, 0.0, aLocale );
 125             uno::Sequence< beans::PropertyValue > aExtraFontProperties;
 126             mxDefaultFont = xCanvas->createFont( aFontRequest, aExtraFontProperties, aFontMatrix );
 127             if( !mxDefaultFont.is() )
 128                 fprintf( stderr, "Failed to create font\n" );
 129         }
 130
 131         void drawGrid()
 132         {
 133             double d, dIncr = maSize.Width() / 3;
 134             for ( d = 0; d <= maSize.Width(); d += dIncr )
 135                 mxCanvas->drawLine( geometry::RealPoint2D( d, 0 ),
 136                                     geometry::RealPoint2D( d, maSize.Height() ),
 137                                     maViewState, maRenderState );
 138             dIncr = maSize.Height() / 3;
 139             for ( d = 0; d <= maSize.Height(); d += dIncr )
 140                 mxCanvas->drawLine( geometry::RealPoint2D( 0, d ),
 141                                     geometry::RealPoint2D( maSize.Width(), d ),
 142                                     maViewState, maRenderState );
 143         }
 144
 145         void drawStringAt( OString aString, double x, double y )
 146         {
 147             rendering::StringContext aText;
 148             aText.Text = OStringToOUString( aString, RTL_TEXTENCODING_UTF8 );
 149             aText.StartPosition = 0;
 150             aText.Length = aString.getLength();
 151             rendering::RenderState aRenderState( maRenderState );
 152             aRenderState.AffineTransform.m02 += x;
 153             aRenderState.AffineTransform.m12 += y;
 154
 155             mxCanvas->drawText( aText, mxDefaultFont, maViewState, aRenderState, 0);
 156         }
 157
 158         void drawRect( tools::Rectangle rRect, const uno::Sequence< double > &aColor, int /*nWidth*/ )
 159         {
 160             uno::Sequence< geometry::RealPoint2D > aPoints(4);
 161             uno::Reference< rendering::XLinePolyPolygon2D > xPoly;
 162
 163             aPoints[0] = geometry::RealPoint2D( rRect.Left(),  rRect.Top() );
 164             aPoints[1] = geometry::RealPoint2D( rRect.Left(),  rRect.Bottom() );
 165             aPoints[2] = geometry::RealPoint2D( rRect.Right(), rRect.Bottom() );
 166             aPoints[3] = geometry::RealPoint2D( rRect.Right(), rRect.Top() );
 167
 168             uno::Sequence< uno::Sequence< geometry::RealPoint2D > > aPolys(1);
 169             aPolys[0] = aPoints;
 170             xPoly = mxDevice->createCompatibleLinePolyPolygon( aPolys );
 171             xPoly->setClosed( 0, true );
 172             uno::Reference< rendering::XPolyPolygon2D> xPP( xPoly, uno::UNO_QUERY );
 173
 174             rendering::RenderState aRenderState( maRenderState );
 175             aRenderState.DeviceColor = aColor;
 176             mxCanvas->drawPolyPolygon( xPP, maViewState, aRenderState );
 177         }
 178
 179         void translate( double x, double y)
 180         {
 181             maRenderState.AffineTransform.m02 += x;
 182             maRenderState.AffineTransform.m12 += y;
 183         }
 184
 185         void drawPolishDiamond( double center_x, double center_y)
 186         {
 187             const int    VERTICES = 10;
 188             const double RADIUS = 60.0;
 189             int i, j;
 190
 191             rendering::RenderState maOldRenderState = maRenderState; // push
 192             translate( center_x, center_y );
 193
 194             for (i = 0; i < VERTICES; i++)
 195             {
 196                 double a = 2.0 * M_PI * i / VERTICES;
 197                 geometry::RealPoint2D aSrc( RADIUS * cos (a), RADIUS * sin (a) );
 198
 199                 for (j = i + 1; j < VERTICES; j++)
 200                 {
 201                     a = 2.0 * M_PI * j / VERTICES;
 202
 203 //                  FIXME: set cap_style to 'ROUND'
 204                     mxCanvas->drawLine( aSrc,
 205                                         geometry::RealPoint2D( RADIUS * cos (a),
 206                                                                RADIUS * sin (a) ),
 207                                         maViewState, maRenderState );
 208                 }
 209             }
 210
 211             maRenderState = maOldRenderState; // pop
 212         }
 213
 214         void drawHilbert( double anchor_x, double anchor_y )
 215         {
 216             const double SCALE=7.0;
 217             const char hilbert[] = "urdrrulurulldluuruluurdrurddldrrruluurdrurddldrddlulldrdldrrurd";
 218             int nLength = SAL_N_ELEMENTS( hilbert );
 219
 220             uno::Sequence< geometry::RealPoint2D > aPoints( nLength );
 221             uno::Reference< rendering::XLinePolyPolygon2D > xPoly;
 222
 223             aPoints[0] = geometry::RealPoint2D( anchor_x, anchor_y );
 224             for (int i = 0; i < nLength; i++ )
 225             {
 226                 switch( hilbert[i] )
 227                 {
 228                     case 'u':
 229                         aPoints[i+1] = geometry::RealPoint2D( aPoints[i].X,
 230                                                             aPoints[i].Y - SCALE );
 231                         break;
 232                     case 'd':
 233                         aPoints[i+1] = geometry::RealPoint2D( aPoints[i].X,
 234                                                             aPoints[i].Y + SCALE );
 235                         break;
 236                     case 'l':
 237                         aPoints[i+1] = geometry::RealPoint2D( aPoints[i].X - SCALE,
 238                                                             aPoints[i].Y );
 239                         break;
 240                     case 'r':
 241                         aPoints[i+1] = geometry::RealPoint2D( aPoints[i].X + SCALE,
 242                                                             aPoints[i].Y );
 243                         break;
 244                 }
 245             }
 246
 247             uno::Sequence< uno::Sequence< geometry::RealPoint2D > > aPolys(1);
 248             aPolys[0] = aPoints;
 249
 250             xPoly = mxDevice->createCompatibleLinePolyPolygon( aPolys );
 251             xPoly->setClosed( 0, false );
 252             uno::Reference< rendering::XPolyPolygon2D> xPP( xPoly, uno::UNO_QUERY );
 253
 254             rendering::RenderState aRenderState( maRenderState );
 255             aRenderState.DeviceColor = maColorRed;
 256 //          aRenderState.DeviceColor[3] = 0.5;
 257             rendering::StrokeAttributes aStrokeAttrs;
 258             aStrokeAttrs.StrokeWidth = 4.0;
 259             aStrokeAttrs.MiterLimit = 2.0; // ?
 260             aStrokeAttrs.StartCapType = rendering::PathCapType::BUTT;
 261             aStrokeAttrs.EndCapType = rendering::PathCapType::BUTT;
 262             aStrokeAttrs.JoinType = rendering::PathJoinType::MITER;
 263             //fprintf( stderr, "FIXME: stroking a tools::PolyPolygon doesn't show up\n" );
 264             //yes it does
 265             mxCanvas->strokePolyPolygon( xPP, maViewState, aRenderState, aStrokeAttrs );
 266             // FIXME: do this instead:
 267             //mxCanvas->drawPolyPolygon( xPP, maViewState, aRenderState );
 268         }
 269
 270         void drawTitle( OString aTitle )
 271         {
 272             // FIXME: text anchoring to be done
 273             double nStringWidth = aTitle.getLength() * 8.0;
 274             drawStringAt ( aTitle, (maBox.Width() - nStringWidth) / 2, 15 );
 275         }
 276
 277         void drawRectangles()
 278         {
 279             rendering::RenderState maOldRenderState = maRenderState; // push
 280
 281             drawTitle( OString( "Rectangles" ) );
 282
 283             drawRect( tools::Rectangle( 20, 30, 70, 60 ), maColorRed, 8 );
 284             // color mediumseagreen, stipple fill, outline black
 285             drawRect( tools::Rectangle( 90, 40, 180, 100 ), maColorBlack, 4 );
 286             // color steelblue, filled, no outline
 287             drawRect( tools::Rectangle( 10, 80, 80, 140 ), maColorBlack, 1 );
 288
 289             maRenderState = maOldRenderState; // pop
 290         }
 291
 292         void drawEllipses()
 293         {
 294             rendering::RenderState maOldRenderState = maRenderState; // push
 295             translate( maBox.Width(), 0.0 );
 296
 297             drawTitle( OString( "Ellipses" ) );
 298
 299             const basegfx::B2DPoint aCenter( maBox.Width()*.5,
 300                                              maBox.Height()*.5 );
 301             const basegfx::B2DPoint aRadii( maBox.Width()*.3,
 302                                             maBox.Height()*.3 );
 303             const basegfx::B2DPolygon& rEllipse(
 304                 basegfx::utils::createPolygonFromEllipse( aCenter,
 305                                                           aRadii.getX(),
 306                                                           aRadii.getY() ));
 307
 308             uno::Reference< rendering::XPolyPolygon2D > xPoly(
 309                 basegfx::unotools::xPolyPolygonFromB2DPolygon(mxDevice,
 310                                                               rEllipse) );
 311
 312             rendering::StrokeAttributes aStrokeAttrs;
 313             aStrokeAttrs.StrokeWidth = 4.0;
 314             aStrokeAttrs.MiterLimit = 2.0; // ?
 315             aStrokeAttrs.StartCapType = rendering::PathCapType::BUTT;
 316             aStrokeAttrs.EndCapType = rendering::PathCapType::BUTT;
 317             aStrokeAttrs.JoinType = rendering::PathJoinType::MITER;
 318             mxCanvas->strokePolyPolygon( xPoly, maViewState, maRenderState, aStrokeAttrs );
 319
 320             maRenderState = maOldRenderState; // pop
 321         }
 322
 323         void drawText()
 324         {
 325             rendering::RenderState maOldRenderState = maRenderState; // push
 326             translate( maBox.Width() * 2.0, 0.0 );
 327
 328             drawTitle( OString( "Text" ) );
 329
 330             translate( 0.0,
 331                        maBox.Height() * .5 );
 332             drawTitle( OString( "This is lame" ) );
 333
 334             maRenderState = maOldRenderState; // pop
 335         }
 336
 337         void drawImages()
 338         {
 339             rendering::RenderState maOldRenderState = maRenderState; // push
 340             translate( 0.0, maBox.Height() );
 341
 342             drawTitle( OString( "Images" ) );
 343
 344             uno::Reference< rendering::XBitmap > xBitmap(mxCanvas, uno::UNO_QUERY);
 345
 346             if( !xBitmap.is() )
 347                 return;
 348
 349             translate( maBox.Width()*0.1, maBox.Height()*0.2 );
 350             maRenderState.AffineTransform.m00 *= 4.0/15;
 351             maRenderState.AffineTransform.m11 *= 3.0/15;
 352
 353             mxCanvas->drawBitmap(xBitmap, maViewState, maRenderState);
 354
 355             // uno::Reference< rendering::XBitmap > xBitmap2( xBitmap->getScaledBitmap(geometry::RealSize2D(48, 48), false) );
 356             // mxCanvas->drawBitmap(xBitmap2, maViewState, maRenderState); //yes, but where?
 357             //cairo-canvas says:
 358             //called CanvasHelper::getScaledBitmap, we return NULL, TODO
 359             //Exception 'BitmapEx vclcanvas::tools::bitmapExFromXBitmap(const css::uno::Reference<css::rendering::XBitmap>&),
 360             //bitmapExFromXBitmap(): could not extract BitmapEx' thrown
 361
 362             //vcl-canvas says:
 363             //Exception 'BitmapEx vclcanvas::tools::bitmapExFromXBitmap(const css::uno::Reference<css::rendering::XBitmap>&),
 364             //bitmapExFromXBitmap(): could not extract bitmap' thrown
 365             //  Thorsten says that this is a bug, and Thorsten never lies.
 366
 367             maRenderState = maOldRenderState; // pop
 368         }
 369
 370         void drawLines()
 371         {
 372             rendering::RenderState maOldRenderState = maRenderState; // push
 373             translate( maBox.Width(), maBox.Height() );
 374
 375             drawTitle( OString( "Lines" ) );
 376
 377             drawPolishDiamond( 70.0, 80.0 );
 378             drawHilbert( 140.0, 140.0 );
 379
 380             maRenderState = maOldRenderState; // pop
 381         }
 382
 383         void drawCurves()
 384         {
 385             rendering::RenderState maOldRenderState = maRenderState; // push
 386             translate( maBox.Width() * 2.0, maBox.Height() );
 387
 388             drawTitle( OString( "Curves" ) );
 389
 390             translate( maBox.Width() * .5, maBox.Height() * .5 );
 391
 392             const double r= 30.0;
 393             const int num_curves = 3;
 394
 395             //hacky hack hack
 396             uno::Sequence< geometry::RealBezierSegment2D > aBeziers (num_curves);
 397             uno::Reference< rendering::XBezierPolyPolygon2D > xPoly;
 398
 399             for (int i= 0; i < num_curves; i++)
 400                 aBeziers[i]= geometry::RealBezierSegment2D( r * cos(i*2*M_PI/num_curves), //Px
 401                                                             r * sin(i*2*M_PI/num_curves), //py
 402                                                             r * 2 * cos((i*2*M_PI + 2*M_PI)/num_curves),  //C1x
 403                                                             r * 2 * sin((i*2*M_PI + 2*M_PI)/num_curves),  //C1y
 404                                                             r * 2 * cos((i*2*M_PI + 2*M_PI)/num_curves),  //C2x
 405                                                             r * 2 * sin((i*2*M_PI + 2*M_PI)/num_curves)); //C2y
 406             uno::Sequence< uno::Sequence< geometry::RealBezierSegment2D > > aPolys(1);
 407             aPolys[0] = aBeziers;
 408             xPoly = mxDevice->createCompatibleBezierPolyPolygon(aPolys);
 409             xPoly->setClosed( 0, true );
 410             //uno::Reference< rendering::XBezierPolyPolygon2D> xPP( xPoly, uno::UNO_QUERY );
 411             //compiles, but totally screws up.  I think it is interpreting the bezier as a line
 412             uno::Reference< rendering::XPolyPolygon2D> xPP( xPoly, uno::UNO_QUERY );
 413
 414             rendering::StrokeAttributes aStrokeAttrs;
 415             aStrokeAttrs.StrokeWidth = 4.0;
 416             aStrokeAttrs.MiterLimit = 2.0; // ?
 417             aStrokeAttrs.StartCapType = rendering::PathCapType::BUTT;
 418             aStrokeAttrs.EndCapType = rendering::PathCapType::BUTT;
 419             aStrokeAttrs.JoinType = rendering::PathJoinType::MITER;
 420             mxCanvas->strokePolyPolygon( xPP, maViewState, maRenderState, aStrokeAttrs );
 421             //you can't draw a BezierPolyPolygon2D with this, even though it is derived from it
 422             //mxCanvas->drawPolyPolygon( xPP, maViewState, maRenderState );
 423
 424             maRenderState = maOldRenderState; // pop
 425         }
 426
 427     double gimmerand()
 428         {
 429             return static_cast<double>(rand()) / RAND_MAX * 100 + 50;
 430         }
 431
 432         void drawArcs()
 433         {
 434             rendering::RenderState maOldRenderState = maRenderState; // push
 435             translate( 0.0, maBox.Height() * 2.0 );
 436
 437             drawTitle( OString( "Arcs" ) );
 438
 439
 440             //begin hacks
 441             //This stuff doesn't belong here, but probably in curves
 442             //This stuff doesn't work in VCL b/c vcl doesn't do beziers
 443             //Hah!  Every time the window redraws, we do this
 444             double bx;
 445             double by;
 446             bx= gimmerand();
 447             by= gimmerand();
 448
 449             for (int i= 0; i < 1; i++)
 450             {
 451                 double ax;
 452                 double ay;
 453                 //point a= point b;
 454                 ax= bx;
 455                 ay= by;
 456                 //point b= rand;
 457                 bx= gimmerand();
 458                 by= gimmerand();
 459                 double c1x= gimmerand();
 460                 double c1y= gimmerand();
 461                 double c2x= gimmerand();
 462                 double c2y= gimmerand();
 463                 maRenderState.DeviceColor = maColorRed;
 464                 mxCanvas->drawLine(geometry::RealPoint2D(ax, ay), geometry::RealPoint2D(c1x, c1y), maViewState, maRenderState);
 465                 mxCanvas->drawLine(geometry::RealPoint2D(c1x, c1y), geometry::RealPoint2D(c2x, c2y), maViewState, maRenderState);
 466                 mxCanvas->drawLine(geometry::RealPoint2D(bx, by), geometry::RealPoint2D(c2x, c2y), maViewState, maRenderState);
 467                  //draw from a to b
 468                 geometry::RealBezierSegment2D aBezierSegment(
 469                     ax, //Px
 470                     ay, //Py
 471                     c1x,
 472                     c1x,
 473                     c2x,
 474                     c2y
 475                     );
 476                 geometry::RealPoint2D aEndPoint(bx, by);
 477                 maRenderState.DeviceColor = maColorBlack;
 478                 mxCanvas->drawBezier(
 479                     aBezierSegment,
 480                     aEndPoint,
 481                     maViewState, maRenderState );
 482             }
 483             maRenderState = maOldRenderState; // pop
 484         }
 485
 486
 487     void drawRegularPolygon(double centerx, double centery, int sides, double r)
 488         {
 489             //hacky hack hack
 490             uno::Sequence< geometry::RealPoint2D > aPoints (sides);
 491             uno::Reference< rendering::XLinePolyPolygon2D > xPoly;
 492
 493             for (int i= 0; i < sides; i++)
 494             {
 495                 aPoints[i]= geometry::RealPoint2D( centerx + r * cos(i*2 * M_PI/sides),
 496                                                    centery + r * sin(i*2 * M_PI/sides));
 497             }
 498             uno::Sequence< uno::Sequence< geometry::RealPoint2D > > aPolys(1);
 499             aPolys[0] = aPoints;
 500             xPoly = mxDevice->createCompatibleLinePolyPolygon( aPolys );
 501             xPoly->setClosed( 0, true );
 502             rendering::RenderState aRenderState( maRenderState );
 503             aRenderState.DeviceColor = maColorRed;
 504             uno::Reference< rendering::XPolyPolygon2D> xPP( xPoly, uno::UNO_QUERY );
 505             mxCanvas->drawPolyPolygon( xPP, maViewState, aRenderState);
 506             mxCanvas->fillPolyPolygon( xPP,
 507                                        maViewState,
 508                                        aRenderState );
 509         }
 510
 511         void drawPolygons()
 512         {
 513             rendering::RenderState maOldRenderState = maRenderState; // push
 514             translate( maBox.Width() * 1.0, maBox.Height() * 2.0 );
 515
 516             drawTitle( OString( "Polgyons" ) );
 517
 518             int sides= 3;
 519             for (int i= 1; i <= 4; i++)
 520             {
 521                 drawRegularPolygon(35*i, 35, sides, 15);
 522                 sides++;
 523             }
 524
 525             maRenderState = maOldRenderState; // pop
 526         }
 527
 528         void drawWidgets() // FIXME: prolly makes no sense
 529         {
 530             rendering::RenderState maOldRenderState = maRenderState; // push
 531             translate( maBox.Width() * 2.0, maBox.Height() * 2.0 );
 532
 533             drawTitle( OString( "Widgets" ) );
 534
 535             maRenderState = maOldRenderState; // pop
 536         }
 537 };
 538
 539
 540 void TestWindow::Paint(vcl::RenderContext&, const tools::Rectangle&)
 541 {
 542     try
 543     {
 544         uno::Reference< rendering::XCanvas > xVDevCanvas( GetCanvas(),
 545                                                           uno::UNO_SET_THROW );
 546         uno::Reference< rendering::XGraphicDevice > xVDevDevice( xVDevCanvas->getDevice(),
 547                                                                  uno::UNO_SET_THROW );
 548         DemoRenderer aVDevRenderer( xVDevDevice, xVDevCanvas, GetSizePixel());
 549         xVDevCanvas->clear();
 550         aVDevRenderer.drawGrid();
 551         aVDevRenderer.drawRectangles();
 552         aVDevRenderer.drawEllipses();
 553         aVDevRenderer.drawText();
 554         aVDevRenderer.drawLines();
 555         aVDevRenderer.drawCurves();
 556         aVDevRenderer.drawArcs();
 557         aVDevRenderer.drawPolygons();
 558
 559         uno::Reference< rendering::XCanvas > xCanvas( GetSpriteCanvas(),
 560                                                           uno::UNO_QUERY_THROW );
 561         uno::Reference< rendering::XGraphicDevice > xDevice( xCanvas->getDevice(),
 562                                                              uno::UNO_SET_THROW );
 563
 564         DemoRenderer aRenderer( xDevice, xCanvas, GetSizePixel() );
 565         xCanvas->clear();
 566         aRenderer.drawGrid();
 567         aRenderer.drawRectangles();
 568         aRenderer.drawEllipses();
 569         aRenderer.drawText();
 570         aRenderer.drawLines();
 571         aRenderer.drawCurves();
 572         aRenderer.drawArcs();
 573         aRenderer.drawPolygons();
 574         aRenderer.drawWidgets();
 575         aRenderer.drawImages();
 576
 577         // check whether virdev actually contained something
 578         uno::Reference< rendering::XBitmap > xBitmap(xVDevCanvas, uno::UNO_QUERY);
 579         if( !xBitmap.is() )
 580             return;
 581
 582         aRenderer.maRenderState.AffineTransform.m02 += 100;
 583         aRenderer.maRenderState.AffineTransform.m12 += 100;
 584         xCanvas->drawBitmap(xBitmap, aRenderer.maViewState, aRenderer.maRenderState);
 585
 586         uno::Reference< rendering::XSpriteCanvas > xSpriteCanvas( xCanvas,
 587                                                                   uno::UNO_QUERY );
 588         if( xSpriteCanvas.is() )
 589             xSpriteCanvas->updateScreen( true ); // without
 590                                                      // updateScreen(),
 591                                                      // nothing is
 592                                                      // visible
 593     }
 594     catch (const uno::Exception &e)
 595     {
 596         fprintf( stderr, "Exception '%s' thrown\n" ,
 597                  OUStringToOString( e.Message, RTL_TEXTENCODING_UTF8 ).getStr() );
 598     }
 599 }
 600
 601 class DemoApp : public Application
 602 {
 603 public:
 604     virtual int Main() override;
 605     virtual void Exception(ExceptionCategory nCategory) override;
 606
 607 protected:
 608     void Init() override;
 609     void DeInit() override;
 610 };
 611
 612 int DemoApp::Main()
 613 {
 614     bool bHelp = false;
 615
 616     for( unsigned int i = 0; i < GetCommandLineParamCount(); i++ )
 617     {
 618         OUString aParam = GetCommandLineParam( i );
 619
 620         if( aParam == "--help" || aParam == "-h" )
 621             bHelp = true;
 622     }
 623
 624     if( bHelp )
 625     {
 626         PrintHelp();
 627         return 1;
 628     }
 629
 630     // Create UCB (for backwards compatibility, in case some code still uses
 631     // plain createInstance w/o args directly to obtain an instance):
 632     ::ucb::UniversalContentBroker::create(
 633         comphelper::getProcessComponentContext() );
 634
 635     ScopedVclPtr<TestWindow> aWindow = VclPtr<TestWindow>::Create();
 636     aWindow->Show();
 637
 638     Application::Execute();
 639     return 0;
 640 }
 641
 642 void DemoApp::Exception( ExceptionCategory nCategory )
 643 {
 644     switch( nCategory )
 645     {
 646         case ExceptionCategory::ResourceNotLoaded:
 647             Abort( "Error: could not load language resources.\nPlease check your installation.\n" );
 648             break;
 649         default:
 650             break;
 651     }
 652 }
 653
 654 void DemoApp::Init()
 655 {
 656     try
 657     {
 658         uno::Reference<uno::XComponentContext> xComponentContext
 659             = ::cppu::defaultBootstrap_InitialComponentContext();
 660         uno::Reference<lang::XMultiServiceFactory> xMSF;
 661         xMSF.set(xComponentContext->getServiceManager(), uno::UNO_QUERY);
 662         if(!xMSF.is())
 663             Application::Abort("Bootstrap failure - no service manager");
 664
 665         ::comphelper::setProcessServiceFactory(xMSF);
 666     }
 667     catch (const uno::Exception &e)
 668     {
 669         Application::Abort("Bootstrap exception " + e.Message);
 670     }
 671 }
 672
 673 void DemoApp::DeInit()
 674 {
 675     uno::Reference< lang::XComponent >(
 676         comphelper::getProcessComponentContext(),
 677         uno::UNO_QUERY_THROW)-> dispose();
 678     ::comphelper::setProcessServiceFactory(nullptr);
 679 }
 680
 681 void vclmain::createApplication()
 682 {
 683     static DemoApp aApp;
 684 }
 685
 686 // TODO
 687 //   - bouncing clip-rectangle mode - bounce a clip-rect around the window...
 688 //   - complete all of pre-existing canvas bits
 689 //   - affine transform tweakage...
 690
 691 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */