cppcanvas/source/wrapper/implpolypolygon.cxx

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