i122132 Some simple extensions to exporter

drawinglayer/source/processor2d/vclmetafileprocessor2d.cxx

@@ -370,6 +370,7 @@ namespace drawinglayer
 
             if(rB2DPolygon.count() && !mnSvtGraphicStrokeCount)
             {
+                basegfx::B2DPolygon aLocalPolygon(rB2DPolygon);
                 basegfx::BColor aStrokeColor;
                 basegfx::B2DPolyPolygon aStartArrow;
                 basegfx::B2DPolyPolygon aEndArrow;
@@ -387,29 +388,37 @@ namespace drawinglayer
                 // SvtGraphicStroke has NO entry for stroke color(!)
                 mpOutputDevice->SetLineColor(Color(aStrokeColor));
 
-                if(!rB2DPolygon.isClosed())
+                if(!aLocalPolygon.isClosed())
                 {
                     double fPolyLength(0.0);
+                    double fStart(0.0);
+                    double fEnd(0.0);
 
                     if(pStart && pStart->isActive())
                     {
-                        fPolyLength = basegfx::tools::getLength(rB2DPolygon);
+                        fPolyLength = basegfx::tools::getLength(aLocalPolygon);
 
                         aStartArrow = basegfx::tools::createAreaGeometryForLineStartEnd(
-                            rB2DPolygon, pStart->getB2DPolyPolygon(), true, pStart->getWidth(),
-                            fPolyLength, pStart->isCentered() ? 0.5 : 0.0, 0);
+                            aLocalPolygon, pStart->getB2DPolyPolygon(), true, pStart->getWidth(),
+                            fPolyLength, pStart->isCentered() ? 0.5 : 0.0, &fStart);
                     }
 
                     if(pEnd && pEnd->isActive())
                     {
                         if(basegfx::fTools::equalZero(fPolyLength))
                         {
-                            fPolyLength = basegfx::tools::getLength(rB2DPolygon);
+                            fPolyLength = basegfx::tools::getLength(aLocalPolygon);
                         }
 
                         aEndArrow = basegfx::tools::createAreaGeometryForLineStartEnd(
-                            rB2DPolygon, pEnd->getB2DPolyPolygon(), false, pEnd->getWidth(),
-                            fPolyLength, pEnd->isCentered() ? 0.5 : 0.0, 0);
+                            aLocalPolygon, pEnd->getB2DPolyPolygon(), false, pEnd->getWidth(),
+                            fPolyLength, pEnd->isCentered() ? 0.5 : 0.0, &fEnd);
+                    }
+
+                    if(0.0 != fStart || 0.0 != fEnd)
+                    {
+                        // build new poly, consume something from old poly
+                        aLocalPolygon = basegfx::tools::getSnippetAbsolute(aLocalPolygon, fStart, fPolyLength - fEnd, fPolyLength);
                     }
                 }
 
@@ -490,14 +499,12 @@ namespace drawinglayer
                 // concept of PDF export and SvtGraphicStroke usage does simply not
                 // allow handling such definitions. The only clean way would be to
                 // add the transformation to SvtGraphicStroke and to handle it there
-                basegfx::B2DPolygon aB2DPolygon(rB2DPolygon);
-
-                aB2DPolygon.transform(maCurrentTransformation);
+                aLocalPolygon.transform(maCurrentTransformation);
                 aStartArrow.transform(maCurrentTransformation);
                 aEndArrow.transform(maCurrentTransformation);
 
                 pRetval = new SvtGraphicStroke(
-                    Polygon(aB2DPolygon),
+                    Polygon(aLocalPolygon),
                     PolyPolygon(aStartArrow),
                     PolyPolygon(aEndArrow),
                     mfCurrentUnifiedTransparence,

filter/source/svg/svgwriter.cxx

@@ -1280,6 +1280,14 @@ void SVGActionWriter::ImplWriteActions( const GDIMetaFile& rMtf,
 
                     if( rPoly.GetSize() )
                     {
+                        const LineInfo& rLineInfo = pA->GetLineInfo();
+
+                        if(rLineInfo.GetWidth())
+                        {
+                            sal_Int32 nStrokeWidth = ImplMap(rLineInfo.GetWidth());
+                            mrExport.AddAttribute( XML_NAMESPACE_NONE, aXMLAttrStrokeWidth, ::rtl::OUString::valueOf( nStrokeWidth ) );
+                        }
+
                         mpContext->AddPaintAttr( mpVDev->GetLineColor(), Color( COL_TRANSPARENT ) );
                         ImplWritePolyPolygon( rPoly, sal_True );
                     }
@@ -1550,10 +1558,7 @@ void SVGActionWriter::ImplWriteActions( const GDIMetaFile& rMtf,
                     aStroke.getEndArrow( aEndArrow );
 
                     // Currently no support for strokes with start/end arrow(s)
-                    sal_Bool bSkip = ( !aStartArrow.Count() && !aEndArrow.Count() );
-
-                    if( bSkip )
-                    {
+                    // added that support
                     Polygon aPoly;
 
                     aStroke.getPath(aPoly);
@@ -1627,6 +1632,35 @@ void SVGActionWriter::ImplWriteActions( const GDIMetaFile& rMtf,
                             break;
                         }
                     }
+
+                    if(mapCurShape.get() &&(aStartArrow.Count() || aEndArrow.Count()))
+                    {
+                        ImplWriteShape( *mapCurShape );
+
+                        mapCurShape->maShapeFillColor = mapCurShape->maShapeLineColor;
+                        mapCurShape->maShapeLineColor = Color(COL_TRANSPARENT);
+                        mapCurShape->mnStrokeWidth = 0;
+                        mapCurShape->maDashArray.clear();
+                        mapCurShape->maLineJoin = basegfx::B2DLINEJOIN_MITER;
+                        mapCurShape->maLineCap = com::sun::star::drawing::LineCap_BUTT;
+
+                        if(aStartArrow.Count())
+                        {
+                            mapCurShape->maShapePolyPoly = aStartArrow;
+                            mapCurShape->maId = *pElementId + B2UCONST("_") + ::rtl::OUString::valueOf(nEntryCount++);
+
+                            ImplWriteShape( *mapCurShape );
+                        }
+
+                        if(aEndArrow.Count())
+                        {
+                            mapCurShape->maShapePolyPoly = aEndArrow;
+                            mapCurShape->maId = *pElementId + B2UCONST("_") + ::rtl::OUString::valueOf(nEntryCount++);
+
+                            ImplWriteShape( *mapCurShape );
+                        }
+
+                        mapCurShape.reset();
                     }
 
                     // write open shape in every case
@@ -1637,6 +1671,8 @@ void SVGActionWriter::ImplWriteActions( const GDIMetaFile& rMtf,
                     }
 
                     // skip rest of comment
+                    sal_Bool bSkip = true;
+
                     while( bSkip && ( ++nCurAction < nCount ) )
                     {
                         pAction = rMtf.GetAction( nCurAction );

vcl/source/gdi/metaact.cxx

@@ -4104,20 +4104,34 @@ void MetaCommentAction::Move( long nXMove, long nYMove )
                 {
                     SvtGraphicStroke aStroke;
                     aMemStm >> aStroke;
+
                     Polygon aPath;
                     aStroke.getPath( aPath );
                     aPath.Move( nXMove, nYMove );
                     aStroke.setPath( aPath );
+
+                    PolyPolygon aStartArrow;
+                    aStroke.getStartArrow(aStartArrow);
+                    aStartArrow.Move(nXMove, nYMove);
+                    aStroke.setStartArrow(aStartArrow);
+
+                    PolyPolygon aEndArrow;
+                    aStroke.getEndArrow(aEndArrow);
+                    aEndArrow.Move(nXMove, nYMove);
+                    aStroke.setEndArrow(aEndArrow);
+
                     aDest << aStroke;
                 }
                 else
                 {
                     SvtGraphicFill aFill;
                     aMemStm >> aFill;
+
                     PolyPolygon aPath;
                     aFill.getPath( aPath );
                     aPath.Move( nXMove, nYMove );
                     aFill.setPath( aPath );
+
                     aDest << aFill;
                 }
                 delete[] mpData;