canvas/source/vcl/canvashelper.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  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <sal/config.h>
  21
  22 #include <basegfx/matrix/b2dhommatrix.hxx>
  23 #include <basegfx/numeric/ftools.hxx>
  24 #include <basegfx/point/b2dpoint.hxx>
  25 #include <basegfx/polygon/b2dlinegeometry.hxx>
  26 #include <basegfx/polygon/b2dpolygon.hxx>
  27 #include <basegfx/polygon/b2dpolygontools.hxx>
  28 #include <basegfx/range/b2drectangle.hxx>
  29 #include <basegfx/utils/canvastools.hxx>
  30 #include <basegfx/vector/b2dsize.hxx>
  31 #include <com/sun/star/drawing/LineCap.hpp>
  32 #include <com/sun/star/rendering/CompositeOperation.hpp>
  33 #include <com/sun/star/rendering/PathCapType.hpp>
  34 #include <com/sun/star/rendering/PathJoinType.hpp>
  35 #include <com/sun/star/rendering/TextDirection.hpp>
  36 #include <comphelper/sequence.hxx>
  37 #include <rtl/math.hxx>
  38 #include <comphelper/diagnose_ex.hxx>
  39 #include <tools/poly.hxx>
  40 #include <vcl/bitmapex.hxx>
  41 #include <vcl/BitmapReadAccess.hxx>
  42 #include <vcl/canvastools.hxx>
  43 #include <vcl/bitmap/BitmapAlphaClampFilter.hxx>
  44 #include <vcl/skia/SkiaHelper.hxx>
  45
  46 #include <canvas/canvastools.hxx>
  47
  48 #include "canvasbitmap.hxx"
  49 #include "canvasfont.hxx"
  50 #include "canvashelper.hxx"
  51 #include "impltools.hxx"
  52 #include "textlayout.hxx"
  53
  54
  55 using namespace ::com::sun::star;
  56
  57 namespace vclcanvas
  58 {
  59     namespace
  60     {
  61         basegfx::B2DLineJoin b2DJoineFromJoin( sal_Int8 nJoinType )
  62         {
  63             switch( nJoinType )
  64             {
  65                 case rendering::PathJoinType::NONE:
  66                     return basegfx::B2DLineJoin::NONE;
  67
  68                 case rendering::PathJoinType::MITER:
  69                     return basegfx::B2DLineJoin::Miter;
  70
  71                 case rendering::PathJoinType::ROUND:
  72                     return basegfx::B2DLineJoin::Round;
  73
  74                 case rendering::PathJoinType::BEVEL:
  75                     return basegfx::B2DLineJoin::Bevel;
  76
  77                 default:
  78                     ENSURE_OR_THROW( false,
  79                                       "b2DJoineFromJoin(): Unexpected join type" );
  80             }
  81
  82             return basegfx::B2DLineJoin::NONE;
  83         }
  84
  85         drawing::LineCap unoCapeFromCap( sal_Int8 nCapType)
  86         {
  87             switch ( nCapType)
  88             {
  89                 case rendering::PathCapType::BUTT:
  90                     return drawing::LineCap_BUTT;
  91
  92                 case rendering::PathCapType::ROUND:
  93                     return drawing::LineCap_ROUND;
  94
  95                 case rendering::PathCapType::SQUARE:
  96                     return drawing::LineCap_SQUARE;
  97
  98                 default:
  99                     ENSURE_OR_THROW( false,
 100                                       "unoCapeFromCap(): Unexpected cap type" );
 101             }
 102             return drawing::LineCap_BUTT;
 103         }
 104     }
 105
 106     CanvasHelper::CanvasHelper() :
 107         mpDevice(),
 108         mbHaveAlpha( false )
 109     {
 110     }
 111
 112     void CanvasHelper::disposing()
 113     {
 114         mpDevice = nullptr;
 115         mpProtectedOutDevProvider.reset();
 116         mpOutDevProvider.reset();
 117         mp2ndOutDevProvider.reset();
 118     }
 119
 120     void CanvasHelper::init( rendering::XGraphicDevice&     rDevice,
 121                              const OutDevProviderSharedPtr& rOutDev,
 122                              bool                           bProtect,
 123                              bool                           bHaveAlpha )
 124     {
 125         // cast away const, need to change refcount (as this is
 126         // ~invisible to client code, still logically const)
 127         mpDevice    = &rDevice;
 128         mbHaveAlpha = bHaveAlpha;
 129
 130         setOutDev( rOutDev, bProtect );
 131     }
 132
 133     void CanvasHelper::setOutDev( const OutDevProviderSharedPtr& rOutDev,
 134                                   bool                           bProtect )
 135     {
 136         if( bProtect )
 137             mpProtectedOutDevProvider = rOutDev;
 138         else
 139             mpProtectedOutDevProvider.reset();
 140
 141         mpOutDevProvider = rOutDev;
 142     }
 143
 144     void CanvasHelper::setBackgroundOutDev( const OutDevProviderSharedPtr& rOutDev )
 145     {
 146         mp2ndOutDevProvider = rOutDev;
 147         mp2ndOutDevProvider->getOutDev().EnableMapMode( false );
 148         mp2ndOutDevProvider->getOutDev().SetAntialiasing( AntialiasingFlags::Enable );
 149     }
 150
 151     void CanvasHelper::clear()
 152     {
 153         // are we disposed?
 154         if( !mpOutDevProvider )
 155             return;
 156
 157         OutputDevice& rOutDev( mpOutDevProvider->getOutDev() );
 158         tools::OutDevStateKeeper aStateKeeper( mpProtectedOutDevProvider );
 159
 160         rOutDev.EnableMapMode( false );
 161         rOutDev.SetAntialiasing( AntialiasingFlags::Enable );
 162         rOutDev.SetLineColor( COL_WHITE );
 163         rOutDev.SetFillColor( COL_WHITE );
 164         rOutDev.SetClipRegion();
 165         rOutDev.DrawRect( ::tools::Rectangle( Point(),
 166                                      rOutDev.GetOutputSizePixel()) );
 167
 168         if( !mp2ndOutDevProvider )
 169             return;
 170
 171         OutputDevice& rOutDev2( mp2ndOutDevProvider->getOutDev() );
 172
 173         rOutDev2.SetDrawMode( DrawModeFlags::Default );
 174         rOutDev2.EnableMapMode( false );
 175         rOutDev2.SetAntialiasing( AntialiasingFlags::Enable );
 176         rOutDev2.SetLineColor( COL_WHITE );
 177         rOutDev2.SetFillColor( COL_WHITE );
 178         rOutDev2.SetClipRegion();
 179         rOutDev2.DrawRect( ::tools::Rectangle( Point(),
 180                                       rOutDev2.GetOutputSizePixel()) );
 181         rOutDev2.SetDrawMode( DrawModeFlags::BlackLine | DrawModeFlags::BlackFill | DrawModeFlags::BlackText |
 182                               DrawModeFlags::BlackGradient | DrawModeFlags::BlackBitmap );
 183     }
 184
 185     void CanvasHelper::drawLine( const rendering::XCanvas*      ,
 186                                  const geometry::RealPoint2D&   aStartRealPoint2D,
 187                                  const geometry::RealPoint2D&   aEndRealPoint2D,
 188                                  const rendering::ViewState&    viewState,
 189                                  const rendering::RenderState&  renderState )
 190     {
 191         // are we disposed?
 192         if( !mpOutDevProvider )
 193             return;
 194
 195         // nope, render
 196         tools::OutDevStateKeeper aStateKeeper( mpProtectedOutDevProvider );
 197         setupOutDevState( viewState, renderState, LINE_COLOR );
 198
 199         const Point aStartPoint( tools::mapRealPoint2D( aStartRealPoint2D,
 200                                                         viewState, renderState ) );
 201         const Point aEndPoint( tools::mapRealPoint2D( aEndRealPoint2D,
 202                                                       viewState, renderState ) );
 203         // TODO(F2): alpha
 204         mpOutDevProvider->getOutDev().DrawLine( aStartPoint, aEndPoint );
 205
 206         if( mp2ndOutDevProvider )
 207             mp2ndOutDevProvider->getOutDev().DrawLine( aStartPoint, aEndPoint );
 208     }
 209
 210     void CanvasHelper::drawBezier( const rendering::XCanvas*            ,
 211                                    const geometry::RealBezierSegment2D& aBezierSegment,
 212                                    const geometry::RealPoint2D&         _aEndPoint,
 213                                    const rendering::ViewState&          viewState,
 214                                    const rendering::RenderState&        renderState )
 215     {
 216         if( !mpOutDevProvider )
 217             return;
 218
 219         tools::OutDevStateKeeper aStateKeeper( mpProtectedOutDevProvider );
 220         setupOutDevState( viewState, renderState, LINE_COLOR );
 221
 222         const Point aStartPoint( tools::mapRealPoint2D( geometry::RealPoint2D(aBezierSegment.Px,
 223                                                                                aBezierSegment.Py),
 224                                                         viewState, renderState ) );
 225         const Point aCtrlPoint1( tools::mapRealPoint2D( geometry::RealPoint2D(aBezierSegment.C1x,
 226                                                                                aBezierSegment.C1y),
 227                                                         viewState, renderState ) );
 228         const Point aCtrlPoint2( tools::mapRealPoint2D( geometry::RealPoint2D(aBezierSegment.C2x,
 229                                                                                aBezierSegment.C2y),
 230                                                          viewState, renderState ) );
 231         const Point aEndPoint( tools::mapRealPoint2D( _aEndPoint,
 232                                                        viewState, renderState ) );
 233
 234         ::tools::Polygon aPoly(4);
 235         aPoly.SetPoint( aStartPoint, 0 );
 236         aPoly.SetFlags( 0, PolyFlags::Normal );
 237         aPoly.SetPoint( aCtrlPoint1, 1 );
 238         aPoly.SetFlags( 1, PolyFlags::Control );
 239         aPoly.SetPoint( aCtrlPoint2, 2 );
 240         aPoly.SetFlags( 2, PolyFlags::Control );
 241         aPoly.SetPoint( aEndPoint, 3 );
 242         aPoly.SetFlags( 3, PolyFlags::Normal );
 243
 244         // TODO(F2): alpha
 245         mpOutDevProvider->getOutDev().DrawPolygon( aPoly );
 246         if( mp2ndOutDevProvider )
 247             mp2ndOutDevProvider->getOutDev().DrawPolygon( aPoly );
 248     }
 249
 250     uno::Reference< rendering::XCachedPrimitive > CanvasHelper::drawPolyPolygon( const rendering::XCanvas*                          ,
 251                                                                                  const uno::Reference< rendering::XPolyPolygon2D >& xPolyPolygon,
 252                                                                                  const rendering::ViewState&                        viewState,
 253                                                                                  const rendering::RenderState&                      renderState )
 254     {
 255         ENSURE_ARG_OR_THROW( xPolyPolygon.is(),
 256                          "polygon is NULL");
 257
 258         if( mpOutDevProvider )
 259         {
 260             tools::OutDevStateKeeper aStateKeeper( mpProtectedOutDevProvider );
 261             setupOutDevState( viewState, renderState, LINE_COLOR );
 262
 263             const ::basegfx::B2DPolyPolygon aBasegfxPolyPoly(
 264                 ::basegfx::unotools::b2DPolyPolygonFromXPolyPolygon2D(xPolyPolygon) );
 265             const ::tools::PolyPolygon aPolyPoly( tools::mapPolyPolygon( aBasegfxPolyPoly, viewState, renderState ) );
 266
 267             if( aBasegfxPolyPoly.isClosed() )
 268             {
 269                 mpOutDevProvider->getOutDev().DrawPolyPolygon( aPolyPoly );
 270
 271                 if( mp2ndOutDevProvider )
 272                     mp2ndOutDevProvider->getOutDev().DrawPolyPolygon( aPolyPoly );
 273             }
 274             else
 275             {
 276                 // mixed open/closed state. Cannot render open polygon
 277                 // via DrawPolyPolygon(), since that implicitly
 278                 // closed every polygon. OTOH, no need to distinguish
 279                 // further and render closed polygons via
 280                 // DrawPolygon(), and open ones via DrawPolyLine():
 281                 // closed polygons will simply already contain the
 282                 // closing segment.
 283                 sal_uInt16 nSize( aPolyPoly.Count() );
 284
 285                 for( sal_uInt16 i=0; i<nSize; ++i )
 286                 {
 287                     mpOutDevProvider->getOutDev().DrawPolyLine( aPolyPoly[i] );
 288
 289                     if( mp2ndOutDevProvider )
 290                         mp2ndOutDevProvider->getOutDev().DrawPolyLine( aPolyPoly[i] );
 291                 }
 292             }
 293         }
 294
 295         // TODO(P1): Provide caching here.
 296         return uno::Reference< rendering::XCachedPrimitive >(nullptr);
 297     }
 298
 299     uno::Reference< rendering::XCachedPrimitive > CanvasHelper::strokePolyPolygon( const rendering::XCanvas*                            ,
 300                                                                                    const uno::Reference< rendering::XPolyPolygon2D >&   xPolyPolygon,
 301                                                                                    const rendering::ViewState&                          viewState,
 302                                                                                    const rendering::RenderState&                        renderState,
 303                                                                                    const rendering::StrokeAttributes&                   strokeAttributes )
 304     {
 305         ENSURE_ARG_OR_THROW( xPolyPolygon.is(),
 306                          "polygon is NULL");
 307
 308         if( mpOutDevProvider )
 309         {
 310             tools::OutDevStateKeeper aStateKeeper( mpProtectedOutDevProvider );
 311
 312             ::basegfx::B2DHomMatrix aMatrix;
 313             ::canvas::tools::mergeViewAndRenderTransform(aMatrix, viewState, renderState);
 314
 315             ::basegfx::B2DPolyPolygon aPolyPoly(
 316                 ::basegfx::unotools::b2DPolyPolygonFromXPolyPolygon2D(xPolyPolygon) );
 317
 318             // apply dashing, if any
 319             if( strokeAttributes.DashArray.hasElements() )
 320             {
 321                 const std::vector<double> aDashArray(
 322                     ::comphelper::sequenceToContainer< std::vector<double> >(strokeAttributes.DashArray) );
 323
 324                 ::basegfx::B2DPolyPolygon aDashedPolyPoly;
 325
 326                 for( sal_uInt32 i=0; i<aPolyPoly.count(); ++i )
 327                 {
 328                     // AW: new interface; You may also get gaps in the same run now
 329                     basegfx::utils::applyLineDashing(aPolyPoly.getB2DPolygon(i), aDashArray, &aDashedPolyPoly);
 330                     //aDashedPolyPoly.append(
 331                     //    ::basegfx::utils::applyLineDashing( aPolyPoly.getB2DPolygon(i),
 332                     //                                        aDashArray ) );
 333                 }
 334
 335                 aPolyPoly = std::move(aDashedPolyPoly);
 336             }
 337
 338             ::basegfx::B2DSize aLinePixelSize(strokeAttributes.StrokeWidth,
 339                                               strokeAttributes.StrokeWidth);
 340             aLinePixelSize *= aMatrix;
 341             ::basegfx::B2DPolyPolygon aStrokedPolyPoly;
 342             if( aLinePixelSize.getLength() < 1.42 )
 343             {
 344                 // line width < 1.0 in device pixel, thus, output as a
 345                 // simple hairline poly-polygon
 346                 setupOutDevState( viewState, renderState, LINE_COLOR );
 347
 348                 aStrokedPolyPoly = std::move(aPolyPoly);
 349             }
 350             else
 351             {
 352                 // render as a 'thick' line
 353                 setupOutDevState( viewState, renderState, FILL_COLOR );
 354
 355                 for( sal_uInt32 i=0; i<aPolyPoly.count(); ++i )
 356                 {
 357                     double fMiterMinimumAngle;
 358                     if (strokeAttributes.MiterLimit <= 1.0)
 359                     {
 360                         fMiterMinimumAngle = M_PI_2;
 361                     }
 362                     else
 363                     {
 364                         fMiterMinimumAngle = 2.0 * asin(1.0/strokeAttributes.MiterLimit);
 365                     }
 366
 367                     // TODO(F2): Also use Cap settings from
 368                     // StrokeAttributes, the
 369                     // createAreaGeometryForLineStartEnd() method does not
 370                     // seem to fit very well here
 371
 372                     // AW: New interface, will create bezier polygons now
 373                     aStrokedPolyPoly.append(basegfx::utils::createAreaGeometry(
 374                         aPolyPoly.getB2DPolygon(i),
 375                         strokeAttributes.StrokeWidth*0.5,
 376                         b2DJoineFromJoin(strokeAttributes.JoinType),
 377                         unoCapeFromCap(strokeAttributes.StartCapType),
 378                         basegfx::deg2rad(12.5) /* default fMaxAllowedAngle*/ ,
 379                         0.4 /* default fMaxPartOfEdge*/ ,
 380                         fMiterMinimumAngle
 381                         ));
 382                     //aStrokedPolyPoly.append(
 383                     //    ::basegfx::utils::createAreaGeometryForPolygon( aPolyPoly.getB2DPolygon(i),
 384                     //                                                    strokeAttributes.StrokeWidth*0.5,
 385                     //                                                    b2DJoineFromJoin(strokeAttributes.JoinType) ) );
 386                 }
 387             }
 388
 389             // transform only _now_, all the StrokeAttributes are in
 390             // user coordinates.
 391             aStrokedPolyPoly.transform( aMatrix );
 392
 393             // TODO(F2): When using alpha here, must handle that via
 394             // temporary surface or somesuch.
 395
 396             // Note: the generated stroke poly-polygon is NOT free of
 397             // self-intersections. Therefore, if we would render it
 398             // via OutDev::DrawPolyPolygon(), on/off fill would
 399             // generate off areas on those self-intersections.
 400             for( sal_uInt32 i=0; i<aStrokedPolyPoly.count(); ++i )
 401             {
 402                 const basegfx::B2DPolygon& polygon = aStrokedPolyPoly.getB2DPolygon( i );
 403                 if( polygon.isClosed()) {
 404                     mpOutDevProvider->getOutDev().DrawPolygon( polygon );
 405                     if( mp2ndOutDevProvider )
 406                         mp2ndOutDevProvider->getOutDev().DrawPolygon( polygon );
 407                 } else {
 408                     mpOutDevProvider->getOutDev().DrawPolyLine( polygon );
 409                     if( mp2ndOutDevProvider )
 410                         mp2ndOutDevProvider->getOutDev().DrawPolyLine( polygon );
 411                 }
 412             }
 413         }
 414
 415         // TODO(P1): Provide caching here.
 416         return uno::Reference< rendering::XCachedPrimitive >(nullptr);
 417     }
 418
 419     uno::Reference< rendering::XCachedPrimitive > CanvasHelper::strokeTexturedPolyPolygon( const rendering::XCanvas*                            ,
 420                                                                                            const uno::Reference< rendering::XPolyPolygon2D >&   ,
 421                                                                                            const rendering::ViewState&                          ,
 422                                                                                            const rendering::RenderState&                        ,
 423                                                                                            const uno::Sequence< rendering::Texture >&           ,
 424                                                                                            const rendering::StrokeAttributes&                    )
 425     {
 426         return uno::Reference< rendering::XCachedPrimitive >(nullptr);
 427     }
 428
 429     uno::Reference< rendering::XCachedPrimitive > CanvasHelper::strokeTextureMappedPolyPolygon( const rendering::XCanvas*                           ,
 430                                                                                                 const uno::Reference< rendering::XPolyPolygon2D >&  ,
 431                                                                                                 const rendering::ViewState&                         ,
 432                                                                                                 const rendering::RenderState&                       ,
 433                                                                                                 const uno::Sequence< rendering::Texture >&          ,
 434                                                                                                 const uno::Reference< geometry::XMapping2D >&       ,
 435                                                                                                 const rendering::StrokeAttributes&                   )
 436     {
 437         return uno::Reference< rendering::XCachedPrimitive >(nullptr);
 438     }
 439
 440     uno::Reference< rendering::XPolyPolygon2D >   CanvasHelper::queryStrokeShapes( const rendering::XCanvas*                            ,
 441                                                                                    const uno::Reference< rendering::XPolyPolygon2D >&   ,
 442                                                                                    const rendering::ViewState&                          ,
 443                                                                                    const rendering::RenderState&                        ,
 444                                                                                    const rendering::StrokeAttributes&                    )
 445     {
 446         return uno::Reference< rendering::XPolyPolygon2D >(nullptr);
 447     }
 448
 449     uno::Reference< rendering::XCachedPrimitive > CanvasHelper::fillPolyPolygon( const rendering::XCanvas*                          ,
 450                                                                                  const uno::Reference< rendering::XPolyPolygon2D >& xPolyPolygon,
 451                                                                                  const rendering::ViewState&                        viewState,
 452                                                                                  const rendering::RenderState&                      renderState )
 453     {
 454         ENSURE_ARG_OR_THROW( xPolyPolygon.is(),
 455                          "polygon is NULL");
 456
 457         if( mpOutDevProvider )
 458         {
 459             tools::OutDevStateKeeper aStateKeeper( mpProtectedOutDevProvider );
 460
 461             const int nAlpha( setupOutDevState( viewState, renderState, FILL_COLOR ) );
 462             ::basegfx::B2DPolyPolygon aB2DPolyPoly(
 463                 ::basegfx::unotools::b2DPolyPolygonFromXPolyPolygon2D(xPolyPolygon));
 464             aB2DPolyPoly.setClosed(true); // ensure closed poly, otherwise VCL does not fill
 465             const ::tools::PolyPolygon aPolyPoly( tools::mapPolyPolygon(
 466                                              aB2DPolyPoly,
 467                                              viewState, renderState ) );
 468             const bool bSourceAlpha( renderState.CompositeOperation == rendering::CompositeOperation::SOURCE );
 469             if( nAlpha == 255 || bSourceAlpha )
 470             {
 471                 mpOutDevProvider->getOutDev().DrawPolyPolygon( aPolyPoly );
 472             }
 473             else
 474             {
 475                 const int nTransPercent( ((255 - nAlpha) * 100 + 128) / 255 );  // normal rounding, no truncation here
 476                 mpOutDevProvider->getOutDev().DrawTransparent( aPolyPoly, static_cast<sal_uInt16>(nTransPercent) );
 477             }
 478
 479             if( mp2ndOutDevProvider )
 480             {
 481                 // HACK. Normally, CanvasHelper does not care about
 482                 // actually what mp2ndOutDev is...  well, here we do &
 483                 // assume a 1bpp target - everything beyond 97%
 484                 // transparency is fully transparent
 485                 if( nAlpha > 2 )
 486                 {
 487                     mp2ndOutDevProvider->getOutDev().SetFillColor( COL_BLACK );
 488                     mp2ndOutDevProvider->getOutDev().DrawPolyPolygon( aPolyPoly );
 489                 }
 490             }
 491         }
 492
 493         // TODO(P1): Provide caching here.
 494         return uno::Reference< rendering::XCachedPrimitive >(nullptr);
 495     }
 496
 497     uno::Reference< rendering::XCachedPrimitive > CanvasHelper::fillTextureMappedPolyPolygon( const rendering::XCanvas*                             ,
 498                                                                                               const uno::Reference< rendering::XPolyPolygon2D >&    ,
 499                                                                                               const rendering::ViewState&                           ,
 500                                                                                               const rendering::RenderState&                         ,
 501                                                                                               const uno::Sequence< rendering::Texture >&            ,
 502                                                                                               const uno::Reference< geometry::XMapping2D >&              )
 503     {
 504         return uno::Reference< rendering::XCachedPrimitive >(nullptr);
 505     }
 506
 507     uno::Reference< rendering::XCanvasFont > CanvasHelper::createFont( const rendering::XCanvas*                        ,
 508                                                                        const rendering::FontRequest&                    fontRequest,
 509                                                                        const uno::Sequence< beans::PropertyValue >&     extraFontProperties,
 510                                                                        const geometry::Matrix2D&                        fontMatrix )
 511     {
 512         if( mpOutDevProvider && mpDevice )
 513         {
 514             // TODO(F2): font properties and font matrix
 515             return uno::Reference< rendering::XCanvasFont >(
 516                     new CanvasFont(fontRequest, extraFontProperties, fontMatrix,
 517                                    *mpDevice, mpOutDevProvider) );
 518         }
 519
 520         return uno::Reference< rendering::XCanvasFont >();
 521     }
 522
 523     uno::Sequence< rendering::FontInfo > CanvasHelper::queryAvailableFonts( const rendering::XCanvas*                       ,
 524                                                                             const rendering::FontInfo&                      ,
 525                                                                             const uno::Sequence< beans::PropertyValue >&     )
 526     {
 527         // TODO(F2)
 528         return uno::Sequence< rendering::FontInfo >();
 529     }
 530
 531     uno::Reference< rendering::XCachedPrimitive > CanvasHelper::drawText( const rendering::XCanvas*                         ,
 532                                                                           const rendering::StringContext&                   text,
 533                                                                           const uno::Reference< rendering::XCanvasFont >&   xFont,
 534                                                                           const rendering::ViewState&                       viewState,
 535                                                                           const rendering::RenderState&                     renderState,
 536                                                                           sal_Int8                                          textDirection )
 537     {
 538         ENSURE_ARG_OR_THROW( xFont.is(),
 539                          "font is NULL");
 540
 541         if( mpOutDevProvider )
 542         {
 543             tools::OutDevStateKeeper aStateKeeper( mpProtectedOutDevProvider );
 544
 545             ::Point aOutpos;
 546             if( !setupTextOutput( aOutpos, viewState, renderState, xFont ) )
 547                 return uno::Reference< rendering::XCachedPrimitive >(nullptr); // no output necessary
 548
 549             // change text direction and layout mode
 550             vcl::text::ComplexTextLayoutFlags nLayoutMode(vcl::text::ComplexTextLayoutFlags::Default);
 551             switch( textDirection )
 552             {
 553                 case rendering::TextDirection::WEAK_LEFT_TO_RIGHT:
 554                 case rendering::TextDirection::STRONG_LEFT_TO_RIGHT:
 555                     nLayoutMode |= vcl::text::ComplexTextLayoutFlags::BiDiStrong;
 556                     nLayoutMode |= vcl::text::ComplexTextLayoutFlags::TextOriginLeft;
 557                     break;
 558
 559                 case rendering::TextDirection::WEAK_RIGHT_TO_LEFT:
 560                     nLayoutMode |= vcl::text::ComplexTextLayoutFlags::BiDiRtl;
 561                     [[fallthrough]];
 562                 case rendering::TextDirection::STRONG_RIGHT_TO_LEFT:
 563                     nLayoutMode |= vcl::text::ComplexTextLayoutFlags::BiDiRtl | vcl::text::ComplexTextLayoutFlags::BiDiStrong;
 564                     nLayoutMode |= vcl::text::ComplexTextLayoutFlags::TextOriginRight;
 565                     break;
 566             }
 567
 568             // TODO(F2): alpha
 569             mpOutDevProvider->getOutDev().SetLayoutMode( nLayoutMode );
 570             mpOutDevProvider->getOutDev().DrawText( aOutpos,
 571                                             text.Text,
 572                                             ::canvas::tools::numeric_cast<sal_uInt16>(text.StartPosition),
 573                                             ::canvas::tools::numeric_cast<sal_uInt16>(text.Length) );
 574
 575             if( mp2ndOutDevProvider )
 576             {
 577                 mp2ndOutDevProvider->getOutDev().SetLayoutMode( nLayoutMode );
 578                 mp2ndOutDevProvider->getOutDev().DrawText( aOutpos,
 579                                                    text.Text,
 580                                                    ::canvas::tools::numeric_cast<sal_uInt16>(text.StartPosition),
 581                                                    ::canvas::tools::numeric_cast<sal_uInt16>(text.Length) );
 582             }
 583         }
 584
 585         return uno::Reference< rendering::XCachedPrimitive >(nullptr);
 586     }
 587
 588     uno::Reference< rendering::XCachedPrimitive > CanvasHelper::drawTextLayout( const rendering::XCanvas*                       ,
 589                                                                                 const uno::Reference< rendering::XTextLayout >& xLayoutedText,
 590                                                                                 const rendering::ViewState&                     viewState,
 591                                                                                 const rendering::RenderState&                   renderState )
 592     {
 593         ENSURE_ARG_OR_THROW( xLayoutedText.is(),
 594                          "layout is NULL");
 595
 596         TextLayout* pTextLayout = dynamic_cast< TextLayout* >( xLayoutedText.get() );
 597
 598         if( pTextLayout )
 599         {
 600             if( mpOutDevProvider )
 601             {
 602                 tools::OutDevStateKeeper aStateKeeper( mpProtectedOutDevProvider );
 603
 604                 // TODO(T3): Race condition. We're taking the font
 605                 // from xLayoutedText, and then calling draw() at it,
 606                 // without exclusive access. Move setupTextOutput(),
 607                 // e.g. to impltools?
 608
 609                 ::Point aOutpos;
 610                 if( !setupTextOutput( aOutpos, viewState, renderState, xLayoutedText->getFont() ) )
 611                     return uno::Reference< rendering::XCachedPrimitive >(nullptr); // no output necessary
 612
 613                 // TODO(F2): What about the offset scalings?
 614                 // TODO(F2): alpha
 615                 pTextLayout->draw( mpOutDevProvider->getOutDev(), aOutpos, viewState, renderState );
 616
 617                 if( mp2ndOutDevProvider )
 618                     pTextLayout->draw( mp2ndOutDevProvider->getOutDev(), aOutpos, viewState, renderState );
 619             }
 620         }
 621         else
 622         {
 623             ENSURE_ARG_OR_THROW( false,
 624                                  "TextLayout not compatible with this canvas" );
 625         }
 626
 627         return uno::Reference< rendering::XCachedPrimitive >(nullptr);
 628     }
 629
 630     uno::Reference< rendering::XCachedPrimitive > CanvasHelper::implDrawBitmap( const rendering::XCanvas*                   pCanvas,
 631                                                                                 const uno::Reference< rendering::XBitmap >& xBitmap,
 632                                                                                 const rendering::ViewState&                 viewState,
 633                                                                                 const rendering::RenderState&               renderState,
 634                                                                                 bool                                        bModulateColors )
 635     {
 636         ENSURE_ARG_OR_THROW( xBitmap.is(),
 637                              "bitmap is NULL");
 638
 639         ::canvas::tools::verifyInput( renderState,
 640                                       __func__,
 641                                       mpDevice,
 642                                       4,
 643                                       bModulateColors ? 3 : 0 );
 644
 645         if( mpOutDevProvider )
 646         {
 647             tools::OutDevStateKeeper aStateKeeper( mpProtectedOutDevProvider );
 648             setupOutDevState( viewState, renderState, IGNORE_COLOR );
 649
 650             ::basegfx::B2DHomMatrix aMatrix;
 651             ::canvas::tools::mergeViewAndRenderTransform(aMatrix, viewState, renderState);
 652
 653             ::basegfx::B2DPoint aOutputPos( 0.0, 0.0 );
 654             aOutputPos *= aMatrix;
 655
 656             BitmapEx aBmpEx( tools::bitmapExFromXBitmap(xBitmap) );
 657
 658             // TODO(F2): Implement modulation again for other color
 659             // channels (currently, works only for alpha). Note: this
 660             // is already implemented in transformBitmap()
 661             if( bModulateColors &&
 662                 renderState.DeviceColor.getLength() > 3 )
 663             {
 664                 // optimize away the case where alpha modulation value
 665                 // is 1.0 - we then simply switch off modulation at all
 666                 bModulateColors = !::rtl::math::approxEqual(
 667                     renderState.DeviceColor[3], 1.0);
 668             }
 669
 670             // check whether we can render bitmap as-is: must not
 671             // modulate colors, matrix must either be the identity
 672             // transform (that's clear), _or_ contain only
 673             // translational components.
 674             if( !bModulateColors &&
 675                 (aMatrix.isIdentity() ||
 676                  (::basegfx::fTools::equalZero( aMatrix.get(0,1) ) &&
 677                   ::basegfx::fTools::equalZero( aMatrix.get(1,0) ) &&
 678                   ::rtl::math::approxEqual(aMatrix.get(0,0), 1.0) &&
 679                   ::rtl::math::approxEqual(aMatrix.get(1,1), 1.0)) ) )
 680             {
 681                 // optimized case: identity matrix, or only
 682                 // translational components.
 683                 mpOutDevProvider->getOutDev().DrawBitmapEx( vcl::unotools::pointFromB2DPoint( aOutputPos ),
 684                                                     aBmpEx );
 685
 686                 if( mp2ndOutDevProvider )
 687                 {
 688                     // HACK. Normally, CanvasHelper does not care about
 689                     // actually what mp2ndOutDev is...  well, here we do &
 690                     // assume a 1bpp target - everything beyond 97%
 691                     // transparency is fully transparent
 692                     if( aBmpEx.IsAlpha() && !SkiaHelper::isVCLSkiaEnabled())
 693                     {
 694                         BitmapFilter::Filter(aBmpEx, BitmapAlphaClampFilter(253));
 695                     }
 696
 697                     mp2ndOutDevProvider->getOutDev().DrawBitmapEx( vcl::unotools::pointFromB2DPoint( aOutputPos ),
 698                                                            aBmpEx );
 699                 }
 700
 701                 // Returning a cache object is not useful, the XBitmap
 702                 // itself serves this purpose
 703                 return uno::Reference< rendering::XCachedPrimitive >(nullptr);
 704             }
 705             else if( mpOutDevProvider->getOutDev().HasFastDrawTransformedBitmap())
 706             {
 707                 ::basegfx::B2DHomMatrix aSizeTransform;
 708                 aSizeTransform.scale( aBmpEx.GetSizePixel().Width(), aBmpEx.GetSizePixel().Height() );
 709                 aMatrix = aMatrix * aSizeTransform;
 710                 const double fAlpha = bModulateColors ? renderState.DeviceColor[3] : 1.0;
 711
 712                 mpOutDevProvider->getOutDev().DrawTransformedBitmapEx( aMatrix, aBmpEx, fAlpha );
 713                 if( mp2ndOutDevProvider )
 714                 {
 715                     if( aBmpEx.IsAlpha() )
 716                     {
 717                         // tdf#157790 invert alpha mask
 718                         // Due to commit 81994cb2b8b32453a92bcb011830fcb884f22ff3,
 719                         // the alpha mask needs to be inverted. Note: when
 720                         // testing tdf#157790, this code only gets executed
 721                         // when Skia is enabled.
 722                         AlphaMask aAlpha( aBmpEx.GetAlphaMask() );
 723                         aAlpha.Invert();
 724                         aBmpEx = BitmapEx( aBmpEx.GetBitmap(), aAlpha );
 725
 726                         // HACK. Normally, CanvasHelper does not care about
 727                         // actually what mp2ndOutDev is...  well, here we do &
 728                         // assume a 1bpp target - everything beyond 97%
 729                         // transparency is fully transparent
 730                         if( !SkiaHelper::isVCLSkiaEnabled())
 731                         {
 732                             BitmapFilter::Filter(aBmpEx, BitmapAlphaClampFilter(253));
 733                         }
 734                     }
 735
 736                     mp2ndOutDevProvider->getOutDev().DrawTransformedBitmapEx( aMatrix, aBmpEx );
 737                 }
 738                 return uno::Reference< rendering::XCachedPrimitive >(nullptr);
 739             }
 740             else
 741             {
 742                 // Matrix contains non-trivial transformation (or
 743                 // color modulation is requested), decompose to check
 744                 // whether GraphicObject suffices
 745                 ::basegfx::B2DVector aScale;
 746                 double               nRotate;
 747                 double               nShearX;
 748                 aMatrix.decompose( aScale, aOutputPos, nRotate, nShearX );
 749
 750                 GraphicAttr             aGrfAttr;
 751                 GraphicObjectSharedPtr  pGrfObj;
 752
 753                 ::Size aBmpSize( aBmpEx.GetSizePixel() );
 754
 755                 // setup alpha modulation
 756                 if( bModulateColors )
 757                 {
 758                     const double nAlphaModulation( renderState.DeviceColor[3] );
 759
 760                     // TODO(F1): Note that the GraphicManager has a
 761                     // subtle difference in how it calculates the
 762                     // resulting alpha value: it's using the inverse
 763                     // alpha values (i.e. 'transparency'), and
 764                     // calculates transOrig + transModulate, instead
 765                     // of transOrig + transModulate -
 766                     // transOrig*transModulate (which would be
 767                     // equivalent to the origAlpha*modulateAlpha the
 768                     // DX canvas performs)
 769                     aGrfAttr.SetAlpha(
 770                         static_cast< sal_uInt8 >(
 771                             ::basegfx::fround( 255.0 * nAlphaModulation ) ) );
 772                 }
 773
 774                 if( ::basegfx::fTools::equalZero( nShearX ) )
 775                 {
 776                     // no shear, GraphicObject is enough (the
 777                     // GraphicObject only supports scaling, rotation
 778                     // and translation)
 779
 780                     // #i75339# don't apply mirror flags, having
 781                     // negative size values is enough to make
 782                     // GraphicObject flip the bitmap
 783
 784                     // The angle has to be mapped from radian to tenths of
 785                     // degrees with the orientation reversed: [0,2Pi) ->
 786                     // (3600,0].  Note that the original angle may have
 787                     // values outside the [0,2Pi) interval.
 788                     const double nAngleInTenthOfDegrees (3600.0 - basegfx::rad2deg<10>(nRotate));
 789                     aGrfAttr.SetRotation( Degree10(::basegfx::fround(nAngleInTenthOfDegrees)) );
 790
 791                     pGrfObj = std::make_shared<GraphicObject>( aBmpEx );
 792                 }
 793                 else
 794                 {
 795                     // modify output position, to account for the fact
 796                     // that transformBitmap() always normalizes its output
 797                     // bitmap into the smallest enclosing box.
 798                     ::basegfx::B2DRectangle aDestRect = ::canvas::tools::calcTransformedRectBounds(
 799                                                                 ::basegfx::B2DRectangle(0,
 800                                                                                         0,
 801                                                                                         aBmpSize.Width(),
 802                                                                                         aBmpSize.Height()),
 803                                                                 aMatrix );
 804
 805                     aOutputPos.setX( aDestRect.getMinX() );
 806                     aOutputPos.setY( aDestRect.getMinY() );
 807
 808                     // complex transformation, use generic affine bitmap
 809                     // transformation
 810                     aBmpEx = tools::transformBitmap( aBmpEx,
 811                                                      aMatrix );
 812
 813                     pGrfObj = std::make_shared<GraphicObject>( aBmpEx );
 814
 815                     // clear scale values, generated bitmap already
 816                     // contains scaling
 817                     aScale.setX( 1.0 ); aScale.setY( 1.0 );
 818
 819                     // update bitmap size, bitmap has changed above.
 820                     aBmpSize = aBmpEx.GetSizePixel();
 821                 }
 822
 823                 // output GraphicObject
 824                 const ::Point aPt( vcl::unotools::pointFromB2DPoint( aOutputPos ) );
 825                 const ::Size  aSz( ::basegfx::fround<::tools::Long>( aScale.getX() * aBmpSize.Width() ),
 826                                    ::basegfx::fround<::tools::Long>( aScale.getY() * aBmpSize.Height() ) );
 827
 828                 pGrfObj->Draw(mpOutDevProvider->getOutDev(),
 829                               aPt,
 830                               aSz,
 831                               &aGrfAttr);
 832
 833                 if( mp2ndOutDevProvider )
 834                 {
 835                     GraphicObjectSharedPtr p2ndGrfObj = pGrfObj;
 836                     if( aBmpEx.IsAlpha() )
 837                     {
 838                         // tdf#157790 invert alpha mask
 839                         // Due to commit 81994cb2b8b32453a92bcb011830fcb884f22ff3,
 840                         // the alpha mask needs to be inverted. Note: when
 841                         // testing tdf#157790, this code only gets executed
 842                         // when Skia is disabled.
 843                         AlphaMask aAlpha( aBmpEx.GetAlphaMask() );
 844                         aAlpha.Invert();
 845                         BitmapEx a2ndBmpEx( aBmpEx.GetBitmap(), aAlpha );
 846                         p2ndGrfObj = std::make_shared<GraphicObject>( a2ndBmpEx );
 847                     }
 848
 849                     p2ndGrfObj->Draw(mp2ndOutDevProvider->getOutDev(),
 850                                   aPt,
 851                                   aSz,
 852                                   &aGrfAttr);
 853                 }
 854
 855                 // created GraphicObject, which possibly cached
 856                 // display bitmap - return cache object, to retain
 857                 // that information.
 858                 return uno::Reference< rendering::XCachedPrimitive >(
 859                     new CachedBitmap( std::move(pGrfObj),
 860                                       aPt,
 861                                       aSz,
 862                                       aGrfAttr,
 863                                       viewState,
 864                                       renderState,
 865                                       // cast away const, need to
 866                                       // change refcount (as this is
 867                                       // ~invisible to client code,
 868                                       // still logically const)
 869                                       const_cast< rendering::XCanvas* >(pCanvas)) );
 870             }
 871         }
 872
 873         // Nothing rendered
 874         return uno::Reference< rendering::XCachedPrimitive >(nullptr);
 875     }
 876
 877     uno::Reference< rendering::XCachedPrimitive > CanvasHelper::drawBitmap( const rendering::XCanvas*                   pCanvas,
 878                                                                             const uno::Reference< rendering::XBitmap >& xBitmap,
 879                                                                             const rendering::ViewState&                 viewState,
 880                                                                             const rendering::RenderState&               renderState )
 881     {
 882         return implDrawBitmap( pCanvas,
 883                                xBitmap,
 884                                viewState,
 885                                renderState,
 886                                false );
 887     }
 888
 889     uno::Reference< rendering::XCachedPrimitive > CanvasHelper::drawBitmapModulated( const rendering::XCanvas*                      pCanvas,
 890                                                                                      const uno::Reference< rendering::XBitmap >&    xBitmap,
 891                                                                                      const rendering::ViewState&                    viewState,
 892                                                                                      const rendering::RenderState&                  renderState )
 893     {
 894         return implDrawBitmap( pCanvas,
 895                                xBitmap,
 896                                viewState,
 897                                renderState,
 898                                true );
 899     }
 900
 901     geometry::IntegerSize2D CanvasHelper::getSize()
 902     {
 903         if( !mpOutDevProvider )
 904             return geometry::IntegerSize2D(); // we're disposed
 905
 906         return vcl::unotools::integerSize2DFromSize( mpOutDevProvider->getOutDev().GetOutputSizePixel() );
 907     }
 908
 909     uno::Reference< rendering::XBitmap > CanvasHelper::getScaledBitmap( const geometry::RealSize2D& newSize,
 910                                                                         bool                        beFast )
 911     {
 912         if( !mpOutDevProvider || !mpDevice )
 913             return uno::Reference< rendering::XBitmap >(); // we're disposed
 914
 915         OutputDevice& rOutDev( mpOutDevProvider->getOutDev() );
 916
 917         tools::OutDevStateKeeper aStateKeeper( mpProtectedOutDevProvider );
 918         rOutDev.EnableMapMode( false );
 919         rOutDev.SetAntialiasing( AntialiasingFlags::Enable );
 920
 921         // TODO(F2): Support alpha vdev canvas here
 922         const Point aEmptyPoint(0,0);
 923         const Size  aBmpSize( rOutDev.GetOutputSizePixel() );
 924
 925         BitmapEx aBitmap( rOutDev.GetBitmapEx(aEmptyPoint, aBmpSize) );
 926
 927         aBitmap.Scale( vcl::unotools::sizeFromRealSize2D(newSize),
 928                        beFast ? BmpScaleFlag::Default : BmpScaleFlag::BestQuality );
 929
 930         return uno::Reference< rendering::XBitmap >(
 931             new CanvasBitmap( aBitmap, *mpDevice, mpOutDevProvider ) );
 932     }
 933
 934     uno::Sequence< sal_Int8 > CanvasHelper::getData( rendering::IntegerBitmapLayout&     rLayout,
 935                                                      const geometry::IntegerRectangle2D& rect )
 936     {
 937         if( !mpOutDevProvider )
 938             return uno::Sequence< sal_Int8 >(); // we're disposed
 939
 940         rLayout = getMemoryLayout();
 941
 942         // TODO(F2): Support alpha canvas here
 943         const ::tools::Rectangle aRect( vcl::unotools::rectangleFromIntegerRectangle2D(rect) );
 944
 945         OutputDevice& rOutDev( mpOutDevProvider->getOutDev() );
 946
 947         tools::OutDevStateKeeper aStateKeeper( mpProtectedOutDevProvider );
 948         rOutDev.EnableMapMode( false );
 949         rOutDev.SetAntialiasing( AntialiasingFlags::Enable );
 950
 951         Bitmap aBitmap( rOutDev.GetBitmapEx(aRect.TopLeft(),
 952                                           aRect.GetSize()).GetBitmap() );
 953
 954         BitmapScopedReadAccess pReadAccess( aBitmap );
 955
 956         ENSURE_OR_THROW( pReadAccess.get() != nullptr,
 957                          "Could not acquire read access to OutDev bitmap" );
 958
 959         const sal_Int32 nWidth( rect.X2 - rect.X1 );
 960         const sal_Int32 nHeight( rect.Y2 - rect.Y1 );
 961
 962         rLayout.ScanLines = nHeight;
 963         rLayout.ScanLineBytes = nWidth*4;
 964         rLayout.ScanLineStride = rLayout.ScanLineBytes;
 965
 966         uno::Sequence< sal_Int8 > aRes( 4*nWidth*nHeight );
 967         sal_Int8* pRes = aRes.getArray();
 968
 969         int nCurrPos(0);
 970         for( int y=0; y<nHeight; ++y )
 971         {
 972             for( int x=0; x<nWidth; ++x )
 973             {
 974                 pRes[ nCurrPos++ ] = pReadAccess->GetColor( y, x ).GetRed();
 975                 pRes[ nCurrPos++ ] = pReadAccess->GetColor( y, x ).GetGreen();
 976                 pRes[ nCurrPos++ ] = pReadAccess->GetColor( y, x ).GetBlue();
 977                 pRes[ nCurrPos++ ] = -1;
 978             }
 979         }
 980
 981         return aRes;
 982     }
 983
 984     uno::Sequence< sal_Int8 > CanvasHelper::getPixel( rendering::IntegerBitmapLayout& rLayout,
 985                                                       const geometry::IntegerPoint2D& pos )
 986     {
 987         if( !mpOutDevProvider )
 988             return uno::Sequence< sal_Int8 >(); // we're disposed
 989
 990         rLayout = getMemoryLayout();
 991         rLayout.ScanLines = 1;
 992         rLayout.ScanLineBytes = 4;
 993         rLayout.ScanLineStride = rLayout.ScanLineBytes;
 994
 995         OutputDevice& rOutDev( mpOutDevProvider->getOutDev() );
 996
 997         tools::OutDevStateKeeper aStateKeeper( mpProtectedOutDevProvider );
 998         rOutDev.EnableMapMode( false );
 999         rOutDev.SetAntialiasing( AntialiasingFlags::Enable );
1000
1001         const Size aBmpSize( rOutDev.GetOutputSizePixel() );
1002
1003         ENSURE_ARG_OR_THROW( pos.X >= 0 && pos.X < aBmpSize.Width(),
1004                              "X coordinate out of bounds" );
1005         ENSURE_ARG_OR_THROW( pos.Y >= 0 && pos.Y < aBmpSize.Height(),
1006                              "Y coordinate out of bounds" );
1007
1008         // TODO(F2): Support alpha canvas here
1009         return ::canvas::tools::colorToStdIntSequence(
1010             rOutDev.GetPixel(
1011                 vcl::unotools::pointFromIntegerPoint2D( pos )));
1012     }
1013
1014     rendering::IntegerBitmapLayout CanvasHelper::getMemoryLayout()
1015     {
1016         if( !mpOutDevProvider )
1017             return rendering::IntegerBitmapLayout(); // we're disposed
1018
1019         rendering::IntegerBitmapLayout aBitmapLayout( ::canvas::tools::getStdMemoryLayout(getSize()) );
1020         if ( !mbHaveAlpha )
1021             aBitmapLayout.ColorSpace = canvas::tools::getStdColorSpaceWithoutAlpha();
1022
1023         return aBitmapLayout;
1024     }
1025
1026     int CanvasHelper::setupOutDevState( const rendering::ViewState&     viewState,
1027                                         const rendering::RenderState&   renderState,
1028                                         ColorType                       eColorType ) const
1029     {
1030         ENSURE_OR_THROW( mpOutDevProvider,
1031                          "outdev null. Are we disposed?" );
1032
1033         ::canvas::tools::verifyInput( renderState,
1034                                       __func__,
1035                                       mpDevice,
1036                                       2,
1037                                       eColorType == IGNORE_COLOR ? 0 : 3 );
1038
1039         OutputDevice& rOutDev( mpOutDevProvider->getOutDev() );
1040         OutputDevice* p2ndOutDev = nullptr;
1041
1042         rOutDev.EnableMapMode( false );
1043         rOutDev.SetAntialiasing( AntialiasingFlags::Enable );
1044
1045         if( mp2ndOutDevProvider )
1046             p2ndOutDev = &mp2ndOutDevProvider->getOutDev();
1047
1048         int nAlpha(255);
1049
1050         // TODO(P2): Don't change clipping all the time, maintain current clip
1051         // state and change only when update is necessary
1052         ::canvas::tools::clipOutDev(viewState, renderState, rOutDev, p2ndOutDev);
1053
1054         Color aColor( COL_WHITE );
1055
1056         if( renderState.DeviceColor.getLength() > 2 )
1057         {
1058             aColor = vcl::unotools::stdColorSpaceSequenceToColor(
1059                 renderState.DeviceColor );
1060         }
1061
1062         // extract alpha, and make color opaque
1063         // afterwards. Otherwise, OutputDevice won't draw anything
1064         nAlpha = aColor.GetAlpha();
1065         aColor.SetAlpha(255);
1066
1067         if( eColorType != IGNORE_COLOR )
1068         {
1069             switch( eColorType )
1070             {
1071                 case LINE_COLOR:
1072                     rOutDev.SetLineColor( aColor );
1073                     rOutDev.SetFillColor();
1074
1075                     if( p2ndOutDev )
1076                     {
1077                         p2ndOutDev->SetLineColor( aColor );
1078                         p2ndOutDev->SetFillColor();
1079                     }
1080                     break;
1081
1082                 case FILL_COLOR:
1083                     rOutDev.SetFillColor( aColor );
1084                     rOutDev.SetLineColor();
1085
1086                     if( p2ndOutDev )
1087                     {
1088                         p2ndOutDev->SetFillColor( aColor );
1089                         p2ndOutDev->SetLineColor();
1090                     }
1091                     break;
1092
1093                 case TEXT_COLOR:
1094                     rOutDev.SetTextColor( aColor );
1095
1096                     if( p2ndOutDev )
1097                         p2ndOutDev->SetTextColor( aColor );
1098                     break;
1099
1100                 default:
1101                     ENSURE_OR_THROW( false,
1102                                      "Unexpected color type");
1103                     break;
1104             }
1105         }
1106
1107         return nAlpha;
1108     }
1109
1110     bool CanvasHelper::setupTextOutput( ::Point&                                        o_rOutPos,
1111                                         const rendering::ViewState&                     viewState,
1112                                         const rendering::RenderState&                   renderState,
1113                                         const uno::Reference< rendering::XCanvasFont >& xFont   ) const
1114     {
1115         ENSURE_OR_THROW( mpOutDevProvider,
1116                          "outdev null. Are we disposed?" );
1117
1118         OutputDevice& rOutDev( mpOutDevProvider->getOutDev() );
1119
1120         setupOutDevState( viewState, renderState, TEXT_COLOR );
1121
1122         CanvasFont* pFont = dynamic_cast< CanvasFont* >( xFont.get() );
1123
1124         ENSURE_ARG_OR_THROW( pFont,
1125                              "Font not compatible with this canvas" );
1126
1127         vcl::Font aVCLFont = pFont->getVCLFont();
1128
1129         Color aColor( COL_BLACK );
1130
1131         if( renderState.DeviceColor.getLength() > 2 )
1132         {
1133             aColor = vcl::unotools::stdColorSpaceSequenceToColor(
1134                 renderState.DeviceColor );
1135         }
1136
1137         // setup font color
1138         aVCLFont.SetColor( aColor );
1139         aVCLFont.SetFillColor( aColor );
1140
1141         // no need to replicate this for mp2ndOutDev, we're modifying only aVCLFont here.
1142         if( !tools::setupFontTransform( o_rOutPos, aVCLFont, viewState, renderState, rOutDev ) )
1143             return false;
1144
1145         rOutDev.SetFont( aVCLFont );
1146
1147         if( mp2ndOutDevProvider )
1148             mp2ndOutDevProvider->getOutDev().SetFont( aVCLFont );
1149
1150         return true;
1151     }
1152
1153     bool CanvasHelper::repaint( const GraphicObjectSharedPtr&   rGrf,
1154                                 const rendering::ViewState&     viewState,
1155                                 const rendering::RenderState&   renderState,
1156                                 const ::Point&                  rPt,
1157                                 const ::Size&                   rSz,
1158                                 const GraphicAttr&              rAttr ) const
1159     {
1160         ENSURE_OR_RETURN_FALSE( rGrf,
1161                           "Invalid Graphic" );
1162
1163         if( !mpOutDevProvider )
1164             return false; // disposed
1165         else
1166         {
1167             tools::OutDevStateKeeper aStateKeeper( mpProtectedOutDevProvider );
1168             setupOutDevState( viewState, renderState, IGNORE_COLOR );
1169
1170             if (!rGrf->Draw(mpOutDevProvider->getOutDev(), rPt, rSz, &rAttr))
1171                 return false;
1172
1173             // #i80779# Redraw also into mask outdev
1174             if (mp2ndOutDevProvider)
1175                 return rGrf->Draw(mp2ndOutDevProvider->getOutDev(), rPt, rSz, &rAttr);
1176
1177             return true;
1178         }
1179     }
1180
1181     void CanvasHelper::flush() const
1182     {
1183         if (mpOutDevProvider)
1184             mpOutDevProvider->getOutDev().Flush();
1185
1186         if  (mp2ndOutDevProvider)
1187             mp2ndOutDevProvider->getOutDev().Flush();
1188     }
1189
1190 }
1191
1192 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */