vcl/backendtest/outputdevice/line.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 <test/outputdevice.hxx>
  12
  13 #include <basegfx/matrix/b2dhommatrix.hxx>
  14 #include <vcl/BitmapReadAccess.hxx>
  15
  16 #include <list>
  17
  18 namespace vcl::test {
  19
  20 namespace
  21 {
  22
  23 void drawLineOffset(OutputDevice& rDevice, tools::Rectangle const & rRect, int nOffset)
  24 {
  25
  26     int nMidOffset = rRect.GetWidth()/2;
  27     Point aLeftTop     (rRect.Left()  + nOffset - (nOffset+1)/2, rRect.Top()    + nOffset - 1);
  28     Point aRightTop    (rRect.Right() - nMidOffset - nOffset/3, rRect.Top()    + nOffset - 1);
  29     Point aLeftBottom  (rRect.Left()  + nOffset - (nOffset+1)/2, rRect.Bottom() - nOffset + 1);
  30     Point aRightBottom (rRect.Right() - nMidOffset - nOffset/3, rRect.Bottom() - nOffset + 1);
  31
  32     rDevice.DrawLine(aLeftTop,     aRightTop);
  33     rDevice.DrawLine(aRightTop,    aRightBottom);
  34     rDevice.DrawLine(aRightBottom, aLeftBottom);
  35     rDevice.DrawLine(aLeftBottom,  aLeftTop);
  36 }
  37
  38 } // end anonymous namespace
  39
  40 Bitmap OutputDeviceTestLine::setupRectangle(bool bEnableAA)
  41 {
  42     initialSetup(13, 13, constBackgroundColor, bEnableAA);
  43
  44     mpVirtualDevice->SetLineColor(constLineColor);
  45     mpVirtualDevice->SetFillColor();
  46
  47     drawLineOffset(*mpVirtualDevice, maVDRectangle, 2);
  48     drawLineOffset(*mpVirtualDevice, maVDRectangle, 5);
  49
  50     return mpVirtualDevice->GetBitmap(maVDRectangle.TopLeft(), maVDRectangle.GetSize());
  51 }
  52
  53 Bitmap OutputDeviceTestLine::setupRectangleOnSize1028()
  54 {
  55     initialSetup(1028, 1028, constBackgroundColor);
  56
  57     mpVirtualDevice->SetLineColor(constLineColor);
  58     mpVirtualDevice->SetFillColor();
  59
  60     drawLineOffset(*mpVirtualDevice, maVDRectangle, 2);
  61     drawLineOffset(*mpVirtualDevice, maVDRectangle, 5);
  62
  63     return mpVirtualDevice->GetBitmap(maVDRectangle.TopLeft(), maVDRectangle.GetSize());
  64 }
  65
  66 Bitmap OutputDeviceTestLine::setupRectangleOnSize4096()
  67 {
  68     initialSetup(4096, 4096, constBackgroundColor);
  69
  70     mpVirtualDevice->SetLineColor(constLineColor);
  71     mpVirtualDevice->SetFillColor();
  72
  73     drawLineOffset(*mpVirtualDevice, maVDRectangle, 2);
  74     drawLineOffset(*mpVirtualDevice, maVDRectangle, 5);
  75
  76     return mpVirtualDevice->GetBitmap(maVDRectangle.TopLeft(), maVDRectangle.GetSize());
  77 }
  78
  79 Bitmap OutputDeviceTestLine::setupDiamond()
  80 {
  81     initialSetup(11, 11, constBackgroundColor);
  82
  83     mpVirtualDevice->SetLineColor(constLineColor);
  84     mpVirtualDevice->SetFillColor();
  85
  86     Point aPoint1, aPoint2, aPoint3, aPoint4;
  87     OutputDeviceTestCommon::createDiamondPoints(maVDRectangle, 4, aPoint1, aPoint2, aPoint3, aPoint4);
  88
  89     mpVirtualDevice->DrawLine(aPoint1, aPoint2);
  90     mpVirtualDevice->DrawLine(aPoint2, aPoint3);
  91     mpVirtualDevice->DrawLine(aPoint3, aPoint4);
  92     mpVirtualDevice->DrawLine(aPoint4, aPoint1);
  93
  94     return mpVirtualDevice->GetBitmap(maVDRectangle.TopLeft(), maVDRectangle.GetSize());
  95 }
  96
  97 Bitmap OutputDeviceTestLine::setupLines()
  98 {
  99     initialSetup(13, 13, constBackgroundColor);
 100
 101     mpVirtualDevice->SetLineColor(constLineColor);
 102     mpVirtualDevice->SetFillColor();
 103
 104     Point aHorizontalLinePoint1, aHorizontalLinePoint2;
 105     Point aVerticalLinePoint1, aVerticalLinePoint2;
 106     Point aDiagonalLinePoint1, aDiagonalLinePoint2;
 107
 108     OutputDeviceTestCommon::createHorizontalVerticalDiagonalLinePoints(
 109                           maVDRectangle, aHorizontalLinePoint1, aHorizontalLinePoint2,
 110                                          aVerticalLinePoint1,   aVerticalLinePoint2,
 111                                          aDiagonalLinePoint1,   aDiagonalLinePoint2);
 112
 113     mpVirtualDevice->DrawLine(aHorizontalLinePoint1, aHorizontalLinePoint2);
 114     mpVirtualDevice->DrawLine(aVerticalLinePoint1,   aVerticalLinePoint2);
 115     mpVirtualDevice->DrawLine(aDiagonalLinePoint1,   aDiagonalLinePoint2);
 116
 117     return mpVirtualDevice->GetBitmap(maVDRectangle.TopLeft(), maVDRectangle.GetSize());
 118 }
 119
 120 Bitmap OutputDeviceTestLine::setupAALines()
 121 {
 122     initialSetup(13, 13, constBackgroundColor);
 123
 124     mpVirtualDevice->SetAntialiasing(AntialiasingFlags::Enable);
 125     mpVirtualDevice->SetLineColor(constLineColor);
 126     mpVirtualDevice->SetFillColor();
 127
 128     Point aHorizontalLinePoint1, aHorizontalLinePoint2;
 129     Point aVerticalLinePoint1, aVerticalLinePoint2;
 130     Point aDiagonalLinePoint1, aDiagonalLinePoint2;
 131
 132     OutputDeviceTestCommon::createHorizontalVerticalDiagonalLinePoints(
 133                           maVDRectangle, aHorizontalLinePoint1, aHorizontalLinePoint2,
 134                                          aVerticalLinePoint1,   aVerticalLinePoint2,
 135                                          aDiagonalLinePoint1,   aDiagonalLinePoint2);
 136
 137     mpVirtualDevice->DrawLine(aHorizontalLinePoint1, aHorizontalLinePoint2);
 138     mpVirtualDevice->DrawLine(aVerticalLinePoint1,   aVerticalLinePoint2);
 139     mpVirtualDevice->DrawLine(aDiagonalLinePoint1,   aDiagonalLinePoint2);
 140
 141     return mpVirtualDevice->GetBitmap(maVDRectangle.TopLeft(), maVDRectangle.GetSize());
 142 }
 143
 144 Bitmap OutputDeviceTestLine::setupDashedLine()
 145 {
 146     initialSetup(13, 13, constBackgroundColor);
 147
 148     mpVirtualDevice->SetLineColor(constLineColor);
 149     mpVirtualDevice->SetFillColor();
 150
 151     tools::Rectangle rectangle = maVDRectangle;
 152     rectangle.shrink(2);
 153
 154     std::vector<double> stroke({ 2.0, 1.0 });
 155     mpVirtualDevice->DrawPolyLineDirect( basegfx::B2DHomMatrix(),
 156         basegfx::B2DPolygon{
 157             basegfx::B2DPoint(rectangle.Left(), rectangle.Top()),
 158             basegfx::B2DPoint(rectangle.Left(), rectangle.Bottom()),
 159             basegfx::B2DPoint(rectangle.Right(), rectangle.Bottom()),
 160             basegfx::B2DPoint(rectangle.Right(), rectangle.Top()),
 161             basegfx::B2DPoint(rectangle.Left(), rectangle.Top())},
 162         1, 0, &stroke, basegfx::B2DLineJoin::NONE );
 163
 164     return mpVirtualDevice->GetBitmap(maVDRectangle.TopLeft(), maVDRectangle.GetSize());
 165 }
 166
 167 TestResult OutputDeviceTestLine::checkDashedLine(Bitmap& rBitmap)
 168 {
 169     TestResult returnValue = TestResult::Passed;
 170     for (int i = 0; i < 7; i++)
 171     {
 172         TestResult eResult = TestResult::Passed;
 173         if( i == 2 )
 174         {
 175             // Build a sequence of pixels for the drawn rectangle border,
 176             // check that they alternate appropriately (there should be
 177             // normally 2 line, 1 background).
 178             std::list< bool > dash; // true - line color, false - background
 179             const int width = rBitmap.GetSizePixel().Width();
 180             const int height = rBitmap.GetSizePixel().Height();
 181             BitmapReadAccess access(rBitmap);
 182             for( int x = 2; x < width - 2; ++x )
 183                 dash.push_back( access.GetPixel( 2, x ) == constLineColor );
 184             for( int y = 3; y < height - 3; ++y )
 185                 dash.push_back( access.GetPixel( y, width - 3 ) == constLineColor );
 186             for( int x = width - 3; x >= 2; --x )
 187                 dash.push_back( access.GetPixel( height - 3, x ) == constLineColor );
 188             for( int y = height - 4; y >= 3; --y )
 189                 dash.push_back( access.GetPixel( y, 2 ) == constLineColor );
 190             for( int x = 2; x < width - 2; ++x ) // repeat, to check also the corner
 191                 dash.push_back( access.GetPixel( 2, x ) == constLineColor );
 192             bool last = false;
 193             int lastCount = 0;
 194             while( !dash.empty())
 195             {
 196                 if( dash.front() == last )
 197                 {
 198                     ++lastCount;
 199                     if( lastCount > ( last ? 4 : 3 ))
 200                         eResult = TestResult::Failed;
 201                     else if( lastCount > ( last ? 3 : 2 ) && eResult != TestResult::Failed)
 202                         eResult = TestResult::PassedWithQuirks;
 203                 }
 204                 else
 205                 {
 206                     last = dash.front();
 207                     lastCount = 1;
 208                 }
 209                 dash.pop_front();
 210             }
 211         }
 212         else
 213         {
 214             eResult = OutputDeviceTestCommon::checkRectangle(rBitmap, i, constBackgroundColor);
 215         }
 216
 217         if (eResult == TestResult::Failed)
 218             returnValue = TestResult::Failed;
 219         if (eResult == TestResult::PassedWithQuirks && returnValue != TestResult::Failed)
 220             returnValue = TestResult::PassedWithQuirks;
 221     }
 222     return returnValue;
 223 }
 224
 225 constexpr int CAPSHRINK = 25;
 226 constexpr int CAPWIDTH = 20;
 227 Bitmap OutputDeviceTestLine::setupLineCap( css::drawing::LineCap lineCap )
 228 {
 229     initialSetup(101, 101, constBackgroundColor);
 230
 231     mpVirtualDevice->SetLineColor(constLineColor);
 232     mpVirtualDevice->SetFillColor();
 233
 234     tools::Rectangle rectangle = maVDRectangle;
 235     rectangle.shrink(CAPSHRINK);
 236
 237     const basegfx::B2DPolygon poly{
 238         basegfx::B2DPoint(rectangle.LeftCenter().getX(), rectangle.LeftCenter().getY()),
 239         basegfx::B2DPoint(rectangle.RightCenter().getX(), rectangle.RightCenter().getY())};
 240
 241     mpVirtualDevice->DrawPolyLineDirect( basegfx::B2DHomMatrix(),poly,
 242         CAPWIDTH, 0, nullptr, basegfx::B2DLineJoin::NONE, lineCap );
 243
 244     mpVirtualDevice->SetLineColor(constFillColor);
 245     mpVirtualDevice->DrawPolyLineDirect( basegfx::B2DHomMatrix(), poly,
 246         0, 0, nullptr, basegfx::B2DLineJoin::NONE );
 247
 248     return mpVirtualDevice->GetBitmap(maVDRectangle.TopLeft(), maVDRectangle.GetSize());
 249 }
 250
 251 Bitmap OutputDeviceTestLine::setupLineJoin( basegfx::B2DLineJoin lineJoin )
 252 {
 253     initialSetup(101, 101, constBackgroundColor);
 254
 255     mpVirtualDevice->SetLineColor(constLineColor);
 256     mpVirtualDevice->SetFillColor();
 257
 258     tools::Rectangle rectangle = maVDRectangle;
 259     rectangle.shrink(CAPSHRINK);
 260
 261     const basegfx::B2DPolygon poly{
 262         basegfx::B2DPoint(rectangle.TopLeft().getX(), rectangle.TopLeft().getY()),
 263         basegfx::B2DPoint(rectangle.TopRight().getX(), rectangle.TopRight().getY()),
 264         basegfx::B2DPoint(rectangle.BottomRight().getX(), rectangle.BottomRight().getY())};
 265
 266     mpVirtualDevice->DrawPolyLineDirect( basegfx::B2DHomMatrix(), poly,
 267         CAPWIDTH, 0, nullptr, lineJoin );
 268
 269     mpVirtualDevice->SetLineColor(constFillColor);
 270     mpVirtualDevice->DrawPolyLineDirect( basegfx::B2DHomMatrix(), poly,
 271         0, 0, nullptr, lineJoin );
 272
 273     return mpVirtualDevice->GetBitmap(maVDRectangle.TopLeft(), maVDRectangle.GetSize());
 274 }
 275
 276 } // end namespace vcl::test
 277
 278 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */