vcl/backendtest/VisualBackendTest.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
  10 #include <math.h>
  11 #include <sal/log.hxx>
  12
  13 #include <comphelper/processfactory.hxx>
  14 #include <cppuhelper/bootstrap.hxx>
  15 #include <com/sun/star/lang/XComponent.hpp>
  16 #include <com/sun/star/uno/XComponentContext.hpp>
  17 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  18
  19 #include <vcl/event.hxx>
  20 #include <vcl/gradient.hxx>
  21 #include <vcl/vclmain.hxx>
  22
  23 #include <vcl/svapp.hxx>
  24 #include <vcl/wrkwin.hxx>
  25 #include <vcl/virdev.hxx>
  26
  27 #include <basegfx/numeric/ftools.hxx>
  28 #include <tools/diagnose_ex.h>
  29
  30 #include <chrono>
  31 #include <iostream>
  32
  33 #include <test/outputdevice.hxx>
  34
  35 using namespace css;
  36
  37 static void drawBitmapCentered(tools::Rectangle const& rRect, const Bitmap& aBitmap,
  38                         vcl::RenderContext& rRenderContext)
  39 {
  40     tools::Long nWidth = rRect.GetWidth();
  41     tools::Long nHeight = rRect.GetHeight();
  42
  43     Size aBitmapSize(aBitmap.GetSizePixel());
  44
  45     Point aPoint(rRect.TopLeft());
  46
  47     aPoint.AdjustX((nWidth  - aBitmapSize.Width())  / 2 );
  48     aPoint.AdjustY((nHeight - aBitmapSize.Height()) / 2 );
  49
  50     rRenderContext.DrawBitmap(aPoint, aBitmap);
  51 }
  52
  53 static void drawBitmapScaledAndCentered(tools::Rectangle const & rRect, Bitmap aBitmap, vcl::RenderContext& rRenderContext, BmpScaleFlag aFlag = BmpScaleFlag::Fast)
  54 {
  55     tools::Long nWidth = rRect.GetWidth();
  56     tools::Long nHeight = rRect.GetHeight();
  57
  58     Size aBitmapSize(aBitmap.GetSizePixel());
  59
  60     double fWidthHeight = std::min(nWidth, nHeight);
  61     double fScale = fWidthHeight / aBitmapSize.Width();
  62     aBitmap.Scale(fScale, fScale, aFlag);
  63
  64     drawBitmapCentered(rRect, aBitmap, rRenderContext);
  65 }
  66
  67 static void drawBackgroundRect(tools::Rectangle const & rRect, Color aColor, vcl::RenderContext& rRenderContext)
  68 {
  69     rRenderContext.Push(PushFlags::LINECOLOR | PushFlags::FILLCOLOR);
  70     rRenderContext.SetFillColor(aColor);
  71     rRenderContext.SetLineColor(aColor);
  72     rRenderContext.DrawRect(rRect);
  73     rRenderContext.Pop();
  74 }
  75
  76 static void assertAndSetBackground(vcl::test::TestResult eResult, tools::Rectangle const & rRect, vcl::RenderContext& rRenderContext)
  77 {
  78     if (eResult == vcl::test::TestResult::Passed)
  79         drawBackgroundRect(rRect, COL_GREEN, rRenderContext);
  80     else if (eResult == vcl::test::TestResult::PassedWithQuirks)
  81         drawBackgroundRect(rRect, COL_YELLOW, rRenderContext);
  82     else if (eResult == vcl::test::TestResult::Failed)
  83         drawBackgroundRect(rRect, COL_RED, rRenderContext);
  84 }
  85
  86 namespace {
  87
  88 class VisualBackendTestWindow : public WorkWindow
  89 {
  90 private:
  91     Timer maUpdateTimer;
  92     std::vector<std::chrono::high_resolution_clock::time_point> mTimePoints;
  93     static constexpr unsigned char gnNumberOfTests = 11;
  94     unsigned char mnTest;
  95     bool mbAnimate;
  96     ScopedVclPtr<VirtualDevice> mpVDev;
  97
  98 public:
  99     VisualBackendTestWindow()
 100         : WorkWindow(nullptr, WB_APP | WB_STDWORK)
 101         , mnTest(10 * gnNumberOfTests)
 102         , mbAnimate(mnTest % gnNumberOfTests == gnNumberOfTests - 1)
 103         , mpVDev(VclPtr<VirtualDevice>::Create())
 104     {
 105         maUpdateTimer.SetInvokeHandler(LINK(this, VisualBackendTestWindow, updateHdl));
 106         maUpdateTimer.SetPriority(TaskPriority::DEFAULT_IDLE);
 107         if (mbAnimate)
 108         {
 109             maUpdateTimer.SetTimeout(1000.0);
 110             maUpdateTimer.Start();
 111         }
 112     }
 113
 114     virtual ~VisualBackendTestWindow() override
 115     {
 116         disposeOnce();
 117     }
 118
 119     DECL_LINK(updateHdl, Timer*, void);
 120
 121     virtual void KeyInput(const KeyEvent& rKEvt) override
 122     {
 123         sal_uInt16 nCode = rKEvt.GetKeyCode().GetCode();
 124
 125         if (nCode == KEY_BACKSPACE)
 126             mnTest--;
 127         else if(nCode == KEY_SPACE)
 128             mnTest++;
 129
 130         if (nCode != KEY_BACKSPACE && nCode != KEY_SPACE)
 131             return;
 132
 133         if (mnTest % gnNumberOfTests == gnNumberOfTests - 1)
 134         {
 135             mbAnimate = true;
 136             maUpdateTimer.Start();
 137         }
 138         else
 139         {
 140             mbAnimate = false;
 141             Invalidate();
 142         }
 143     }
 144
 145     static std::vector<tools::Rectangle> setupRegions(int nPartitionsX, int nPartitionsY, int nWidth, int nHeight)
 146     {
 147         std::vector<tools::Rectangle> aRegions;
 148
 149         for (int y = 0; y < nPartitionsY; y++)
 150         {
 151             for (int x = 0; x < nPartitionsX; x++)
 152             {
 153                 tools::Long x1 =  x    * (nWidth  / nPartitionsX);
 154                 tools::Long y1 =  y    * (nHeight / nPartitionsY);
 155                 tools::Long x2 = (x+1) * (nWidth  / nPartitionsX);
 156                 tools::Long y2 = (y+1) * (nHeight / nPartitionsY);
 157
 158                 aRegions.emplace_back(x1 + 1, y1 + 1, x2 - 6, y2 - 2);
 159             }
 160         }
 161         return aRegions;
 162     }
 163
 164     static void testRectangles(vcl::RenderContext& rRenderContext, int nWidth, int nHeight, bool AA)
 165     {
 166         tools::Rectangle aRectangle;
 167         size_t index = 0;
 168
 169         std::vector<tools::Rectangle> aRegions = setupRegions(4, 2, nWidth, nHeight);
 170
 171         aRectangle = aRegions[index++];
 172         {
 173             vcl::test::OutputDeviceTestRect aOutDevTest;
 174             Bitmap aBitmap = aOutDevTest.setupRectangle(AA);
 175             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkRectangle(aBitmap), aRectangle, rRenderContext);
 176             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 177         }
 178
 179         aRectangle = aRegions[index++];
 180         {
 181             vcl::test::OutputDeviceTestPixel aOutDevTest;
 182             Bitmap aBitmap = aOutDevTest.setupRectangle(AA);
 183             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkRectangle(aBitmap), aRectangle, rRenderContext);
 184             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 185         }
 186
 187         aRectangle = aRegions[index++];
 188         {
 189             vcl::test::OutputDeviceTestLine aOutDevTest;
 190             Bitmap aBitmap = aOutDevTest.setupRectangle(AA);
 191             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkRectangle(aBitmap), aRectangle, rRenderContext);
 192             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 193         }
 194
 195         aRectangle = aRegions[index++];
 196         {
 197             vcl::test::OutputDeviceTestPolygon aOutDevTest;
 198             Bitmap aBitmap = aOutDevTest.setupRectangle(AA);
 199             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkRectangle(aBitmap), aRectangle, rRenderContext);
 200             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 201         }
 202
 203         aRectangle = aRegions[index++];
 204         {
 205             vcl::test::OutputDeviceTestPolyLine aOutDevTest;
 206             Bitmap aBitmap = aOutDevTest.setupRectangle(AA);
 207             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkRectangle(aBitmap), aRectangle, rRenderContext);
 208             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 209         }
 210
 211         aRectangle = aRegions[index++];
 212         {
 213             vcl::test::OutputDeviceTestPolyLineB2D aOutDevTest;
 214             Bitmap aBitmap = aOutDevTest.setupRectangle(AA);
 215             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkRectangle(aBitmap), aRectangle, rRenderContext);
 216             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 217         }
 218
 219         aRectangle = aRegions[index++];
 220         {
 221             vcl::test::OutputDeviceTestPolyPolygon aOutDevTest;
 222             Bitmap aBitmap = aOutDevTest.setupRectangle(AA);
 223             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkRectangle(aBitmap), aRectangle, rRenderContext);
 224             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 225         }
 226
 227         aRectangle = aRegions[index++];
 228         {
 229             vcl::test::OutputDeviceTestPolyPolygonB2D aOutDevTest;
 230             Bitmap aBitmap = aOutDevTest.setupRectangle(AA);
 231             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkRectangle(aBitmap), aRectangle, rRenderContext);
 232             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 233         }
 234     }
 235
 236     static void testFilledRectangles(vcl::RenderContext& rRenderContext, int nWidth, int nHeight)
 237     {
 238         tools::Rectangle aRectangle;
 239         size_t index = 0;
 240
 241         std::vector<tools::Rectangle> aRegions = setupRegions(4, 2, nWidth, nHeight);
 242
 243         aRectangle = aRegions[index++];
 244         {
 245             vcl::test::OutputDeviceTestRect aOutDevTest;
 246             Bitmap aBitmap = aOutDevTest.setupFilledRectangle(false);
 247             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkFilledRectangle(aBitmap, false), aRectangle, rRenderContext);
 248             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 249         }
 250
 251         aRectangle = aRegions[index++];
 252         {
 253             vcl::test::OutputDeviceTestPolygon aOutDevTest;
 254             Bitmap aBitmap = aOutDevTest.setupFilledRectangle(false);
 255             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkFilledRectangle(aBitmap, false), aRectangle, rRenderContext);
 256             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 257         }
 258
 259         aRectangle = aRegions[index++];
 260         {
 261             vcl::test::OutputDeviceTestPolyPolygon aOutDevTest;
 262             Bitmap aBitmap = aOutDevTest.setupFilledRectangle(false);
 263             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkFilledRectangle(aBitmap, false), aRectangle, rRenderContext);
 264             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 265         }
 266
 267         aRectangle = aRegions[index++];
 268         {
 269             vcl::test::OutputDeviceTestPolyPolygonB2D aOutDevTest;
 270             Bitmap aBitmap = aOutDevTest.setupFilledRectangle(false);
 271             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkFilledRectangle(aBitmap, false), aRectangle, rRenderContext);
 272             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 273         }
 274
 275         aRectangle = aRegions[index++];
 276         {
 277             vcl::test::OutputDeviceTestRect aOutDevTest;
 278             Bitmap aBitmap = aOutDevTest.setupFilledRectangle(true);
 279             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkFilledRectangle(aBitmap, true), aRectangle, rRenderContext);
 280             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 281         }
 282
 283         aRectangle = aRegions[index++];
 284         {
 285             vcl::test::OutputDeviceTestPolygon aOutDevTest;
 286             Bitmap aBitmap = aOutDevTest.setupFilledRectangle(true);
 287             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkFilledRectangle(aBitmap, true), aRectangle, rRenderContext);
 288             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 289         }
 290
 291         aRectangle = aRegions[index++];
 292         {
 293             vcl::test::OutputDeviceTestPolyPolygon aOutDevTest;
 294             Bitmap aBitmap = aOutDevTest.setupFilledRectangle(true);
 295             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkFilledRectangle(aBitmap, true), aRectangle, rRenderContext);
 296             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 297         }
 298
 299         aRectangle = aRegions[index++];
 300         {
 301             vcl::test::OutputDeviceTestPolyPolygonB2D aOutDevTest;
 302             Bitmap aBitmap = aOutDevTest.setupFilledRectangle(true);
 303             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkFilledRectangle(aBitmap, true), aRectangle, rRenderContext);
 304             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 305         }
 306     }
 307
 308     static void testDiamondsAndBezier(vcl::RenderContext& rRenderContext, int nWidth, int nHeight)
 309     {
 310         tools::Rectangle aRectangle;
 311         size_t index = 0;
 312
 313         std::vector<tools::Rectangle> aRegions = setupRegions(3, 2, nWidth, nHeight);
 314
 315         aRectangle = aRegions[index++];
 316         {
 317             vcl::test::OutputDeviceTestPolygon aOutDevTest;
 318             Bitmap aBitmap = aOutDevTest.setupDiamond();
 319             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkDiamond(aBitmap), aRectangle, rRenderContext);
 320             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 321         }
 322         aRectangle = aRegions[index++];
 323         {
 324             vcl::test::OutputDeviceTestLine aOutDevTest;
 325             Bitmap aBitmap = aOutDevTest.setupDiamond();
 326             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkDiamond(aBitmap), aRectangle, rRenderContext);
 327             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 328         }
 329         aRectangle = aRegions[index++];
 330         {
 331             vcl::test::OutputDeviceTestPolyLine aOutDevTest;
 332             Bitmap aBitmap = aOutDevTest.setupDiamond();
 333             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkDiamond(aBitmap), aRectangle, rRenderContext);
 334             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 335         }
 336         aRectangle = aRegions[index++];
 337         {
 338             vcl::test::OutputDeviceTestPolyLineB2D aOutDevTest;
 339             Bitmap aBitmap = aOutDevTest.setupDiamond();
 340             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkDiamond(aBitmap), aRectangle, rRenderContext);
 341             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 342         }
 343
 344         aRectangle = aRegions[index++];
 345         {
 346             vcl::test::OutputDeviceTestPolyLineB2D aOutDevTest;
 347             Bitmap aBitmap = aOutDevTest.setupBezier();
 348             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkBezier(aBitmap), aRectangle, rRenderContext);
 349             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 350         }
 351         aRectangle = aRegions[index++];
 352         {
 353             vcl::test::OutputDeviceTestPolyLineB2D aOutDevTest;
 354             Bitmap aBitmap = aOutDevTest.setupAABezier();
 355             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkBezier(aBitmap), aRectangle, rRenderContext);
 356             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 357         }
 358     }
 359
 360     static void testLines(vcl::RenderContext& rRenderContext, int nWidth, int nHeight)
 361     {
 362         tools::Rectangle aRectangle;
 363         size_t index = 0;
 364
 365         std::vector<tools::Rectangle> aRegions = setupRegions(3, 2, nWidth, nHeight);
 366
 367         aRectangle = aRegions[index++];
 368         {
 369             vcl::test::OutputDeviceTestLine aOutDevTest;
 370             Bitmap aBitmap = aOutDevTest.setupLines();
 371             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkLines(aBitmap), aRectangle, rRenderContext);
 372             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 373         }
 374         aRectangle = aRegions[index++];
 375         {
 376             vcl::test::OutputDeviceTestPolyLine aOutDevTest;
 377             Bitmap aBitmap = aOutDevTest.setupLines();
 378             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkLines(aBitmap), aRectangle, rRenderContext);
 379             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 380         }
 381         aRectangle = aRegions[index++];
 382         {
 383             vcl::test::OutputDeviceTestPolygon aOutDevTest;
 384             Bitmap aBitmap = aOutDevTest.setupLines();
 385             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkLines(aBitmap), aRectangle, rRenderContext);
 386             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 387         }
 388         aRectangle = aRegions[index++];
 389         {
 390             vcl::test::OutputDeviceTestLine aOutDevTest;
 391             Bitmap aBitmap = aOutDevTest.setupAALines();
 392             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkAALines(aBitmap), aRectangle, rRenderContext);
 393             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 394         }
 395         aRectangle = aRegions[index++];
 396         {
 397             vcl::test::OutputDeviceTestPolyLine aOutDevTest;
 398             Bitmap aBitmap = aOutDevTest.setupAALines();
 399             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkAALines(aBitmap), aRectangle, rRenderContext);
 400             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 401         }
 402         aRectangle = aRegions[index++];
 403         {
 404             vcl::test::OutputDeviceTestPolygon aOutDevTest;
 405             Bitmap aBitmap = aOutDevTest.setupAALines();
 406             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkAALines(aBitmap), aRectangle, rRenderContext);
 407             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 408         }
 409     }
 410
 411     static void testBitmaps(vcl::RenderContext& rRenderContext, int nWidth, int nHeight)
 412     {
 413         tools::Rectangle aRectangle;
 414         size_t index = 0;
 415
 416         std::vector<tools::Rectangle> aRegions = setupRegions(3, 2, nWidth, nHeight);
 417
 418         aRectangle = aRegions[index++];
 419         {
 420             vcl::test::OutputDeviceTestBitmap aOutDevTest;
 421             Bitmap aBitmap = aOutDevTest.setupDrawBitmap();
 422             assertAndSetBackground(vcl::test::OutputDeviceTestBitmap::checkTransformedBitmap(aBitmap), aRectangle, rRenderContext);
 423             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 424         }
 425         aRectangle = aRegions[index++];
 426         {
 427             vcl::test::OutputDeviceTestBitmap aOutDevTest;
 428             Bitmap aBitmap = aOutDevTest.setupDrawTransformedBitmap();
 429             assertAndSetBackground(vcl::test::OutputDeviceTestBitmap::checkTransformedBitmap(aBitmap), aRectangle, rRenderContext);
 430             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 431         }
 432         aRectangle = aRegions[index++];
 433         {
 434             vcl::test::OutputDeviceTestBitmap aOutDevTest;
 435             Bitmap aBitmap = aOutDevTest.setupDrawBitmapExWithAlpha();
 436             assertAndSetBackground(vcl::test::OutputDeviceTestBitmap::checkBitmapExWithAlpha(aBitmap), aRectangle, rRenderContext);
 437             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 438         }
 439         aRectangle = aRegions[index++];
 440         {
 441             vcl::test::OutputDeviceTestBitmap aOutDevTest;
 442             Bitmap aBitmap = aOutDevTest.setupDrawMask();
 443             assertAndSetBackground(vcl::test::OutputDeviceTestBitmap::checkMask(aBitmap), aRectangle, rRenderContext);
 444             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 445         }
 446         aRectangle = aRegions[index++];
 447         {
 448             vcl::test::OutputDeviceTestBitmap aOutDevTest;
 449             BitmapEx aBitmap = aOutDevTest.setupDrawBlend();
 450             assertAndSetBackground(vcl::test::OutputDeviceTestBitmap::checkBlend(aBitmap), aRectangle, rRenderContext);
 451             drawBitmapScaledAndCentered(aRectangle, aBitmap.GetBitmap(), rRenderContext);
 452         }
 453     }
 454
 455     static void testInvert(vcl::RenderContext& rRenderContext, int nWidth, int nHeight)
 456     {
 457         tools::Rectangle aRectangle;
 458         size_t index = 0;
 459
 460         std::vector<tools::Rectangle> aRegions = setupRegions(2, 2, nWidth, nHeight);
 461
 462         aRectangle = aRegions[index++];
 463         {
 464             vcl::test::OutputDeviceTestRect aOutDevTest;
 465             Bitmap aBitmap = aOutDevTest.setupInvert_NONE();
 466             assertAndSetBackground(vcl::test::OutputDeviceTestRect::checkInvertRectangle(aBitmap), aRectangle, rRenderContext);
 467             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 468         }
 469         aRectangle = aRegions[index++];
 470         {
 471             vcl::test::OutputDeviceTestRect aOutDevTest;
 472             Bitmap aBitmap = aOutDevTest.setupInvert_N50();
 473             assertAndSetBackground(vcl::test::OutputDeviceTestRect::checkInvertN50Rectangle(aBitmap), aRectangle, rRenderContext);
 474             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 475         }
 476         aRectangle = aRegions[index++];
 477         {
 478             vcl::test::OutputDeviceTestRect aOutDevTest;
 479             Bitmap aBitmap = aOutDevTest.setupInvert_TrackFrame();
 480             assertAndSetBackground(vcl::test::OutputDeviceTestRect::checkInvertTrackFrameRectangle(aBitmap), aRectangle, rRenderContext);
 481             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 482         }
 483         aRectangle = aRegions[index++];
 484         {
 485             vcl::test::OutputDeviceTestAnotherOutDev aOutDevTest;
 486             Bitmap aBitmap = aOutDevTest.setupXOR();
 487             assertAndSetBackground(vcl::test::OutputDeviceTestAnotherOutDev::checkXOR(aBitmap), aRectangle, rRenderContext);
 488             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 489         }
 490     }
 491
 492     static void testClip(vcl::RenderContext& rRenderContext, int nWidth, int nHeight)
 493     {
 494         tools::Rectangle aRectangle;
 495         size_t index = 0;
 496
 497         std::vector<tools::Rectangle> aRegions = setupRegions(2, 2, nWidth, nHeight);
 498
 499         aRectangle = aRegions[index++];
 500         {
 501             vcl::test::OutputDeviceTestClip aOutDevTest;
 502             Bitmap aBitmap = aOutDevTest.setupClipRectangle();
 503             assertAndSetBackground(vcl::test::OutputDeviceTestClip::checkClip(aBitmap), aRectangle, rRenderContext);
 504             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 505         }
 506         aRectangle = aRegions[index++];
 507         {
 508             vcl::test::OutputDeviceTestClip aOutDevTest;
 509             Bitmap aBitmap = aOutDevTest.setupClipPolygon();
 510             assertAndSetBackground(vcl::test::OutputDeviceTestClip::checkClip(aBitmap), aRectangle, rRenderContext);
 511             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 512         }
 513         aRectangle = aRegions[index++];
 514         {
 515             vcl::test::OutputDeviceTestClip aOutDevTest;
 516             Bitmap aBitmap = aOutDevTest.setupClipPolyPolygon();
 517             assertAndSetBackground(vcl::test::OutputDeviceTestClip::checkClip(aBitmap), aRectangle, rRenderContext);
 518             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 519         }
 520         aRectangle = aRegions[index++];
 521         {
 522             vcl::test::OutputDeviceTestClip aOutDevTest;
 523             Bitmap aBitmap = aOutDevTest.setupClipB2DPolyPolygon();
 524             assertAndSetBackground(vcl::test::OutputDeviceTestClip::checkClip(aBitmap), aRectangle, rRenderContext);
 525             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 526         }
 527     }
 528
 529     static void testGradients(vcl::RenderContext& rRenderContext, int nWidth, int nHeight)
 530     {
 531         tools::Rectangle aRectangle;
 532         size_t index = 0;
 533
 534         std::vector<tools::Rectangle> aRegions = setupRegions(4, 2, nWidth, nHeight);
 535
 536         aRectangle = aRegions[index++];
 537         {
 538             vcl::test::OutputDeviceTestGradient aOutDevTest;
 539             Bitmap aBitmap = aOutDevTest.setupLinearGradient();
 540             assertAndSetBackground(vcl::test::OutputDeviceTestGradient::checkLinearGradient(aBitmap), aRectangle, rRenderContext);
 541             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 542         }
 543         aRectangle = aRegions[index++];
 544         {
 545             vcl::test::OutputDeviceTestGradient aOutDevTest;
 546             Bitmap aBitmap = aOutDevTest.setupLinearGradientAngled();
 547             assertAndSetBackground(vcl::test::OutputDeviceTestGradient::checkLinearGradientAngled(aBitmap), aRectangle, rRenderContext);
 548             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 549         }
 550         aRectangle = aRegions[index++];
 551         {
 552             vcl::test::OutputDeviceTestGradient aOutDevTest;
 553             Bitmap aBitmap = aOutDevTest.setupLinearGradientBorder();
 554             assertAndSetBackground(vcl::test::OutputDeviceTestGradient::checkLinearGradientBorder(aBitmap), aRectangle, rRenderContext);
 555             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 556         }
 557         aRectangle = aRegions[index++];
 558         {
 559             vcl::test::OutputDeviceTestGradient aOutDevTest;
 560             Bitmap aBitmap = aOutDevTest.setupLinearGradientIntensity();
 561             assertAndSetBackground(vcl::test::OutputDeviceTestGradient::checkLinearGradientIntensity(aBitmap), aRectangle, rRenderContext);
 562             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 563         }
 564         aRectangle = aRegions[index++];
 565         {
 566             vcl::test::OutputDeviceTestGradient aOutDevTest;
 567             Bitmap aBitmap = aOutDevTest.setupLinearGradientSteps();
 568             assertAndSetBackground(vcl::test::OutputDeviceTestGradient::checkLinearGradientSteps(aBitmap), aRectangle, rRenderContext);
 569             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 570         }
 571         aRectangle = aRegions[index++];
 572         {
 573             vcl::test::OutputDeviceTestGradient aOutDevTest;
 574             Bitmap aBitmap = aOutDevTest.setupAxialGradient();
 575             assertAndSetBackground(vcl::test::OutputDeviceTestGradient::checkAxialGradient(aBitmap), aRectangle, rRenderContext);
 576             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 577         }
 578         aRectangle = aRegions[index++];
 579         {
 580             vcl::test::OutputDeviceTestGradient aOutDevTest;
 581             Bitmap aBitmap = aOutDevTest.setupRadialGradient();
 582             assertAndSetBackground(vcl::test::OutputDeviceTestGradient::checkRadialGradient(aBitmap), aRectangle, rRenderContext);
 583             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 584         }
 585         aRectangle = aRegions[index++];
 586         {
 587             vcl::test::OutputDeviceTestGradient aOutDevTest;
 588             Bitmap aBitmap = aOutDevTest.setupRadialGradientOfs();
 589             assertAndSetBackground(vcl::test::OutputDeviceTestGradient::checkRadialGradientOfs(aBitmap), aRectangle, rRenderContext);
 590             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 591         }
 592     }
 593
 594     virtual void Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& /*rRect*/) override
 595     {
 596         if (mnTest % gnNumberOfTests == gnNumberOfTests - 1)
 597         {
 598             rRenderContext.SetBackground(Wallpaper(COL_GREEN));
 599
 600             static size_t nTimeIndex = 0;
 601             static const size_t constSamplesFPS = 120;
 602             double fps = 0.0;
 603
 604             if (mTimePoints.size() < constSamplesFPS)
 605             {
 606                 mTimePoints.push_back(std::chrono::high_resolution_clock::now());
 607                 nTimeIndex++;
 608             }
 609             else
 610             {
 611                 size_t current = nTimeIndex % constSamplesFPS;
 612                 mTimePoints[current] = std::chrono::high_resolution_clock::now();
 613                 size_t last = (nTimeIndex + 1) % constSamplesFPS;
 614                 auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(mTimePoints[current] - mTimePoints[last]).count();
 615                 fps = constSamplesFPS * 1000.0 / ms;
 616                 nTimeIndex++;
 617             }
 618
 619             double fTime = 0.5 + std::sin(nTimeIndex / 100.0) / 2.0;
 620
 621             Size aSizePixel = GetSizePixel();
 622
 623             mpVDev->SetAntialiasing(AntialiasingFlags::Enable | AntialiasingFlags::PixelSnapHairline);
 624             mpVDev->SetOutputSizePixel(aSizePixel);
 625             mpVDev->SetBackground(Wallpaper(COL_LIGHTGRAY));
 626             mpVDev->Erase();
 627             mpVDev->SetFillColor(COL_LIGHTRED);
 628             mpVDev->SetLineColor(COL_LIGHTBLUE);
 629
 630             basegfx::B2DPolyPolygon polyPolygon;
 631
 632             for (int b=10; b<14; b++)
 633             {
 634                 basegfx::B2DPolygon polygon;
 635                 for (double a=0.0; a<360.0; a+=0.5)
 636                 {
 637                     double x = std::sin(basegfx::deg2rad(a)) * (b+1) * 20;
 638                     double y = std::cos(basegfx::deg2rad(a)) * (b+1) * 20;
 639                     polygon.append(basegfx::B2DPoint(x + 200 + 500 * fTime, y + 200 + 500 * fTime));
 640                 }
 641                 polygon.setClosed(true);
 642                 polyPolygon.append(polygon);
 643             }
 644
 645             mpVDev->DrawPolyPolygon(polyPolygon);
 646
 647             tools::Rectangle aGradientRect(Point(200, 200), Size(200 + fTime * 300, 200 + fTime * 300));
 648             mpVDev->DrawGradient(aGradientRect, Gradient(GradientStyle::Linear, COL_YELLOW, COL_BLUE));
 649
 650             rRenderContext.DrawOutDev(Point(), mpVDev->GetOutputSizePixel(),
 651                                       Point(), mpVDev->GetOutputSizePixel(),
 652                                       *mpVDev);
 653             rRenderContext.SetTextColor(COL_LIGHTRED);
 654             rRenderContext.DrawText(Point(10, 10), "FPS: " + OUString::number(int(fps)));
 655             return;
 656         }
 657
 658         rRenderContext.SetBackground(Wallpaper(COL_GREEN));
 659
 660         Size aSize = GetOutputSizePixel();
 661
 662         tools::Long nWidth = aSize.Width();
 663         tools::Long nHeight = aSize.Height();
 664
 665         if (mnTest % gnNumberOfTests == 0)
 666         {
 667             testRectangles(rRenderContext, nWidth, nHeight, false);
 668         }
 669         else if (mnTest % gnNumberOfTests == 1)
 670         {
 671             testRectangles(rRenderContext, nWidth, nHeight, true);
 672         }
 673         else if (mnTest % gnNumberOfTests == 2)
 674         {
 675             testFilledRectangles(rRenderContext, nWidth, nHeight);
 676         }
 677         else if (mnTest % gnNumberOfTests == 3)
 678         {
 679             testDiamondsAndBezier(rRenderContext, nWidth, nHeight);
 680         }
 681         else if (mnTest % gnNumberOfTests == 4)
 682         {
 683             testLines(rRenderContext, nWidth, nHeight);
 684         }
 685         else if (mnTest % gnNumberOfTests == 5)
 686         {
 687             testBitmaps(rRenderContext, nWidth, nHeight);
 688         }
 689         else if (mnTest % gnNumberOfTests == 6)
 690         {
 691             testInvert(rRenderContext, nWidth, nHeight);
 692         }
 693         else if (mnTest % gnNumberOfTests == 7)
 694         {
 695             testClip(rRenderContext, nWidth, nHeight);
 696         }
 697         else if (mnTest % gnNumberOfTests == 8)
 698         {
 699             testGradients(rRenderContext, nWidth, nHeight);
 700         }
 701         else if (mnTest % gnNumberOfTests == 9)
 702         {
 703             std::vector<tools::Rectangle> aRegions = setupRegions(2, 1, nWidth, nHeight);
 704             size_t index = 0;
 705
 706             tools::Rectangle aRectangle = aRegions[index++];
 707             {
 708                 vcl::test::OutputDeviceTestAnotherOutDev aOutDevTest;
 709                 Bitmap aBitmap = aOutDevTest.setupDrawOutDev();
 710                 assertAndSetBackground(vcl::test::OutputDeviceTestAnotherOutDev::checkDrawOutDev(aBitmap), aRectangle, rRenderContext);
 711                 drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 712             }
 713             aRectangle = aRegions[index++];
 714             {
 715                 vcl::test::OutputDeviceTestLine aOutDevTest;
 716                 Bitmap aBitmap = aOutDevTest.setupDashedLine();
 717                 assertAndSetBackground(vcl::test::OutputDeviceTestLine::checkDashedLine(aBitmap), aRectangle, rRenderContext);
 718                 drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 719             }
 720         }
 721     }
 722 };
 723
 724 }
 725
 726 IMPL_LINK_NOARG(VisualBackendTestWindow, updateHdl, Timer *, void)
 727 {
 728     if (mbAnimate)
 729     {
 730         maUpdateTimer.SetTimeout(1.0);
 731         maUpdateTimer.Start();
 732         Invalidate();
 733     }
 734 }
 735
 736 namespace {
 737
 738 class VisualBackendTestApp : public Application
 739 {
 740
 741 public:
 742     VisualBackendTestApp()
 743     {}
 744
 745     virtual int Main() override
 746     {
 747         try
 748         {
 749             ScopedVclPtrInstance<VisualBackendTestWindow> aMainWindow;
 750
 751             aMainWindow->SetText("VCL Test");
 752             aMainWindow->Show();
 753
 754             Application::Execute();
 755         }
 756         catch (const css::uno::Exception&)
 757         {
 758             DBG_UNHANDLED_EXCEPTION("vcl.app", "Fatal");
 759             return 1;
 760         }
 761         catch (const std::exception& rException)
 762         {
 763             SAL_WARN("vcl.app", "Fatal exception: " << rException.what());
 764             return 1;
 765         }
 766         return 0;
 767     }
 768
 769 protected:
 770     void Init() override
 771     {
 772         try
 773         {
 774             uno::Reference<uno::XComponentContext> xComponentContext = ::cppu::defaultBootstrap_InitialComponentContext();
 775             uno::Reference<lang::XMultiServiceFactory> xMSF(xComponentContext->getServiceManager(), uno::UNO_QUERY);
 776
 777             if (!xMSF.is())
 778                 Application::Abort("Bootstrap failure - no service manager");
 779
 780             comphelper::setProcessServiceFactory(xMSF);
 781         }
 782         catch (const uno::Exception &e)
 783         {
 784             Application::Abort("Bootstrap exception " + e.Message);
 785         }
 786     }
 787
 788     void DeInit() override
 789     {
 790         uno::Reference<lang::XComponent> xComponent(comphelper::getProcessComponentContext(), uno::UNO_QUERY_THROW);
 791         xComponent->dispose();
 792         comphelper::setProcessServiceFactory(nullptr);
 793     }
 794 };
 795
 796 }
 797
 798 void vclmain::createApplication()
 799 {
 800     static VisualBackendTestApp aApplication;
 801 }
 802
 803 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */