LCOV - code coverage report
Current view: top level - basegfx/source/tools - unopolypolygon.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 22 183 12.0 %
Date: 2015-06-13 12:38:46 Functions: 4 21 19.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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 <com/sun/star/geometry/AffineMatrix2D.hpp>
      21             : #include <com/sun/star/rendering/RenderState.hpp>
      22             : #include <com/sun/star/rendering/ViewState.hpp>
      23             : #include <com/sun/star/rendering/XCanvas.hpp>
      24             : #include <com/sun/star/rendering/CompositeOperation.hpp>
      25             : 
      26             : #include <basegfx/matrix/b2dhommatrix.hxx>
      27             : #include <basegfx/range/b2drange.hxx>
      28             : #include <basegfx/range/b2drectangle.hxx>
      29             : #include <basegfx/point/b2dpoint.hxx>
      30             : #include <basegfx/tools/canvastools.hxx>
      31             : #include <basegfx/polygon/b2dpolygon.hxx>
      32             : #include <basegfx/polygon/b2dpolypolygontools.hxx>
      33             : #include <basegfx/tools/unopolypolygon.hxx>
      34             : #include <basegfx/matrix/b2dhommatrixtools.hxx>
      35             : #include <cppuhelper/supportsservice.hxx>
      36             : 
      37             : using namespace ::com::sun::star;
      38             : 
      39             : namespace basegfx
      40             : {
      41             : namespace unotools
      42             : {
      43          34 :     UnoPolyPolygon::UnoPolyPolygon( const B2DPolyPolygon& rPolyPoly ) :
      44             :         UnoPolyPolygonBase( m_aMutex ),
      45             :         maPolyPoly( rPolyPoly ),
      46          34 :         meFillRule( rendering::FillRule_EVEN_ODD )
      47             :     {
      48             :         // or else races will haunt us.
      49          34 :         maPolyPoly.makeUnique();
      50          34 :     }
      51             : 
      52           0 :     void SAL_CALL UnoPolyPolygon::addPolyPolygon(
      53             :         const geometry::RealPoint2D&                        position,
      54             :         const uno::Reference< rendering::XPolyPolygon2D >&  polyPolygon ) throw (lang::IllegalArgumentException,uno::RuntimeException, std::exception)
      55             :     {
      56           0 :         osl::MutexGuard const guard( m_aMutex );
      57           0 :         modifying();
      58             : 
      59             :         // TODO(F1): Correctly fulfill the UNO API
      60             :         // specification. This will probably result in a vector of
      61             :         // poly-polygons to be stored in this object.
      62             : 
      63           0 :         const sal_Int32 nPolys( polyPolygon->getNumberOfPolygons() );
      64             : 
      65           0 :         if( !polyPolygon.is() || !nPolys )
      66             :         {
      67             :             // invalid or empty polygon - nothing to do.
      68           0 :             return;
      69             :         }
      70             : 
      71           0 :         B2DPolyPolygon        aSrcPoly;
      72           0 :         const UnoPolyPolygon* pSrc( dynamic_cast< UnoPolyPolygon* >(polyPolygon.get()) );
      73             : 
      74             :         // try to extract polygon data from interface. First,
      75             :         // check whether it's the same implementation object,
      76             :         // which we can tunnel then.
      77           0 :         if( pSrc )
      78             :         {
      79           0 :             aSrcPoly = pSrc->getPolyPolygon();
      80             :         }
      81             :         else
      82             :         {
      83             :             // not a known implementation object - try data source
      84             :             // interfaces
      85             :             uno::Reference< rendering::XBezierPolyPolygon2D > xBezierPoly(
      86             :                 polyPolygon,
      87           0 :                 uno::UNO_QUERY );
      88             : 
      89           0 :             if( xBezierPoly.is() )
      90             :             {
      91           0 :                 aSrcPoly = unotools::polyPolygonFromBezier2DSequenceSequence(
      92           0 :                     xBezierPoly->getBezierSegments( 0,
      93             :                                                     nPolys,
      94             :                                                     0,
      95           0 :                                                     -1 ) );
      96             :             }
      97             :             else
      98             :             {
      99             :                 uno::Reference< rendering::XLinePolyPolygon2D > xLinePoly(
     100             :                     polyPolygon,
     101           0 :                     uno::UNO_QUERY );
     102             : 
     103             :                 // no implementation class and no data provider
     104             :                 // found - contract violation.
     105           0 :                 if( !xLinePoly.is() )
     106             :                     throw lang::IllegalArgumentException(
     107             :                         "UnoPolyPolygon::addPolyPolygon(): Invalid input "
     108             :                         "poly-polygon, cannot retrieve vertex data",
     109           0 :                         static_cast<cppu::OWeakObject*>(this), 1);
     110             : 
     111           0 :                 aSrcPoly = unotools::polyPolygonFromPoint2DSequenceSequence(
     112           0 :                     xLinePoly->getPoints( 0,
     113             :                                           nPolys,
     114             :                                           0,
     115           0 :                                           -1 ) );
     116           0 :             }
     117             :         }
     118             : 
     119           0 :         const B2DRange  aBounds( tools::getRange( aSrcPoly ) );
     120           0 :         const B2DVector     aOffset( unotools::b2DPointFromRealPoint2D( position ) -
     121           0 :                                              aBounds.getMinimum() );
     122             : 
     123           0 :         if( !aOffset.equalZero() )
     124             :         {
     125           0 :             const B2DHomMatrix aTranslate(tools::createTranslateB2DHomMatrix(aOffset));
     126           0 :             aSrcPoly.transform( aTranslate );
     127             :         }
     128             : 
     129           0 :         maPolyPoly.append( aSrcPoly );
     130             :     }
     131             : 
     132           0 :     sal_Int32 SAL_CALL UnoPolyPolygon::getNumberOfPolygons() throw (uno::RuntimeException, std::exception)
     133             :     {
     134           0 :         osl::MutexGuard const guard( m_aMutex );
     135           0 :         return maPolyPoly.count();
     136             :     }
     137             : 
     138           0 :     sal_Int32 SAL_CALL UnoPolyPolygon::getNumberOfPolygonPoints(
     139             :         sal_Int32 polygon ) throw (lang::IndexOutOfBoundsException,uno::RuntimeException, std::exception)
     140             :     {
     141           0 :         osl::MutexGuard const guard( m_aMutex );
     142           0 :         checkIndex( polygon );
     143             : 
     144           0 :         return maPolyPoly.getB2DPolygon(polygon).count();
     145             :     }
     146             : 
     147          22 :     rendering::FillRule SAL_CALL UnoPolyPolygon::getFillRule() throw (uno::RuntimeException, std::exception)
     148             :     {
     149          22 :         osl::MutexGuard const guard( m_aMutex );
     150          22 :         return meFillRule;
     151             :     }
     152             : 
     153           0 :     void SAL_CALL UnoPolyPolygon::setFillRule(
     154             :         rendering::FillRule fillRule ) throw (uno::RuntimeException, std::exception)
     155             :     {
     156           0 :         osl::MutexGuard const guard( m_aMutex );
     157           0 :         modifying();
     158             : 
     159           0 :         meFillRule = fillRule;
     160           0 :     }
     161             : 
     162           0 :     sal_Bool SAL_CALL UnoPolyPolygon::isClosed(
     163             :         sal_Int32 index ) throw (lang::IndexOutOfBoundsException,uno::RuntimeException, std::exception)
     164             :     {
     165           0 :         osl::MutexGuard const guard( m_aMutex );
     166           0 :         checkIndex( index );
     167             : 
     168           0 :         return maPolyPoly.getB2DPolygon(index).isClosed();
     169             :     }
     170             : 
     171          48 :     void SAL_CALL UnoPolyPolygon::setClosed(
     172             :         sal_Int32 index,
     173             :         sal_Bool closedState ) throw (lang::IndexOutOfBoundsException,uno::RuntimeException, std::exception)
     174             :     {
     175          48 :         osl::MutexGuard const guard( m_aMutex );
     176          48 :         modifying();
     177             : 
     178          48 :         if( index == -1L )
     179             :         {
     180             :             // set all
     181           0 :             maPolyPoly.setClosed( closedState );
     182             :         }
     183             :         else
     184             :         {
     185          48 :             checkIndex( index );
     186             : 
     187             :             // fetch referenced polygon, change state
     188          48 :             B2DPolygon aTmp( maPolyPoly.getB2DPolygon(index) );
     189          48 :             aTmp.setClosed( closedState );
     190             : 
     191             :             // set back to container
     192          48 :             maPolyPoly.setB2DPolygon( index, aTmp );
     193          48 :         }
     194          48 :     }
     195             : 
     196           0 :     uno::Sequence< uno::Sequence< geometry::RealPoint2D > > SAL_CALL UnoPolyPolygon::getPoints(
     197             :         sal_Int32 nPolygonIndex,
     198             :         sal_Int32 nNumberOfPolygons,
     199             :         sal_Int32 nPointIndex,
     200             :         sal_Int32 nNumberOfPoints ) throw (lang::IndexOutOfBoundsException,uno::RuntimeException, std::exception)
     201             :     {
     202           0 :         osl::MutexGuard const guard( m_aMutex );
     203             : 
     204             :         return unotools::pointSequenceSequenceFromB2DPolyPolygon(
     205             :             getSubsetPolyPolygon( nPolygonIndex,
     206             :                                   nNumberOfPolygons,
     207             :                                   nPointIndex,
     208           0 :                                   nNumberOfPoints ) );
     209             :     }
     210             : 
     211           0 :     void SAL_CALL UnoPolyPolygon::setPoints(
     212             :         const uno::Sequence< uno::Sequence< geometry::RealPoint2D > >& points,
     213             :         sal_Int32 nPolygonIndex ) throw (lang::IndexOutOfBoundsException,uno::RuntimeException, std::exception)
     214             :     {
     215           0 :         osl::MutexGuard const guard( m_aMutex );
     216           0 :         modifying();
     217             : 
     218             :         const B2DPolyPolygon& rNewPolyPoly(
     219           0 :             unotools::polyPolygonFromPoint2DSequenceSequence( points ) );
     220             : 
     221           0 :         if( nPolygonIndex == -1 )
     222             :         {
     223           0 :             maPolyPoly = rNewPolyPoly;
     224             :         }
     225             :         else
     226             :         {
     227           0 :             checkIndex( nPolygonIndex );
     228             : 
     229           0 :             maPolyPoly.insert( nPolygonIndex, rNewPolyPoly );
     230           0 :         }
     231           0 :     }
     232             : 
     233           0 :     geometry::RealPoint2D SAL_CALL UnoPolyPolygon::getPoint(
     234             :         sal_Int32 nPolygonIndex,
     235             :         sal_Int32 nPointIndex ) throw (lang::IndexOutOfBoundsException,uno::RuntimeException, std::exception)
     236             :     {
     237           0 :         osl::MutexGuard const guard( m_aMutex );
     238           0 :         checkIndex( nPolygonIndex );
     239             : 
     240           0 :         const B2DPolygon& rPoly( maPolyPoly.getB2DPolygon( nPolygonIndex ) );
     241             : 
     242           0 :         if( nPointIndex < 0 || nPointIndex >= static_cast<sal_Int32>(rPoly.count()) )
     243           0 :             throw lang::IndexOutOfBoundsException();
     244             : 
     245           0 :         return unotools::point2DFromB2DPoint( rPoly.getB2DPoint( nPointIndex ) );
     246             :     }
     247             : 
     248           0 :     void SAL_CALL UnoPolyPolygon::setPoint(
     249             :         const geometry::RealPoint2D& point,
     250             :         sal_Int32 nPolygonIndex,
     251             :         sal_Int32 nPointIndex ) throw (lang::IndexOutOfBoundsException,uno::RuntimeException, std::exception)
     252             :     {
     253           0 :         osl::MutexGuard const guard( m_aMutex );
     254           0 :         checkIndex( nPolygonIndex );
     255           0 :         modifying();
     256             : 
     257           0 :         B2DPolygon aPoly( maPolyPoly.getB2DPolygon( nPolygonIndex ) );
     258             : 
     259           0 :         if( nPointIndex < 0 || nPointIndex >= static_cast<sal_Int32>(aPoly.count()) )
     260           0 :             throw lang::IndexOutOfBoundsException();
     261             : 
     262             :         aPoly.setB2DPoint( nPointIndex,
     263           0 :                            unotools::b2DPointFromRealPoint2D( point ) );
     264           0 :         maPolyPoly.setB2DPolygon( nPolygonIndex, aPoly );
     265           0 :     }
     266             : 
     267           0 :     uno::Sequence< uno::Sequence< geometry::RealBezierSegment2D > > SAL_CALL UnoPolyPolygon::getBezierSegments(
     268             :         sal_Int32 nPolygonIndex,
     269             :         sal_Int32 nNumberOfPolygons,
     270             :         sal_Int32 nPointIndex,
     271             :         sal_Int32 nNumberOfPoints ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException, std::exception)
     272             :     {
     273           0 :         osl::MutexGuard const guard( m_aMutex );
     274             :         return unotools::bezierSequenceSequenceFromB2DPolyPolygon(
     275             :             getSubsetPolyPolygon( nPolygonIndex,
     276             :                                   nNumberOfPolygons,
     277             :                                   nPointIndex,
     278           0 :                                   nNumberOfPoints ) );
     279             :     }
     280             : 
     281           0 :     void SAL_CALL UnoPolyPolygon::setBezierSegments(
     282             :         const uno::Sequence< uno::Sequence< geometry::RealBezierSegment2D > >&  points,
     283             :         sal_Int32                                                               nPolygonIndex ) throw (lang::IndexOutOfBoundsException,
     284             :                                                                                                        uno::RuntimeException, std::exception)
     285             :     {
     286           0 :         osl::MutexGuard const guard( m_aMutex );
     287           0 :         modifying();
     288             :         const B2DPolyPolygon& rNewPolyPoly(
     289           0 :             unotools::polyPolygonFromBezier2DSequenceSequence( points ) );
     290             : 
     291           0 :         if( nPolygonIndex == -1 )
     292             :         {
     293           0 :             maPolyPoly = rNewPolyPoly;
     294             :         }
     295             :         else
     296             :         {
     297           0 :             checkIndex( nPolygonIndex );
     298             : 
     299           0 :             maPolyPoly.insert( nPolygonIndex, rNewPolyPoly );
     300           0 :         }
     301           0 :     }
     302             : 
     303           0 :     geometry::RealBezierSegment2D SAL_CALL UnoPolyPolygon::getBezierSegment( sal_Int32 nPolygonIndex,
     304             :                                                                              sal_Int32 nPointIndex ) throw (lang::IndexOutOfBoundsException,
     305             :                                                                                                             uno::RuntimeException, std::exception)
     306             :     {
     307           0 :         osl::MutexGuard const guard( m_aMutex );
     308           0 :         checkIndex( nPolygonIndex );
     309             : 
     310           0 :         const B2DPolygon& rPoly( maPolyPoly.getB2DPolygon( nPolygonIndex ) );
     311           0 :         const sal_uInt32  nPointCount(rPoly.count());
     312             : 
     313           0 :         if( nPointIndex < 0 || nPointIndex >= static_cast<sal_Int32>(nPointCount) )
     314           0 :             throw lang::IndexOutOfBoundsException();
     315             : 
     316           0 :         const B2DPoint& rPt( rPoly.getB2DPoint( nPointIndex ) );
     317           0 :         const B2DPoint& rCtrl0( rPoly.getNextControlPoint(nPointIndex) );
     318           0 :         const B2DPoint& rCtrl1( rPoly.getPrevControlPoint((nPointIndex + 1) % nPointCount) );
     319             : 
     320           0 :         return geometry::RealBezierSegment2D( rPt.getX(),
     321           0 :                                               rPt.getY(),
     322           0 :                                               rCtrl0.getX(),
     323           0 :                                               rCtrl0.getY(),
     324           0 :                                               rCtrl1.getX(),
     325           0 :                                               rCtrl1.getY() );
     326             :     }
     327             : 
     328           0 :     void SAL_CALL UnoPolyPolygon::setBezierSegment( const geometry::RealBezierSegment2D& segment,
     329             :                                                          sal_Int32                       nPolygonIndex,
     330             :                                                          sal_Int32                       nPointIndex ) throw (lang::IndexOutOfBoundsException,
     331             :                                                                                                               uno::RuntimeException, std::exception)
     332             :     {
     333           0 :         osl::MutexGuard const guard( m_aMutex );
     334           0 :         checkIndex( nPolygonIndex );
     335           0 :         modifying();
     336             : 
     337           0 :         B2DPolygon aPoly( maPolyPoly.getB2DPolygon( nPolygonIndex ) );
     338           0 :         const sal_uInt32 nPointCount(aPoly.count());
     339             : 
     340           0 :         if( nPointIndex < 0 || nPointIndex >= static_cast<sal_Int32>(nPointCount) )
     341           0 :             throw lang::IndexOutOfBoundsException();
     342             : 
     343             :         aPoly.setB2DPoint( nPointIndex,
     344             :                            B2DPoint( segment.Px,
     345           0 :                                      segment.Py ) );
     346             :         aPoly.setNextControlPoint(nPointIndex,
     347           0 :                                   B2DPoint(segment.C1x, segment.C1y));
     348           0 :         aPoly.setPrevControlPoint((nPointIndex + 1) % nPointCount,
     349           0 :                                   B2DPoint(segment.C2x, segment.C2y));
     350             : 
     351           0 :         maPolyPoly.setB2DPolygon( nPolygonIndex, aPoly );
     352           0 :     }
     353             : 
     354           0 :     B2DPolyPolygon UnoPolyPolygon::getSubsetPolyPolygon(
     355             :         sal_Int32 nPolygonIndex,
     356             :         sal_Int32 nNumberOfPolygons,
     357             :         sal_Int32 nPointIndex,
     358             :         sal_Int32 nNumberOfPoints ) const
     359             :     {
     360           0 :         osl::MutexGuard const guard( m_aMutex );
     361           0 :         checkIndex( nPolygonIndex );
     362             : 
     363           0 :         const sal_Int32 nPolyCount( maPolyPoly.count() );
     364             : 
     365             :         // check for "full polygon" case
     366           0 :         if( !nPolygonIndex &&
     367           0 :             !nPointIndex &&
     368           0 :             nNumberOfPolygons == nPolyCount &&
     369             :             nNumberOfPoints == -1 )
     370             :         {
     371           0 :             return maPolyPoly;
     372             :         }
     373             : 
     374           0 :         B2DPolyPolygon aSubsetPoly;
     375             : 
     376             :         // create temporary polygon (as an extract from maPoly,
     377             :         // which contains the requested subset)
     378           0 :         for( sal_Int32 i=nPolygonIndex; i<nNumberOfPolygons; ++i )
     379             :         {
     380           0 :             checkIndex(i);
     381             : 
     382           0 :             const B2DPolygon& rCurrPoly( maPolyPoly.getB2DPolygon(i) );
     383             : 
     384           0 :             sal_Int32 nFirstPoint(0);
     385           0 :             sal_Int32 nLastPoint(nPolyCount-1);
     386             : 
     387           0 :             if( nPointIndex && i==nPolygonIndex )
     388             :             {
     389             :                 // very first polygon - respect nPointIndex, if
     390             :                 // not zero
     391             : 
     392             :                 // empty polygon - impossible to specify _any_
     393             :                 // legal value except 0 here!
     394           0 :                 if( !nPolyCount && nPointIndex )
     395           0 :                     throw lang::IndexOutOfBoundsException();
     396             : 
     397           0 :                 nFirstPoint = nPointIndex;
     398             :             }
     399             : 
     400           0 :             if( i==nNumberOfPolygons-1 && nNumberOfPoints != -1 )
     401             :             {
     402             :                 // very last polygon - respect nNumberOfPoints
     403             : 
     404             :                 // empty polygon - impossible to specify _any_
     405             :                 // legal value except -1 here!
     406           0 :                 if( !nPolyCount )
     407           0 :                     throw lang::IndexOutOfBoundsException();
     408             : 
     409           0 :                 nLastPoint = nFirstPoint+nNumberOfPoints;
     410             :             }
     411             : 
     412           0 :             if( !nPolyCount )
     413             :             {
     414             :                 // empty polygon - index checks already performed
     415             :                 // above, now simply append empty polygon
     416           0 :                 aSubsetPoly.append( rCurrPoly );
     417             :             }
     418             :             else
     419             :             {
     420           0 :                 if( nFirstPoint < 0 || nFirstPoint >= nPolyCount )
     421           0 :                     throw lang::IndexOutOfBoundsException();
     422             : 
     423           0 :                 if( nLastPoint < 0 || nLastPoint >= nPolyCount )
     424           0 :                     throw lang::IndexOutOfBoundsException();
     425             : 
     426           0 :                 B2DPolygon aTmp;
     427           0 :                 for( sal_Int32 j=nFirstPoint; j<nLastPoint; ++j )
     428           0 :                     aTmp.append( rCurrPoly.getB2DPoint(j) );
     429             : 
     430           0 :                 aSubsetPoly.append( aTmp );
     431             :             }
     432           0 :         }
     433             : 
     434           0 :         return aSubsetPoly;
     435             :     }
     436             : 
     437             : #define IMPLEMENTATION_NAME "gfx::internal::UnoPolyPolygon"
     438             : #define SERVICE_NAME "com.sun.star.rendering.PolyPolygon2D"
     439           0 :     OUString SAL_CALL UnoPolyPolygon::getImplementationName() throw( uno::RuntimeException, std::exception )
     440             :     {
     441           0 :         return OUString( IMPLEMENTATION_NAME );
     442             :     }
     443             : 
     444           0 :     sal_Bool SAL_CALL UnoPolyPolygon::supportsService( const OUString& ServiceName ) throw( uno::RuntimeException, std::exception )
     445             :     {
     446           0 :         return cppu::supportsService(this, ServiceName);
     447             :     }
     448             : 
     449           0 :     uno::Sequence< OUString > SAL_CALL UnoPolyPolygon::getSupportedServiceNames()  throw( uno::RuntimeException, std::exception )
     450             :     {
     451           0 :         uno::Sequence< OUString > aRet(1);
     452           0 :         aRet[0] = SERVICE_NAME ;
     453             : 
     454           0 :         return aRet;
     455             :     }
     456             : 
     457          40 :     B2DPolyPolygon UnoPolyPolygon::getPolyPolygon() const
     458             :     {
     459          40 :         osl::MutexGuard const guard( m_aMutex );
     460             : 
     461             :         // detach result from us
     462          40 :         B2DPolyPolygon aRet( maPolyPoly );
     463          40 :         aRet.makeUnique();
     464          40 :         return aRet;
     465             :     }
     466             : 
     467             : }
     468             : }
     469             : 
     470             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11