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