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