LCOV - code coverage report
Current view: top level - filter/source/graphicfilter/icgm - actimpr.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 222 502 44.2 %
Date: 2015-06-13 12:38:46 Functions: 14 23 60.9 %
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 <vcl/bitmapex.hxx>
      21             : #include <com/sun/star/drawing/XDrawPagesSupplier.hpp>
      22             : #include <com/sun/star/drawing/LineStyle.hpp>
      23             : #include <com/sun/star/drawing/LineDash.hpp>
      24             : #include <com/sun/star/drawing/FillStyle.hpp>
      25             : #include <com/sun/star/drawing/Hatch.hpp>
      26             : #include <com/sun/star/awt/FontDescriptor.hpp>
      27             : #include <com/sun/star/awt/FontWeight.hpp>
      28             : #include <com/sun/star/awt/FontUnderline.hpp>
      29             : #include <com/sun/star/drawing/XShapeGrouper.hpp>
      30             : #include <com/sun/star/drawing/CircleKind.hpp>
      31             : #include <com/sun/star/awt/XBitmap.hpp>
      32             : #include <com/sun/star/drawing/PointSequenceSequence.hpp>
      33             : #include <com/sun/star/drawing/PointSequence.hpp>
      34             : #include <com/sun/star/drawing/PolyPolygonBezierCoords.hpp>
      35             : #include <com/sun/star/drawing/FlagSequence.hpp>
      36             : #include <com/sun/star/drawing/ShapeCollection.hpp>
      37             : #include <com/sun/star/drawing/TextAdjust.hpp>
      38             : #include <com/sun/star/text/XText.hpp>
      39             : #include <com/sun/star/text/XTextRange.hpp>
      40             : #include <com/sun/star/style/HorizontalAlignment.hpp>
      41             : 
      42             : #include <comphelper/processfactory.hxx>
      43             : #include <toolkit/helper/vclunohelper.hxx>
      44             : 
      45             : #include "main.hxx"
      46             : #include "outact.hxx"
      47             : 
      48             : using namespace ::com::sun::star;
      49             : 
      50             : 
      51             : 
      52           2 : CGMImpressOutAct::CGMImpressOutAct( CGM& rCGM, const uno::Reference< frame::XModel > & rModel ) :
      53             :         CGMOutAct       ( rCGM ),
      54           2 :         nFinalTextCount ( 0 )
      55             : {
      56           2 :     if ( mpCGM->mbStatus )
      57             :     {
      58           2 :         bool bStatRet = false;
      59             : 
      60           2 :         uno::Reference< drawing::XDrawPagesSupplier >  aDrawPageSup( rModel, uno::UNO_QUERY );
      61           2 :         if( aDrawPageSup.is() )
      62             :         {
      63           2 :             maXDrawPages = aDrawPageSup->getDrawPages();
      64           2 :             if ( maXDrawPages.is() )
      65             :             {
      66           2 :                 maXMultiServiceFactory.set( rModel, uno::UNO_QUERY);
      67           2 :                 if( maXMultiServiceFactory.is() )
      68             :                 {
      69           2 :                     maXDrawPage = *static_cast<uno::Reference< drawing::XDrawPage > const *>(maXDrawPages->getByIndex( 0 ).getValue());
      70           2 :                     if ( ImplInitPage() )
      71           2 :                         bStatRet = true;
      72             :                 }
      73             :             }
      74             :         }
      75           2 :         mpCGM->mbStatus = bStatRet;
      76             :     }
      77           2 : }
      78             : 
      79          15 : bool CGMImpressOutAct::ImplInitPage()
      80             : {
      81          15 :     bool    bStatRet = false;
      82          15 :     if( maXDrawPage.is() )
      83             :     {
      84          15 :         maXShapes = uno::Reference< drawing::XShapes >( maXDrawPage, uno::UNO_QUERY );
      85          15 :         if ( maXShapes.is() )
      86             :         {
      87          15 :             bStatRet = true;
      88             :         }
      89             :     }
      90          15 :     return bStatRet;
      91             : }
      92             : 
      93             : 
      94             : 
      95         116 : bool CGMImpressOutAct::ImplCreateShape( const OUString& rType )
      96             : {
      97         116 :     uno::Reference< uno::XInterface > xNewShape( maXMultiServiceFactory->createInstance( rType ) );
      98         116 :     maXShape = uno::Reference< drawing::XShape >( xNewShape, uno::UNO_QUERY );
      99         116 :     maXPropSet = uno::Reference< beans::XPropertySet >( xNewShape, uno::UNO_QUERY );
     100         116 :     if ( maXShape.is() && maXPropSet.is() )
     101             :     {
     102         116 :         maXShapes->add( maXShape );
     103         116 :         return true;
     104             :     }
     105           0 :     return false;
     106             : }
     107             : 
     108             : 
     109             : 
     110           0 : void CGMImpressOutAct::ImplSetOrientation( FloatPoint& rRefPoint, double& rOrientation )
     111             : {
     112           0 :     uno::Any aAny;
     113           0 :     aAny <<= (sal_Int32)rRefPoint.X;
     114           0 :     maXPropSet->setPropertyValue( "RotationPointX", aAny );
     115           0 :     aAny <<= (sal_Int32)rRefPoint.Y;
     116           0 :     maXPropSet->setPropertyValue( "RotationPointY", aAny );
     117           0 :     aAny <<= (sal_Int32)( rOrientation * 100.0 );
     118           0 :     maXPropSet->setPropertyValue( "RotateAngle", aAny );
     119           0 : }
     120             : 
     121             : 
     122             : 
     123          68 : void CGMImpressOutAct::ImplSetLineBundle()
     124             : {
     125          68 :     uno::Any            aAny;
     126             :     drawing::LineStyle  eLS;
     127             : 
     128             :     sal_uInt32          nLineColor;
     129             :     LineType            eLineType;
     130             :     double              fLineWidth;
     131             : 
     132          68 :     if ( mpCGM->pElement->nAspectSourceFlags & ASF_LINECOLOR )
     133           0 :         nLineColor = mpCGM->pElement->pLineBundle->GetColor();
     134             :     else
     135          68 :         nLineColor = mpCGM->pElement->aLineBundle.GetColor();
     136          68 :     if ( mpCGM->pElement->nAspectSourceFlags & ASF_LINETYPE )
     137           0 :         eLineType = mpCGM->pElement->pLineBundle->eLineType;
     138             :     else
     139          68 :         eLineType = mpCGM->pElement->aLineBundle.eLineType;
     140          68 :     if ( mpCGM->pElement->nAspectSourceFlags & ASF_LINEWIDTH )
     141           0 :         fLineWidth = mpCGM->pElement->pLineBundle->nLineWidth;
     142             :     else
     143          68 :         fLineWidth = mpCGM->pElement->aLineBundle.nLineWidth;
     144             : 
     145          68 :     aAny <<= (sal_Int32)nLineColor;
     146          68 :     maXPropSet->setPropertyValue( "LineColor", aAny );
     147             : 
     148          68 :     aAny <<= (sal_Int32)fLineWidth;
     149          68 :     maXPropSet->setPropertyValue( "LineWidth", aAny );
     150             : 
     151          68 :     switch( eLineType )
     152             :     {
     153             :         case LT_NONE :
     154           0 :             eLS = drawing::LineStyle_NONE;
     155           0 :         break;
     156             :         case LT_DASH :
     157             :         case LT_DOT :
     158             :         case LT_DASHDOT :
     159             :         case LT_DOTDOTSPACE :
     160             :         case LT_LONGDASH :
     161             :         case LT_DASHDASHDOT :
     162          42 :             eLS = drawing::LineStyle_DASH;
     163          42 :         break;
     164             :         case LT_SOLID :
     165             :         default:
     166          26 :             eLS = drawing::LineStyle_SOLID;
     167          26 :         break;
     168             :     }
     169          68 :     aAny <<= eLS;
     170          68 :     maXPropSet->setPropertyValue( "LineStyle", aAny );
     171          68 :     if ( eLS == drawing::LineStyle_DASH )
     172             :     {
     173          42 :         drawing::LineDash aLineDash( drawing::DashStyle_RECTRELATIVE, 1, 50, 3, 33, 100 );
     174          42 :         aAny <<= aLineDash;
     175          42 :         maXPropSet->setPropertyValue( "LineDash", aAny );
     176          68 :     }
     177          68 : }
     178             : 
     179          48 : void CGMImpressOutAct::ImplSetFillBundle()
     180             : {
     181             : 
     182          48 :     uno::Any                aAny;
     183             :     drawing::LineStyle      eLS;
     184             :     drawing::FillStyle      eFS;
     185             : 
     186          48 :     sal_uInt32              nEdgeColor = 0;
     187             :     EdgeType                eEdgeType;
     188          48 :     double                  fEdgeWidth = 0;
     189             : 
     190             :     sal_uInt32              nFillColor;
     191             :     FillInteriorStyle       eFillStyle;
     192             :     sal_uInt32              nHatchIndex;
     193             : 
     194          48 :     if ( mpCGM->pElement->eEdgeVisibility == EV_ON )
     195             :     {
     196          30 :         if ( mpCGM->pElement->nAspectSourceFlags & ASF_EDGETYPE )
     197           0 :             eEdgeType = mpCGM->pElement->pEdgeBundle->eEdgeType;
     198             :         else
     199          30 :             eEdgeType = mpCGM->pElement->aEdgeBundle.eEdgeType;
     200          30 :         if ( mpCGM->pElement->nAspectSourceFlags & ASF_EDGEWIDTH )
     201           0 :             fEdgeWidth = mpCGM->pElement->pEdgeBundle->nEdgeWidth;
     202             :         else
     203          30 :             fEdgeWidth = mpCGM->pElement->aEdgeBundle.nEdgeWidth;
     204          30 :         if ( mpCGM->pElement->nAspectSourceFlags & ASF_EDGECOLOR )
     205           0 :             nEdgeColor = mpCGM->pElement->pEdgeBundle->GetColor();
     206             :         else
     207          30 :             nEdgeColor = mpCGM->pElement->aEdgeBundle.GetColor();
     208             :     }
     209             :     else
     210          18 :         eEdgeType = ET_NONE;
     211             : 
     212          48 :     if ( mpCGM->pElement->nAspectSourceFlags & ASF_FILLINTERIORSTYLE )
     213           0 :         eFillStyle = mpCGM->pElement->pFillBundle->eFillInteriorStyle;
     214             :     else
     215          48 :         eFillStyle = mpCGM->pElement->aFillBundle.eFillInteriorStyle;
     216          48 :     if ( mpCGM->pElement->nAspectSourceFlags & ASF_FILLCOLOR )
     217           0 :         nFillColor = mpCGM->pElement->pFillBundle->GetColor();
     218             :     else
     219          48 :         nFillColor = mpCGM->pElement->aFillBundle.GetColor();
     220          48 :     if ( mpCGM->pElement->nAspectSourceFlags & ASF_HATCHINDEX )
     221           0 :         nHatchIndex = (sal_uInt32)mpCGM->pElement->pFillBundle->nFillHatchIndex;
     222             :     else
     223          48 :         nHatchIndex = (sal_uInt32)mpCGM->pElement->aFillBundle.nFillHatchIndex;
     224             : 
     225          48 :     aAny <<= (sal_Int32)nFillColor;
     226          48 :     maXPropSet->setPropertyValue( "FillColor", aAny );
     227             : 
     228          48 :     switch ( eFillStyle )
     229             :     {
     230             :         case FIS_HATCH   :
     231             :         {
     232          32 :             if ( nHatchIndex == 0 )
     233           0 :                 eFS = drawing::FillStyle_NONE;
     234             :             else
     235          32 :                 eFS = drawing::FillStyle_HATCH;
     236             :         }
     237          32 :         break;
     238             :         case FIS_PATTERN :
     239             :         case FIS_SOLID :
     240             :         {
     241           8 :             eFS = drawing::FillStyle_SOLID;
     242             :         }
     243           8 :         break;
     244             : 
     245             :         case FIS_GEOPATTERN :
     246             :         {
     247           0 :             if ( mpCGM->pElement->eTransparency == T_ON )
     248           0 :                 nFillColor = mpCGM->pElement->nAuxiliaryColor;
     249           0 :             eFS = drawing::FillStyle_NONE;
     250             :         }
     251           0 :         break;
     252             : 
     253             :         case FIS_INTERPOLATED :
     254             :         case FIS_GRADIENT :
     255             :         {
     256           0 :             eFS = drawing::FillStyle_GRADIENT;
     257             :         }
     258           0 :         break;
     259             : 
     260             :         case FIS_HOLLOW :
     261             :         case FIS_EMPTY :
     262             :         default:
     263             :         {
     264           8 :             eFS = drawing::FillStyle_NONE;
     265             :         }
     266             :     }
     267             : 
     268          48 :     if ( mpCGM->mnAct4PostReset & ACT4_GRADIENT_ACTION )
     269           0 :         eFS = drawing::FillStyle_GRADIENT;
     270             : 
     271          48 :     if ( eFS == drawing::FillStyle_GRADIENT )
     272             :     {
     273           0 :         aAny <<= *mpGradient;
     274           0 :         maXPropSet->setPropertyValue( "FillGradient", aAny );
     275             :     }
     276          48 :     aAny <<= eFS;
     277          48 :     maXPropSet->setPropertyValue( "FillStyle", aAny );
     278             : 
     279          48 :     eLS = drawing::LineStyle_NONE;
     280          48 :     if ( eFillStyle == FIS_HOLLOW )
     281             :     {
     282           4 :         eLS = drawing::LineStyle_SOLID;
     283           4 :         aAny <<= (sal_Int32)nFillColor;
     284           4 :         maXPropSet->setPropertyValue( "LineColor", aAny );
     285           4 :         aAny <<= (sal_Int32)0;
     286           4 :         maXPropSet->setPropertyValue( "LineWidth", aAny );
     287             :     }
     288          44 :     else if ( eEdgeType != ET_NONE )
     289             :     {
     290          26 :         aAny <<= (sal_Int32)nEdgeColor;
     291          26 :         maXPropSet->setPropertyValue( "LineColor", aAny );
     292             : 
     293          26 :         aAny <<= (sal_Int32)fEdgeWidth;
     294          26 :         maXPropSet->setPropertyValue( "LineWidth", aAny );
     295             : 
     296             :         switch( eEdgeType )
     297             :         {
     298             :             case ET_DASH :
     299             :             case ET_DOT :
     300             :             case ET_DASHDOT :
     301             :             case ET_DASHDOTDOT :
     302             :             case ET_DOTDOTSPACE :
     303             :             case ET_LONGDASH :
     304             :             case ET_DASHDASHDOT :
     305             :             default:            // case ET_SOLID :
     306             :             {
     307          26 :                 eLS = drawing::LineStyle_SOLID;
     308             :             }
     309          26 :             break;
     310             :         }
     311             :     }
     312             : 
     313          48 :     aAny <<= eLS;
     314          48 :     maXPropSet->setPropertyValue( "LineStyle", aAny );
     315             : 
     316          48 :     if ( eFS == drawing::FillStyle_HATCH )
     317             :     {
     318          32 :         drawing::Hatch aHatch;
     319             : 
     320          32 :         aHatch.Color = nFillColor;
     321          32 :         if ( mpCGM->pElement->maHatchMap.find( nHatchIndex ) !=  mpCGM->pElement->maHatchMap.end() )
     322             :         {
     323          32 :             HatchEntry& rHatchEntry = mpCGM->pElement->maHatchMap[ nHatchIndex ];
     324          32 :             switch ( rHatchEntry.HatchStyle )
     325             :             {
     326          24 :             case 0 : aHatch.Style = drawing::HatchStyle_SINGLE; break;
     327           8 :             case 1 : aHatch.Style = drawing::HatchStyle_DOUBLE; break;
     328           0 :             case 2 : aHatch.Style = drawing::HatchStyle_TRIPLE; break;
     329             :             }
     330          32 :             aHatch.Distance = rHatchEntry.HatchDistance;
     331          32 :             aHatch.Angle = rHatchEntry.HatchAngle;
     332             :         }
     333             :         else
     334             :         {
     335           0 :             aHatch.Style = drawing::HatchStyle_TRIPLE;
     336           0 :             aHatch.Distance = 10 * ( nHatchIndex & 0x1f ) | 100;
     337           0 :             aHatch.Angle = 15 * ( ( nHatchIndex & 0x1f ) - 5 );
     338             :         }
     339          32 :         aAny <<= aHatch;
     340          32 :         maXPropSet->setPropertyValue( "FillHatch", aAny );
     341          48 :     }
     342          48 : }
     343             : 
     344           0 : void CGMImpressOutAct::ImplSetTextBundle( const uno::Reference< beans::XPropertySet > & rProperty )
     345             : {
     346           0 :     uno::Any        aAny;
     347             :     sal_uInt32      nTextFontIndex;
     348             :     sal_uInt32      nTextColor;
     349             : 
     350           0 :     if ( mpCGM->pElement->nAspectSourceFlags & ASF_TEXTFONTINDEX )
     351           0 :         nTextFontIndex = mpCGM->pElement->pTextBundle->nTextFontIndex;
     352             :     else
     353           0 :         nTextFontIndex = mpCGM->pElement->aTextBundle.nTextFontIndex;
     354           0 :     if ( mpCGM->pElement->nAspectSourceFlags & ASF_TEXTCOLOR )
     355           0 :         nTextColor = mpCGM->pElement->pTextBundle->GetColor();
     356             :     else
     357           0 :         nTextColor = mpCGM->pElement->aTextBundle.GetColor();
     358             : 
     359           0 :     aAny <<= (sal_Int32)nTextColor;
     360           0 :     rProperty->setPropertyValue( "CharColor", aAny );
     361             : 
     362           0 :     sal_uInt32 nFontType = 0;
     363           0 :     awt::FontDescriptor aFontDescriptor;
     364           0 :     FontEntry* pFontEntry = mpCGM->pElement->aFontList.GetFontEntry( nTextFontIndex );
     365           0 :     if ( pFontEntry )
     366             :     {
     367           0 :         nFontType = pFontEntry->nFontType;
     368           0 :         aFontDescriptor.Name = OUString::createFromAscii( reinterpret_cast<char*>(pFontEntry->pFontName) );
     369             :     }
     370           0 :     aFontDescriptor.Height = ( sal_Int16 )( ( mpCGM->pElement->nCharacterHeight * (double)1.50 ) );
     371           0 :     if ( nFontType & 1 )
     372           0 :         aFontDescriptor.Slant = awt::FontSlant_ITALIC;
     373           0 :     if ( nFontType & 2 )
     374           0 :         aFontDescriptor.Weight = awt::FontWeight::BOLD;
     375             :     else
     376           0 :         aFontDescriptor.Weight = awt::FontWeight::NORMAL;
     377             : 
     378           0 :     if ( mpCGM->pElement->eUnderlineMode != UM_OFF )
     379             :     {
     380           0 :         aFontDescriptor.Underline = awt::FontUnderline::SINGLE;
     381             :     }
     382           0 :     aAny <<= aFontDescriptor;
     383           0 :     rProperty->setPropertyValue( "FontDescriptor", aAny );
     384           0 : }
     385             : 
     386          14 : void CGMImpressOutAct::InsertPage()
     387             : {
     388          14 :     if ( mnCurrentPage )    // one side is always existing, therefore the first side will be left out
     389             :     {
     390          13 :         uno::Reference< drawing::XDrawPage > xPage( maXDrawPages->insertNewByIndex( 0xffff ), uno::UNO_QUERY );
     391          13 :         maXDrawPage = xPage;
     392          13 :         if ( !ImplInitPage() )
     393           0 :             mpCGM->mbStatus = false;
     394             :     }
     395          14 :     mnCurrentPage++;
     396          14 : }
     397             : 
     398          14 : void CGMImpressOutAct::BeginGroup()
     399             : {
     400          14 :     if ( mnGroupLevel < CGM_OUTACT_MAX_GROUP_LEVEL )
     401             :     {
     402          14 :         mpGroupLevel[ mnGroupLevel ] = maXShapes->getCount();
     403             :     }
     404          14 :     mnGroupLevel++;
     405          14 :     mnGroupActCount = mpCGM->mnActCount;
     406          14 : }
     407             : 
     408          28 : void CGMImpressOutAct::EndGroup()
     409             : {
     410          28 :     if ( mnGroupLevel )     // preserve overflow
     411          14 :         mnGroupLevel--;
     412          28 :     if ( mnGroupLevel < CGM_OUTACT_MAX_GROUP_LEVEL )
     413             :     {
     414          28 :         sal_uInt32 mnFirstIndex = mpGroupLevel[ mnGroupLevel ];
     415          28 :         if ( mnFirstIndex == 0xffffffff )
     416           0 :             mnFirstIndex = 0;
     417          28 :         sal_uInt32 mnCurrentCount = maXShapes->getCount();
     418          28 :         if ( ( mnCurrentCount - mnFirstIndex ) > 1 )
     419             :         {
     420          28 :             uno::Reference< drawing::XShapeGrouper > aXShapeGrouper;
     421          28 :             aXShapeGrouper.set( maXDrawPage, uno::UNO_QUERY );
     422          28 :             if( aXShapeGrouper.is() )
     423             :             {
     424          28 :                 uno::Reference< drawing::XShapes >  aXShapes = drawing::ShapeCollection::create(comphelper::getProcessComponentContext());
     425         144 :                 for ( sal_uInt32 i = mnFirstIndex; i < mnCurrentCount; i++ )
     426             :                 {
     427         116 :                     uno::Reference< drawing::XShape >  aXShape = *static_cast<uno::Reference< drawing::XShape > const *>(maXShapes->getByIndex( i ).getValue());
     428         116 :                     if (aXShape.is() )
     429             :                     {
     430         116 :                         aXShapes->add( aXShape );
     431             :                     }
     432         116 :                 }
     433          28 :                 uno::Reference< drawing::XShapeGroup >  aXShapeGroup = aXShapeGrouper->group( aXShapes );
     434          28 :             }
     435             :         }
     436             :     }
     437          28 : }
     438             : 
     439          14 : void CGMImpressOutAct::EndGrouping()
     440             : {
     441          28 :     while ( mnGroupLevel )
     442             :     {
     443           0 :         EndGroup();
     444             :     }
     445          14 : }
     446             : 
     447          11 : void CGMImpressOutAct::DrawRectangle( FloatRect& rFloatRect )
     448             : {
     449          11 :     if ( mnGroupActCount != ( mpCGM->mnActCount - 1 ) )         // POWERPOINT HACK !!!
     450             :     {
     451          11 :         if ( ImplCreateShape( "com.sun.star.drawing.RectangleShape" ) )
     452             :         {
     453          11 :             awt::Size aSize( (long)(rFloatRect.Right - rFloatRect.Left ), (long)(rFloatRect.Bottom-rFloatRect.Top ) );
     454          11 :             maXShape->setSize( aSize );
     455          11 :             maXShape->setPosition( awt::Point( (long)rFloatRect.Left, (long)rFloatRect.Top ) );
     456          11 :             ImplSetFillBundle();
     457             :         }
     458             :     }
     459          11 : }
     460             : 
     461          11 : void CGMImpressOutAct::DrawEllipse( FloatPoint& rCenter, FloatPoint& rSize, double& rOrientation )
     462             : {
     463          11 :     if ( ImplCreateShape( "com.sun.star.drawing.EllipseShape" ) )
     464             :     {
     465          11 :         drawing::CircleKind eCircleKind = drawing::CircleKind_FULL;
     466          11 :         uno::Any aAny( &eCircleKind, ::cppu::UnoType<drawing::CircleKind>::get() );
     467          11 :         maXPropSet->setPropertyValue( "CircleKind", aAny );
     468             : 
     469          11 :         long nXSize = (long)( rSize.X * 2.0 );      // strange behaviour with a awt::Size of 0
     470          11 :         long nYSize = (long)( rSize.Y * 2.0 );
     471          11 :         if ( nXSize < 1 )
     472           0 :             nXSize = 1;
     473          11 :         if ( nYSize < 1 )
     474           0 :             nYSize = 1;
     475          11 :         maXShape->setSize( awt::Size( nXSize, nYSize ) );
     476          11 :         maXShape->setPosition( awt::Point( (long)( rCenter.X - rSize.X ), (long)( rCenter.Y - rSize.Y ) ) );
     477             : 
     478          11 :         if ( rOrientation != 0 )
     479             :         {
     480           0 :             ImplSetOrientation( rCenter, rOrientation );
     481             :         }
     482          11 :         ImplSetFillBundle();
     483             :     }
     484          11 : }
     485             : 
     486          38 : void CGMImpressOutAct::DrawEllipticalArc( FloatPoint& rCenter, FloatPoint& rSize, double& rOrientation,
     487             :             sal_uInt32 nType, double& fStartAngle, double& fEndAngle )
     488             : {
     489          38 :     if ( ImplCreateShape( "com.sun.star.drawing.EllipseShape" ) )
     490             :     {
     491          38 :         uno::Any aAny;
     492             :         drawing::CircleKind eCircleKind;
     493             : 
     494             : 
     495          38 :         long nXSize = (long)( rSize.X * 2.0 );      // strange behaviour with a awt::Size of 0
     496          38 :         long nYSize = (long)( rSize.Y * 2.0 );
     497          38 :         if ( nXSize < 1 )
     498           0 :             nXSize = 1;
     499          38 :         if ( nYSize < 1 )
     500           0 :             nYSize = 1;
     501             : 
     502          38 :         maXShape->setSize( awt::Size ( nXSize, nYSize ) );
     503             : 
     504          38 :         if ( rOrientation != 0 )
     505             :         {
     506           0 :             fStartAngle += rOrientation;
     507           0 :             if ( fStartAngle >= 360 )
     508           0 :                 fStartAngle -= 360;
     509           0 :             fEndAngle += rOrientation;
     510           0 :             if ( fEndAngle >= 360 )
     511           0 :                 fEndAngle -= 360;
     512             :         }
     513          38 :         switch( nType )
     514             :         {
     515          14 :             case 0 : eCircleKind = drawing::CircleKind_SECTION; break;
     516          12 :             case 1 : eCircleKind = drawing::CircleKind_CUT; break;
     517          12 :             case 2 : eCircleKind = drawing::CircleKind_ARC; break;
     518           0 :             default : eCircleKind = drawing::CircleKind_FULL; break;
     519             :         }
     520          38 :         if ( (long)fStartAngle == (long)fEndAngle )
     521             :         {
     522           2 :             eCircleKind = drawing::CircleKind_FULL;
     523           2 :             aAny.setValue( &eCircleKind, ::cppu::UnoType<drawing::CircleKind>::get() );
     524             :         }
     525             :         else
     526             :         {
     527          36 :             aAny.setValue( &eCircleKind, ::cppu::UnoType<drawing::CircleKind>::get() );
     528          36 :             maXPropSet->setPropertyValue( "CircleKind", aAny );
     529          36 :             aAny <<= (sal_Int32)( (long)( fStartAngle * 100 ) );
     530          36 :             maXPropSet->setPropertyValue( "CircleStartAngle", aAny );
     531          36 :             aAny <<= (sal_Int32)( (long)( fEndAngle * 100 ) );
     532          36 :             maXPropSet->setPropertyValue( "CircleEndAngle", aAny );
     533             :         }
     534          38 :         maXShape->setPosition( awt::Point( (long)( rCenter.X - rSize.X ), (long)( rCenter.Y - rSize.Y ) ) );
     535          38 :         if ( rOrientation != 0 )
     536             :         {
     537           0 :             ImplSetOrientation( rCenter, rOrientation );
     538             :         }
     539          38 :         if ( eCircleKind == drawing::CircleKind_ARC )
     540             :         {
     541          12 :             ImplSetLineBundle();
     542             :         }
     543             :         else
     544             :         {
     545          26 :             ImplSetFillBundle();
     546          26 :             if ( nType == 2 )
     547             :             {
     548           0 :                 ImplSetLineBundle();
     549           0 :                 drawing::FillStyle eFillStyle = drawing::FillStyle_NONE;
     550           0 :                 aAny.setValue( &eFillStyle, cppu::UnoType<drawing::FillStyle>::get());
     551           0 :                 maXPropSet->setPropertyValue( "FillStyle", aAny );
     552             :             }
     553          38 :         }
     554             :     }
     555          38 : }
     556             : 
     557           0 : void CGMImpressOutAct::DrawBitmap( CGMBitmapDescriptor* pBmpDesc )
     558             : {
     559           0 :     if ( pBmpDesc->mbStatus && pBmpDesc->mpBitmap )
     560             :     {
     561           0 :         FloatPoint aOrigin = pBmpDesc->mnOrigin;
     562           0 :         double fdx = pBmpDesc->mndx;
     563           0 :         double fdy = pBmpDesc->mndy;
     564             : 
     565           0 :         BmpMirrorFlags nMirr = BmpMirrorFlags::NONE;
     566           0 :         if ( pBmpDesc->mbVMirror )
     567           0 :             nMirr |= BmpMirrorFlags::Vertical;
     568           0 :         if ( pBmpDesc->mbHMirror )
     569           0 :             nMirr |= BmpMirrorFlags::Horizontal;
     570           0 :         if ( nMirr != BmpMirrorFlags::NONE )
     571           0 :             pBmpDesc->mpBitmap->Mirror( nMirr );
     572             : 
     573           0 :         mpCGM->ImplMapPoint( aOrigin );
     574           0 :         mpCGM->ImplMapX( fdx );
     575           0 :         mpCGM->ImplMapY( fdy );
     576             : 
     577           0 :         if ( ImplCreateShape( "com.sun.star.drawing.GraphicObjectShape" ) )
     578             :         {
     579           0 :             maXShape->setSize( awt::Size( (long)fdx, (long)fdy ) );
     580           0 :             maXShape->setPosition( awt::Point( (long)aOrigin.X, (long)aOrigin.Y ) );
     581             : 
     582           0 :             if ( pBmpDesc->mnOrientation != 0 )
     583             :             {
     584           0 :                 ImplSetOrientation( aOrigin, pBmpDesc->mnOrientation );
     585             :             }
     586             : 
     587           0 :             uno::Reference< awt::XBitmap > xBitmap( VCLUnoHelper::CreateBitmap( BitmapEx( *( pBmpDesc->mpBitmap ) ) ) );
     588           0 :             uno::Any aAny;
     589           0 :             aAny <<= xBitmap;
     590           0 :             maXPropSet->setPropertyValue( "GraphicObjectFillBitmap", aAny );
     591             : 
     592             :         }
     593             :     }
     594           0 : }
     595             : 
     596           0 : void CGMImpressOutAct::DrawPolygon( Polygon& rPoly )
     597             : {
     598           0 :     sal_uInt16 nPoints = rPoly.GetSize();
     599             : 
     600           0 :     if ( ( nPoints > 1 ) && ImplCreateShape( "com.sun.star.drawing.PolyPolygonShape" ) )
     601             :     {
     602           0 :         drawing::PointSequenceSequence aRetval;
     603             : 
     604             :         // prepare inside polygons
     605           0 :         aRetval.realloc( 1 );
     606             : 
     607             :         // get pointer to outside arrays
     608           0 :         drawing::PointSequence* pOuterSequence = aRetval.getArray();
     609             : 
     610             :         // make room in arrays
     611           0 :         pOuterSequence->realloc((sal_Int32)nPoints);
     612             : 
     613             :         // get pointer to arrays
     614           0 :         awt::Point* pInnerSequence = pOuterSequence->getArray();
     615             : 
     616           0 :         for( sal_uInt16 n = 0; n < nPoints; n++ )
     617           0 :             *pInnerSequence++ = awt::Point( rPoly[ n ].X(), rPoly[n].Y() );
     618             : 
     619           0 :         uno::Any aParam;
     620           0 :         aParam <<= aRetval;
     621           0 :         maXPropSet->setPropertyValue( "PolyPolygon", aParam );
     622           0 :         ImplSetFillBundle();
     623             :     }
     624           0 : }
     625             : 
     626          56 : void CGMImpressOutAct::DrawPolyLine( Polygon& rPoly )
     627             : {
     628          56 :     sal_uInt16 nPoints = rPoly.GetSize();
     629             : 
     630          56 :     if ( ( nPoints > 1 ) && ImplCreateShape( "com.sun.star.drawing.PolyLineShape" ) )
     631             :     {
     632          56 :         drawing::PointSequenceSequence aRetval;
     633             : 
     634             :         // prepare inside polygons
     635          56 :         aRetval.realloc( 1 );
     636             : 
     637             :         // get pointer to outside arrays
     638          56 :         drawing::PointSequence* pOuterSequence = aRetval.getArray();
     639             : 
     640             :         // make room in arrays
     641          56 :         pOuterSequence->realloc((sal_Int32)nPoints);
     642             : 
     643             :         // get pointer to arrays
     644          56 :         awt::Point* pInnerSequence = pOuterSequence->getArray();
     645             : 
     646         210 :         for( sal_uInt16 n = 0; n < nPoints; n++ )
     647         154 :             *pInnerSequence++ = awt::Point( rPoly[ n ].X(), rPoly[n].Y() );
     648             : 
     649         112 :         uno::Any aParam;
     650          56 :         aParam <<= aRetval;
     651          56 :         maXPropSet->setPropertyValue( "PolyPolygon", aParam );
     652         112 :         ImplSetLineBundle();
     653             :     }
     654          56 : }
     655             : 
     656           0 : void CGMImpressOutAct::DrawPolybezier( Polygon& rPolygon )
     657             : {
     658           0 :     sal_uInt16 nPoints = rPolygon.GetSize();
     659           0 :     if ( ( nPoints > 1 ) && ImplCreateShape( "com.sun.star.drawing.OpenBezierShape" ) )
     660             :     {
     661           0 :         drawing::PolyPolygonBezierCoords aRetval;
     662             : 
     663           0 :         aRetval.Coordinates.realloc( 1 );
     664           0 :         aRetval.Flags.realloc( 1 );
     665             : 
     666             :         // get pointer to outside arrays
     667           0 :         drawing::PointSequence* pOuterSequence = aRetval.Coordinates.getArray();
     668           0 :         drawing::FlagSequence* pOuterFlags = aRetval.Flags.getArray();
     669             : 
     670             :         // make room in arrays
     671           0 :         pOuterSequence->realloc( nPoints );
     672           0 :         pOuterFlags->realloc( nPoints );
     673             : 
     674           0 :         awt::Point* pInnerSequence = pOuterSequence->getArray();
     675           0 :         drawing::PolygonFlags* pInnerFlags = pOuterFlags->getArray();
     676             : 
     677           0 :         for( sal_uInt16 i = 0; i < nPoints; i++ )
     678             :         {
     679           0 :             *pInnerSequence++ = awt::Point( rPolygon[ i ].X(), rPolygon[ i ].Y() );
     680           0 :             *pInnerFlags++ = (drawing::PolygonFlags)rPolygon.GetFlags( i );
     681             :         }
     682           0 :         uno::Any aParam;
     683           0 :         aParam <<= aRetval;
     684           0 :         maXPropSet->setPropertyValue( "PolyPolygonBezier", aParam );
     685           0 :         ImplSetLineBundle();
     686             :     }
     687           0 : }
     688             : 
     689          14 : void CGMImpressOutAct::DrawPolyPolygon( tools::PolyPolygon& rPolyPolygon )
     690             : {
     691          14 :     sal_uInt32 nNumPolys = rPolyPolygon.Count();
     692          14 :     if ( nNumPolys && ImplCreateShape( "com.sun.star.drawing.ClosedBezierShape" ) )
     693             :     {
     694           0 :         drawing::PolyPolygonBezierCoords aRetval;
     695             : 
     696             :         // prepare inside polygons
     697           0 :         aRetval.Coordinates.realloc((sal_Int32)nNumPolys);
     698           0 :         aRetval.Flags.realloc((sal_Int32)nNumPolys);
     699             : 
     700             :         // get pointer to outside arrays
     701           0 :         drawing::PointSequence* pOuterSequence = aRetval.Coordinates.getArray();
     702           0 :         drawing::FlagSequence* pOuterFlags = aRetval.Flags.getArray();
     703             : 
     704           0 :         for( sal_uInt32 a = 0; a < nNumPolys; a++ )
     705             :         {
     706           0 :             Polygon aPolygon( rPolyPolygon.GetObject( a ) );
     707           0 :             sal_uInt32 nNumPoints = aPolygon.GetSize();
     708             : 
     709             :             // make room in arrays
     710           0 :             pOuterSequence->realloc((sal_Int32)nNumPoints);
     711           0 :             pOuterFlags->realloc((sal_Int32)nNumPoints);
     712             : 
     713             :             // get pointer to arrays
     714           0 :             awt::Point* pInnerSequence = pOuterSequence->getArray();
     715           0 :             drawing::PolygonFlags* pInnerFlags = pOuterFlags->getArray();
     716             : 
     717           0 :             for( sal_uInt32 b = 0; b < nNumPoints; b++ )
     718             :             {
     719           0 :                 *pInnerSequence++ = awt::Point( aPolygon.GetPoint( b ).X(), aPolygon.GetPoint( b ).Y() ) ;
     720           0 :                 *pInnerFlags++ = (drawing::PolygonFlags)aPolygon.GetFlags( b );
     721             :             }
     722           0 :             pOuterSequence++;
     723           0 :             pOuterFlags++;
     724           0 :         }
     725           0 :         uno::Any aParam;
     726           0 :         aParam <<= aRetval;
     727           0 :         maXPropSet->setPropertyValue( "PolyPolygonBezier", aParam);
     728           0 :         ImplSetFillBundle();
     729             :     }
     730          14 : }
     731             : 
     732           0 : void CGMImpressOutAct::DrawText( awt::Point& rTextPos, awt::Size& rTextSize, char* pString, sal_uInt32 /*nSize*/, FinalFlag eFlag )
     733             : {
     734           0 :     if ( ImplCreateShape( "com.sun.star.drawing.TextShape" ) )
     735             :     {
     736           0 :         uno::Any    aAny;
     737           0 :         long    nWidth = rTextSize.Width;
     738           0 :         long    nHeight = rTextSize.Height;
     739             : 
     740           0 :         awt::Point aTextPos( rTextPos );
     741           0 :         switch ( mpCGM->pElement->eTextAlignmentV )
     742             :         {
     743             :             case TAV_HALF :
     744             :             {
     745           0 :                 aTextPos.Y -= static_cast<sal_Int32>( ( mpCGM->pElement->nCharacterHeight * 1.5 ) / 2 );
     746             :             }
     747           0 :             break;
     748             : 
     749             :             case TAV_BASE :
     750             :             case TAV_BOTTOM :
     751             :             case TAV_NORMAL :
     752           0 :                 aTextPos.Y -= static_cast<sal_Int32>( mpCGM->pElement->nCharacterHeight * 1.5 );
     753             :             case TAV_TOP :
     754           0 :                 break;
     755             :             case TAV_CAP:
     756             :             case TAV_CONT:
     757           0 :                 break;  // -Wall these two were not here.
     758             :         }
     759             : 
     760           0 :         if ( nWidth < 0 )
     761             :         {
     762           0 :             nWidth = -nWidth;
     763             :         }
     764           0 :         else if ( nWidth == 0 )
     765             :         {
     766           0 :             nWidth = -1;
     767             :         }
     768           0 :         if ( nHeight < 0 )
     769             :         {
     770           0 :             nHeight = -nHeight;
     771             :         }
     772           0 :         else if ( nHeight == 0 )
     773             :         {
     774           0 :             nHeight = -1;
     775             :         }
     776           0 :         maXShape->setPosition( aTextPos );
     777           0 :         maXShape->setSize( awt::Size( nWidth, nHeight ) );
     778           0 :         double nX = mpCGM->pElement->nCharacterOrientation[ 2 ];
     779           0 :         double nY = mpCGM->pElement->nCharacterOrientation[ 3 ];
     780           0 :         double nOrientation = acos( nX / sqrt( nX * nX + nY * nY ) ) * 57.29577951308;
     781           0 :         if ( nY < 0 )
     782           0 :             nOrientation = 360 - nOrientation;
     783             : 
     784           0 :         if ( nOrientation )
     785             :         {
     786           0 :             aAny <<= (sal_Int32)( aTextPos.X );
     787           0 :             maXPropSet->setPropertyValue( "RotationPointX", aAny );
     788           0 :             aAny <<= (sal_Int32)( aTextPos.Y + nHeight );
     789           0 :             maXPropSet->setPropertyValue( "RotationPointY", aAny );
     790           0 :             aAny <<= (sal_Int32)( (sal_Int32)( nOrientation * 100 ) );
     791           0 :             maXPropSet->setPropertyValue( "RotateAngle", aAny );
     792             :         }
     793           0 :         if ( nWidth == -1 )
     794             :         {
     795           0 :             sal_Bool bTrue( sal_True );
     796           0 :             aAny.setValue( &bTrue, cppu::UnoType<sal_Bool>::get());
     797           0 :             maXPropSet->setPropertyValue( "TextAutoGrowWidth", aAny );
     798             : 
     799             :             drawing::TextAdjust eTextAdjust;
     800           0 :             switch ( mpCGM->pElement->eTextAlignmentH )
     801             :             {
     802             :                 case TAH_RIGHT :
     803           0 :                     eTextAdjust = drawing::TextAdjust_RIGHT;
     804           0 :                 break;
     805             :                 case TAH_LEFT :
     806             :                 case TAH_CONT :
     807             :                 case TAH_NORMAL :
     808           0 :                     eTextAdjust = drawing::TextAdjust_LEFT;
     809           0 :                 break;
     810             :                 case TAH_CENTER :
     811           0 :                     eTextAdjust = drawing::TextAdjust_CENTER;
     812           0 :                 break;
     813             :             }
     814           0 :             aAny <<= eTextAdjust;
     815           0 :             maXPropSet->setPropertyValue( "TextHorizontalAdjust", aAny );
     816             :         }
     817           0 :         if ( nHeight == -1 )
     818             :         {
     819           0 :             sal_Bool bTrue = sal_True;
     820           0 :             aAny.setValue( &bTrue, cppu::UnoType<sal_Bool>::get());
     821           0 :             maXPropSet->setPropertyValue( "TextAutoGrowHeight", aAny );
     822             :         }
     823           0 :         uno::Reference< text::XText >  xText;
     824           0 :         uno::Any aFirstQuery( maXShape->queryInterface( cppu::UnoType<text::XText>::get()));
     825           0 :         if( aFirstQuery >>= xText )
     826             :         {
     827           0 :             OUString aStr( OUString::createFromAscii( pString ) );
     828             : 
     829           0 :             uno::Reference< text::XTextCursor >  aXTextCursor( xText->createTextCursor() );
     830             :             {
     831           0 :                 aXTextCursor->gotoEnd( sal_False );
     832           0 :                 uno::Reference< text::XTextRange >  aCursorText;
     833           0 :                 uno::Any aSecondQuery( aXTextCursor->queryInterface( cppu::UnoType<text::XTextRange>::get()));
     834           0 :                 if ( aSecondQuery >>= aCursorText )
     835             :                 {
     836           0 :                     uno::Reference< beans::XPropertySet >  aCursorPropSet;
     837             : 
     838           0 :                     uno::Any aQuery( aCursorText->queryInterface( cppu::UnoType<beans::XPropertySet>::get()));
     839           0 :                     if( aQuery >>= aCursorPropSet )
     840             :                     {
     841           0 :                         if ( nWidth != -1 )     // paragraph adjusting in a valid textbox ?
     842             :                         {
     843           0 :                             switch ( mpCGM->pElement->eTextAlignmentH )
     844             :                             {
     845             :                                 case TAH_RIGHT :
     846           0 :                                     aAny <<= (sal_Int16)style::HorizontalAlignment_RIGHT;
     847           0 :                                 break;
     848             :                                 case TAH_LEFT :
     849             :                                 case TAH_CONT :
     850             :                                 case TAH_NORMAL :
     851           0 :                                     aAny <<= (sal_Int16)style::HorizontalAlignment_LEFT;
     852           0 :                                 break;
     853             :                                 case TAH_CENTER :
     854           0 :                                     aAny <<= (sal_Int16)style::HorizontalAlignment_CENTER;
     855           0 :                                 break;
     856             :                             }
     857           0 :                             aCursorPropSet->setPropertyValue( "ParaAdjust", aAny );
     858             :                         }
     859           0 :                         if ( nWidth > 0 && nHeight > 0 )    // restricted text
     860             :                         {
     861           0 :                             sal_Bool bTrue = sal_True;
     862           0 :                             aAny.setValue( &bTrue, cppu::UnoType<sal_Bool>::get());
     863           0 :                             maXPropSet->setPropertyValue( "TextFitToSize", aAny );
     864             :                         }
     865           0 :                         aCursorText->setString( aStr );
     866           0 :                         aXTextCursor->gotoEnd( sal_True );
     867           0 :                         ImplSetTextBundle( aCursorPropSet );
     868           0 :                     }
     869           0 :                 }
     870           0 :             }
     871             :         }
     872           0 :         if ( eFlag == FF_NOT_FINAL )
     873             :         {
     874           0 :             nFinalTextCount = maXShapes->getCount();
     875           0 :         }
     876             :     }
     877           0 : }
     878             : 
     879           0 : void CGMImpressOutAct::AppendText( char* pString, sal_uInt32 /*nSize*/, FinalFlag /*eFlag*/ )
     880             : {
     881           0 :     if ( nFinalTextCount )
     882             :     {
     883           0 :         uno::Reference< drawing::XShape >  aShape = *static_cast<uno::Reference< drawing::XShape > const *>(maXShapes->getByIndex( nFinalTextCount - 1 ).getValue());
     884           0 :         if ( aShape.is() )
     885             :         {
     886           0 :             uno::Reference< text::XText >  xText;
     887           0 :             uno::Any aFirstQuery(  aShape->queryInterface( cppu::UnoType<text::XText>::get()) );
     888           0 :             if( aFirstQuery >>= xText )
     889             :             {
     890           0 :                 OUString aStr( OUString::createFromAscii( pString ) );
     891             : 
     892           0 :                 uno::Reference< text::XTextCursor >  aXTextCursor( xText->createTextCursor() );
     893           0 :                 if ( aXTextCursor.is() )
     894             :                 {
     895           0 :                     aXTextCursor->gotoEnd( sal_False );
     896           0 :                     uno::Reference< text::XTextRange >  aCursorText;
     897           0 :                     uno::Any aSecondQuery(aXTextCursor->queryInterface( cppu::UnoType<text::XTextRange>::get()));
     898           0 :                     if ( aSecondQuery >>= aCursorText )
     899             :                     {
     900           0 :                         uno::Reference< beans::XPropertySet >  aPropSet;
     901           0 :                         uno::Any aQuery(aCursorText->queryInterface( cppu::UnoType<beans::XPropertySet>::get()));
     902           0 :                         if( aQuery >>= aPropSet )
     903             :                         {
     904           0 :                             aCursorText->setString( aStr );
     905           0 :                             aXTextCursor->gotoEnd( sal_True );
     906           0 :                             ImplSetTextBundle( aPropSet );
     907           0 :                         }
     908           0 :                     }
     909           0 :                 }
     910           0 :             }
     911           0 :         }
     912             :     }
     913           0 : }
     914             : 
     915             : 
     916             : // nCount != 0 -> Append Text
     917           0 : sal_uInt32 CGMImpressOutAct::DrawText( TextEntry* /*pTextEntry*/, NodeFrameSet& /*rNodeFrameSet*/, sal_uInt32 /*nObjCount*/ )
     918             : {
     919           0 : return 0;
     920             : }
     921             : 
     922             : 
     923             : 
     924           0 : void CGMImpressOutAct::DrawChart()
     925             : {
     926           0 : }
     927             : 
     928             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11