vcl/workben/outdevgrind.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 #include <sal/main.h>
  21 #include <tools/extendapplicationenvironment.hxx>
  22
  23 #include <cppuhelper/bootstrap.hxx>
  24 #include <comphelper/processfactory.hxx>
  25 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  26 #include <com/sun/star/uno/XComponentContext.hpp>
  27
  28 #include <vcl/svapp.hxx>
  29 #include <vcl/window.hxx>
  30 #include <vcl/dialog.hxx>
  31 #include <vcl/outdev.hxx>
  32 #include <vcl/virdev.hxx>
  33 #include <vcl/hatch.hxx>
  34 #include <vcl/bitmap.hxx>
  35 #include <vcl/wall.hxx>
  36 #include <vcl/image.hxx>
  37 #include <vcl/gdimtf.hxx>
  38 #include <vcl/metaact.hxx>
  39 #include <vcl/bitmapex.hxx>
  40 #include <vcl/gradient.hxx>
  41 #include <vcl/lineinfo.hxx>
  42
  43 #include <rtl/bootstrap.hxx>
  44
  45 #include <osl/time.h>
  46
  47 #include <functional>
  48
  49 #include <stdio.h>
  50
  51 using namespace ::com::sun::star;
  52
  53 namespace
  54 {
  55
  56 class GrindApp : public Application
  57 {
  58 public:
  59     virtual int Main() override;
  60     virtual void Exception( ExceptionCategory nCategory ) override;
  61 };
  62
  63 class TestWindow : public Dialog
  64 {
  65     public:
  66         TestWindow() : Dialog( nullptr )
  67         {
  68             SetText( "OutDev grinding" );
  69             SetSizePixel( Size( 1024, 1024 ) );
  70             EnablePaint( true );
  71             Show();
  72         }
  73
  74         virtual void Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect) override;
  75 };
  76
  77 typedef std::function<void (OutputDevice*)>   functor_type;
  78 typedef std::vector< std::pair<const char*,
  79                                functor_type> >  functor_vector_type;
  80
  81 template< typename Functor > void add( functor_vector_type& res,
  82                                        const char*          pStr,
  83                                        const Functor&       func )
  84 {
  85     res.push_back( std::make_pair(pStr,functor_type(func)) );
  86 }
  87
  88 void setupMethodStubs( functor_vector_type& res )
  89 {
  90     const Color aWhiteColor( COL_WHITE );
  91     const Color aBlackColor( COL_BLACK );
  92
  93     const Point aPt1(10,10);
  94     const Point aPt2(500,500);
  95     const Point aPt3(0,0);
  96     const Point aPt4(450,450);
  97
  98     const tools::Rectangle aRect(aPt1,aPt2);
  99     const tools::Rectangle   aRect2(aPt3,aPt4);
 100     const tools::Polygon aPoly(aRect);
 101     const tools::Polygon aPoly2(aRect2);
 102     tools::PolyPolygon aPolyPoly(aPoly);
 103     aPolyPoly.Insert( aPoly2 );
 104     tools::Polygon aPoly3(aPoly2);
 105     aPoly3.Rotate( aPoly3.GetBoundRect().Center(), 900 );
 106     const LineInfo    aLineInfo(LineStyle::Solid,5);
 107
 108 #ifdef FIXME_VDEV
 109     const OUString    aString("This is a test");
 110
 111     // unfortunately, VDevs have inaccessible copy constructors
 112     static VirtualDevice aVDev;
 113     static VirtualDevice aVDevBW(1);
 114
 115     const Size aVDevSize;
 116     aVDev.SetOutputSizePixel(aVDevSize);
 117     aVDevBW.SetOutputSizePixel(aVDevSize);
 118
 119     const Bitmap      aBitmap( aVDev.GetBitmap(aPt1,aVDevSize) );
 120     const Bitmap      aBitmapBW( aVDevBW.GetBitmap(aPt1,aVDevSize) );
 121     const Bitmap      aBitmapAlien( aVDevSize, 8 );
 122 #else
 123     BitmapEx aIntro;
 124     rtl::Bootstrap::set("BRAND_BASE_DIR", ".");
 125     if (Application::LoadBrandBitmap ("intro", aIntro))
 126         Application::Abort( "Failed to load intro image, run inside program/" );
 127
 128     const Bitmap      aBitmap( aIntro.GetBitmap() );
 129     Bitmap            aBitmapBW( aBitmap );
 130     aBitmapBW.Filter( BmpFilter::EmbossGrey );
 131     Bitmap      aBitmapAlien( Size( 100, 100 ), 8 );
 132     aBitmapAlien.Erase( COL_RED );
 133 #endif
 134
 135     const BitmapEx    aBitmapEx( aBitmap, aBitmapBW );
 136     const BitmapEx    aBitmapExBW( aBitmapBW, aBitmapBW );
 137     const BitmapEx    aBitmapExAlien( aBitmapAlien, aBitmapBW );
 138     const BitmapEx    aBitmapExAlpha( aBitmap, aBitmapAlien );
 139     const BitmapEx    aBitmapExAlphaAlien( aBitmapAlien, aBitmapAlien );
 140
 141 #ifdef NEEDS_QUALITY_PARAMETER
 142     const Image       aImage( aBitmapEx );
 143 #endif
 144     const Gradient    aGradient(GradientStyle::Elliptical,aBlackColor,aWhiteColor);
 145     const Hatch       aHatch(HatchStyle::Triple,aBlackColor,4,450);
 146     const Wallpaper   aWallpaper( aWhiteColor );
 147
 148     GDIMetaFile       aMtf;
 149     aMtf.AddAction( new MetaFillColorAction(Color(COL_RED),true) );
 150     aMtf.AddAction( new MetaRectAction(aRect) );
 151
 152 #ifdef FIXME_NEEDS_LOVE
 153     add(res,
 154         "DrawTextArray",
 155         [&] (OutputDevice * pDev) {
 156             return pDev->DrawTextArray(aPt1, aString, (const sal_Int32*)0, (sal_uInt16)0, aString.getLength());
 157         });
 158 #endif
 159
 160     /* void DrawPixel( const Point& rPt, const Color& rColor ); */
 161     add(res,
 162         "DrawPixel",
 163         [aPt1, aBlackColor](OutputDevice *pOutDev) { return pOutDev->DrawPixel(aPt1, aBlackColor); });
 164
 165     /* void DrawLine( const Point& rStartPt, const Point& rEndPt ); */
 166     add(res,
 167         "DrawLine",
 168         [aPt1, aPt2] (OutputDevice *pOutDev) { return pOutDev->DrawLine(aPt1, aPt2); });
 169
 170     /* void DrawLine( const Point& rStartPt, const Point& rEndPt,
 171                                   const LineInfo& rLineInfo );
 172     */
 173     add(res,
 174         "DrawLine(LineInfo)",
 175         [aPt1, aPt2, aLineInfo] (OutputDevice *pOutDev) { return pOutDev->DrawLine(aPt1, aPt2, aLineInfo); });
 176
 177     /* void DrawPolyLine( const Polygon& rPoly ); */
 178     add(res,
 179         "DrawPolyLine",
 180         [aPoly] (OutputDevice *pOutDev) {return pOutDev->DrawPolyLine(aPoly); });
 181
 182     /* void DrawPolyLine( const Polygon& rPoly,
 183                                       const LineInfo& rLineInfo );
 184     */
 185     add(res,
 186         "DrawPolyLine(LineInfo)",
 187         [aPoly, aLineInfo] (OutputDevice *pOutDev) { return pOutDev->DrawPolyLine(aPoly, aLineInfo); });
 188
 189     /* void DrawPolygon( const Polygon& rPoly ); */
 190     add(res,
 191         "DrawPolygon",
 192         [aPoly] (OutputDevice *pOutDev) { return pOutDev->DrawPolygon(aPoly);  });
 193
 194     /* void DrawPolyPolygon( const tools::PolyPolygon& rPolyPoly ); */
 195     add(res,
 196         "DrawPolyPolygon",
 197         [aPolyPoly] (OutputDevice *pOutDev) { return pOutDev->DrawPolyPolygon(aPolyPoly); });
 198
 199     /* void DrawRect( const Rectangle& rRect ); */
 200     add(res,
 201         "DrawRect",
 202         [aRect] (OutputDevice *pOutDev) { return pOutDev->DrawRect(aRect); });
 203
 204     /* void DrawRect( const Rectangle& rRect,
 205                                   sal_uLong nHorzRount, sal_uLong nVertRound );
 206     */
 207     add(res,
 208         "DrawRect(round corners)",
 209         [aRect2] (OutputDevice *pOutDev) { return pOutDev->DrawRect(aRect2,4,4); });
 210
 211     /* void DrawEllipse( const Rectangle& rRect ); */
 212     add(res,
 213         "DrawEllipse",
 214         [aRect] (OutputDevice *pOutDev) { return pOutDev->DrawEllipse(aRect); });
 215
 216     /* void DrawArc( const Rectangle& rRect,
 217                                  const Point& rStartPt, const Point& rEndPt );
 218     */
 219     add(res,
 220         "DrawArc",
 221         [aRect,aPt1,aPt2] (OutputDevice *pOutDev) { return pOutDev->DrawArc(aRect,aPt1,aPt2); });
 222
 223     /* void DrawPie( const Rectangle& rRect,
 224                                  const Point& rStartPt, const Point& rEndPt );
 225     */
 226     add(res,
 227         "DrawPie",
 228         [aRect2,aPt3,aPt4] (OutputDevice *pOutDev) { return pOutDev->DrawPie(aRect2,aPt3,aPt4); });
 229
 230     /* void DrawChord( const Rectangle& rRect,
 231                                    const Point& rStartPt, const Point& rEndPt );
 232     */
 233     add(res,
 234         "DrawChord",
 235         [aRect2,aPt3,aPt4] (OutputDevice *pOutDev) { return pOutDev->DrawChord(aRect2,aPt3,aPt4); });
 236
 237     /* void DrawOutDev( const Point& rDestPt, const Size& rDestSize,
 238                                     const Point& rSrcPt,  const Size& rSrcSize );
 239     */
 240     add(res,
 241         "DrawOutDev",
 242         [aRect,aRect2] (OutputDevice *pOutDev) { return pOutDev->DrawOutDev(aRect2.TopLeft(), aRect2.GetSize(),
 243                                                                             aRect.TopLeft(),  aRect.GetSize()); });
 244
 245 #ifdef FIXME_VDEV
 246     /* void DrawOutDev( const Point& rDestPt, const Size& rDestSize,
 247                                     const Point& rSrcPt,  const Size& rSrcSize,
 248                                     const OutputDevice& rOutDev );
 249     */
 250     add(res,
 251         "DrawOutDev(foreign source)",
 252         [&] (OutputDevice * pDev) {
 253             return pDev->DrawOutDev(aRect2.TopLeft(), aRect2.GetSize(),
 254                 aRect.TopLeft(), aRect.GetSize(), aVDevBW);
 255         });
 256
 257     /* void DrawOutDev( const Point& rDestPt, const Size& rDestSize,
 258                                     const Point& rSrcPt,  const Size& rSrcSize,
 259                                     const OutputDevice& rOutDev );
 260     */
 261     add(res,
 262         "DrawOutDev(foreign source, scaled)",
 263         [&] (OutputDevice * pDev) {
 264             return pDev->DrawOutDev(aRect2.TopLeft(), aRect2.GetSize(),
 265                 aRect.TopLeft(), aRect.GetSize(), aVDev);
 266         });
 267 #endif
 268
 269     /* void CopyArea( const Point& rDestPt,
 270                                   const Point& rSrcPt,  const Size& rSrcSize,
 271                                   sal_uInt16 nFlags = 0 );
 272     */
 273     add(res,
 274         "CopyArea",
 275         [&] (OutputDevice * pDev) { return pDev->CopyArea(aPt1, aPt3, aRect2.GetSize()); } );
 276
 277 #ifdef NEEDS_QUALITY_PARAMETER
 278     /* void DrawBitmap( const Point& rDestPt,
 279                                     const Bitmap& rBitmap );
 280     */
 281     add(res,
 282         "DrawBitmap(alien source)",
 283         [&] (OutputDevice * pDev) { return pDev->DrawBitmap(aPt1, aBitmapAlien); });
 284
 285     /* void DrawBitmap( const Point& rDestPt,
 286                                     const Bitmap& rBitmap );
 287     */
 288     add(res,
 289         "DrawBitmap",
 290         [&] (OutputDevice * pDev) { return pDev->DrawBitmap(aPt1, aBitmap); });
 291
 292     /* void DrawBitmap( const Point& rDestPt, const Size& rDestSize,
 293                                     const Bitmap& rBitmap );
 294     */
 295     add(res,
 296         "DrawBitmap(scaled,alien source)",
 297         [&] (OutputDevice * pDev) {
 298             return pDev->DrawBitmap(aPt1, aRect.GetSize(), aBitmapAlien);
 299         });
 300
 301     /* void DrawBitmap( const Point& rDestPt, const Size& rDestSize,
 302                                     const Bitmap& rBitmap );
 303     */
 304     add(res,
 305         "DrawBitmap(scaled)",
 306         [&] (OutputDevice * pDev) {
 307             return pDev->DrawBitmap(aPt1, aRect.GetSize(), aBitmap);
 308         });
 309
 310 #if 0
 311     /* void DrawBitmap( const Point& rDestPt, const Size& rDestSize,
 312                                     const Point& rSrcPtPixel, const Size& rSrcSizePixel,
 313                                     const Bitmap& rBitmap );
 314     */
 315     add(res,
 316         "DrawBitmap(scaled subset,alien source)",
 317         [&] (OutputDevice * pDev) {
 318                 return pDev->DrawBitmap(aPt1, aRect.GetSize(), aPt3,
 319                         aRect2.GetSize(), aBitmapAlien);
 320             });
 321 #endif
 322
 323     /* void DrawBitmap( const Point& rDestPt, const Size& rDestSize,
 324                                     const Point& rSrcPtPixel, const Size& rSrcSizePixel,
 325                                     const Bitmap& rBitmap );
 326     */
 327     add(res,
 328         "DrawBitmap(scaled subset)",
 329         [&] (OutputDevice * pDev) {
 330             return pDev->DrawBitmap(aPt1, aRect.GetSize(), aPt3, aRect2.GetSize(), aBitmap);
 331         });
 332
 333     /* void DrawBitmapEx( const Point& rDestPt,
 334                                       const BitmapEx& rBitmapEx );
 335     */
 336     add(res,
 337         "DrawBitmapEx(alien source)",
 338         [&] (OutputDevice * pDev) { return pDev->DrawBitmapEx(aPt1, aBitmapExAlien); });
 339
 340     /* void DrawBitmapEx( const Point& rDestPt,
 341                                       const BitmapEx& rBitmapEx );
 342     */
 343     add(res,
 344         "DrawBitmapEx",
 345         [&] (OutputDevice * pDev) { return pDev->DrawBitmapEx(aPt1, aBitmapEx); });
 346
 347     /* void DrawBitmapEx( const Point& rDestPt,
 348                                       const BitmapEx& rBitmapEx );
 349     */
 350     add(res,
 351         "DrawBitmapEx(alpha)",
 352         [&] (OutputDevice * pDev) { return pDev->DrawBitmapEx(aPt1, aBitmapExAlpha); });
 353
 354     /* void DrawBitmapEx( const Point& rDestPt,
 355                                       const BitmapEx& rBitmapEx );
 356     */
 357     add(res,
 358         "DrawBitmapEx(alpha, alien source)",
 359         [&] (OutputDevice * pDev) { return pDev->DrawBitmapEx(aPt1, aBitmapExAlphaAlien); });
 360
 361     /* void DrawBitmapEx( const Point& rDestPt, const Size& rDestSize,
 362                                       const BitmapEx& rBitmapEx );
 363     */
 364     add(res,
 365         "DrawBitmapEx(scaled,alien source)",
 366         [&] (OutputDevice * pDev) {
 367             return pDev->DrawBitmapEx(aPt1, aRect.GetSize(), aBitmapExAlien);
 368         });
 369
 370     /* void DrawBitmapEx( const Point& rDestPt, const Size& rDestSize,
 371                                       const BitmapEx& rBitmapEx );
 372     */
 373     add(res,
 374         "DrawBitmapEx(scaled)",
 375         [&] (OutputDevice * pDev) {
 376             return pDev->DrawBitmapEx(aPt1, aRect.GetSize(), aBitmapEx);
 377         });
 378
 379     /* void DrawBitmapEx( const Point& rDestPt, const Size& rDestSize,
 380                                       const BitmapEx& rBitmapEx );
 381     */
 382     add(res,
 383         "DrawBitmapEx(scaled alpha)",
 384         [&] (OutputDevice * pDev) {
 385             return pDev->DrawBitmapEx(aPt1, aRect.GetSize(), aBitmapExAlpha);
 386         });
 387
 388     /* void DrawBitmapEx( const Point& rDestPt, const Size& rDestSize,
 389                                       const BitmapEx& rBitmapEx );
 390     */
 391     add(res,
 392         "DrawBitmapEx(scaled alpha, alien source)",
 393         [&] (OutputDevice * pDev) {
 394             return pDev->DrawBitmapEx(aPt1, aRect.GetSize(), aBitmapExAlphaAlien);
 395         });
 396
 397     /* void DrawBitmapEx( const Point& rDestPt, const Size& rDestSize,
 398                                       const Point& rSrcPtPixel, const Size& rSrcSizePixel,
 399                                       const BitmapEx& rBitmapEx );
 400     */
 401     add(res,
 402         "DrawBitmapEx(scaled subset,alien source)",
 403         [&] (OutputDevice * pDev) {
 404             return pDev->DrawBitmapEx(aPt1, aRect.GetSize(), aPt3, aRect2.GetSize(), aBitmapExAlien);
 405         });
 406
 407     /* void DrawBitmapEx( const Point& rDestPt, const Size& rDestSize,
 408                                       const Point& rSrcPtPixel, const Size& rSrcSizePixel,
 409                                       const BitmapEx& rBitmapEx );
 410     */
 411     add(res,
 412         "DrawBitmapEx(scaled subset)",
 413         [&] (OutputDevice * pDev) {
 414             return pDev->DrawBitmapEx(aPt1, aRect.GetSize(), aPt3, aRect2.GetSize(), aBitmapEx);
 415         });
 416
 417     /* void DrawBitmapEx( const Point& rDestPt, const Size& rDestSize,
 418                                       const Point& rSrcPtPixel, const Size& rSrcSizePixel,
 419                                       const BitmapEx& rBitmapEx );
 420     */
 421     add(res,
 422         "DrawBitmapEx(scaled subset, alpha)",
 423         [&] (OutputDevice * pDev) {
 424             return pDev->DrawBitmapEx(aPt1, aRect.GetSize(), aPt3, aRect2.GetSize(), aBitmapExAlpha);
 425         });
 426
 427     /* void DrawBitmapEx( const Point& rDestPt, const Size& rDestSize,
 428                                       const Point& rSrcPtPixel, const Size& rSrcSizePixel,
 429                                       const BitmapEx& rBitmapEx );
 430     */
 431     add(res,
 432         "DrawBitmapEx(scaled subset, alpha alien source)",
 433         [&] (OutputDevice * pDev) {
 434             return pDev->DrawBitmapEx(aPt1, aRect.GetSize(), aPt3, aRect2.GetSize(), aBitmapExAlphaAlien);
 435         });
 436
 437     /* void DrawMask( const Point& rDestPt,
 438                                   const Bitmap& rBitmap, const Color& rMaskColor );
 439     */
 440     add(res,
 441         "DrawMask(alien source)",
 442         [&] (OutputDevice * pDev) {
 443             return pDev->DrawMask(aPt1, aBitmapAlien, aBlackColor);
 444         });
 445
 446     /* void DrawMask( const Point& rDestPt,
 447                                   const Bitmap& rBitmap, const Color& rMaskColor );
 448     */
 449     add(res,
 450         "DrawMask",
 451         [&] (OutputDevice * pDev) {
 452             return pDev->DrawMask(aPt1, aBitmap, aBlackColor);
 453         });
 454
 455     /* void DrawMask( const Point& rDestPt, const Size& rDestSize,
 456                                   const Bitmap& rBitmap, const Color& rMaskColor );
 457     */
 458     add(res,
 459         "DrawMask(scaled,alien source)",
 460         [&] (OutputDevice * pDev) {
 461             return pDev->DrawMask(aPt1, aRect.GetSize(), aBitmapAlien, aBlackColor);
 462         });
 463
 464     /* void DrawMask( const Point& rDestPt, const Size& rDestSize,
 465                                   const Bitmap& rBitmap, const Color& rMaskColor );
 466     */
 467     add(res,
 468         "DrawMask(scaled)",
 469         [&] (OutputDevice * pDev) {
 470             return pDev->DrawMask(aPt1, aRect.GetSize(), aBitmap, aBlackColor);
 471         });
 472
 473     /* void DrawMask( const Point& rDestPt, const Size& rDestSize,
 474                                   const Point& rSrcPtPixel, const Size& rSrcSizePixel,
 475                                   const Bitmap& rBitmap, const Color& rMaskColor );
 476     */
 477     add(res,
 478         "DrawMask(scaled subset,alien source)",
 479         [&] (OutputDevice * pDev) {
 480             return pDev->DrawMask(aPt1, aRect.GetSize(), aPt3, aRect2.GetSize(),
 481                     aBitmapAlien, aBlackColor);
 482         });
 483
 484     /* void DrawMask( const Point& rDestPt, const Size& rDestSize,
 485                                   const Point& rSrcPtPixel, const Size& rSrcSizePixel,
 486                                   const Bitmap& rBitmap, const Color& rMaskColor );
 487     */
 488     add(res,
 489         "DrawMask(scaled subset)",
 490         [&] (OutputDevice * pDev) {
 491             return pDev->DrawMask(aPt1, aRect.GetSize(), aPt3, aRect2.GetSize(), aBitmap, aBlackColor);
 492         });
 493
 494     /* void DrawImage( const Point& rPos,
 495                                    const Image& rImage, sal_uInt16 nStyle = 0 );
 496     */
 497     add(res,
 498         "DrawImage",
 499         [&] (OutputDevice * pDev) {
 500             return pDev->DrawImage(aPt1, aImage, static_cast<sal_uInt16>(0));
 501         });
 502
 503     /* void DrawImage( const Point& rPos, const Size& rSize,
 504                                    const Image& rImage, sal_uInt16 nStyle = 0 );
 505     */
 506     add(res,
 507         "DrawImage(scaled)",
 508         [&] (OutputDevice * pDev) {
 509             return pDev->DrawImage(aPt1, aRect.GetSize(), aImage, static_cast<sal_uInt16>(0)));
 510         });
 511
 512 #endif // NEEDS_QUALITY_PARAMETER
 513
 514     /* void DrawGradient( const Rectangle& rRect, const Gradient& rGradient ); */
 515     add(res,
 516         "DrawGradient",
 517         [&] (OutputDevice * pDev) {
 518             return pDev->DrawGradient(aRect, aGradient);
 519         });
 520
 521     /* void DrawGradient( const tools::PolyPolygon& rPolyPoly, const Gradient& rGradient ); */
 522     add(res,
 523         "DrawGradient(polygon)",
 524         [&] (OutputDevice * pDev) {
 525             return pDev->DrawGradient(aPoly3, aGradient);
 526         });
 527
 528     /* void DrawHatch( const tools::PolyPolygon& rPolyPoly, const Hatch& rHatch ); */
 529     add(res,
 530         "DrawHatch",
 531         [&] (OutputDevice * pDev) {
 532             return pDev->DrawHatch(aPoly3, aHatch);
 533         });
 534
 535     /* void DrawWallpaper( const Rectangle& rRect, const Wallpaper& rWallpaper ); */
 536     add(res,
 537         "DrawWallpaper",
 538         [&] (OutputDevice * pDev) {
 539             return pDev->DrawWallpaper(aRect2, aWallpaper);
 540         });
 541
 542 #ifdef FIXME_HAVE_WAVE_NORMAL
 543     /* void DrawWaveLine( const Point& rStartPos, const Point& rEndPos, sal_uInt16 nStyle ); */
 544     add(res,
 545         "DrawWaveLine",
 546         [&] (OutputDevice * pDev) {
 547             return pDev->DrawWaveLine(aPt1, aPt2, (sal_uInt16)WAVE_NORMAL);
 548         });
 549 #endif
 550
 551     /* void DrawGrid( const Rectangle& rRect, const Size& rDist, sal_uLong nFlags ); */
 552     add(res,
 553         "DrawGrid",
 554         [&] (OutputDevice * pDev) {
 555             return pDev->DrawGrid(aRect, Size(10,20), DrawGridFlags::HorzLines|DrawGridFlags::VertLines);
 556         });
 557
 558     /* void DrawTransparent( const tools::PolyPolygon& rPolyPoly,
 559                                          sal_uInt16 nTransparencePercent );
 560     */
 561     add(res,
 562         "DrawTransparent",
 563         [&] (OutputDevice * pDev) {
 564             return pDev->DrawTransparent(aPoly3, (sal_uInt16)50);
 565         });
 566
 567     /* void DrawTransparent( const GDIMetaFile& rMtf,
 568                                          const Point& rPos, const Size& rSize,
 569                                          const Gradient& rTransparenceGradient );
 570     */
 571     add(res,
 572         "DrawTransparent(metafile)",
 573         [&] (OutputDevice * pDev) {
 574             return pDev->DrawTransparent(aMtf, aPt1, aRect.GetSize(), aGradient);
 575         });
 576
 577     /* void Erase(); */
 578     add(res,
 579         "Erase",
 580         [] (OutputDevice * pDev) { return pDev->Erase(); } );
 581
 582 }
 583
 584 void grindFunc( OutputDevice&                       rTarget,
 585                 functor_vector_type::const_iterator const & iter,
 586                 sal_Int32                           nTurns,
 587                 const char*                         pMsg )
 588 {
 589     const sal_uInt32 nStartTime( osl_getGlobalTimer() );
 590
 591     for( sal_Int32 i=0; i<nTurns; ++i )
 592         iter->second(&rTarget);
 593
 594     if( rTarget.GetOutDevType() == OUTDEV_WINDOW )
 595         static_cast< vcl::Window & >( rTarget ).Flush();
 596
 597     fprintf( stdout,
 598              "Duration: %d ms (%d repetitions)\tOperation: %s\tSetup: %s\n",
 599              (int)(osl_getGlobalTimer() - nStartTime),
 600              (int)(nTurns),
 601              iter->first,
 602              pMsg );
 603 }
 604
 605 /** Call OutputDevice render methods repeatedly, and output elapsed
 606     time to stdout
 607  */
 608 void outDevGrind(vcl::RenderContext& rTarget)
 609 {
 610     sal_Int32 nTurns = 100;
 611     // TODO(F1): also profile pure complex clip setup times!
 612
 613     // State: fill/line color, draw mode, w/o clip, rect clip, complex clip
 614     functor_vector_type aMethods;
 615     setupMethodStubs( aMethods );
 616
 617     const tools::Rectangle aClipRect(10,10,1000,1000);
 618     const tools::Polygon aPoly1( aClipRect );
 619     tools::Polygon aPoly2( aClipRect );
 620     aPoly2.Rotate(aClipRect.Center(),450);
 621     tools::PolyPolygon     aClipPoly(aPoly1);
 622     aClipPoly.Insert(aPoly2);
 623
 624     functor_vector_type::const_iterator       iter = aMethods.begin();
 625     const functor_vector_type::const_iterator end  = aMethods.end();
 626     while( iter != end )
 627     {
 628         rTarget.SetLineColor( Color(COL_BLACK) );
 629         rTarget.SetFillColor( Color(COL_GREEN) );
 630         rTarget.SetRasterOp( RasterOp::OverPaint );
 631         rTarget.SetClipRegion();
 632         grindFunc( rTarget, iter, nTurns, "w/o clip, w/o xor" );
 633
 634         rTarget.SetLineColor( Color(COL_BLACK) );
 635         rTarget.SetFillColor( Color(COL_GREEN) );
 636         rTarget.SetRasterOp( RasterOp::OverPaint );
 637         rTarget.SetClipRegion( vcl::Region( aClipRect ) );
 638         grindFunc( rTarget, iter, nTurns, "with rect clip, w/o xor" );
 639
 640         rTarget.SetLineColor( Color(COL_BLACK) );
 641         rTarget.SetFillColor( Color(COL_GREEN) );
 642         rTarget.SetRasterOp( RasterOp::OverPaint );
 643         rTarget.SetClipRegion( vcl::Region( aClipPoly ) );
 644         grindFunc( rTarget, iter, nTurns, "with complex clip, w/o xor" );
 645
 646         rTarget.SetLineColor( Color(COL_BLACK) );
 647         rTarget.SetFillColor( Color(COL_GREEN) );
 648         rTarget.SetRasterOp( RasterOp::Xor );
 649         rTarget.SetClipRegion();
 650         grindFunc( rTarget, iter, nTurns, "w/o clip, with xor" );
 651
 652         rTarget.SetLineColor( Color(COL_BLACK) );
 653         rTarget.SetFillColor( Color(COL_GREEN) );
 654         rTarget.SetRasterOp( RasterOp::Xor );
 655         rTarget.SetClipRegion( vcl::Region( aClipRect ) );
 656         grindFunc( rTarget, iter, nTurns, "with rect clip, with xor" );
 657
 658         rTarget.SetLineColor( Color(COL_BLACK) );
 659         rTarget.SetFillColor( Color(COL_GREEN) );
 660         rTarget.SetRasterOp( RasterOp::Xor );
 661         rTarget.SetClipRegion( vcl::Region( aClipPoly ) );
 662         grindFunc( rTarget, iter, nTurns, "with complex clip, with xor" );
 663
 664         ++iter;
 665     }
 666 }
 667
 668 void TestWindow::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle&)
 669 {
 670     outDevGrind(rRenderContext);
 671     fflush(stdout);
 672 }
 673
 674 void GrindApp::Exception( ExceptionCategory nCategory )
 675 {
 676     switch( nCategory )
 677     {
 678         case ExceptionCategory::ResourceNotLoaded:
 679             Abort( "Error: could not load language resources.\nPlease check your installation.\n" );
 680             break;
 681         default: break;
 682     }
 683 }
 684
 685 int GrindApp::Main()
 686 {
 687     ScopedVclPtrInstance<TestWindow> aWindow;
 688     aWindow->Execute();
 689     return 0;
 690 }
 691
 692 } // namespace
 693
 694
 695 SAL_IMPLEMENT_MAIN()
 696 {
 697     try
 698     {
 699         bool bHelp = false;
 700
 701         for( sal_uInt16 i = 0; i < Application::GetCommandLineParamCount(); i++ )
 702         {
 703             OUString aParam = Application::GetCommandLineParam( i );
 704
 705             if( aParam == "--help" || aParam == "-h" )
 706                     bHelp = true;
 707         }
 708
 709         if( bHelp )
 710         {
 711             printf( "outdevgrind - Profile OutputDevice\n" );
 712             return EXIT_SUCCESS;
 713         }
 714
 715         tools::extendApplicationEnvironment();
 716
 717         uno::Reference< uno::XComponentContext > xContext = cppu::defaultBootstrap_InitialComponentContext();
 718         uno::Reference< lang::XMultiServiceFactory > xServiceManager( xContext->getServiceManager(), uno::UNO_QUERY );
 719
 720         if( !xServiceManager.is() )
 721             Application::Abort( "Failed to bootstrap" );
 722
 723         comphelper::setProcessServiceFactory( xServiceManager );
 724
 725         InitVCL();
 726
 727         GrindApp aGrindApp;
 728         aGrindApp.Main();
 729
 730         DeInitVCL();
 731     }
 732     catch (const css::uno::Exception& e)
 733     {
 734         SAL_WARN("vcl.app", "Fatal exception: " << e.Message);
 735         return EXIT_FAILURE;
 736     }
 737     catch (const std::exception& e)
 738     {
 739         SAL_WARN("vcl.app", "Fatal exception: " << e.what());
 740         return EXIT_FAILURE;
 741     }
 742
 743     return EXIT_SUCCESS;
 744 }
 745
 746 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */