vcl/qa/cppunit/svm/svmtest.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
  11 #include <sal/config.h>
  12
  13 #include <string_view>
  14
  15 #include <osl/endian.h>
  16 #include <test/bootstrapfixture.hxx>
  17 #include <test/xmltesttools.hxx>
  18 #include <vcl/gdimtf.hxx>
  19 #include <vcl/gradient.hxx>
  20 #include <vcl/hatch.hxx>
  21 #include <vcl/lineinfo.hxx>
  22 #include <vcl/virdev.hxx>
  23 #include <vcl/filter/PngImageWriter.hxx>
  24 #include <tools/fract.hxx>
  25 #include <vcl/metaact.hxx>
  26 #include <vcl/filter/SvmReader.hxx>
  27 #include <vcl/filter/SvmWriter.hxx>
  28 #include <salhelper/simplereferenceobject.hxx>
  29
  30 #include <bitmap/BitmapWriteAccess.hxx>
  31
  32 #include <basegfx/polygon/b2dpolypolygon.hxx>
  33
  34 #include <config_features.h>
  35 #include <config_fonts.h>
  36 #include <vcl/skia/SkiaHelper.hxx>
  37
  38 using namespace css;
  39
  40 class SvmTest : public test::BootstrapFixture, public XmlTestTools
  41 {
  42     OUString maDataUrl;
  43
  44     OUString getFullUrl(std::u16string_view sFileName)
  45     {
  46         return m_directories.getURLFromSrc(maDataUrl) + sFileName;
  47     }
  48
  49     void checkRendering(ScopedVclPtrInstance<VirtualDevice> const & pVirtualDev, const GDIMetaFile& rMetaFile);
  50
  51     // write GDI Metafile to a file in data directory
  52     // only use this for new tests to create the svm file
  53     void writeToFile(GDIMetaFile& rMetaFile, std::u16string_view rName);
  54
  55     GDIMetaFile writeAndReadStream(
  56         GDIMetaFile& rMetaFile, std::u16string_view rName = std::u16string_view());
  57
  58     GDIMetaFile readFile(std::u16string_view sName);
  59
  60     xmlDocUniquePtr dumpMeta(const GDIMetaFile& rMetaFile);
  61
  62     void checkVirtualDevice(const xmlDocUniquePtr& pDoc);
  63     void checkErase(const xmlDocUniquePtr& pDoc);
  64
  65     void checkPixel(const GDIMetaFile& rMetaFile);
  66     void testPixel();
  67
  68     void checkPoint(const GDIMetaFile& rMetaFile);
  69     void testPoint();
  70
  71     void checkLine(const GDIMetaFile& rMetaFile);
  72     void testLine();
  73
  74     void checkRect(const GDIMetaFile& rMetaFile);
  75     void testRect();
  76
  77     void checkRoundRect(const GDIMetaFile& rMetaFile);
  78     void testRoundRect();
  79
  80     void checkEllipse(const GDIMetaFile& rMetaFile);
  81     void testEllipse();
  82
  83     void checkArc(const GDIMetaFile& rMetaFile);
  84     void testArc();
  85
  86     void checkPie(const GDIMetaFile& rMetaFile);
  87     void testPie();
  88
  89     void checkChord(const GDIMetaFile& rMetaFile);
  90     void testChord();
  91
  92     void checkPolyLine(const GDIMetaFile& rMetaFile);
  93     void testPolyLine();
  94
  95     void checkPolygon(const GDIMetaFile& rMetaFile);
  96     void testPolygon();
  97
  98     void checkPolyPolygon(const GDIMetaFile& rMetaFile);
  99     void testPolyPolygon();
 100
 101     void checkText(const GDIMetaFile& rMetaFile);
 102     void testText();
 103
 104     void checkTextArray(const GDIMetaFile& rMetaFile);
 105     void testTextArray();
 106
 107     void checkstretchText(const GDIMetaFile& rMetaFile);
 108     void teststretchText();
 109
 110     void checkTextRect(const GDIMetaFile& rMetaFile);
 111     void testTextRect();
 112
 113     void checkTextLine(const GDIMetaFile& rMetaFile);
 114     void testTextLine();
 115
 116     void checkBitmaps(const GDIMetaFile& rMetaFile);
 117     void testBitmaps();
 118
 119     void checkBitmapExs(const GDIMetaFile& rMetaFile);
 120     void testBitmapExs();
 121
 122     void checkMasks(const GDIMetaFile& rMetaFile);
 123     void testMasks();
 124
 125     void checkGradient(const GDIMetaFile& rMetaFile);
 126     void testGradient();
 127
 128     void checkGradientEx(const GDIMetaFile& rMetaFile);
 129     void testGradientEx();
 130
 131     void checkHatch(const GDIMetaFile& rMetaFile);
 132     void testHatch();
 133
 134     void checkWallpaper(const GDIMetaFile& rMetaFile);
 135     void testWallpaper();
 136
 137     void checkClipRegion(const GDIMetaFile& rMetaFile);
 138     void testClipRegion();
 139
 140     void checkIntersectRectClipRegion(const GDIMetaFile& rMetaFile);
 141     void testIntersectRectClipRegion();
 142
 143     void checkIntersectRegionClipRegion(const GDIMetaFile& rMetaFile);
 144     void testIntersectRegionClipRegion();
 145
 146     void checkMoveClipRegion(const GDIMetaFile& rMetaFile);
 147     void testMoveClipRegion();
 148
 149     void checkLineColor(const GDIMetaFile& rMetaFile);
 150     void testLineColor();
 151
 152     void checkFillColor(const GDIMetaFile& rMetaFile);
 153     void testFillColor();
 154
 155     void checkTextColor(const GDIMetaFile& rMetaFile);
 156     void testTextColor();
 157
 158     void checkTextFillColor(const GDIMetaFile& rMetaFile);
 159     void testTextFillColor();
 160
 161     void checkTextLineColor(const GDIMetaFile& rMetaFile);
 162     void testTextLineColor();
 163
 164     void checkOverLineColor(const GDIMetaFile& rMetaFile);
 165     void testOverLineColor();
 166
 167     void checkTextAlign(const GDIMetaFile& rMetaFile);
 168     void testTextAlign();
 169
 170     void checkMapMode(const GDIMetaFile& rMetaFile);
 171     void testMapMode();
 172
 173 #if HAVE_MORE_FONTS && !defined(_WIN32)
 174     void checkFont(const GDIMetaFile& rMetaFile);
 175 #endif
 176     void testFont();
 177
 178     void checkPushPop(const GDIMetaFile& rMetaFile);
 179     void testPushPop();
 180
 181     void checkRasterOp(const GDIMetaFile& rMetaFile);
 182     void testRasterOp();
 183
 184     void checkTransparent(const GDIMetaFile& rMetaFile);
 185     void testTransparent();
 186
 187     void checkFloatTransparent(const GDIMetaFile& rMetaFile);
 188     void testFloatTransparent();
 189
 190     void checkEPS(const GDIMetaFile& rMetaFile);
 191     void testEPS();
 192
 193     void checkRefPoint(const GDIMetaFile& rMetaFile);
 194     void testRefPoint();
 195
 196     void checkComment(const GDIMetaFile& rMetaFile);
 197     void testComment();
 198
 199     void checkLayoutMode(const GDIMetaFile& rMetaFile);
 200     void testLayoutMode();
 201
 202     void checkTextLanguage(const GDIMetaFile& rMetaFile);
 203     void testTextLanguage();
 204
 205 public:
 206     SvmTest()
 207         : BootstrapFixture(true, false)
 208         , maDataUrl("/vcl/qa/cppunit/svm/data/")
 209     {}
 210
 211     CPPUNIT_TEST_SUITE(SvmTest);
 212     CPPUNIT_TEST(testPixel);
 213     CPPUNIT_TEST(testPoint);
 214     CPPUNIT_TEST(testLine);
 215     CPPUNIT_TEST(testRect);
 216     CPPUNIT_TEST(testRoundRect);
 217     CPPUNIT_TEST(testEllipse);
 218     CPPUNIT_TEST(testArc);
 219     CPPUNIT_TEST(testPie);
 220     CPPUNIT_TEST(testChord);
 221     CPPUNIT_TEST(testPolyLine);
 222     CPPUNIT_TEST(testPolygon);
 223     CPPUNIT_TEST(testPolyPolygon);
 224     CPPUNIT_TEST(testText);
 225     CPPUNIT_TEST(testTextArray);
 226     CPPUNIT_TEST(teststretchText);
 227     CPPUNIT_TEST(testTextRect);
 228     CPPUNIT_TEST(testTextLine);
 229     CPPUNIT_TEST(testBitmaps); // BMP, BMPSCALE, BMPSCALEPART
 230     CPPUNIT_TEST(testBitmapExs); // BMPEX, BMPEXSCALE, BMPEXSCALEPART
 231     CPPUNIT_TEST(testMasks); // MASK, MASKSCALE, MASKSCALEPART
 232     CPPUNIT_TEST(testGradient);
 233     CPPUNIT_TEST(testGradientEx);
 234     CPPUNIT_TEST(testHatch);
 235     CPPUNIT_TEST(testWallpaper);
 236     CPPUNIT_TEST(testClipRegion);
 237     CPPUNIT_TEST(testIntersectRectClipRegion);
 238     CPPUNIT_TEST(testIntersectRegionClipRegion);
 239     CPPUNIT_TEST(testMoveClipRegion);
 240     CPPUNIT_TEST(testLineColor);
 241     CPPUNIT_TEST(testFillColor);
 242     CPPUNIT_TEST(testTextColor);
 243     CPPUNIT_TEST(testTextFillColor);
 244     CPPUNIT_TEST(testTextLineColor);
 245     CPPUNIT_TEST(testOverLineColor);
 246     CPPUNIT_TEST(testTextAlign);
 247     CPPUNIT_TEST(testMapMode);
 248     CPPUNIT_TEST(testFont);
 249     CPPUNIT_TEST(testPushPop);
 250     CPPUNIT_TEST(testRasterOp);
 251     CPPUNIT_TEST(testTransparent);
 252     CPPUNIT_TEST(testFloatTransparent);
 253     CPPUNIT_TEST(testEPS);
 254     CPPUNIT_TEST(testRefPoint);
 255     CPPUNIT_TEST(testComment);
 256     CPPUNIT_TEST(testLayoutMode);
 257     CPPUNIT_TEST(testTextLanguage);
 258
 259     CPPUNIT_TEST_SUITE_END();
 260 };
 261
 262 static void setupBaseVirtualDevice(VirtualDevice& rDevice, GDIMetaFile& rMeta)
 263 {
 264     rDevice.SetConnectMetaFile(&rMeta);
 265     Size aVDSize(10, 10);
 266     rDevice.SetOutputSizePixel(aVDSize);
 267     rDevice.SetBackground(Wallpaper(COL_LIGHTRED));
 268     rDevice.Erase();
 269 }
 270
 271 void SvmTest::checkRendering(ScopedVclPtrInstance<VirtualDevice> const & pVirtualDev, const GDIMetaFile& rMetaFile)
 272 {
 273     BitmapEx aSourceBitmapEx = pVirtualDev->GetBitmapEx(Point(), Size(10, 10));
 274     ScopedVclPtrInstance<VirtualDevice> pVirtualDevResult;
 275     pVirtualDevResult->SetOutputSizePixel(Size(10, 10));
 276     const_cast<GDIMetaFile&>(rMetaFile).Play(*pVirtualDevResult);
 277     BitmapEx aResultBitmapEx = pVirtualDevResult->GetBitmapEx(Point(), Size(10, 10));
 278
 279     const bool bWriteCompareBitmap = false;
 280
 281     if (bWriteCompareBitmap)
 282     {
 283         utl::TempFileNamed aTempFile;
 284         aTempFile.EnableKillingFile();
 285
 286         {
 287             SvFileStream aStream(aTempFile.GetURL() + ".source.png", StreamMode::WRITE | StreamMode::TRUNC);
 288             vcl::PngImageWriter aPNGWriter(aStream);
 289             aPNGWriter.write(aSourceBitmapEx);
 290         }
 291         {
 292             SvFileStream aStream(aTempFile.GetURL() + ".result.png", StreamMode::WRITE | StreamMode::TRUNC);
 293             vcl::PngImageWriter aPNGWriter(aStream);
 294             aPNGWriter.write(aResultBitmapEx);
 295         }
 296     }
 297     CPPUNIT_ASSERT_EQUAL(aSourceBitmapEx.GetChecksum(), aResultBitmapEx.GetChecksum());
 298 }
 299
 300 static GDIMetaFile readMetafile(const OUString& rUrl)
 301 {
 302     GDIMetaFile aResultMetafile;
 303     SvFileStream aFileStream(rUrl, StreamMode::READ);
 304     aFileStream.Seek(STREAM_SEEK_TO_BEGIN);
 305     SvmReader aReader(aFileStream);
 306     aReader.Read(aResultMetafile);
 307     return aResultMetafile;
 308 }
 309
 310 static void writeMetaFile(GDIMetaFile& rInputMetafile, const OUString& rUrl)
 311 {
 312     SvFileStream aFileStream(rUrl, StreamMode::WRITE);
 313     aFileStream.Seek(STREAM_SEEK_TO_BEGIN);
 314     SvmWriter aWriter(aFileStream);
 315     aWriter.Write(rInputMetafile);
 316     aFileStream.Close();
 317 }
 318
 319 void SvmTest::writeToFile(GDIMetaFile& rMetaFile, std::u16string_view rName)
 320 {
 321     if (rName.empty())
 322         return;
 323     OUString sFilePath = getFullUrl(rName);
 324     writeMetaFile(rMetaFile, sFilePath);
 325 }
 326
 327 GDIMetaFile SvmTest::writeAndReadStream(GDIMetaFile& rMetaFile, std::u16string_view rName)
 328 {
 329     if (!rName.empty())
 330         writeToFile(rMetaFile, rName);
 331
 332     SvMemoryStream aStream;
 333     SvmWriter aWriter(aStream);
 334     aWriter.Write(rMetaFile);
 335     aStream.Seek(STREAM_SEEK_TO_BEGIN);
 336
 337     GDIMetaFile aResultMetafile;
 338     SvmReader aReader(aStream);
 339     aResultMetafile.Clear();
 340     aReader.Read(aResultMetafile);
 341     return aResultMetafile;
 342 }
 343
 344 GDIMetaFile SvmTest::readFile(std::u16string_view sName)
 345 {
 346     OUString sFilePath = getFullUrl(sName);
 347     return readMetafile(sFilePath);
 348 }
 349
 350 xmlDocUniquePtr SvmTest::dumpMeta(const GDIMetaFile& rMetaFile)
 351 {
 352     MetafileXmlDump dumper;
 353     xmlDocUniquePtr pDoc = dumpAndParse(dumper, rMetaFile);
 354     CPPUNIT_ASSERT (pDoc);
 355
 356     checkVirtualDevice(pDoc);
 357     checkErase(pDoc);
 358
 359     return pDoc;
 360 }
 361
 362 void SvmTest::checkVirtualDevice(const xmlDocUniquePtr& pDoc)
 363 {
 364     assertXPath(pDoc, "/metafile/linecolor[1]", "color", "#000000");
 365     assertXPath(pDoc, "/metafile/fillcolor[1]", "color", "#ffffff");
 366
 367     assertXPathAttrs(pDoc, "/metafile/rect[1]", {
 368         {"left", "0"},  {"top", "0"},
 369         {"right", "9"}, {"bottom", "9"}
 370     });
 371
 372     assertXPath(pDoc, "/metafile/linecolor[2]", "color", "#000000");
 373     assertXPath(pDoc, "/metafile/fillcolor[2]", "color", "#ffffff");
 374 }
 375
 376 void SvmTest::checkErase(const xmlDocUniquePtr& pDoc)
 377 {
 378     assertXPath(pDoc, "/metafile/linecolor[3]", "color", "#000000");
 379     assertXPath(pDoc, "/metafile/fillcolor[3]", "color", "#ff0000");
 380
 381     assertXPathAttrs(pDoc, "/metafile/rect[2]", {
 382         {"left", "0"},  {"top", "0"},
 383         {"right", "9"}, {"bottom", "9"}
 384     });
 385 }
 386
 387 void SvmTest::checkPixel(const GDIMetaFile& rMetaFile)
 388 {
 389     xmlDocUniquePtr pDoc = dumpMeta(rMetaFile);
 390
 391     assertXPathAttrs(pDoc, "/metafile/pixel[1]", {
 392         {"x", "8"}, {"y", "1"}, {"color", "#008000"},
 393     });
 394
 395     assertXPathAttrs(pDoc, "/metafile/pixel[2]", {
 396         {"x", "1"}, {"y", "8"}, {"color", "#000080"},
 397     });
 398 }
 399
 400 void SvmTest::testPixel()
 401 {
 402     GDIMetaFile aGDIMetaFile;
 403     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
 404     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
 405
 406     pVirtualDev->DrawPixel(Point(8, 1), COL_GREEN);
 407     pVirtualDev->DrawPixel(Point(1, 8), COL_BLUE);
 408
 409     checkPixel(writeAndReadStream(aGDIMetaFile));
 410     checkPixel(readFile(u"pixel.svm"));
 411 }
 412
 413 void SvmTest::checkPoint(const GDIMetaFile& rMetaFile)
 414 {
 415     xmlDocUniquePtr pDoc = dumpMeta(rMetaFile);
 416
 417     assertXPathAttrs(pDoc, "/metafile/point[1]", {
 418         {"x", "4"}, {"y", "4"}
 419     });
 420 }
 421
 422 void SvmTest::testPoint()
 423 {
 424     GDIMetaFile aGDIMetaFile;
 425     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
 426     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
 427
 428     pVirtualDev->DrawPixel(Point(4, 4));
 429
 430     checkPoint(writeAndReadStream(aGDIMetaFile));
 431     checkPoint(readFile(u"point.svm"));
 432 }
 433
 434 void SvmTest::checkLine(const GDIMetaFile& rMetaFile)
 435 {
 436     xmlDocUniquePtr pDoc = dumpMeta(rMetaFile);
 437
 438     assertXPathAttrs(pDoc, "/metafile/line[1]", {
 439         {"startx", "1"}, {"starty", "1"},
 440         {"endx", "8"},   {"endy", "8"},
 441     });
 442
 443     assertXPathAttrs(pDoc, "/metafile/line[1]", {
 444         {"style", "solid"}, {"width", "0"},
 445         {"dashlen", "0"},   {"dashcount", "0"},
 446         {"dotlen", "0"},    {"dotcount", "0"},
 447         {"distance", "0"},
 448         {"join", "round"},  {"cap", "butt"}
 449     });
 450
 451     assertXPathAttrs(pDoc, "/metafile/line[2]", {
 452         {"startx", "1"}, {"starty", "8"},
 453         {"endx", "8"},   {"endy", "1"},
 454     });
 455
 456     assertXPathAttrs(pDoc, "/metafile/line[2]", {
 457         {"style", "dash"},  {"width", "7"},
 458         {"dashlen", "5"},   {"dashcount", "4"},
 459         {"dotlen", "3"},    {"dotcount", "2"},
 460         {"distance", "1"},
 461         {"join", "miter"},  {"cap", "round"}
 462     });
 463 }
 464
 465 void SvmTest::testLine()
 466 {
 467     GDIMetaFile aGDIMetaFile;
 468     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
 469     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
 470
 471     pVirtualDev->DrawLine(Point(1, 1), Point(8, 8));
 472     LineInfo aLineInfo(LineStyle::Dash, 7);
 473     aLineInfo.SetDashLen(5);
 474     aLineInfo.SetDashCount(4);
 475     aLineInfo.SetDotLen(3);
 476     aLineInfo.SetDotCount(2);
 477     aLineInfo.SetDistance(1);
 478     aLineInfo.SetLineJoin(basegfx::B2DLineJoin::Miter);
 479     aLineInfo.SetLineCap(css::drawing::LineCap_ROUND);
 480     pVirtualDev->DrawLine(Point(1, 8), Point(8, 1), aLineInfo);
 481
 482     checkLine(writeAndReadStream(aGDIMetaFile));
 483     checkLine(readFile(u"line.svm"));
 484 }
 485
 486 void SvmTest::checkRect(const GDIMetaFile& rMetaFile)
 487 {
 488
 489     xmlDocUniquePtr pDoc = dumpMeta(rMetaFile);
 490
 491     assertXPath(pDoc, "/metafile/linecolor[5]", "color", "#123456");
 492     assertXPath(pDoc, "/metafile/fillcolor[5]", "color", "#654321");
 493
 494     assertXPathAttrs(pDoc, "/metafile/rect[3]", {
 495         {"left", "1"}, {"top", "2"},
 496         {"right", "4"},   {"bottom", "5"},
 497     });
 498 }
 499
 500 void SvmTest::testRect()
 501 {
 502     GDIMetaFile aGDIMetaFile;
 503     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
 504     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
 505
 506     pVirtualDev->SetLineColor(Color(0x123456));
 507     pVirtualDev->SetFillColor(Color(0x654321));
 508
 509     pVirtualDev->DrawRect(tools::Rectangle(Point(1, 2), Size(4, 4)));
 510
 511     checkRect(writeAndReadStream(aGDIMetaFile));
 512     checkRect(readFile(u"rect.svm"));
 513 }
 514
 515 void SvmTest::checkRoundRect(const GDIMetaFile& rMetaFile)
 516 {
 517     xmlDocUniquePtr pDoc = dumpMeta(rMetaFile);
 518
 519     assertXPath(pDoc, "/metafile/linecolor[5]", "color", "#123456");
 520     assertXPath(pDoc, "/metafile/fillcolor[5]", "color", "#654321");
 521
 522     assertXPathAttrs(pDoc, "/metafile/roundrect[1]", {
 523         {"left", "1"}, {"top", "2"},
 524         {"right", "4"},   {"bottom", "5"},
 525         {"horizontalround", "1"}, {"verticalround", "2"}
 526     });
 527 }
 528
 529 void SvmTest::testRoundRect()
 530 {
 531     GDIMetaFile aGDIMetaFile;
 532     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
 533     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
 534
 535     pVirtualDev->SetLineColor(Color(0x123456));
 536     pVirtualDev->SetFillColor(Color(0x654321));
 537
 538     pVirtualDev->DrawRect(tools::Rectangle(Point(1, 2), Size(4, 4)), 1, 2);
 539
 540     checkRoundRect(writeAndReadStream(aGDIMetaFile));
 541     checkRoundRect(readFile(u"roundrect.svm"));
 542 }
 543
 544 void SvmTest::checkEllipse(const GDIMetaFile& rMetaFile)
 545 {
 546     xmlDocUniquePtr pDoc = dumpMeta(rMetaFile);
 547
 548     assertXPath(pDoc, "/metafile/linecolor[5]", "color", "#123456");
 549     assertXPath(pDoc, "/metafile/fillcolor[5]", "color", "#654321");
 550
 551     assertXPathAttrs(pDoc, "/metafile/ellipse[1]", {
 552         {"left", "1"}, {"top", "2"},
 553         {"right", "4"},   {"bottom", "5"},
 554     });
 555 }
 556
 557 void SvmTest::testEllipse()
 558 {
 559     GDIMetaFile aGDIMetaFile;
 560     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
 561     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
 562
 563     pVirtualDev->SetLineColor(Color(0x123456));
 564     pVirtualDev->SetFillColor(Color(0x654321));
 565
 566     pVirtualDev->DrawEllipse(tools::Rectangle(Point(1, 2), Size(4, 4)));
 567
 568     checkEllipse(writeAndReadStream(aGDIMetaFile));
 569     checkEllipse(readFile(u"ellipse.svm"));
 570 }
 571
 572 void SvmTest::checkArc(const GDIMetaFile& rMetaFile)
 573 {
 574     xmlDocUniquePtr pDoc = dumpMeta(rMetaFile);
 575
 576     assertXPath(pDoc, "/metafile/linecolor[5]", "color", "#123456");
 577     assertXPath(pDoc, "/metafile/fillcolor[5]", "color", "#654321");
 578
 579     assertXPathAttrs(pDoc, "/metafile/arc[1]", {
 580         {"left",  "1"}, {"top",    "2"},
 581         {"right", "4"}, {"bottom", "5"},
 582
 583         {"startx", "10"}, {"starty", "11"},
 584         {"endx",   "12"}, {"endy",   "13"},
 585     });
 586 }
 587
 588 void SvmTest::testArc()
 589 {
 590     GDIMetaFile aGDIMetaFile;
 591     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
 592     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
 593
 594     pVirtualDev->SetLineColor(Color(0x123456));
 595     pVirtualDev->SetFillColor(Color(0x654321));
 596
 597     pVirtualDev->DrawArc(tools::Rectangle(Point(1, 2), Size(4, 4)), Point(10, 11), Point(12, 13));
 598
 599     checkArc(writeAndReadStream(aGDIMetaFile));
 600     checkArc(readFile(u"arc.svm"));
 601 }
 602
 603 void SvmTest::checkPie(const GDIMetaFile& rMetaFile)
 604 {
 605     xmlDocUniquePtr pDoc = dumpMeta(rMetaFile);
 606
 607     assertXPath(pDoc, "/metafile/linecolor[5]", "color", "#123456");
 608     assertXPath(pDoc, "/metafile/fillcolor[5]", "color", "#654321");
 609
 610     assertXPathAttrs(pDoc, "/metafile/pie[1]", {
 611         {"left",  "11"}, {"top",    "12"},
 612         {"right", "14"}, {"bottom", "15"},
 613
 614         {"startx", "20"}, {"starty", "21"},
 615         {"endx",   "22"}, {"endy",   "23"},
 616     });
 617 }
 618
 619 void SvmTest::testPie()
 620 {
 621     GDIMetaFile aGDIMetaFile;
 622     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
 623     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
 624
 625     pVirtualDev->SetLineColor(Color(0x123456));
 626     pVirtualDev->SetFillColor(Color(0x654321));
 627
 628     pVirtualDev->DrawPie(tools::Rectangle(Point(11, 12), Size(4, 4)), Point(20, 21), Point(22, 23));
 629
 630     checkPie(writeAndReadStream(aGDIMetaFile));
 631     checkPie(readFile(u"pie.svm"));
 632 }
 633
 634 void SvmTest::checkChord(const GDIMetaFile& rMetaFile)
 635 {
 636     xmlDocUniquePtr pDoc = dumpMeta(rMetaFile);
 637
 638     assertXPath(pDoc, "/metafile/linecolor[5]", "color", "#123456");
 639     assertXPath(pDoc, "/metafile/fillcolor[5]", "color", "#654321");
 640
 641     assertXPathAttrs(pDoc, "/metafile/chord[1]", {
 642         {"left",  "21"}, {"top",    "22"},
 643         {"right", "24"}, {"bottom", "25"},
 644
 645         {"startx", "30"}, {"starty", "31"},
 646         {"endx",   "32"}, {"endy",   "33"},
 647     });
 648 }
 649
 650 void SvmTest::testChord()
 651 {
 652     GDIMetaFile aGDIMetaFile;
 653     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
 654     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
 655
 656     pVirtualDev->SetLineColor(Color(0x123456));
 657     pVirtualDev->SetFillColor(Color(0x654321));
 658
 659     pVirtualDev->DrawChord(tools::Rectangle(Point(21, 22), Size(4, 4)), Point(30, 31), Point(32, 33));
 660
 661     checkChord(writeAndReadStream(aGDIMetaFile));
 662     checkChord(readFile(u"chord.svm"));
 663 }
 664
 665 void SvmTest::checkPolyLine(const GDIMetaFile& rMetaFile)
 666 {
 667     xmlDocUniquePtr pDoc = dumpMeta(rMetaFile);
 668
 669     assertXPathAttrs(pDoc, "/metafile/polyline[1]", {
 670         {"style", "solid"}, {"width", "0"},
 671         {"dashlen", "0"},   {"dashcount", "0"},
 672         {"dotlen", "0"},    {"dotcount", "0"},
 673         {"distance", "0"},
 674         {"join", "round"},  {"cap", "butt"}
 675     });
 676
 677     assertXPathAttrs(pDoc, "/metafile/polyline[1]/point[1]", {{"x", "1"}, {"y", "8"}});
 678     assertXPathAttrs(pDoc, "/metafile/polyline[1]/point[2]", {{"x", "2"}, {"y", "7"}});
 679     assertXPathAttrs(pDoc, "/metafile/polyline[1]/point[3]", {{"x", "3"}, {"y", "6"}});
 680
 681     assertXPathAttrs(pDoc, "/metafile/polyline[2]", {
 682         {"style", "dash"},  {"width", "7"},
 683         {"dashlen", "5"},   {"dashcount", "4"},
 684         {"dotlen", "3"},    {"dotcount", "2"},
 685         {"distance", "1"},
 686         {"join", "miter"},  {"cap", "round"}
 687     });
 688     assertXPathAttrs(pDoc, "/metafile/polyline[2]/point[1]", {{"x", "8"}, {"y", "1"}, {"flags", "normal"}});
 689     assertXPathAttrs(pDoc, "/metafile/polyline[2]/point[2]", {{"x", "7"}, {"y", "2"}, {"flags", "control"}});
 690     assertXPathAttrs(pDoc, "/metafile/polyline[2]/point[3]", {{"x", "6"}, {"y", "3"}, {"flags", "smooth"}});
 691     assertXPathAttrs(pDoc, "/metafile/polyline[2]/point[4]", {{"x", "5"}, {"y", "4"}, {"flags", "symmetric"}});
 692 }
 693
 694 void SvmTest::testPolyLine()
 695 {
 696     GDIMetaFile aGDIMetaFile;
 697     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
 698     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
 699
 700     tools::Polygon aPolygon(3);
 701     aPolygon.SetPoint(Point(1, 8), 0);
 702     aPolygon.SetPoint(Point(2, 7), 1);
 703     aPolygon.SetPoint(Point(3, 6), 2);
 704
 705     pVirtualDev->DrawPolyLine(aPolygon);
 706
 707     tools::Polygon aPolygonWithControl(4);
 708     aPolygonWithControl.SetPoint(Point(8, 1), 0);
 709     aPolygonWithControl.SetPoint(Point(7, 2), 1);
 710     aPolygonWithControl.SetPoint(Point(6, 3), 2);
 711     aPolygonWithControl.SetPoint(Point(5, 4), 3);
 712
 713     aPolygonWithControl.SetFlags(0, PolyFlags::Normal);
 714     aPolygonWithControl.SetFlags(1, PolyFlags::Control);
 715     aPolygonWithControl.SetFlags(2, PolyFlags::Smooth);
 716     aPolygonWithControl.SetFlags(3, PolyFlags::Symmetric);
 717
 718     LineInfo aLineInfo(LineStyle::Dash, 7);
 719     aLineInfo.SetDashLen(5);
 720     aLineInfo.SetDashCount(4);
 721     aLineInfo.SetDotLen(3);
 722     aLineInfo.SetDotCount(2);
 723     aLineInfo.SetDistance(1);
 724     aLineInfo.SetLineJoin(basegfx::B2DLineJoin::Miter);
 725     aLineInfo.SetLineCap(css::drawing::LineCap_ROUND);
 726
 727     pVirtualDev->DrawPolyLine(aPolygonWithControl, aLineInfo);
 728
 729     checkPolyLine(writeAndReadStream(aGDIMetaFile));
 730     checkPolyLine(readFile(u"polyline.svm"));
 731 }
 732
 733 void SvmTest::checkPolygon(const GDIMetaFile& rMetaFile)
 734 {
 735     xmlDocUniquePtr pDoc = dumpMeta(rMetaFile);
 736
 737     assertXPathAttrs(pDoc, "/metafile/polygon[1]/point[1]", {{"x", "1"}, {"y", "8"}});
 738     assertXPathAttrs(pDoc, "/metafile/polygon[1]/point[2]", {{"x", "2"}, {"y", "7"}});
 739     assertXPathAttrs(pDoc, "/metafile/polygon[1]/point[3]", {{"x", "3"}, {"y", "6"}});
 740
 741     assertXPathAttrs(pDoc, "/metafile/polygon[2]/point[1]", {{"x", "8"}, {"y", "1"}, {"flags", "normal"}});
 742     assertXPathAttrs(pDoc, "/metafile/polygon[2]/point[2]", {{"x", "7"}, {"y", "2"}, {"flags", "control"}});
 743     assertXPathAttrs(pDoc, "/metafile/polygon[2]/point[3]", {{"x", "6"}, {"y", "3"}, {"flags", "smooth"}});
 744     assertXPathAttrs(pDoc, "/metafile/polygon[2]/point[4]", {{"x", "5"}, {"y", "4"}, {"flags", "symmetric"}});
 745 }
 746
 747 void SvmTest::testPolygon()
 748 {
 749     GDIMetaFile aGDIMetaFile;
 750     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
 751     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
 752
 753     tools::Polygon aPolygon(3);
 754     aPolygon.SetPoint(Point(1, 8), 0);
 755     aPolygon.SetPoint(Point(2, 7), 1);
 756     aPolygon.SetPoint(Point(3, 6), 2);
 757
 758     pVirtualDev->DrawPolygon(aPolygon);
 759
 760     tools::Polygon aPolygonWithControl(4);
 761     aPolygonWithControl.SetPoint(Point(8, 1), 0);
 762     aPolygonWithControl.SetPoint(Point(7, 2), 1);
 763     aPolygonWithControl.SetPoint(Point(6, 3), 2);
 764     aPolygonWithControl.SetPoint(Point(5, 4), 3);
 765
 766     aPolygonWithControl.SetFlags(0, PolyFlags::Normal);
 767     aPolygonWithControl.SetFlags(1, PolyFlags::Control);
 768     aPolygonWithControl.SetFlags(2, PolyFlags::Smooth);
 769     aPolygonWithControl.SetFlags(3, PolyFlags::Symmetric);
 770
 771     pVirtualDev->DrawPolygon(aPolygonWithControl);
 772
 773     checkPolygon(writeAndReadStream(aGDIMetaFile));
 774     checkPolygon(readFile(u"polygon.svm"));
 775 }
 776
 777 void SvmTest::checkPolyPolygon(const GDIMetaFile& rMetaFile)
 778 {
 779     xmlDocUniquePtr pDoc = dumpMeta(rMetaFile);
 780
 781     assertXPathAttrs(pDoc, "/metafile/polypolygon[1]/polygon[1]/point[1]", {{"x", "1"}, {"y", "8"}});
 782     assertXPathAttrs(pDoc, "/metafile/polypolygon[1]/polygon[1]/point[2]", {{"x", "2"}, {"y", "7"}});
 783     assertXPathAttrs(pDoc, "/metafile/polypolygon[1]/polygon[1]/point[3]", {{"x", "3"}, {"y", "6"}});
 784
 785     assertXPathAttrs(pDoc, "/metafile/polypolygon[1]/polygon[2]/point[1]", {{"x", "8"}, {"y", "1"}, {"flags", "normal"}});
 786     assertXPathAttrs(pDoc, "/metafile/polypolygon[1]/polygon[2]/point[2]", {{"x", "7"}, {"y", "2"}, {"flags", "control"}});
 787     assertXPathAttrs(pDoc, "/metafile/polypolygon[1]/polygon[2]/point[3]", {{"x", "6"}, {"y", "3"}, {"flags", "smooth"}});
 788     assertXPathAttrs(pDoc, "/metafile/polypolygon[1]/polygon[2]/point[4]", {{"x", "5"}, {"y", "4"}, {"flags", "symmetric"}});
 789 }
 790
 791 void SvmTest::testPolyPolygon()
 792 {
 793     GDIMetaFile aGDIMetaFile;
 794     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
 795     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
 796
 797     tools::Polygon aPolygon(3);
 798     aPolygon.SetPoint(Point(1, 8), 0);
 799     aPolygon.SetPoint(Point(2, 7), 1);
 800     aPolygon.SetPoint(Point(3, 6), 2);
 801
 802     tools::Polygon aPolygonWithControl(4);
 803     aPolygonWithControl.SetPoint(Point(8, 1), 0);
 804     aPolygonWithControl.SetPoint(Point(7, 2), 1);
 805     aPolygonWithControl.SetPoint(Point(6, 3), 2);
 806     aPolygonWithControl.SetPoint(Point(5, 4), 3);
 807
 808     aPolygonWithControl.SetFlags(0, PolyFlags::Normal);
 809     aPolygonWithControl.SetFlags(1, PolyFlags::Control);
 810     aPolygonWithControl.SetFlags(2, PolyFlags::Smooth);
 811     aPolygonWithControl.SetFlags(3, PolyFlags::Symmetric);
 812
 813     tools::PolyPolygon aPolyPolygon(2);
 814     aPolyPolygon.Insert(aPolygon);
 815     aPolyPolygon.Insert(aPolygonWithControl);
 816
 817     pVirtualDev->DrawPolyPolygon(aPolyPolygon);
 818
 819     checkPolyPolygon(writeAndReadStream(aGDIMetaFile));
 820     checkPolyPolygon(readFile(u"polypolygon.svm"));
 821 }
 822
 823 void SvmTest::checkText(const GDIMetaFile& rMetaFile)
 824 {
 825     xmlDocUniquePtr pDoc = dumpMeta(rMetaFile);
 826
 827     assertXPathAttrs(pDoc, "/metafile/text[1]", {
 828         {"x", "4"}, {"y", "6"}, {"index", "1"}, {"length", "2"},
 829     });
 830
 831     assertXPathContent(pDoc, "/metafile/text[1]/textcontent", "xABC");
 832 }
 833
 834 void SvmTest::testText()
 835 {
 836     GDIMetaFile aGDIMetaFile;
 837     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
 838     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
 839
 840     pVirtualDev->DrawText(Point(4,6), "xABC", 1, 2);
 841
 842     checkText(writeAndReadStream(aGDIMetaFile));
 843     checkText(readFile(u"text.svm"));
 844 }
 845
 846 void SvmTest::checkTextArray(const GDIMetaFile& rMetaFile)
 847 {
 848     xmlDocUniquePtr pDoc = dumpMeta(rMetaFile);
 849
 850     assertXPathAttrs(pDoc, "/metafile/textarray[1]", {
 851         {"x", "4"}, {"y", "6"}, {"index", "1"}, {"length", "4"},
 852     });
 853     assertXPathContent(pDoc, "/metafile/textarray[1]/dxarray", "15 20 25 ");
 854     assertXPathContent(pDoc, "/metafile/textarray[1]/text", "123456");
 855 }
 856
 857 void SvmTest::testTextArray()
 858 {
 859     GDIMetaFile aGDIMetaFile;
 860     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
 861     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
 862     sal_Int32 const aDX[] = { 10, 15, 20, 25, 30, 35 };
 863     pVirtualDev->DrawTextArray(Point(4,6), "123456", KernArraySpan(aDX), {}, 1, 4);
 864
 865     checkTextArray(writeAndReadStream(aGDIMetaFile));
 866     checkTextArray(readFile(u"textarray.svm"));
 867 }
 868
 869 void SvmTest::checkstretchText(const GDIMetaFile& rMetaFile)
 870 {
 871     xmlDocUniquePtr pDoc = dumpMeta(rMetaFile);
 872
 873     assertXPathAttrs(pDoc, "/metafile/stretchtext[1]", {
 874         {"x", "4"}, {"y", "6"}, {"index", "1"}, {"length", "4"}, {"width", "10"}
 875     });
 876
 877     assertXPathContent(pDoc, "/metafile/stretchtext[1]/textcontent", "123456");
 878 }
 879
 880 void SvmTest::teststretchText()
 881 {
 882     GDIMetaFile aGDIMetaFile;
 883     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
 884     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
 885     pVirtualDev->DrawStretchText(Point(4,6), 10, "123456", 1, 4);
 886
 887     checkstretchText(writeAndReadStream(aGDIMetaFile));
 888     checkstretchText(readFile(u"strecthtext.svm"));
 889 }
 890
 891 void SvmTest::checkTextRect(const GDIMetaFile& rMetaFile)
 892 {
 893     xmlDocUniquePtr pDoc = dumpMeta(rMetaFile);
 894
 895     assertXPathAttrs(pDoc, "/metafile/textrect[1]", {
 896         {"left", "0"}, {"top", "0"}, {"right", "4"}, {"bottom", "4"}
 897     });
 898     assertXPathContent(pDoc, "/metafile/textrect[1]/textcontent", "123456");
 899     assertXPathContent(pDoc, "/metafile/textrect[1]/style", "Center");
 900 }
 901
 902 void SvmTest::testTextRect()
 903 {
 904     GDIMetaFile aGDIMetaFile;
 905     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
 906     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
 907     pVirtualDev->DrawText(tools::Rectangle(Point(0,0), Size(5,5)), "123456", DrawTextFlags::Center);
 908
 909     checkTextRect(writeAndReadStream(aGDIMetaFile));
 910     checkTextRect(readFile(u"textrectangle.svm"));
 911 }
 912
 913 void SvmTest::checkTextLine(const GDIMetaFile& rMetaFile)
 914 {
 915     xmlDocUniquePtr pDoc = dumpMeta(rMetaFile);
 916
 917     assertXPathAttrs(pDoc, "/metafile/textline[1]", {
 918         {"x", "4"}, {"y", "6"}, {"width", "10"},
 919         {"strikeout", "single"}, {"underline", "single"}, {"overline", "single"}
 920     });
 921 }
 922
 923 void SvmTest::testTextLine()
 924 {
 925     GDIMetaFile aGDIMetaFile;
 926     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
 927     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
 928     pVirtualDev->DrawTextLine(Point(4,6), 10, STRIKEOUT_SINGLE, LINESTYLE_SINGLE, LINESTYLE_SINGLE);
 929
 930     checkTextLine(writeAndReadStream(aGDIMetaFile));
 931     checkTextLine(readFile(u"textline.svm"));
 932 }
 933
 934 void SvmTest::checkBitmaps(const GDIMetaFile& rMetaFile)
 935 {
 936     xmlDocUniquePtr pDoc = dumpMeta(rMetaFile);
 937
 938     if (SkiaHelper::isVCLSkiaEnabled())
 939         return; // TODO SKIA using CRCs is broken (the idea of it)
 940
 941     assertXPathAttrs(pDoc, "/metafile/bmp[1]", {{"x", "1"}, {"y", "2"}, {"crc",
 942 #if defined OSL_BIGENDIAN
 943         "5e01ddcc"
 944 #else
 945         "469f0820"
 946 #endif
 947         }});
 948     assertXPathAttrs(pDoc, "/metafile/bmpscale[1]", {
 949         {"x", "1"}, {"y", "2"}, {"width", "3"}, {"height", "4"}, {"crc", "4937e32d"}
 950     });
 951     assertXPathAttrs(pDoc, "/metafile/bmpscalepart[1]", {
 952         {"destx", "1"}, {"desty", "2"}, {"destwidth", "3"}, {"destheight", "4"},
 953         {"srcx", "2"},  {"srcy", "1"},  {"srcwidth", "4"},  {"srcheight", "3"},
 954         {"crc",
 955 #if defined OSL_BIGENDIAN
 956          "b8dee5da"
 957 #else
 958          "3789377b"
 959 #endif
 960         }
 961     });
 962 }
 963
 964 void SvmTest::testBitmaps()
 965 {
 966     GDIMetaFile aGDIMetaFile;
 967     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
 968     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
 969
 970     Bitmap aBitmap1(Size(4,4), vcl::PixelFormat::N24_BPP);
 971     {
 972         BitmapScopedWriteAccess pAccess(aBitmap1);
 973         pAccess->Erase(COL_RED);
 974     }
 975     Bitmap aBitmap2(Size(4,4), vcl::PixelFormat::N24_BPP);
 976     {
 977         BitmapScopedWriteAccess pAccess(aBitmap2);
 978         pAccess->Erase(COL_GREEN);
 979     }
 980     Bitmap aBitmap3(Size(4,4), vcl::PixelFormat::N24_BPP);
 981     {
 982         BitmapScopedWriteAccess pAccess(aBitmap3);
 983         pAccess->Erase(COL_BLUE);
 984     }
 985     pVirtualDev->DrawBitmap(Point(1, 2), aBitmap1);
 986     pVirtualDev->DrawBitmap(Point(1, 2), Size(3, 4), aBitmap2);
 987     pVirtualDev->DrawBitmap(Point(1, 2), Size(3, 4), Point(2, 1), Size(4, 3), aBitmap3);
 988
 989     {
 990         GDIMetaFile aReloadedGDIMetaFile = writeAndReadStream(aGDIMetaFile);
 991         checkBitmaps(aReloadedGDIMetaFile);
 992         checkRendering(pVirtualDev, aReloadedGDIMetaFile);
 993     }
 994     {
 995         GDIMetaFile aFileGDIMetaFile = readFile(u"bitmaps.svm");
 996         checkBitmaps(aFileGDIMetaFile);
 997         checkRendering(pVirtualDev, aFileGDIMetaFile);
 998     }
 999 }
1000
1001 void SvmTest::checkBitmapExs(const GDIMetaFile& rMetaFile)
1002 {
1003     xmlDocUniquePtr pDoc = dumpMeta(rMetaFile);
1004
1005     if (SkiaHelper::isVCLSkiaEnabled())
1006         return; // TODO SKIA using CRCs is broken (the idea of it)
1007
1008     std::vector<OUString> aExpectedCRC;
1009     aExpectedCRC.insert(aExpectedCRC.end(),
1010     {
1011 #if defined OSL_BIGENDIAN
1012         "08feb5d3",
1013         "281fc589",
1014         "b8dee5da",
1015         "4df0e464",
1016         "186ff868",
1017         "33b4a07c", // 4-bit color bitmap - same as 8-bit color bitmap
1018         "33b4a07c",
1019         "742c3e35",
1020 #else
1021         "ac936607",
1022         "4937e32d",
1023         "3789377b",
1024         "839e8cce",
1025         "132f02c7",
1026         "2949ccc7", // 4-bit color bitmap - same as 8-bit color bitmap
1027         "2949ccc7",
1028         "e5df8aad",
1029 #endif
1030     });
1031
1032     assertXPathAttrs(pDoc, "/metafile/bmpex[1]", {
1033         {"x", "1"}, {"y", "1"}, {"crc", aExpectedCRC[0]}, {"transparenttype", "bitmap"}
1034     });
1035     assertXPathAttrs(pDoc, "/metafile/bmpexscale[1]", {
1036         {"x", "5"}, {"y", "0"}, {"width", "2"}, {"height", "3"},
1037         {"crc", aExpectedCRC[1]}, {"transparenttype", "bitmap"}
1038     });
1039     assertXPathAttrs(pDoc, "/metafile/bmpexscalepart[1]", {
1040         {"destx", "7"}, {"desty", "1"}, {"destwidth", "2"}, {"destheight", "2"},
1041         {"srcx", "0"},  {"srcy", "0"},  {"srcwidth", "3"},  {"srcheight", "4"},
1042         {"crc", aExpectedCRC[2]}, {"transparenttype", "bitmap"}
1043     });
1044
1045 #ifndef MACOSX
1046     assertXPathAttrs(pDoc, "/metafile/bmpex[2]", {
1047         {"x", "6"}, {"y", "6"}, {"crc", aExpectedCRC[3]}, {"transparenttype", "bitmap"}
1048     });
1049     assertXPathAttrs(pDoc, "/metafile/bmpex[3]", {
1050         {"x", "0"}, {"y", "6"}, {"crc", aExpectedCRC[4]}, {"transparenttype", "bitmap"}
1051     });
1052     assertXPathAttrs(pDoc, "/metafile/bmpex[4]", {
1053         {"x", "2"}, {"y", "6"}, {"crc", aExpectedCRC[5]}, {"transparenttype", "bitmap"}
1054     });
1055     assertXPathAttrs(pDoc, "/metafile/bmpex[5]", {
1056         {"x", "0"}, {"y", "8"}, {"crc", aExpectedCRC[6]}, {"transparenttype", "bitmap"}
1057     });
1058     assertXPathAttrs(pDoc, "/metafile/bmpex[6]", {
1059         {"x", "2"}, {"y", "8"}, {"crc", aExpectedCRC[7]}, {"transparenttype", "bitmap"}
1060     });
1061 #endif
1062 }
1063
1064 void SvmTest::testBitmapExs()
1065 {
1066     GDIMetaFile aGDIMetaFile;
1067     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
1068     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
1069
1070     // DrawBitmapEx
1071     {
1072         Bitmap aBitmap(Size(4,4), vcl::PixelFormat::N24_BPP);
1073         {
1074             BitmapScopedWriteAccess pAccess(aBitmap);
1075             pAccess->Erase(COL_YELLOW);
1076         }
1077
1078         pVirtualDev->DrawBitmapEx(Point(1, 1), BitmapEx(aBitmap, COL_WHITE));
1079     }
1080
1081     // DrawBitmapEx - Scale
1082     {
1083         Bitmap aBitmap(Size(4,4), vcl::PixelFormat::N24_BPP);
1084         {
1085             BitmapScopedWriteAccess pAccess(aBitmap);
1086             pAccess->Erase(COL_GREEN);
1087         }
1088         pVirtualDev->DrawBitmapEx(Point(5, 0), Size(2, 3), BitmapEx(aBitmap, COL_WHITE));
1089     }
1090
1091     // DrawBitmapEx - Scale - Part
1092     {
1093         Bitmap aBitmap(Size(4,4), vcl::PixelFormat::N24_BPP);
1094         {
1095             BitmapScopedWriteAccess pAccess(aBitmap);
1096             pAccess->Erase(COL_BLUE);
1097         }
1098         pVirtualDev->DrawBitmapEx(Point(7, 1), Size(2, 2), Point(0, 0), Size(3, 4), BitmapEx(aBitmap, COL_WHITE));
1099     }
1100
1101     // DrawBitmapEx - 50% transparent
1102     {
1103         Bitmap aBitmap(Size(4, 4), vcl::PixelFormat::N24_BPP);
1104         AlphaMask aAlpha(Size(4, 4));
1105         {
1106             BitmapScopedWriteAccess pAccess(aBitmap);
1107             pAccess->Erase(COL_MAGENTA);
1108
1109             AlphaScopedWriteAccess pAlphaAccess(aAlpha);
1110             pAlphaAccess->Erase(Color(128, 128, 128));
1111         }
1112         pVirtualDev->DrawBitmapEx(Point(6, 6), BitmapEx(aBitmap, aAlpha));
1113     }
1114
1115     // DrawBitmapEx - 1-bit
1116     {
1117         Bitmap aBitmap(Size(2, 2), vcl::PixelFormat::N24_BPP);
1118         {
1119             BitmapScopedWriteAccess pAccess(aBitmap);
1120             pAccess->Erase(COL_MAGENTA);
1121         }
1122         aBitmap.Convert(BmpConversion::N1BitThreshold);
1123         pVirtualDev->DrawBitmapEx(Point(0, 6), BitmapEx(aBitmap, COL_WHITE));
1124     }
1125
1126     // DrawBitmapEx - used to be 4-bit
1127     {
1128         Bitmap aBitmap(Size(2, 2), vcl::PixelFormat::N24_BPP);
1129         {
1130             BitmapScopedWriteAccess pAccess(aBitmap);
1131             pAccess->Erase(COL_MAGENTA);
1132         }
1133         aBitmap.Convert(BmpConversion::N8BitColors);
1134         pVirtualDev->DrawBitmapEx(Point(2, 6), BitmapEx(aBitmap, COL_WHITE));
1135     }
1136
1137     // DrawBitmapEx - 8-bit Color
1138     {
1139         Bitmap aBitmap(Size(2, 2), vcl::PixelFormat::N24_BPP);
1140         {
1141             BitmapScopedWriteAccess pAccess(aBitmap);
1142             pAccess->Erase(COL_MAGENTA);
1143         }
1144         aBitmap.Convert(BmpConversion::N8BitColors);
1145         pVirtualDev->DrawBitmapEx(Point(0, 8), BitmapEx(aBitmap, COL_WHITE));
1146     }
1147
1148     // DrawBitmapEx - 8-bit Grey
1149     {
1150         Bitmap aBitmap(Size(2, 2), vcl::PixelFormat::N24_BPP);
1151         {
1152             BitmapScopedWriteAccess pAccess(aBitmap);
1153             pAccess->Erase(COL_MAGENTA);
1154         }
1155         aBitmap.Convert(BmpConversion::N8BitGreys);
1156         pVirtualDev->DrawBitmapEx(Point(2, 8), BitmapEx(aBitmap, COL_WHITE));
1157     }
1158
1159     {
1160         GDIMetaFile aReloadedGDIMetaFile = writeAndReadStream(aGDIMetaFile);
1161         checkBitmapExs(aReloadedGDIMetaFile);
1162         checkRendering(pVirtualDev, aReloadedGDIMetaFile);
1163     }
1164     {
1165         GDIMetaFile aFileGDIMetaFile = readFile(u"bitmapexs.svm");
1166         checkBitmapExs(aFileGDIMetaFile);
1167         checkRendering(pVirtualDev, aFileGDIMetaFile);
1168     }
1169 }
1170
1171 void SvmTest::checkMasks(const GDIMetaFile& rMetaFile)
1172 {
1173     xmlDocUniquePtr pDoc = dumpMeta(rMetaFile);
1174
1175     assertXPathAttrs(pDoc, "/metafile/mask[1]", {
1176         {"x", "1"}, {"y", "2"},
1177         {"color", "#000000"}
1178     });
1179     assertXPathAttrs(pDoc, "/metafile/maskscale[1]", {
1180         {"x", "1"}, {"y", "2"}, {"width", "3"}, {"height", "4"},
1181         {"color", "#000000"}
1182     });
1183     assertXPathAttrs(pDoc, "/metafile/maskscalepart[1]", {
1184         {"destx", "1"}, {"desty", "2"}, {"destwidth", "3"}, {"destheight", "4"},
1185         {"srcx", "2"},  {"srcy", "1"},  {"srcwidth", "4"},  {"srcheight", "3"},
1186         {"color", "#ff0000"}
1187     });
1188 }
1189
1190 // TODO: Masks are kind-of special - we don't persist the color attribute (it is
1191 // always #000000) of the meta-action (which is wrong), but rely on alpha to do
1192 // the right thing.
1193 void SvmTest::testMasks()
1194 {
1195     GDIMetaFile aGDIMetaFile;
1196     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
1197     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
1198
1199     Bitmap aBitmap1(Size(4,4), vcl::PixelFormat::N24_BPP);
1200     {
1201         BitmapScopedWriteAccess pAccess(aBitmap1);
1202         pAccess->Erase(COL_RED);
1203     }
1204     Bitmap aBitmap2(Size(4,4), vcl::PixelFormat::N24_BPP);
1205     {
1206         BitmapScopedWriteAccess pAccess(aBitmap2);
1207         pAccess->Erase(COL_GREEN);
1208     }
1209     Bitmap aBitmap3(Size(4,4), vcl::PixelFormat::N24_BPP);
1210     {
1211         BitmapScopedWriteAccess pAccess(aBitmap3);
1212         pAccess->Erase(COL_BLUE);
1213     }
1214
1215     pVirtualDev->DrawMask(Point(1, 2), aBitmap1, COL_LIGHTRED);
1216     pVirtualDev->DrawMask(Point(1, 2), Size(3, 4), aBitmap2, COL_LIGHTRED);
1217     pVirtualDev->DrawMask(Point(1, 2), Size(3, 4), Point(2, 1), Size(4, 3), aBitmap3, COL_LIGHTRED, MetaActionType::MASKSCALEPART);
1218
1219     checkMasks(writeAndReadStream(aGDIMetaFile));
1220     checkMasks(readFile(u"masks.svm"));
1221 }
1222
1223 void SvmTest::checkGradient(const GDIMetaFile& rMetaFile)
1224 {
1225     xmlDocUniquePtr pDoc = dumpMeta(rMetaFile);
1226
1227     assertXPathAttrs(pDoc, "/metafile/gradient[1]", {
1228         {"style", "Linear"},
1229         {"startcolor", "#ffffff"},
1230         {"endcolor", "#000000"},
1231         {"angle", "0"},
1232         {"border", "0"},
1233         {"offsetx", "50"},
1234         {"offsety", "50"},
1235         {"startintensity", "100"},
1236         {"endintensity", "100"},
1237         {"steps", "0"},
1238     });
1239     assertXPathAttrs(pDoc, "/metafile/gradient[1]/rectangle", {
1240         {"left", "1"},
1241         {"top", "2"},
1242         {"right", "4"},
1243         {"bottom", "6"},
1244     });
1245
1246     assertXPathAttrs(pDoc, "/metafile/gradient[2]", {
1247         {"style", "Radial"},
1248         {"startcolor", "#ff0000"},
1249         {"endcolor", "#00ff00"},
1250         {"angle", "55"},
1251         {"border", "10"},
1252         {"offsetx", "22"},
1253         {"offsety", "24"},
1254         {"startintensity", "4"},
1255         {"endintensity", "14"},
1256         {"steps", "64"},
1257     });
1258     assertXPathAttrs(pDoc, "/metafile/gradient[2]/rectangle", {
1259         {"left", "3"},
1260         {"top", "4"},
1261         {"right", "3"},
1262         {"bottom", "5"},
1263     });
1264 }
1265
1266 void SvmTest::testGradient()
1267 {
1268     GDIMetaFile aGDIMetaFile;
1269     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
1270     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
1271
1272     tools::Rectangle aRectangle(Point(1, 2), Size(4,5));
1273
1274     Gradient aGradient(css::awt::GradientStyle_LINEAR, COL_WHITE, COL_BLACK);
1275     pVirtualDev->DrawGradient(aRectangle, aGradient);
1276
1277     tools::Rectangle aRectangle2(Point(3, 4), Size(1,2));
1278
1279     Gradient aGradient2;
1280     aGradient2.SetStyle(css::awt::GradientStyle_RADIAL);
1281     aGradient2.SetStartColor(COL_LIGHTRED);
1282     aGradient2.SetEndColor(COL_LIGHTGREEN);
1283     aGradient2.SetAngle(Degree10(55));
1284     aGradient2.SetBorder(10);
1285     aGradient2.SetOfsX(22);
1286     aGradient2.SetOfsY(24);
1287     aGradient2.SetStartIntensity(4);
1288     aGradient2.SetEndIntensity(14);
1289     aGradient2.SetSteps(64);
1290     pVirtualDev->DrawGradient(aRectangle2, aGradient2);
1291
1292     checkGradient(writeAndReadStream(aGDIMetaFile));
1293     checkGradient(readFile(u"gradient.svm"));
1294 }
1295
1296 void SvmTest::checkGradientEx(const GDIMetaFile& rMetaFile)
1297 {
1298     xmlDocUniquePtr pDoc = dumpMeta(rMetaFile);
1299
1300     assertXPathAttrs(pDoc, "/metafile/gradientex[1]", {
1301         {"style", "Linear"},
1302         {"startcolor", "#ffffff"},
1303         {"endcolor", "#000000"},
1304         {"angle", "0"},
1305         {"border", "0"},
1306         {"offsetx", "50"},
1307         {"offsety", "50"},
1308         {"startintensity", "100"},
1309         {"endintensity", "100"},
1310         {"steps", "0"}
1311     });
1312     assertXPathAttrs(pDoc, "/metafile/gradientex[1]/polygon/point[1]", {
1313         {"x", "1"},
1314         {"y", "8"}
1315     });
1316     assertXPathAttrs(pDoc, "/metafile/gradientex[1]/polygon/point[2]", {
1317         {"x", "2"},
1318         {"y", "7"}
1319     });
1320     assertXPathAttrs(pDoc, "/metafile/gradientex[1]/polygon/point[3]", {
1321         {"x", "3"},
1322         {"y", "6"}
1323     });
1324     assertXPathAttrs(pDoc, "/metafile/gradientex[2]", {
1325         {"style", "Axial"},
1326         {"startcolor", "#ff00ff"},
1327         {"endcolor", "#008080"},
1328         {"angle", "55"},
1329         {"border", "10"},
1330         {"offsetx", "22"},
1331         {"offsety", "24"},
1332         {"startintensity", "4"},
1333         {"endintensity", "14"},
1334         {"steps", "64"}
1335     });
1336     assertXPathAttrs(pDoc, "/metafile/gradientex[2]/polygon[1]/point[1]", {
1337         {"x", "1"},
1338         {"y", "2"}
1339     });
1340     assertXPathAttrs(pDoc, "/metafile/gradientex[2]/polygon[1]/point[2]", {
1341         {"x", "3"},
1342         {"y", "4"}
1343     });
1344     assertXPathAttrs(pDoc, "/metafile/gradientex[2]/polygon[2]/point[1]", {
1345         {"x", "8"},
1346         {"y", "9"}
1347     });
1348     assertXPathAttrs(pDoc, "/metafile/gradientex[2]/polygon[2]/point[2]", {
1349         {"x", "6"},
1350         {"y", "7"}
1351     });
1352 }
1353
1354 void SvmTest::testGradientEx()
1355 {
1356     GDIMetaFile aGDIMetaFile;
1357     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
1358     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
1359
1360     tools::Polygon aPolygon(3);
1361     aPolygon.SetPoint(Point(1, 8), 0);
1362     aPolygon.SetPoint(Point(2, 7), 1);
1363     aPolygon.SetPoint(Point(3, 6), 2);
1364
1365     tools::PolyPolygon aPolyPolygon(1);
1366     aPolyPolygon.Insert(aPolygon);
1367
1368     Gradient aGradient(css::awt::GradientStyle_LINEAR, COL_WHITE, COL_BLACK);
1369     pVirtualDev->DrawGradient(aPolyPolygon, aGradient);
1370
1371     tools::Polygon aPolygon2(2);
1372     aPolygon2.SetPoint(Point(1, 2), 0);
1373     aPolygon2.SetPoint(Point(3, 4), 1);
1374
1375     tools::Polygon aPolygon3(2);
1376     aPolygon3.SetPoint(Point(8, 9), 0);
1377     aPolygon3.SetPoint(Point(6, 7), 1);
1378
1379     tools::PolyPolygon aPolyPolygon2(1);
1380     aPolyPolygon2.Insert(aPolygon2);
1381     aPolyPolygon2.Insert(aPolygon3);
1382
1383     Gradient aGradient2;
1384     aGradient2.SetStyle(css::awt::GradientStyle_AXIAL);
1385     aGradient2.SetStartColor(COL_LIGHTMAGENTA);
1386     aGradient2.SetEndColor(COL_CYAN);
1387     aGradient2.SetAngle(Degree10(55));
1388     aGradient2.SetBorder(10);
1389     aGradient2.SetOfsX(22);
1390     aGradient2.SetOfsY(24);
1391     aGradient2.SetStartIntensity(4);
1392     aGradient2.SetEndIntensity(14);
1393     aGradient2.SetSteps(64);
1394     pVirtualDev->DrawGradient(aPolyPolygon2, aGradient2);
1395
1396     checkGradientEx(writeAndReadStream(aGDIMetaFile));
1397     checkGradientEx(readFile(u"gradientex.svm"));
1398 }
1399
1400 void SvmTest::checkHatch(const GDIMetaFile& rMetaFile)
1401 {
1402     xmlDocUniquePtr pDoc = dumpMeta(rMetaFile);
1403
1404     assertXPathAttrs(pDoc, "/metafile/hatch[1]/polygon/point[1]", {
1405         {"x", "1"}, {"y", "8"},
1406     });
1407     assertXPathAttrs(pDoc, "/metafile/hatch[1]/polygon/point[2]", {
1408         {"x", "2"}, {"y", "7"},
1409     });
1410     assertXPathAttrs(pDoc, "/metafile/hatch[1]/polygon/point[3]", {
1411         {"x", "3"}, {"y", "6"},
1412     });
1413
1414     assertXPathAttrs(pDoc, "/metafile/hatch[1]/hatch", {
1415         {"style", "Single"},
1416         {"color", "#ffff00"},
1417         {"distance", "15"},
1418         {"angle", "900"},
1419     });
1420 }
1421
1422 void SvmTest::testHatch()
1423 {
1424     GDIMetaFile aGDIMetaFile;
1425     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
1426     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
1427
1428     tools::Polygon aPolygon(3);
1429     aPolygon.SetPoint(Point(1, 8), 0);
1430     aPolygon.SetPoint(Point(2, 7), 1);
1431     aPolygon.SetPoint(Point(3, 6), 2);
1432
1433     tools::PolyPolygon aPolyPolygon(1);
1434     aPolyPolygon.Insert(aPolygon);
1435
1436     Hatch aHatch(HatchStyle::Single, COL_YELLOW, 15, 900_deg10);
1437
1438     pVirtualDev->DrawHatch(aPolyPolygon, aHatch);
1439
1440     checkHatch(writeAndReadStream(aGDIMetaFile));
1441     checkHatch(readFile(u"hatch.svm"));
1442 }
1443
1444 void SvmTest::checkWallpaper(const GDIMetaFile& rMetaFile)
1445 {
1446     xmlDocUniquePtr pDoc = dumpMeta(rMetaFile);
1447
1448     // Funny enough - we don't serialize the rectangle of the wallpaper so it's always EMPTY
1449     assertXPathAttrs(pDoc, "/metafile/wallpaper[1]",
1450     {
1451         {"left", "0"},
1452         {"top", "0"},
1453         {"right", "empty"},
1454         {"bottom", "empty"},
1455     });
1456
1457     assertXPathAttrs(pDoc, "/metafile/wallpaper[1]/wallpaper",
1458     {
1459         {"color", "#00ff00"},
1460         {"style", "Tile"},
1461         {"fixed", "true"},
1462         {"scrollable", "true"},
1463     });
1464 }
1465
1466 void SvmTest::testWallpaper()
1467 {
1468     GDIMetaFile aGDIMetaFile;
1469     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
1470     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
1471
1472     Wallpaper aWallpaper(COL_LIGHTGREEN);
1473     pVirtualDev->DrawWallpaper(tools::Rectangle(Point(1, 1), Size(3, 3)), aWallpaper);
1474
1475     checkWallpaper(writeAndReadStream(aGDIMetaFile));
1476     checkWallpaper(readFile(u"wallpaper.svm"));
1477 }
1478
1479 void SvmTest::checkClipRegion(const GDIMetaFile& rMetaFile)
1480 {
1481     xmlDocUniquePtr pDoc = dumpMeta(rMetaFile);
1482
1483     assertXPathAttrs(pDoc, "/metafile/clipregion[1]", {
1484         {"left", "2"},
1485         {"top", "2"},
1486         {"right", "5"},
1487         {"bottom", "5"},
1488     });
1489
1490     assertXPathAttrs(pDoc, "/metafile/clipregion[2]/polygon[1]/point[1]", {
1491         {"x", "1"},
1492         {"y", "8"}
1493     });
1494
1495     assertXPathAttrs(pDoc, "/metafile/clipregion[2]/polygon[1]/point[2]", {
1496         {"x", "2"},
1497         {"y", "7"}
1498     });
1499
1500     assertXPathAttrs(pDoc, "/metafile/clipregion[2]/polygon[1]/point[3]", {
1501         {"x", "3"},
1502         {"y", "6"}
1503     });
1504
1505     assertXPathAttrs(pDoc, "/metafile/clipregion[3]/polygon[1]/point[1]", {
1506         {"x", "1"},
1507         {"y", "8"}
1508     });
1509
1510     assertXPathAttrs(pDoc, "/metafile/clipregion[3]/polygon[1]/point[2]", {
1511         {"x", "2"},
1512         {"y", "7"}
1513     });
1514
1515     assertXPathAttrs(pDoc, "/metafile/clipregion[3]/polygon[1]/point[3]", {
1516         {"x", "3"},
1517         {"y", "6"}
1518     });
1519
1520     assertXPathAttrs(pDoc, "/metafile/clipregion[3]/polygon[2]/point[1]", {
1521         {"x", "4"},
1522         {"y", "9"}
1523     });
1524
1525     assertXPathAttrs(pDoc, "/metafile/clipregion[3]/polygon[2]/point[2]", {
1526         {"x", "5"},
1527         {"y", "10"}
1528     });
1529
1530     assertXPathAttrs(pDoc, "/metafile/clipregion[3]/polygon[2]/point[3]", {
1531         {"x", "6"},
1532         {"y", "11"}
1533     });
1534
1535     assertXPathAttrs(pDoc, "/metafile/clipregion[4]/polygon[1]/point[1]", {
1536         {"x", "0"},
1537         {"y", "1"}
1538     });
1539
1540     assertXPathAttrs(pDoc, "/metafile/clipregion[4]/polygon[1]/point[2]", {
1541         {"x", "2"},
1542         {"y", "3"}
1543     });
1544
1545     assertXPathAttrs(pDoc, "/metafile/clipregion[4]/polygon[1]/point[3]", {
1546         {"x", "4"},
1547         {"y", "4"}
1548     });
1549 }
1550
1551 void SvmTest::testClipRegion()
1552 {
1553     GDIMetaFile aGDIMetaFile;
1554     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
1555     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
1556
1557     vcl::Region aRegion(tools::Rectangle(Point(2, 2), Size(4, 4)));
1558
1559     pVirtualDev->SetClipRegion(aRegion);
1560
1561     tools::Polygon aPolygon(3);
1562     aPolygon.SetPoint(Point(1, 8), 0);
1563     aPolygon.SetPoint(Point(2, 7), 1);
1564     aPolygon.SetPoint(Point(3, 6), 2);
1565
1566     vcl::Region aRegion2(aPolygon);
1567     pVirtualDev->SetClipRegion(aRegion2);
1568
1569     tools::Polygon aPolygon1(3);
1570     aPolygon1.SetPoint(Point(4, 9), 0);
1571     aPolygon1.SetPoint(Point(5, 10), 1);
1572     aPolygon1.SetPoint(Point(6, 11), 2);
1573
1574     tools::PolyPolygon aPolyPolygon(2);
1575     aPolyPolygon.Insert(aPolygon);
1576     aPolyPolygon.Insert(aPolygon1);
1577
1578     vcl::Region aRegion3(aPolyPolygon);
1579     pVirtualDev->SetClipRegion(aRegion3);
1580
1581     basegfx::B2DPolygon aB2DPolygon;
1582     aB2DPolygon.append(basegfx::B2DPoint(0.0, 1.1));
1583     aB2DPolygon.append(basegfx::B2DPoint(2.2, 3.3));
1584     aB2DPolygon.append(basegfx::B2DPoint(3.7, 3.8));
1585
1586     basegfx::B2DPolyPolygon aB2DPolyPolygon(aB2DPolygon);
1587
1588     vcl::Region aRegion4(aB2DPolyPolygon);
1589     pVirtualDev->SetClipRegion(aRegion4);
1590
1591     checkClipRegion(writeAndReadStream(aGDIMetaFile));
1592     checkClipRegion(readFile(u"clipregion.svm"));
1593 }
1594
1595 void SvmTest::checkIntersectRectClipRegion(const GDIMetaFile& rMetaFile)
1596 {
1597     xmlDocUniquePtr pDoc = dumpMeta(rMetaFile);
1598
1599     assertXPathAttrs(pDoc, "/metafile/sectregionclipregion[1]", {
1600         {"left", "1"},
1601         {"top", "2"},
1602         {"right", "4"},
1603         {"bottom", "9"}
1604     });
1605 }
1606
1607 void SvmTest::testIntersectRectClipRegion()
1608 {
1609     GDIMetaFile aGDIMetaFile;
1610     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
1611     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
1612
1613     tools::Rectangle aRectangle(Point(1, 2), Size(4, 8));
1614
1615     vcl::Region aRegion(aRectangle);
1616
1617     pVirtualDev->IntersectClipRegion(aRegion);
1618     checkIntersectRectClipRegion(writeAndReadStream(aGDIMetaFile));
1619     checkIntersectRectClipRegion(readFile(u"intersectrectclipregion.svm"));
1620 }
1621
1622 void SvmTest::checkIntersectRegionClipRegion(const GDIMetaFile& rMetaFile)
1623 {
1624     xmlDocUniquePtr pDoc = dumpMeta(rMetaFile);
1625
1626     assertXPathAttrs(pDoc, "/metafile/sectregionclipregion[1]", {
1627         {"left", "1"},
1628         {"top", "2"},
1629         {"right", "5"},
1630         {"bottom", "6"}
1631     });
1632
1633     assertXPathAttrs(pDoc, "/metafile/sectregionclipregion[2]", {
1634         {"left", "1"},
1635         {"top", "2"},
1636         {"right", "7"},
1637         {"bottom", "8"}
1638     });
1639
1640     assertXPathAttrs(pDoc, "/metafile/sectregionclipregion[3]", {
1641         {"left", "0"},
1642         {"top", "3"},
1643         {"right", "2"},
1644         {"bottom", "6"}
1645     });
1646 }
1647
1648 void SvmTest::testIntersectRegionClipRegion()
1649 {
1650     GDIMetaFile aGDIMetaFile;
1651     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
1652     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
1653
1654     tools::Polygon aPolygon(3);
1655     aPolygon.SetPoint(Point(1, 2), 0);
1656     aPolygon.SetPoint(Point(3, 4), 1);
1657     aPolygon.SetPoint(Point(5, 6), 2);
1658
1659     vcl::Region aRegion(aPolygon);
1660     pVirtualDev->IntersectClipRegion(aRegion);
1661
1662     tools::Polygon aPolygon1(2);
1663     aPolygon1.SetPoint(Point(5, 6), 0);
1664     aPolygon1.SetPoint(Point(7, 8), 1);
1665
1666     tools::PolyPolygon aPolyPolygon(2);
1667     aPolyPolygon.Insert(aPolygon);
1668     aPolyPolygon.Insert(aPolygon1);
1669
1670     vcl::Region aRegion1(aPolyPolygon);
1671     pVirtualDev->IntersectClipRegion(aRegion1);
1672
1673     basegfx::B2DPolygon aB2DPolygon;
1674     aB2DPolygon.append(basegfx::B2DPoint(0.0, 3.3));
1675     aB2DPolygon.append(basegfx::B2DPoint(1.1, 4.4));
1676     aB2DPolygon.append(basegfx::B2DPoint(2.2, 5.5));
1677
1678     basegfx::B2DPolyPolygon aB2DPolyPolygon(aB2DPolygon);
1679
1680     vcl::Region aRegion2(aB2DPolyPolygon);
1681     pVirtualDev->IntersectClipRegion(aRegion2);
1682
1683     checkIntersectRegionClipRegion(writeAndReadStream(aGDIMetaFile));
1684     checkIntersectRegionClipRegion(readFile(u"intersectregionclipregion.svm"));
1685 }
1686
1687 void SvmTest::checkMoveClipRegion(const GDIMetaFile& rMetaFile)
1688 {
1689     xmlDocUniquePtr pDoc = dumpMeta(rMetaFile);
1690
1691     assertXPathAttrs(pDoc, "/metafile/moveclipregion[1]", {
1692         {"horzmove", "1"},
1693         {"vertmove", "2"}
1694     });
1695
1696     assertXPathAttrs(pDoc, "/metafile/moveclipregion[2]", {
1697         {"horzmove", "-3"},
1698         {"vertmove", "-4"}
1699     });
1700 }
1701
1702 void SvmTest::testMoveClipRegion()
1703 {
1704     GDIMetaFile aGDIMetaFile;
1705     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
1706     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
1707
1708     tools::Rectangle aRectangle(Point(1, 2), Size(4, 8));
1709
1710     vcl::Region aRegion(aRectangle);
1711     aRegion.Move(2, 2);
1712     pVirtualDev->SetClipRegion(aRegion);
1713
1714     pVirtualDev->MoveClipRegion(1, 2);
1715     pVirtualDev->MoveClipRegion(-3, -4);
1716
1717     checkMoveClipRegion(writeAndReadStream(aGDIMetaFile));
1718     checkMoveClipRegion(readFile(u"moveclipregion.svm"));
1719 }
1720
1721 void SvmTest::checkLineColor(const GDIMetaFile& rMetaFile)
1722 {
1723     xmlDocUniquePtr pDoc = dumpMeta(rMetaFile);
1724
1725     assertXPathAttrs(pDoc, "/metafile/push/linecolor[1]", {
1726         {"color", "#654321"},
1727     });
1728 }
1729
1730 void SvmTest::testLineColor()
1731 {
1732     GDIMetaFile aGDIMetaFile;
1733     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
1734     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
1735
1736     pVirtualDev->Push();
1737     pVirtualDev->SetLineColor(Color(0x654321));
1738     pVirtualDev->Pop();
1739
1740     checkLineColor(writeAndReadStream(aGDIMetaFile));
1741     checkLineColor(readFile(u"linecolor.svm"));
1742 }
1743
1744 void SvmTest::checkFillColor(const GDIMetaFile& rMetaFile)
1745 {
1746     xmlDocUniquePtr pDoc = dumpMeta(rMetaFile);
1747
1748     assertXPathAttrs(pDoc, "/metafile/push/fillcolor[1]", {
1749         {"color", "#456789"},
1750     });
1751 }
1752
1753 void SvmTest::testFillColor()
1754 {
1755     GDIMetaFile aGDIMetaFile;
1756     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
1757     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
1758
1759     pVirtualDev->Push();
1760     pVirtualDev->SetFillColor(Color(0x456789));
1761     pVirtualDev->Pop();
1762
1763     checkFillColor(writeAndReadStream(aGDIMetaFile));
1764     checkFillColor(readFile(u"fillcolor.svm"));
1765 }
1766
1767 void SvmTest::checkTextColor(const GDIMetaFile& rMetaFile)
1768 {
1769     xmlDocUniquePtr pDoc = dumpMeta(rMetaFile);
1770
1771     assertXPathAttrs(pDoc, "/metafile/textcolor[1]", {
1772         {"color", "#123456"},
1773     });
1774 }
1775
1776 void SvmTest::testTextColor()
1777 {
1778     GDIMetaFile aGDIMetaFile;
1779     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
1780     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
1781
1782     pVirtualDev->SetTextColor(Color(0x123456));
1783
1784     checkTextColor(writeAndReadStream(aGDIMetaFile));
1785     checkTextColor(readFile(u"textcolor.svm"));
1786 }
1787
1788 void SvmTest::checkTextFillColor(const GDIMetaFile& rMetaFile)
1789 {
1790     xmlDocUniquePtr pDoc = dumpMeta(rMetaFile);
1791
1792     assertXPathAttrs(pDoc, "/metafile/textfillcolor[1]", {
1793         {"color", "#234567"},
1794     });
1795 }
1796
1797 void SvmTest::testTextFillColor()
1798 {
1799     GDIMetaFile aGDIMetaFile;
1800     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
1801     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
1802
1803     pVirtualDev->SetTextFillColor(Color(0x234567));
1804
1805     checkTextFillColor(writeAndReadStream(aGDIMetaFile));
1806     checkTextFillColor(readFile(u"textfillecolor.svm"));
1807 }
1808
1809 void SvmTest::checkTextLineColor(const GDIMetaFile& rMetaFile)
1810 {
1811     xmlDocUniquePtr pDoc = dumpMeta(rMetaFile);
1812
1813     assertXPathAttrs(pDoc, "/metafile/textlinecolor[1]", {
1814         {"color", "#345678"},
1815     });
1816 }
1817
1818 void SvmTest::testTextLineColor()
1819 {
1820     GDIMetaFile aGDIMetaFile;
1821     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
1822     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
1823
1824     pVirtualDev->SetTextLineColor(Color(0x345678));
1825
1826     checkTextLineColor(writeAndReadStream(aGDIMetaFile));
1827     checkTextLineColor(readFile(u"textlinecolor.svm"));
1828 }
1829
1830 void SvmTest::checkOverLineColor(const GDIMetaFile& rMetaFile)
1831 {
1832     xmlDocUniquePtr pDoc = dumpMeta(rMetaFile);
1833
1834     assertXPathAttrs(pDoc, "/metafile/push/overlinecolor[1]", {
1835         {"color", "#345678"},
1836     });
1837 }
1838
1839 void SvmTest::testOverLineColor()
1840 {
1841     GDIMetaFile aGDIMetaFile;
1842     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
1843     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
1844
1845     pVirtualDev->Push();
1846     pVirtualDev->SetOverlineColor(Color(0x345678));
1847     pVirtualDev->Pop();
1848
1849     checkOverLineColor(writeAndReadStream(aGDIMetaFile));
1850     checkOverLineColor(readFile(u"overlinecolor.svm"));
1851 }
1852
1853 void SvmTest::checkTextAlign(const GDIMetaFile& rMetaFile)
1854 {
1855     xmlDocUniquePtr pDoc = dumpMeta(rMetaFile);
1856
1857     assertXPathAttrs(pDoc, "/metafile/textalign[1]", {
1858         {"align", "bottom"},
1859     });
1860 }
1861
1862 void SvmTest::testTextAlign()
1863 {
1864     GDIMetaFile aGDIMetaFile;
1865     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
1866     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
1867
1868     pVirtualDev->SetTextAlign(TextAlign::ALIGN_BOTTOM);
1869
1870     checkTextAlign(writeAndReadStream(aGDIMetaFile));
1871     checkTextAlign(readFile(u"textalign.svm"));
1872 }
1873
1874 void SvmTest::checkMapMode(const GDIMetaFile& rMetafile)
1875 {
1876     xmlDocUniquePtr pDoc = dumpMeta(rMetafile);
1877
1878     assertXPathAttrs(pDoc, "/metafile/mapmode[1]", {
1879         {"mapunit", "MapPixel"},
1880         {"x", "0"},
1881         {"y", "0"},
1882         {"scalex", "(1/1)"},
1883         {"scaley", "(1/1)"}
1884     });
1885
1886     assertXPathAttrs(pDoc, "/metafile/mapmode[2]", {
1887         {"mapunit", "Map100thInch"},
1888         {"x", "0"},
1889         {"y", "1"},
1890         {"scalex", "(1/2)"},
1891         {"scaley", "(2/3)"}
1892     });
1893
1894     assertXPathAttrs(pDoc, "/metafile/mapmode[3]", {
1895         {"mapunit", "MapRelative"},
1896         {"x", "0"},
1897         {"y", "-1"},
1898         {"scalex", "(25/12)"},
1899         {"scaley", "(25/16)"}
1900     });
1901 }
1902
1903 void SvmTest::testMapMode()
1904 {
1905     if (!IsDefaultDPI())
1906         return;
1907     GDIMetaFile aGDIMetafile;
1908     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
1909     setupBaseVirtualDevice(*pVirtualDev, aGDIMetafile);
1910
1911     MapMode aMapMode;
1912
1913     pVirtualDev->SetMapMode(aMapMode);
1914
1915     MapMode aMapMode1(MapUnit::Map100thInch);
1916     aMapMode1.SetOrigin(Point(0, 1));
1917     aMapMode1.SetScaleX(Fraction(1, 2));
1918     aMapMode1.SetScaleY(Fraction(2, 3));
1919
1920     pVirtualDev->SetMetafileMapMode(aMapMode1, false);
1921
1922     MapMode aMapMode2;
1923     pVirtualDev->SetMetafileMapMode(aMapMode2, true);
1924
1925     checkMapMode(writeAndReadStream(aGDIMetafile));
1926     checkMapMode(readFile(u"mapmode.svm"));
1927 }
1928
1929 #if HAVE_MORE_FONTS && !defined(_WIN32)
1930 void SvmTest::checkFont(const GDIMetaFile& rMetafile)
1931 {
1932     xmlDocUniquePtr pDoc = dumpMeta(rMetafile);
1933     assertXPathAttrs(pDoc, "/metafile/font[1]", {
1934         {"color", "#ffffff"},
1935         {"fillcolor", "#ffffff"},
1936         {"name", "Liberation Sans"},
1937         {"stylename", "Regular"},
1938         {"width", "12"},
1939         {"height", "12"},
1940         {"orientation", "50"},
1941         {"weight", "thin"},
1942         {"vertical", "true"},
1943     });
1944 }
1945 #endif
1946
1947 void SvmTest::testFont()
1948 {
1949 #if HAVE_MORE_FONTS
1950 // Windows interprets Width differently causing build errors
1951 #if !defined(_WIN32)
1952     GDIMetaFile aGDIMetaFile;
1953     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
1954     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
1955     vcl::Font aFont(FontFamily::FAMILY_SCRIPT, Size(15, 15));
1956     aFont.SetWeight(FontWeight::WEIGHT_THIN);
1957     aFont.SetFamilyName("Liberation Sans");
1958     aFont.SetStyleName("Regular");
1959     aFont.SetFontHeight(12);
1960     aFont.SetAverageFontWidth(12);
1961     aFont.SetVertical(true);
1962     aFont.SetOrientation(Degree10(50));
1963     pVirtualDev->SetFont(aFont);
1964     checkFont(writeAndReadStream(aGDIMetaFile));
1965     checkFont(readFile(u"font.svm"));
1966 #endif // _WIN32
1967 #endif
1968 }
1969
1970 void SvmTest::checkPushPop(const GDIMetaFile& rMetaFile)
1971 {
1972     xmlDocUniquePtr pDoc = dumpMeta(rMetaFile);
1973
1974     assertXPathAttrs(pDoc, "/metafile/push[1]", {{"flags", "PushAll"}});
1975     assertXPathAttrs(pDoc, "/metafile/push[1]/linecolor[1]", {{"color", "#800000"}});
1976     assertXPathAttrs(pDoc, "/metafile/push[1]/line[1]", {
1977         {"startx", "4"}, {"starty", "4"},
1978         {"endx", "6"},   {"endy", "6"},
1979     });
1980     assertXPathAttrs(pDoc, "/metafile/push[1]/push[1]", {{"flags", "PushLineColor, PushFillColor"}});
1981     assertXPathAttrs(pDoc, "/metafile/push[1]/push[1]/line[1]", {
1982         {"startx", "5"}, {"starty", "5"},
1983         {"endx", "7"},   {"endy", "7"},
1984     });
1985 }
1986
1987 void SvmTest::testPushPop()
1988 {
1989     GDIMetaFile aGDIMetaFile;
1990     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
1991     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
1992
1993     pVirtualDev->SetLineColor(COL_YELLOW);
1994     pVirtualDev->Push();
1995     pVirtualDev->SetLineColor(COL_RED);
1996     pVirtualDev->DrawLine(Point(4,4), Point(6,6));
1997     pVirtualDev->Push(vcl::PushFlags::FILLCOLOR | vcl::PushFlags::LINECOLOR);
1998     pVirtualDev->SetLineColor(COL_LIGHTRED);
1999     pVirtualDev->DrawLine(Point(5,5), Point(7,7));
2000     pVirtualDev->Pop();
2001     pVirtualDev->Pop();
2002     pVirtualDev->DrawLine(Point(1,1), Point(8,8));
2003
2004     checkPushPop(writeAndReadStream(aGDIMetaFile));
2005     checkPushPop(readFile(u"pushpop.svm"));
2006 }
2007
2008 void SvmTest::checkRasterOp(const GDIMetaFile& rMetaFile)
2009 {
2010     xmlDocUniquePtr pDoc = dumpMeta(rMetaFile);
2011
2012     assertXPathAttrs(pDoc, "/metafile/rasterop[1]", {
2013         {"operation", "xor"},
2014     });
2015 }
2016
2017 void SvmTest::testRasterOp()
2018 {
2019     GDIMetaFile aGDIMetaFile;
2020     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
2021     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
2022
2023     pVirtualDev->SetRasterOp(RasterOp::Xor);
2024
2025     checkRasterOp(writeAndReadStream(aGDIMetaFile));
2026     checkRasterOp(readFile(u"rasterop.svm"));
2027 }
2028
2029 void SvmTest::checkTransparent(const GDIMetaFile& rMetaFile)
2030 {
2031     xmlDocUniquePtr pDoc = dumpMeta(rMetaFile);
2032
2033     assertXPathAttrs(pDoc, "/metafile/transparent[1]", {
2034         {"transparence", "50"},
2035     });
2036
2037     assertXPathAttrs(pDoc, "/metafile/transparent[1]/polygon/point[1]", {
2038         {"x", "1"}, {"y", "8"},
2039     });
2040     assertXPathAttrs(pDoc, "/metafile/transparent[1]/polygon/point[2]", {
2041         {"x", "2"}, {"y", "7"},
2042     });
2043     assertXPathAttrs(pDoc, "/metafile/transparent[1]/polygon/point[3]", {
2044         {"x", "3"}, {"y", "6"},
2045     });
2046 }
2047
2048 void SvmTest::testTransparent()
2049 {
2050     GDIMetaFile aGDIMetaFile;
2051     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
2052     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
2053
2054     tools::Polygon aPolygon(3);
2055     aPolygon.SetPoint(Point(1, 8), 0);
2056     aPolygon.SetPoint(Point(2, 7), 1);
2057     aPolygon.SetPoint(Point(3, 6), 2);
2058
2059     tools::PolyPolygon aPolyPolygon(1);
2060     aPolyPolygon.Insert(aPolygon);
2061
2062     pVirtualDev->DrawTransparent(aPolygon, 50);
2063
2064     CPPUNIT_ASSERT(aGDIMetaFile.HasTransparentActions());
2065     checkTransparent(writeAndReadStream(aGDIMetaFile));
2066     checkTransparent(readFile(u"transparent.svm"));
2067 }
2068
2069 void SvmTest::checkFloatTransparent(const GDIMetaFile& rMetaFile)
2070 {
2071     xmlDocUniquePtr pDoc = dumpMeta(rMetaFile);
2072
2073     assertXPathAttrs(pDoc, "/metafile/floattransparent[1]", {
2074         {"x", "1"},
2075         {"y", "2"},
2076         {"width", "3"},
2077         {"height", "4"},
2078         {"transparent", "true"}
2079     });
2080
2081     assertXPathAttrs(pDoc, "/metafile/floattransparent[1]/gradient[1]", {
2082         {"style", "Linear"},
2083         {"startcolor", "#ffffff"},
2084         {"endcolor", "#000000"},
2085         {"angle", "0"},
2086         {"border", "0"},
2087         {"offsetx", "50"},
2088         {"offsety", "50"},
2089         {"startintensity", "100"},
2090         {"endintensity", "100"},
2091         {"steps", "0"}
2092     });
2093
2094     assertXPathAttrs(pDoc, "/metafile/floattransparent[1]/metafile[1]/point[1]", {
2095         {"x", "1"},
2096         {"y", "8"}
2097     });
2098
2099     assertXPathAttrs(pDoc, "/metafile/floattransparent[1]/metafile[1]/point[2]", {
2100         {"x", "2"},
2101         {"y", "7"}
2102     });
2103 }
2104
2105 void SvmTest::testFloatTransparent()
2106 {
2107     GDIMetaFile aGDIMetaFile;
2108     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
2109     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
2110
2111     GDIMetaFile aGDIMetaFile1;
2112     ScopedVclPtrInstance<VirtualDevice> pVirtualDev1;
2113     setupBaseVirtualDevice(*pVirtualDev1, aGDIMetaFile1);
2114
2115     pVirtualDev1->DrawPixel(Point(1, 8));
2116     pVirtualDev1->DrawPixel(Point(2, 7));
2117
2118     Gradient aGradient(css::awt::GradientStyle_LINEAR, COL_WHITE, COL_BLACK);
2119
2120     pVirtualDev->DrawTransparent(aGDIMetaFile1, Point(1, 2), Size(3, 4), aGradient);
2121
2122     checkFloatTransparent(writeAndReadStream(aGDIMetaFile));
2123     checkFloatTransparent(readFile(u"floattransparent.svm"));
2124 }
2125
2126 void SvmTest::checkEPS(const GDIMetaFile& rMetaFile)
2127 {
2128     xmlDocUniquePtr pDoc = dumpMeta(rMetaFile);
2129
2130     assertXPathAttrs(pDoc, "/metafile/eps[1]", {
2131         {"x", "1"},
2132         {"y", "8"},
2133         {"width", "2"},
2134         {"height", "7"}
2135     });
2136
2137     assertXPathAttrs(pDoc, "/metafile/eps[1]/gfxlink[1]", {
2138         {"width", "3"},
2139         {"height", "6"},
2140         {"type", "EpsBuffer"},
2141         {"userid", "12345"},
2142         {"datasize", "3"},
2143         {"data", "616263"},
2144         {"native", "false"},
2145         {"emf", "false"},
2146         {"validmapmode", "true"}
2147     });
2148
2149     assertXPathAttrs(pDoc, "/metafile/eps[1]/gfxlink[1]/prefmapmode[1]", {
2150         {"mapunit", "Map100thInch"},
2151         {"x", "0"},
2152         {"y", "1"},
2153         {"scalex", "(1/2)"},
2154         {"scaley", "(2/3)"}
2155     });
2156
2157     assertXPathAttrs(pDoc, "/metafile/eps[1]/metafile[1]/point[1]", {
2158         {"x", "1"},
2159         {"y", "8"}
2160     });
2161
2162     assertXPathAttrs(pDoc, "/metafile/eps[1]/metafile[1]/point[2]", {
2163         {"x", "2"},
2164         {"y", "7"}
2165     });
2166 }
2167
2168 void SvmTest::testEPS()
2169 {
2170     GDIMetaFile aGDIMetaFile;
2171     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
2172     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
2173
2174     sal_uInt8 aBuffer[] = { 'a','b','c' };
2175     SvMemoryStream stream(aBuffer, std::size(aBuffer), StreamMode::READ);
2176     BinaryDataContainer aContainer(stream, std::size(aBuffer));
2177
2178     MapMode aMapMode1(MapUnit::Map100thInch);
2179     aMapMode1.SetOrigin(Point(0, 1));
2180     aMapMode1.SetScaleX(Fraction(1, 2));
2181     aMapMode1.SetScaleY(Fraction(2, 3));
2182
2183     GDIMetaFile aGDIMetaFile1;
2184     ScopedVclPtrInstance<VirtualDevice> pVirtualDev1;
2185     setupBaseVirtualDevice(*pVirtualDev1, aGDIMetaFile1);
2186
2187     pVirtualDev1->DrawPixel(Point(1, 8));
2188     pVirtualDev1->DrawPixel(Point(2, 7));
2189
2190     GfxLink aGfxLink(aContainer, GfxLinkType::EpsBuffer);
2191     aGfxLink.SetPrefMapMode(aMapMode1);
2192     aGfxLink.SetUserId(12345);
2193     aGfxLink.SetPrefSize(Size(3, 6));
2194     pVirtualDev->DrawEPS(Point(1, 8), Size(2, 7), aGfxLink, &aGDIMetaFile1);
2195
2196     checkEPS(writeAndReadStream(aGDIMetaFile));
2197     checkEPS(readFile(u"eps.svm"));
2198 }
2199
2200 void SvmTest::checkRefPoint(const GDIMetaFile& rMetaFile)
2201 {
2202     xmlDocUniquePtr pDoc = dumpMeta(rMetaFile);
2203
2204     assertXPathAttrs(pDoc, "/metafile/refpoint[1]", {
2205         {"x", "0"},
2206         {"y", "0"},
2207         {"set", "false"}
2208     });
2209
2210     assertXPathAttrs(pDoc, "/metafile/refpoint[2]", {
2211         {"x", "1"},
2212         {"y", "2"},
2213         {"set", "true"}
2214     });
2215 }
2216
2217 void SvmTest::testRefPoint()
2218 {
2219     GDIMetaFile aGDIMetaFile;
2220     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
2221     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
2222
2223     pVirtualDev->SetRefPoint();
2224
2225     pVirtualDev->SetRefPoint(Point(1,2));
2226
2227     checkRefPoint(writeAndReadStream(aGDIMetaFile));
2228     checkRefPoint(readFile(u"refpoint.svm"));
2229 }
2230
2231 void SvmTest::checkComment(const GDIMetaFile& rMetafile)
2232 {
2233     xmlDocUniquePtr pDoc = dumpMeta(rMetafile);
2234
2235     assertXPathAttrs(pDoc, "/metafile/comment[1]", {
2236         {"value", "0"}
2237     });
2238
2239     assertXPathContent(pDoc, "/metafile/comment[1]/comment[1]", "Test comment");
2240
2241     assertXPathAttrs(pDoc, "/metafile/comment[2]", {
2242         {"datasize", "48"}
2243     });
2244
2245     assertXPathAttrs(pDoc, "/metafile/comment[2]", {
2246         {"data", "540068006500730065002000610072006500200073006f006d0065002000740065007300740020006400610074006100"}
2247     });
2248
2249     assertXPathAttrs(pDoc, "/metafile/comment[2]", {
2250         {"value", "4"}
2251     });
2252
2253     assertXPathContent(pDoc, "/metafile/comment[2]/comment[1]", "This is a test comment");
2254 }
2255
2256 void SvmTest::testComment()
2257 {
2258     GDIMetaFile aGDIMetaFile;
2259     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
2260     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
2261
2262     aGDIMetaFile.AddAction(new MetaCommentAction("Test comment"));
2263
2264     using namespace std::literals::string_view_literals;
2265     static constexpr auto aString
2266         = "T\0h\0e\0s\0e\0 \0a\0r\0e\0 \0s\0o\0m\0e\0 \0t\0e\0s\0t\0 \0d\0a\0t\0a\0"sv;
2267     aGDIMetaFile.AddAction(new MetaCommentAction("This is a test comment", \
2268                                                     4, \
2269                                                     reinterpret_cast<const sal_uInt8*>(aString.data()), \
2270                                                     aString.length() ));
2271
2272     checkComment(writeAndReadStream(aGDIMetaFile));
2273     checkComment(readFile(u"comment.svm"));
2274 }
2275
2276 void SvmTest::checkLayoutMode(const GDIMetaFile& rMetaFile)
2277 {
2278     xmlDocUniquePtr pDoc = dumpMeta(rMetaFile);
2279
2280     assertXPathAttrs(pDoc, "/metafile/layoutmode[1]", {
2281         {"textlayout", "#0004"}
2282     });
2283
2284     assertXPathAttrs(pDoc, "/metafile/layoutmode[2]", {
2285         {"textlayout", "#0001"}
2286     });
2287 }
2288
2289 void SvmTest::testLayoutMode()
2290 {
2291     GDIMetaFile aGDIMetaFile;
2292     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
2293     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
2294
2295     pVirtualDev->SetLayoutMode(vcl::text::ComplexTextLayoutFlags::TextOriginLeft);
2296     pVirtualDev->SetLayoutMode(vcl::text::ComplexTextLayoutFlags::BiDiRtl);
2297
2298     checkLayoutMode(writeAndReadStream(aGDIMetaFile));
2299     checkLayoutMode(readFile(u"layoutmode.svm"));
2300 }
2301
2302 void SvmTest::checkTextLanguage(const GDIMetaFile& rMetaFile)
2303 {
2304     xmlDocUniquePtr pDoc = dumpMeta(rMetaFile);
2305
2306     assertXPathAttrs(pDoc, "/metafile/textlanguage[1]", {
2307         {"language", "#0408"}
2308     });
2309
2310     assertXPathAttrs(pDoc, "/metafile/textlanguage[2]", {
2311         {"language", "#00ff"}
2312     });
2313 }
2314
2315 void SvmTest::testTextLanguage()
2316 {
2317     GDIMetaFile aGDIMetaFile;
2318     ScopedVclPtrInstance<VirtualDevice> pVirtualDev;
2319     setupBaseVirtualDevice(*pVirtualDev, aGDIMetaFile);
2320
2321     pVirtualDev->SetDigitLanguage(LANGUAGE_GREEK);
2322     pVirtualDev->SetDigitLanguage(LANGUAGE_NONE);
2323
2324     checkTextLanguage(writeAndReadStream(aGDIMetaFile));
2325     checkTextLanguage(readFile(u"textlanguage.svm"));
2326 }
2327
2328 CPPUNIT_TEST_SUITE_REGISTRATION(SvmTest);
2329
2330 CPPUNIT_PLUGIN_IMPLEMENT();
2331
2332 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */