cppcanvas/source/wrapper/implpolypolygon.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: implpolypolygon.cxx,v $
  10  * $Revision: 1.10 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_cppcanvas.hxx"
  33
  34 #include <rtl/math.hxx>
  35
  36 #include <com/sun/star/rendering/XCanvas.hpp>
  37 #include <com/sun/star/rendering/PathJoinType.hpp>
  38 #include <com/sun/star/rendering/PathCapType.hpp>
  39
  40 #include <basegfx/matrix/b2dhommatrix.hxx>
  41 #include <basegfx/tools/canvastools.hxx>
  42
  43 #include "implpolypolygon.hxx"
  44 #include "tools.hxx"
  45
  46
  47 using namespace ::com::sun::star;
  48
  49
  50 namespace cppcanvas
  51 {
  52     namespace internal
  53     {
  54         ImplPolyPolygon::ImplPolyPolygon( const CanvasSharedPtr& rParentCanvas,
  55                                           const uno::Reference< rendering::XPolyPolygon2D >& rPolyPoly ) :
  56             CanvasGraphicHelper( rParentCanvas ),
  57             mxPolyPoly( rPolyPoly ),
  58             maStrokeAttributes(1.0,
  59                                10.0,
  60                                uno::Sequence< double >(),
  61                                uno::Sequence< double >(),
  62                                rendering::PathCapType::ROUND,
  63                                rendering::PathCapType::ROUND,
  64                                rendering::PathJoinType::ROUND ),
  65             maFillColor(),
  66             maStrokeColor(),
  67             mbFillColorSet( false ),
  68             mbStrokeColorSet( false )
  69         {
  70             OSL_ENSURE( mxPolyPoly.is(), "PolyPolygonImpl::PolyPolygonImpl: no valid polygon" );
  71         }
  72
  73         ImplPolyPolygon::~ImplPolyPolygon()
  74         {
  75         }
  76
  77         void ImplPolyPolygon::addPolygon( const ::basegfx::B2DPolygon& rPoly )
  78         {
  79             OSL_ENSURE( mxPolyPoly.is(),
  80                         "ImplPolyPolygon::addPolygon(): Invalid polygon" );
  81
  82             if( !mxPolyPoly.is() )
  83                 return;
  84
  85             uno::Reference< rendering::XGraphicDevice > xDevice( getGraphicDevice() );
  86
  87             OSL_ENSURE( xDevice.is(),
  88                         "ImplPolyPolygon::addPolygon(): Invalid graphic device" );
  89
  90             if( !xDevice.is() )
  91                 return;
  92
  93             mxPolyPoly->addPolyPolygon( geometry::RealPoint2D(0.0, 0.0),
  94                                         ::basegfx::unotools::xPolyPolygonFromB2DPolygon(
  95                                             xDevice,
  96                                             rPoly) );
  97         }
  98
  99         void ImplPolyPolygon::addPolyPolygon( const ::basegfx::B2DPolyPolygon& rPoly )
 100         {
 101             OSL_ENSURE( mxPolyPoly.is(),
 102                         "ImplPolyPolygon::addPolyPolygon(): Invalid polygon" );
 103
 104             if( !mxPolyPoly.is() )
 105                 return;
 106
 107             uno::Reference< rendering::XGraphicDevice > xDevice( getGraphicDevice() );
 108
 109             OSL_ENSURE( xDevice.is(),
 110                         "ImplPolyPolygon::addPolyPolygon(): Invalid graphic device" );
 111
 112             if( !xDevice.is() )
 113                 return;
 114
 115             mxPolyPoly->addPolyPolygon( geometry::RealPoint2D(0.0, 0.0),
 116                                         ::basegfx::unotools::xPolyPolygonFromB2DPolyPolygon(
 117                                             xDevice,
 118                                             rPoly) );
 119         }
 120
 121         void ImplPolyPolygon::setRGBAFillColor( Color::IntSRGBA aColor )
 122         {
 123             maFillColor = tools::intSRGBAToDoubleSequence( getGraphicDevice(),
 124                                                            aColor );
 125             mbFillColorSet = true;
 126         }
 127
 128         void ImplPolyPolygon::setRGBALineColor( Color::IntSRGBA aColor )
 129         {
 130             maStrokeColor = tools::intSRGBAToDoubleSequence( getGraphicDevice(),
 131                                                              aColor );
 132             mbStrokeColorSet = true;
 133         }
 134
 135         Color::IntSRGBA ImplPolyPolygon::getRGBAFillColor() const
 136         {
 137             return tools::doubleSequenceToIntSRGBA( getGraphicDevice(),
 138                                                     maFillColor );
 139         }
 140
 141         Color::IntSRGBA ImplPolyPolygon::getRGBALineColor() const
 142         {
 143             return tools::doubleSequenceToIntSRGBA( getGraphicDevice(),
 144                                                     maStrokeColor );
 145         }
 146
 147         void ImplPolyPolygon::setStrokeWidth( const double& rStrokeWidth )
 148         {
 149             maStrokeAttributes.StrokeWidth = rStrokeWidth;
 150         }
 151
 152         double ImplPolyPolygon::getStrokeWidth() const
 153         {
 154             return maStrokeAttributes.StrokeWidth;
 155         }
 156
 157         bool ImplPolyPolygon::draw() const
 158         {
 159             CanvasSharedPtr pCanvas( getCanvas() );
 160
 161             OSL_ENSURE( pCanvas.get() != NULL &&
 162                         pCanvas->getUNOCanvas().is(),
 163                         "ImplBitmap::draw: invalid canvas" );
 164
 165             if( pCanvas.get() == NULL ||
 166                 !pCanvas->getUNOCanvas().is() )
 167                 return false;
 168
 169             if( mbFillColorSet )
 170             {
 171                 rendering::RenderState aLocalState( getRenderState() );
 172                 aLocalState.DeviceColor = maFillColor;
 173
 174                 pCanvas->getUNOCanvas()->fillPolyPolygon( mxPolyPoly,
 175                                                           pCanvas->getViewState(),
 176                                                           aLocalState );
 177             }
 178
 179             if( mbStrokeColorSet )
 180             {
 181                 rendering::RenderState aLocalState( getRenderState() );
 182                 aLocalState.DeviceColor = maStrokeColor;
 183
 184                 if( ::rtl::math::approxEqual(maStrokeAttributes.StrokeWidth, 1.0) )
 185                     pCanvas->getUNOCanvas()->drawPolyPolygon( mxPolyPoly,
 186                                                               pCanvas->getViewState(),
 187                                                               aLocalState );
 188                 else
 189                     pCanvas->getUNOCanvas()->strokePolyPolygon( mxPolyPoly,
 190                                                                 pCanvas->getViewState(),
 191                                                                 aLocalState,
 192                                                                 maStrokeAttributes );
 193             }
 194
 195             return true;
 196         }
 197
 198         uno::Reference< rendering::XPolyPolygon2D > ImplPolyPolygon::getUNOPolyPolygon() const
 199         {
 200             return mxPolyPoly;
 201         }
 202
 203     }
 204 }