cppcanvas/source/mtfrenderer/polypolyaction.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
  21 #include <com/sun/star/rendering/XCanvas.hpp>
  22
  23 #include <sal/types.h>
  24
  25 #include <basegfx/range/b2drectangle.hxx>
  26 #include <basegfx/utils/canvastools.hxx>
  27 #include <basegfx/polygon/b2dpolypolygon.hxx>
  28 #include <basegfx/polygon/b2dpolypolygontools.hxx>
  29 #include <basegfx/matrix/b2dhommatrix.hxx>
  30 #include <canvas/canvastools.hxx>
  31 #include <sal/log.hxx>
  32
  33 #include "cachedprimitivebase.hxx"
  34 #include "polypolyaction.hxx"
  35 #include <outdevstate.hxx>
  36 #include "mtftools.hxx"
  37
  38
  39 using namespace ::com::sun::star;
  40
  41 namespace cppcanvas::internal
  42 {
  43         namespace
  44         {
  45             class PolyPolyAction : public CachedPrimitiveBase
  46             {
  47             public:
  48                 PolyPolyAction( const ::basegfx::B2DPolyPolygon&,
  49                                 const CanvasSharedPtr&,
  50                                 const OutDevState&,
  51                                 bool bFill,
  52                                 bool bStroke );
  53                 PolyPolyAction( const ::basegfx::B2DPolyPolygon&,
  54                                 const CanvasSharedPtr&,
  55                                 const OutDevState&,
  56                                 bool bFill,
  57                                 bool bStroke,
  58                                 int nTransparency );
  59
  60                 virtual bool renderSubset( const ::basegfx::B2DHomMatrix& rTransformation,
  61                                            const Subset&                  rSubset ) const override;
  62
  63                 virtual ::basegfx::B2DRange getBounds( const ::basegfx::B2DHomMatrix& rTransformation ) const override;
  64                 virtual ::basegfx::B2DRange getBounds( const ::basegfx::B2DHomMatrix&   rTransformation,
  65                                                        const Subset&                    rSubset ) const override;
  66
  67                 virtual sal_Int32 getActionCount() const override;
  68
  69             private:
  70                 using Action::render;
  71                 virtual bool renderPrimitive( uno::Reference< rendering::XCachedPrimitive >& rCachedPrimitive,
  72                                               const ::basegfx::B2DHomMatrix&                 rTransformation ) const override;
  73
  74                 const uno::Reference< rendering::XPolyPolygon2D >   mxPolyPoly;
  75                 const ::basegfx::B2DRange                           maBounds;
  76                 const CanvasSharedPtr                               mpCanvas;
  77
  78                 // stroke color is now implicit: the maState.DeviceColor member
  79                 rendering::RenderState                              maState;
  80
  81                 uno::Sequence< double >                             maFillColor;
  82             };
  83
  84             PolyPolyAction::PolyPolyAction( const ::basegfx::B2DPolyPolygon&    rPolyPoly,
  85                                             const CanvasSharedPtr&              rCanvas,
  86                                             const OutDevState&                  rState,
  87                                             bool                                bFill,
  88                                             bool                                bStroke ) :
  89                 CachedPrimitiveBase( rCanvas, false ),
  90                 mxPolyPoly( ::basegfx::unotools::xPolyPolygonFromB2DPolyPolygon( rCanvas->getUNOCanvas()->getDevice(), rPolyPoly) ),
  91                 maBounds( ::basegfx::utils::getRange(rPolyPoly) ),
  92                 mpCanvas( rCanvas )
  93             {
  94                 tools::initRenderState(maState,rState);
  95
  96                 if( bFill )
  97                     maFillColor = rState.fillColor;
  98
  99                 if( bStroke )
 100                     maState.DeviceColor = rState.lineColor;
 101             }
 102
 103             PolyPolyAction::PolyPolyAction( const ::basegfx::B2DPolyPolygon&    rPolyPoly,
 104                                             const CanvasSharedPtr&              rCanvas,
 105                                             const OutDevState&                  rState,
 106                                             bool                                bFill,
 107                                             bool                                bStroke,
 108                                             int                                 nTransparency ) :
 109                 CachedPrimitiveBase( rCanvas, false ),
 110                 mxPolyPoly( ::basegfx::unotools::xPolyPolygonFromB2DPolyPolygon( rCanvas->getUNOCanvas()->getDevice(), rPolyPoly) ),
 111                 maBounds( ::basegfx::utils::getRange(rPolyPoly) ),
 112                 mpCanvas( rCanvas )
 113             {
 114                 tools::initRenderState(maState,rState);
 115
 116                 if( bFill )
 117                 {
 118                     maFillColor = rState.fillColor;
 119
 120                     if( maFillColor.getLength() < 4 )
 121                         maFillColor.realloc( 4 );
 122
 123                     // TODO(F1): Color management
 124                     // adapt fill color transparency
 125                     maFillColor.getArray()[3] = 1.0 - nTransparency / 100.0;
 126                 }
 127
 128                 if( bStroke )
 129                 {
 130                     maState.DeviceColor = rState.lineColor;
 131
 132                     if( maState.DeviceColor.getLength() < 4 )
 133                         maState.DeviceColor.realloc( 4 );
 134
 135                     // TODO(F1): Color management
 136                     // adapt fill color transparency
 137                     maState.DeviceColor.getArray()[3] = 1.0 - nTransparency / 100.0;
 138                 }
 139             }
 140
 141             bool PolyPolyAction::renderPrimitive( uno::Reference< rendering::XCachedPrimitive >& rCachedPrimitive,
 142                                                   const ::basegfx::B2DHomMatrix&                 rTransformation ) const
 143             {
 144                 SAL_INFO( "cppcanvas.emf", "::cppcanvas::internal::PolyPolyAction::renderPrimitive()" );
 145                 SAL_INFO( "cppcanvas.emf", "::cppcanvas::internal::PolyPolyAction: 0x" << std::hex << this );
 146
 147                 rendering::RenderState aLocalState( maState );
 148                 ::canvas::tools::prependToRenderState(aLocalState, rTransformation);
 149
 150                 if( maFillColor.hasElements() )
 151                 {
 152                     // TODO(E3): Use DBO's finalizer here,
 153                     // fillPolyPolygon() might throw
 154                     const uno::Sequence< double > aTmpColor( aLocalState.DeviceColor );
 155                     aLocalState.DeviceColor = maFillColor;
 156
 157                     rCachedPrimitive = mpCanvas->getUNOCanvas()->fillPolyPolygon( mxPolyPoly,
 158                                                                                   mpCanvas->getViewState(),
 159                                                                                   aLocalState );
 160
 161                     aLocalState.DeviceColor = aTmpColor;
 162                 }
 163
 164                 if( aLocalState.DeviceColor.hasElements() )
 165                 {
 166                     rCachedPrimitive = mpCanvas->getUNOCanvas()->drawPolyPolygon( mxPolyPoly,
 167                                                                                   mpCanvas->getViewState(),
 168                                                                                   aLocalState );
 169                 }
 170
 171                 return true;
 172             }
 173
 174             bool PolyPolyAction::renderSubset( const ::basegfx::B2DHomMatrix& rTransformation,
 175                                                const Subset&                  rSubset ) const
 176             {
 177                 // TODO(F1): Split up poly-polygon into polygons, or even
 178                 // line segments, when subsets are requested.
 179
 180                 // polygon only contains a single action, fail if subset
 181                 // requests different range
 182                 if( rSubset.mnSubsetBegin != 0 ||
 183                     rSubset.mnSubsetEnd != 1 )
 184                     return false;
 185
 186                 return CachedPrimitiveBase::render( rTransformation );
 187             }
 188
 189             ::basegfx::B2DRange PolyPolyAction::getBounds( const ::basegfx::B2DHomMatrix&   rTransformation ) const
 190             {
 191                 rendering::RenderState aLocalState( maState );
 192                 ::canvas::tools::prependToRenderState(aLocalState, rTransformation);
 193
 194                 return tools::calcDevicePixelBounds(
 195                     maBounds,
 196                     mpCanvas->getViewState(),
 197                     aLocalState );
 198             }
 199
 200             ::basegfx::B2DRange PolyPolyAction::getBounds( const ::basegfx::B2DHomMatrix&   rTransformation,
 201                                                            const Subset&                    rSubset ) const
 202             {
 203                 // TODO(F1): Split up poly-polygon into polygons, or even
 204                 // line segments, when subsets are requested.
 205
 206                 // polygon only contains a single action, empty bounds
 207                 // if subset requests different range
 208                 if( rSubset.mnSubsetBegin != 0 ||
 209                     rSubset.mnSubsetEnd != 1 )
 210                     return ::basegfx::B2DRange();
 211
 212                 return getBounds( rTransformation );
 213             }
 214
 215             sal_Int32 PolyPolyAction::getActionCount() const
 216             {
 217                 // TODO(F1): Split up poly-polygon into polygons, or even
 218                 // line segments, when subsets are requested.
 219                 return 1;
 220             }
 221
 222
 223             class TexturedPolyPolyAction : public CachedPrimitiveBase
 224             {
 225             public:
 226                 TexturedPolyPolyAction( const ::basegfx::B2DPolyPolygon& rPoly,
 227                                         const CanvasSharedPtr&           rCanvas,
 228                                         const OutDevState&               rState,
 229                                         const rendering::Texture&        rTexture );
 230
 231                 virtual bool renderSubset( const ::basegfx::B2DHomMatrix& rTransformation,
 232                                            const Subset&                  rSubset ) const override;
 233
 234                 virtual ::basegfx::B2DRange getBounds( const ::basegfx::B2DHomMatrix& rTransformation ) const override;
 235                 virtual ::basegfx::B2DRange getBounds( const ::basegfx::B2DHomMatrix&   rTransformation,
 236                                                        const Subset&                    rSubset ) const override;
 237
 238                 virtual sal_Int32 getActionCount() const override;
 239
 240             private:
 241                 using Action::render;
 242                 virtual bool renderPrimitive( uno::Reference< rendering::XCachedPrimitive >& rCachedPrimitive,
 243                                               const ::basegfx::B2DHomMatrix&                 rTransformation ) const override;
 244
 245                 const uno::Reference< rendering::XPolyPolygon2D >   mxPolyPoly;
 246                 const ::basegfx::B2DRectangle                       maBounds;
 247                 const CanvasSharedPtr                               mpCanvas;
 248
 249                 // stroke color is now implicit: the maState.DeviceColor member
 250                 rendering::RenderState                              maState;
 251                 const rendering::Texture                            maTexture;
 252             };
 253
 254             TexturedPolyPolyAction::TexturedPolyPolyAction( const ::basegfx::B2DPolyPolygon& rPolyPoly,
 255                                                             const CanvasSharedPtr&           rCanvas,
 256                                                             const OutDevState&               rState,
 257                                                             const rendering::Texture&        rTexture ) :
 258                 CachedPrimitiveBase( rCanvas, true ),
 259                 mxPolyPoly( ::basegfx::unotools::xPolyPolygonFromB2DPolyPolygon( rCanvas->getUNOCanvas()->getDevice(), rPolyPoly) ),
 260                 maBounds( ::basegfx::utils::getRange(rPolyPoly) ),
 261                 mpCanvas( rCanvas ),
 262                 maTexture( rTexture )
 263             {
 264                 tools::initRenderState(maState,rState);
 265             }
 266
 267             bool TexturedPolyPolyAction::renderPrimitive( uno::Reference< rendering::XCachedPrimitive >& rCachedPrimitive,
 268                                                           const ::basegfx::B2DHomMatrix&                 rTransformation ) const
 269             {
 270                 SAL_INFO( "cppcanvas.emf", "::cppcanvas::internal::PolyPolyAction::renderPrimitive()" );
 271                 SAL_INFO( "cppcanvas.emf", "::cppcanvas::internal::PolyPolyAction: 0x" << std::hex << this );
 272
 273                 rendering::RenderState aLocalState( maState );
 274                 ::canvas::tools::prependToRenderState(aLocalState, rTransformation);
 275
 276                 uno::Sequence< rendering::Texture > aSeq { maTexture };
 277
 278                 rCachedPrimitive = mpCanvas->getUNOCanvas()->fillTexturedPolyPolygon( mxPolyPoly,
 279                                                                                       mpCanvas->getViewState(),
 280                                                                                       aLocalState,
 281                                                                                       aSeq );
 282                 return true;
 283             }
 284
 285             bool TexturedPolyPolyAction::renderSubset( const ::basegfx::B2DHomMatrix& rTransformation,
 286                                                        const Subset&                  rSubset ) const
 287             {
 288                 // TODO(F1): Split up poly-polygon into polygons, or even
 289                 // line segments, when subsets are requested.
 290
 291                 // polygon only contains a single action, fail if subset
 292                 // requests different range
 293                 if( rSubset.mnSubsetBegin != 0 ||
 294                     rSubset.mnSubsetEnd != 1 )
 295                     return false;
 296
 297                 return CachedPrimitiveBase::render( rTransformation );
 298             }
 299
 300             ::basegfx::B2DRange TexturedPolyPolyAction::getBounds( const ::basegfx::B2DHomMatrix&   rTransformation ) const
 301             {
 302                 rendering::RenderState aLocalState( maState );
 303                 ::canvas::tools::prependToRenderState(aLocalState, rTransformation);
 304
 305                 return tools::calcDevicePixelBounds(
 306                     maBounds,
 307                     mpCanvas->getViewState(),
 308                     aLocalState );
 309             }
 310
 311             ::basegfx::B2DRange TexturedPolyPolyAction::getBounds( const ::basegfx::B2DHomMatrix&   rTransformation,
 312                                                                    const Subset&                    rSubset ) const
 313             {
 314                 // TODO(F1): Split up poly-polygon into polygons, or even
 315                 // line segments, when subsets are requested.
 316
 317                 // polygon only contains a single action, empty bounds
 318                 // if subset requests different range
 319                 if( rSubset.mnSubsetBegin != 0 ||
 320                     rSubset.mnSubsetEnd != 1 )
 321                     return ::basegfx::B2DRange();
 322
 323                 return getBounds( rTransformation );
 324             }
 325
 326             sal_Int32 TexturedPolyPolyAction::getActionCount() const
 327             {
 328                 // TODO(F1): Split up poly-polygon into polygons, or even
 329                 // line segments, when subsets are requested.
 330                 return 1;
 331             }
 332
 333
 334             class StrokedPolyPolyAction : public CachedPrimitiveBase
 335             {
 336             public:
 337                 StrokedPolyPolyAction( const ::basegfx::B2DPolyPolygon&     rPoly,
 338                                        const CanvasSharedPtr&               rCanvas,
 339                                        const OutDevState&                   rState,
 340                                        const rendering::StrokeAttributes&   rStrokeAttributes );
 341
 342                 virtual bool renderSubset( const ::basegfx::B2DHomMatrix& rTransformation,
 343                                            const Subset&                  rSubset ) const override;
 344
 345                 virtual ::basegfx::B2DRange getBounds( const ::basegfx::B2DHomMatrix& rTransformation ) const override;
 346                 virtual ::basegfx::B2DRange getBounds( const ::basegfx::B2DHomMatrix&   rTransformation,
 347                                                        const Subset&                    rSubset ) const override;
 348
 349                 virtual sal_Int32 getActionCount() const override;
 350
 351             private:
 352                 using Action::render;
 353                 virtual bool renderPrimitive( uno::Reference< rendering::XCachedPrimitive >& rCachedPrimitive,
 354                                               const ::basegfx::B2DHomMatrix&                 rTransformation ) const override;
 355
 356                 const uno::Reference< rendering::XPolyPolygon2D >   mxPolyPoly;
 357                 const ::basegfx::B2DRectangle                       maBounds;
 358                 const CanvasSharedPtr                               mpCanvas;
 359                 rendering::RenderState                              maState;
 360                 const rendering::StrokeAttributes                   maStrokeAttributes;
 361             };
 362
 363             StrokedPolyPolyAction::StrokedPolyPolyAction( const ::basegfx::B2DPolyPolygon&      rPolyPoly,
 364                                                           const CanvasSharedPtr&                rCanvas,
 365                                                           const OutDevState&                    rState,
 366                                                           const rendering::StrokeAttributes&    rStrokeAttributes ) :
 367                 CachedPrimitiveBase( rCanvas, false ),
 368                 mxPolyPoly( ::basegfx::unotools::xPolyPolygonFromB2DPolyPolygon( rCanvas->getUNOCanvas()->getDevice(), rPolyPoly) ),
 369                 maBounds( ::basegfx::utils::getRange(rPolyPoly) ),
 370                 mpCanvas( rCanvas ),
 371                 maStrokeAttributes( rStrokeAttributes )
 372             {
 373                 tools::initRenderState(maState,rState);
 374                 maState.DeviceColor = rState.lineColor;
 375             }
 376
 377             bool StrokedPolyPolyAction::renderPrimitive( uno::Reference< rendering::XCachedPrimitive >& rCachedPrimitive,
 378                                                          const ::basegfx::B2DHomMatrix&                 rTransformation ) const
 379             {
 380                 SAL_INFO( "cppcanvas.emf", "::cppcanvas::internal::PolyPolyAction::renderPrimitive()" );
 381                 SAL_INFO( "cppcanvas.emf", "::cppcanvas::internal::PolyPolyAction: 0x" << std::hex << this );
 382
 383                 rendering::RenderState aLocalState( maState );
 384                 ::canvas::tools::prependToRenderState(aLocalState, rTransformation);
 385
 386                 rCachedPrimitive = mpCanvas->getUNOCanvas()->strokePolyPolygon( mxPolyPoly,
 387                                                                                 mpCanvas->getViewState(),
 388                                                                                 aLocalState,
 389                                                                                 maStrokeAttributes );
 390                 return true;
 391             }
 392
 393             bool StrokedPolyPolyAction::renderSubset( const ::basegfx::B2DHomMatrix&  rTransformation,
 394                                                       const Subset&                   rSubset ) const
 395             {
 396                 // TODO(F1): Split up poly-polygon into polygons, or even
 397                 // line segments, when subsets are requested.
 398
 399                 // polygon only contains a single action, fail if subset
 400                 // requests different range
 401                 if( rSubset.mnSubsetBegin != 0 ||
 402                     rSubset.mnSubsetEnd != 1 )
 403                     return false;
 404
 405                 return CachedPrimitiveBase::render( rTransformation );
 406             }
 407
 408             ::basegfx::B2DRange StrokedPolyPolyAction::getBounds( const ::basegfx::B2DHomMatrix&    rTransformation ) const
 409             {
 410                 rendering::RenderState aLocalState( maState );
 411                 ::canvas::tools::prependToRenderState(aLocalState, rTransformation);
 412
 413                 return tools::calcDevicePixelBounds(
 414                     maBounds,
 415                     mpCanvas->getViewState(),
 416                     aLocalState );
 417             }
 418
 419             ::basegfx::B2DRange StrokedPolyPolyAction::getBounds( const ::basegfx::B2DHomMatrix&    rTransformation,
 420                                                                   const Subset&                 rSubset ) const
 421             {
 422                 // TODO(F1): Split up poly-polygon into polygons, or even
 423                 // line segments, when subsets are requested.
 424
 425                 // polygon only contains a single action, empty bounds
 426                 // if subset requests different range
 427                 if( rSubset.mnSubsetBegin != 0 ||
 428                     rSubset.mnSubsetEnd != 1 )
 429                     return ::basegfx::B2DRange();
 430
 431                 return getBounds( rTransformation );
 432             }
 433
 434             sal_Int32 StrokedPolyPolyAction::getActionCount() const
 435             {
 436                 // TODO(F1): Split up poly-polygon into polygons, or even
 437                 // line segments, when subsets are requested.
 438                 return 1;
 439             }
 440         }
 441
 442         std::shared_ptr<Action> PolyPolyActionFactory::createPolyPolyAction( const ::basegfx::B2DPolyPolygon& rPoly,
 443                                                                      const CanvasSharedPtr&           rCanvas,
 444                                                                      const OutDevState&               rState    )
 445         {
 446             OSL_ENSURE( rState.isLineColorSet || rState.isFillColorSet,
 447                         "PolyPolyActionFactory::createPolyPolyAction() with empty line and fill color" );
 448             return std::make_shared<PolyPolyAction>( rPoly, rCanvas, rState,
 449                                                      rState.isFillColorSet,
 450                                                      rState.isLineColorSet );
 451         }
 452
 453         std::shared_ptr<Action> PolyPolyActionFactory::createPolyPolyAction( const ::basegfx::B2DPolyPolygon&   rPoly,
 454                                                                      const CanvasSharedPtr&             rCanvas,
 455                                                                      const OutDevState&                 rState,
 456                                                                      const rendering::Texture&          rTexture )
 457         {
 458             return std::make_shared<TexturedPolyPolyAction>( rPoly, rCanvas, rState, rTexture );
 459         }
 460
 461         std::shared_ptr<Action> PolyPolyActionFactory::createLinePolyPolyAction( const ::basegfx::B2DPolyPolygon& rPoly,
 462                                                                          const CanvasSharedPtr&           rCanvas,
 463                                                                          const OutDevState&               rState )
 464         {
 465             OSL_ENSURE( rState.isLineColorSet,
 466                         "PolyPolyActionFactory::createLinePolyPolyAction() called with empty line color" );
 467
 468             return std::make_shared<PolyPolyAction>( rPoly, rCanvas, rState,
 469                                                      false,
 470                                                      rState.isLineColorSet );
 471         }
 472
 473         std::shared_ptr<Action> PolyPolyActionFactory::createPolyPolyAction( const ::basegfx::B2DPolyPolygon&   rPoly,
 474                                                                      const CanvasSharedPtr&             rCanvas,
 475                                                                      const OutDevState&                 rState,
 476                                                                      const rendering::StrokeAttributes& rStrokeAttributes )
 477         {
 478             OSL_ENSURE( rState.isLineColorSet,
 479                         "PolyPolyActionFactory::createPolyPolyAction() for strokes called with empty line color" );
 480             return std::make_shared<StrokedPolyPolyAction>( rPoly, rCanvas, rState, rStrokeAttributes );
 481         }
 482
 483         std::shared_ptr<Action> PolyPolyActionFactory::createPolyPolyAction( const ::basegfx::B2DPolyPolygon& rPoly,
 484                                                                      const CanvasSharedPtr&           rCanvas,
 485                                                                      const OutDevState&               rState,
 486                                                                      int                              nTransparency     )
 487         {
 488             OSL_ENSURE( rState.isLineColorSet || rState.isFillColorSet,
 489                         "PolyPolyActionFactory::createPolyPolyAction() with empty line and fill color" );
 490             return std::make_shared<PolyPolyAction>( rPoly, rCanvas, rState,
 491                                                      rState.isFillColorSet,
 492                                                      rState.isLineColorSet,
 493                                                      nTransparency );
 494         }
 495
 496 }
 497
 498 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */