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     long nWidth = rRect.GetWidth();
  41     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     long nWidth = rRect.GetWidth();
  56     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 class VisualBackendTestWindow : public WorkWindow
  87 {
  88 private:
  89     Timer maUpdateTimer;
  90     std::vector<std::chrono::high_resolution_clock::time_point> mTimePoints;
  91     static constexpr unsigned char gnNumberOfTests = 6;
  92     unsigned char mnTest;
  93     bool mbAnimate;
  94     ScopedVclPtr<VirtualDevice> mpVDev;
  95
  96 public:
  97     VisualBackendTestWindow()
  98         : WorkWindow(nullptr, WB_APP | WB_STDWORK)
  99         , mnTest(10 * gnNumberOfTests)
 100         , mbAnimate(mnTest % gnNumberOfTests == gnNumberOfTests - 1)
 101         , mpVDev(VclPtr<VirtualDevice>::Create())
 102     {
 103         maUpdateTimer.SetInvokeHandler(LINK(this, VisualBackendTestWindow, updateHdl));
 104         maUpdateTimer.SetPriority(TaskPriority::REPAINT);
 105         if (mbAnimate)
 106         {
 107             maUpdateTimer.SetTimeout(1000.0);
 108             maUpdateTimer.Start();
 109         }
 110     }
 111
 112     virtual ~VisualBackendTestWindow() override
 113     {
 114         disposeOnce();
 115     }
 116
 117     DECL_LINK(updateHdl, Timer*, void);
 118
 119     virtual void KeyInput(const KeyEvent& rKEvt) override
 120     {
 121         sal_uInt16 nCode = rKEvt.GetKeyCode().GetCode();
 122
 123         if (nCode == KEY_BACKSPACE)
 124             mnTest--;
 125         else if(nCode == KEY_SPACE)
 126             mnTest++;
 127
 128         if (nCode == KEY_BACKSPACE || nCode == KEY_SPACE)
 129         {
 130             if (mnTest % gnNumberOfTests == gnNumberOfTests - 1)
 131             {
 132                 mbAnimate = true;
 133                 maUpdateTimer.Start();
 134             }
 135             else
 136             {
 137                 mbAnimate = false;
 138                 Invalidate();
 139             }
 140         }
 141     }
 142
 143     static std::vector<tools::Rectangle> setupRegions(int nPartitionsX, int nPartitionsY, int nWidth, int nHeight)
 144     {
 145         std::vector<tools::Rectangle> aRegions;
 146
 147         for (int y = 0; y < nPartitionsY; y++)
 148         {
 149             for (int x = 0; x < nPartitionsX; x++)
 150             {
 151                 long x1 =  x    * (nWidth  / nPartitionsX);
 152                 long y1 =  y    * (nHeight / nPartitionsY);
 153                 long x2 = (x+1) * (nWidth  / nPartitionsX);
 154                 long y2 = (y+1) * (nHeight / nPartitionsY);
 155
 156                 aRegions.emplace_back(x1 + 1, y1 + 1, x2 - 2, y2 - 2);
 157             }
 158         }
 159         return aRegions;
 160     }
 161
 162     static void testRectangles(vcl::RenderContext& rRenderContext, int nWidth, int nHeight)
 163     {
 164         tools::Rectangle aRectangle;
 165         size_t index = 0;
 166
 167         std::vector<tools::Rectangle> aRegions = setupRegions(3, 2, nWidth, nHeight);
 168
 169         aRectangle = aRegions[index++];
 170         {
 171             vcl::test::OutputDeviceTestRect aOutDevTest;
 172             Bitmap aBitmap = aOutDevTest.setupRectangle(false);
 173             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkRectangle(aBitmap), aRectangle, rRenderContext);
 174             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 175         }
 176
 177         aRectangle = aRegions[index++];
 178         {
 179             vcl::test::OutputDeviceTestPixel aOutDevTest;
 180             Bitmap aBitmap = aOutDevTest.setupRectangle(false);
 181             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkRectangle(aBitmap), aRectangle, rRenderContext);
 182             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 183         }
 184
 185         aRectangle = aRegions[index++];
 186         {
 187             vcl::test::OutputDeviceTestLine aOutDevTest;
 188             Bitmap aBitmap = aOutDevTest.setupRectangle(false);
 189             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkRectangle(aBitmap), aRectangle, rRenderContext);
 190             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 191         }
 192
 193         aRectangle = aRegions[index++];
 194         {
 195             vcl::test::OutputDeviceTestPolygon aOutDevTest;
 196             Bitmap aBitmap = aOutDevTest.setupRectangle(false);
 197             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkRectangle(aBitmap), aRectangle, rRenderContext);
 198             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 199         }
 200
 201         aRectangle = aRegions[index++];
 202         {
 203             vcl::test::OutputDeviceTestPolyLine aOutDevTest;
 204             Bitmap aBitmap = aOutDevTest.setupRectangle(false);
 205             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkRectangle(aBitmap), aRectangle, rRenderContext);
 206             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 207         }
 208
 209         aRectangle = aRegions[index++];
 210         {
 211             vcl::test::OutputDeviceTestPolyPolygon aOutDevTest;
 212             Bitmap aBitmap = aOutDevTest.setupRectangle(false);
 213             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkRectangle(aBitmap), aRectangle, rRenderContext);
 214             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 215         }
 216     }
 217
 218     static void testFilledRectangles(vcl::RenderContext& rRenderContext, int nWidth, int nHeight)
 219     {
 220         tools::Rectangle aRectangle;
 221         size_t index = 0;
 222
 223         std::vector<tools::Rectangle> aRegions = setupRegions(3, 2, nWidth, nHeight);
 224
 225         aRectangle = aRegions[index++];
 226         {
 227             vcl::test::OutputDeviceTestRect aOutDevTest;
 228             Bitmap aBitmap = aOutDevTest.setupFilledRectangle();
 229             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkFilledRectangle(aBitmap), aRectangle, rRenderContext);
 230             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 231         }
 232
 233         aRectangle = aRegions[index++];
 234         {
 235             vcl::test::OutputDeviceTestPolygon aOutDevTest;
 236             Bitmap aBitmap = aOutDevTest.setupFilledRectangle();
 237             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkFilledRectangle(aBitmap), aRectangle, rRenderContext);
 238             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 239         }
 240
 241         aRectangle = aRegions[index++];
 242         {
 243             vcl::test::OutputDeviceTestPolyPolygon aOutDevTest;
 244             Bitmap aBitmap = aOutDevTest.setupFilledRectangle();
 245             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkFilledRectangle(aBitmap), aRectangle, rRenderContext);
 246             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 247         }
 248
 249         aRectangle = aRegions[index++];
 250         {
 251             vcl::test::OutputDeviceTestPolygon aOutDevTest;
 252             Bitmap aBitmap = aOutDevTest.setupDiamond();
 253             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkDiamond(aBitmap), aRectangle, rRenderContext);
 254             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 255         }
 256         aRectangle = aRegions[index++];
 257         {
 258             vcl::test::OutputDeviceTestLine aOutDevTest;
 259             Bitmap aBitmap = aOutDevTest.setupDiamond();
 260             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkDiamond(aBitmap), aRectangle, rRenderContext);
 261             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 262         }
 263         aRectangle = aRegions[index++];
 264         {
 265             vcl::test::OutputDeviceTestPolyLine aOutDevTest;
 266             Bitmap aBitmap = aOutDevTest.setupDiamond();
 267             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkDiamond(aBitmap), aRectangle, rRenderContext);
 268             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 269         }
 270     }
 271
 272     static void testLines(vcl::RenderContext& rRenderContext, int nWidth, int nHeight)
 273     {
 274         tools::Rectangle aRectangle;
 275         size_t index = 0;
 276
 277         std::vector<tools::Rectangle> aRegions = setupRegions(3, 2, nWidth, nHeight);
 278
 279         aRectangle = aRegions[index++];
 280         {
 281             vcl::test::OutputDeviceTestLine aOutDevTest;
 282             Bitmap aBitmap = aOutDevTest.setupLines();
 283             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkLines(aBitmap), aRectangle, rRenderContext);
 284             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 285         }
 286         aRectangle = aRegions[index++];
 287         {
 288             vcl::test::OutputDeviceTestPolyLine aOutDevTest;
 289             Bitmap aBitmap = aOutDevTest.setupLines();
 290             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkLines(aBitmap), aRectangle, rRenderContext);
 291             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 292         }
 293         aRectangle = aRegions[index++];
 294         {
 295             vcl::test::OutputDeviceTestPolygon aOutDevTest;
 296             Bitmap aBitmap = aOutDevTest.setupLines();
 297             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkLines(aBitmap), aRectangle, rRenderContext);
 298             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 299         }
 300         aRectangle = aRegions[index++];
 301         {
 302             vcl::test::OutputDeviceTestLine aOutDevTest;
 303             Bitmap aBitmap = aOutDevTest.setupAALines();
 304             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkAALines(aBitmap), aRectangle, rRenderContext);
 305             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 306         }
 307         aRectangle = aRegions[index++];
 308         {
 309             vcl::test::OutputDeviceTestPolyLine aOutDevTest;
 310             Bitmap aBitmap = aOutDevTest.setupAALines();
 311             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkAALines(aBitmap), aRectangle, rRenderContext);
 312             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 313         }
 314         aRectangle = aRegions[index++];
 315         {
 316             vcl::test::OutputDeviceTestPolygon aOutDevTest;
 317             Bitmap aBitmap = aOutDevTest.setupAALines();
 318             assertAndSetBackground(vcl::test::OutputDeviceTestCommon::checkAALines(aBitmap), aRectangle, rRenderContext);
 319             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 320         }
 321     }
 322
 323     static void testBitmaps(vcl::RenderContext& rRenderContext, int nWidth, int nHeight)
 324     {
 325         tools::Rectangle aRectangle;
 326         size_t index = 0;
 327
 328         std::vector<tools::Rectangle> aRegions = setupRegions(2, 2, nWidth, nHeight);
 329
 330         aRectangle = aRegions[index++];
 331         {
 332             vcl::test::OutputDeviceTestBitmap aOutDevTest;
 333             Bitmap aBitmap = aOutDevTest.setupDrawBitmap();
 334             assertAndSetBackground(vcl::test::OutputDeviceTestBitmap::checkTransformedBitmap(aBitmap), aRectangle, rRenderContext);
 335             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 336         }
 337         aRectangle = aRegions[index++];
 338         {
 339             vcl::test::OutputDeviceTestBitmap aOutDevTest;
 340             Bitmap aBitmap = aOutDevTest.setupDrawTransformedBitmap();
 341             assertAndSetBackground(vcl::test::OutputDeviceTestBitmap::checkTransformedBitmap(aBitmap), aRectangle, rRenderContext);
 342             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 343         }
 344         aRectangle = aRegions[index++];
 345         {
 346             vcl::test::OutputDeviceTestBitmap aOutDevTest;
 347             Bitmap aBitmap = aOutDevTest.setupDrawBitmapExWithAlpha();
 348             assertAndSetBackground(vcl::test::OutputDeviceTestBitmap::checkBitmapExWithAlpha(aBitmap), aRectangle, rRenderContext);
 349             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 350         }
 351         aRectangle = aRegions[index++];
 352         {
 353             vcl::test::OutputDeviceTestBitmap aOutDevTest;
 354             Bitmap aBitmap = aOutDevTest.setupDrawMask();
 355             assertAndSetBackground(vcl::test::OutputDeviceTestBitmap::checkMask(aBitmap), aRectangle, rRenderContext);
 356             drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 357         }
 358     }
 359
 360     virtual void Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& /*rRect*/) override
 361     {
 362         if (mnTest % gnNumberOfTests == gnNumberOfTests - 1)
 363         {
 364             rRenderContext.SetBackground(Wallpaper(COL_GREEN));
 365
 366             static size_t nTimeIndex = 0;
 367             static const size_t constSamplesFPS = 120;
 368             double fps = 0.0;
 369
 370             if (mTimePoints.size() < constSamplesFPS)
 371             {
 372                 mTimePoints.push_back(std::chrono::high_resolution_clock::now());
 373                 nTimeIndex++;
 374             }
 375             else
 376             {
 377                 size_t current = nTimeIndex % constSamplesFPS;
 378                 mTimePoints[current] = std::chrono::high_resolution_clock::now();
 379                 size_t last = (nTimeIndex + 1) % constSamplesFPS;
 380                 auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(mTimePoints[current] - mTimePoints[last]).count();
 381                 fps = constSamplesFPS * 1000.0 / ms;
 382                 nTimeIndex++;
 383             }
 384
 385             double fTime = 0.5 + std::sin(nTimeIndex / 100.0) / 2.0;
 386
 387             Size aSizePixel = GetSizePixel();
 388
 389             mpVDev->SetAntialiasing(AntialiasingFlags::EnableB2dDraw | AntialiasingFlags::PixelSnapHairline);
 390             mpVDev->SetOutputSizePixel(aSizePixel);
 391             mpVDev->SetBackground(Wallpaper(COL_LIGHTGRAY));
 392             mpVDev->Erase();
 393             mpVDev->SetFillColor(COL_LIGHTRED);
 394             mpVDev->SetLineColor(COL_LIGHTBLUE);
 395
 396             basegfx::B2DPolyPolygon polyPolygon;
 397
 398             for (int b=10; b<14; b++)
 399             {
 400                 basegfx::B2DPolygon polygon;
 401                 for (double a=0.0; a<360.0; a+=0.5)
 402                 {
 403                     double x = std::sin(basegfx::deg2rad(a)) * (b+1) * 20;
 404                     double y = std::cos(basegfx::deg2rad(a)) * (b+1) * 20;
 405                     polygon.append(basegfx::B2DPoint(x + 200 + 500 * fTime, y + 200 + 500 * fTime));
 406                 }
 407                 polygon.setClosed(true);
 408                 polyPolygon.append(polygon);
 409             }
 410
 411             mpVDev->DrawPolyPolygon(polyPolygon);
 412
 413             tools::Rectangle aGradientRect(Point(200, 200), Size(200 + fTime * 300, 200 + fTime * 300));
 414             mpVDev->DrawGradient(aGradientRect, Gradient(GradientStyle::Linear, COL_YELLOW, COL_BLUE));
 415
 416             rRenderContext.DrawOutDev(Point(), mpVDev->GetOutputSizePixel(),
 417                                       Point(), mpVDev->GetOutputSizePixel(),
 418                                       *mpVDev);
 419             rRenderContext.SetTextColor(COL_LIGHTRED);
 420             rRenderContext.DrawText(Point(10, 10), "FPS: " + OUString::number(int(fps)));
 421             return;
 422         }
 423
 424         rRenderContext.SetBackground(Wallpaper(COL_GREEN));
 425
 426         Size aSize = GetOutputSizePixel();
 427
 428         long nWidth = aSize.Width();
 429         long nHeight = aSize.Height();
 430
 431         tools::Rectangle aRectangle;
 432         size_t index = 0;
 433
 434         if (mnTest % gnNumberOfTests == 0)
 435         {
 436             testRectangles(rRenderContext, nWidth, nHeight);
 437         }
 438         else if (mnTest % gnNumberOfTests == 1)
 439         {
 440             testFilledRectangles(rRenderContext, nWidth, nHeight);
 441         }
 442         else if (mnTest % gnNumberOfTests == 2)
 443         {
 444             testLines(rRenderContext, nWidth, nHeight);
 445         }
 446         else if (mnTest % gnNumberOfTests == 3)
 447         {
 448             testBitmaps(rRenderContext, nWidth, nHeight);
 449         }
 450         else if (mnTest % gnNumberOfTests == 4)
 451         {
 452             std::vector<tools::Rectangle> aRegions = setupRegions(3, 2, nWidth, nHeight);
 453
 454             aRectangle = aRegions[index++];
 455             {
 456                 vcl::test::OutputDeviceTestAnotherOutDev aOutDevTest;
 457                 Bitmap aBitmap = aOutDevTest.setupDrawOutDev();
 458                 assertAndSetBackground(vcl::test::OutputDeviceTestAnotherOutDev::checkDrawOutDev(aBitmap), aRectangle, rRenderContext);
 459                 drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 460             }
 461             aRectangle = aRegions[index++];
 462             {
 463                 vcl::test::OutputDeviceTestAnotherOutDev aOutDevTest;
 464                 Bitmap aBitmap = aOutDevTest.setupXOR();
 465                 assertAndSetBackground(vcl::test::OutputDeviceTestAnotherOutDev::checkXOR(aBitmap), aRectangle, rRenderContext);
 466                 drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 467             }
 468             aRectangle = aRegions[index++];
 469             {
 470                 vcl::test::OutputDeviceTestGradient aOutDevTest;
 471                 Bitmap aBitmap = aOutDevTest.setupLinearGradient();
 472                 drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 473             }
 474             aRectangle = aRegions[index++];
 475             {
 476                 vcl::test::OutputDeviceTestGradient aOutDevTest;
 477                 Bitmap aBitmap = aOutDevTest.setupRadialGradient();
 478                 drawBitmapScaledAndCentered(aRectangle, aBitmap, rRenderContext);
 479             }
 480         }
 481     }
 482 };
 483
 484 IMPL_LINK_NOARG(VisualBackendTestWindow, updateHdl, Timer *, void)
 485 {
 486     if (mbAnimate)
 487     {
 488         maUpdateTimer.SetTimeout(1000.0 / 60.0);
 489         maUpdateTimer.Start();
 490         Invalidate();
 491     }
 492 }
 493
 494 class VisualBackendTestApp : public Application
 495 {
 496
 497 public:
 498     VisualBackendTestApp()
 499     {}
 500
 501     virtual int Main() override
 502     {
 503         try
 504         {
 505             ScopedVclPtrInstance<VisualBackendTestWindow> aMainWindow;
 506
 507             aMainWindow->SetText("VCL Test");
 508             aMainWindow->Show();
 509
 510             Application::Execute();
 511         }
 512         catch (const css::uno::Exception&)
 513         {
 514             DBG_UNHANDLED_EXCEPTION("vcl.app", "Fatal");
 515             return 1;
 516         }
 517         catch (const std::exception& rException)
 518         {
 519             SAL_WARN("vcl.app", "Fatal exception: " << rException.what());
 520             return 1;
 521         }
 522         return 0;
 523     }
 524
 525 protected:
 526     void Init() override
 527     {
 528         try
 529         {
 530             uno::Reference<uno::XComponentContext> xComponentContext = ::cppu::defaultBootstrap_InitialComponentContext();
 531             uno::Reference<lang::XMultiServiceFactory> xMSF(xComponentContext->getServiceManager(), uno::UNO_QUERY);
 532
 533             if (!xMSF.is())
 534                 Application::Abort("Bootstrap failure - no service manager");
 535
 536             comphelper::setProcessServiceFactory(xMSF);
 537         }
 538         catch (const uno::Exception &e)
 539         {
 540             Application::Abort("Bootstrap exception " + e.Message);
 541         }
 542     }
 543
 544     void DeInit() override
 545     {
 546         uno::Reference<lang::XComponent> xComponent(comphelper::getProcessComponentContext(), uno::UNO_QUERY_THROW);
 547         xComponent->dispose();
 548         comphelper::setProcessServiceFactory(nullptr);
 549     }
 550 };
 551
 552 void vclmain::createApplication()
 553 {
 554     static VisualBackendTestApp aApplication;
 555 }
 556
 557 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */