drawinglayer/source/tools/emfppen.cxx

   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/rendering/PathCapType.hpp>
  21 #include <com/sun/star/rendering/PathJoinType.hpp>
  22 #include <o3tl/safeint.hxx>
  23 #include <sal/log.hxx>
  24 #include <rtl/ustrbuf.hxx>
  25
  26 #include "emfppen.hxx"
  27 #include "emfpcustomlinecap.hxx"
  28
  29 using namespace ::com::sun::star;
  30 using namespace ::basegfx;
  31
  32 namespace emfplushelper
  33 {
  34     namespace {
  35
  36     enum EmfPlusPenData
  37     {
  38         PenDataTransform        = 0x00000001,
  39         PenDataStartCap         = 0x00000002,
  40         PenDataEndCap           = 0x00000004,
  41         PenDataJoin             = 0x00000008,
  42         PenDataMiterLimit       = 0x00000010,
  43         PenDataLineStyle        = 0x00000020,
  44         PenDataDashedLineCap    = 0x00000040,
  45         PenDataDashedLineOffset = 0x00000080,
  46         PenDataDashedLine       = 0x00000100,
  47         PenDataAlignment        = 0x00000200,
  48         PenDataCompoundLine     = 0x00000400,
  49         PenDataCustomStartCap   = 0x00000800,
  50         PenDataCustomEndCap     = 0x00001000
  51     };
  52
  53     }
  54
  55     EMFPPen::EMFPPen()
  56         : EMFPBrush()
  57         , penDataFlags(0)
  58         , penUnit(0)
  59         , penWidth(0.0)
  60         , startCap(0)
  61         , endCap(0)
  62         , lineJoin(0)
  63         , miterLimit(0.0)
  64         , dashStyle(0)
  65         , dashCap(0)
  66         , dashOffset(0.0)
  67         , alignment(0)
  68         , customStartCapLen(0)
  69         , customEndCapLen(0)
  70     {
  71     }
  72
  73     EMFPPen::~EMFPPen()
  74     {
  75     }
  76
  77     static OUString PenDataFlagsToString(sal_uInt32 flags)
  78     {
  79         rtl::OUStringBuffer sFlags;
  80
  81         if (flags & EmfPlusPenDataTransform)
  82             sFlags.append("\nEMF+\t\t\tEmfPlusPenDataTransform");
  83
  84         if (flags & EmfPlusPenDataStartCap)
  85             sFlags.append("\nEMF+\t\t\tEmfPlusPenDataStartCap");
  86
  87         if (flags & EmfPlusPenDataEndCap)
  88              sFlags.append("\nEMF+\t\t\tEmfPlusPenDataEndCap");
  89
  90         if (flags & EmfPlusPenDataJoin)
  91             sFlags.append("\nEMF+\t\t\tEmfPlusPenDataJoin");
  92
  93         if (flags & EmfPlusPenDataMiterLimit)
  94             sFlags.append("\nEMF+\t\t\tEmfPlusPenDataMiterLimit");
  95
  96         if (flags & EmfPlusPenDataLineStyle)
  97             sFlags.append("\nEMF+\t\t\tEmfPlusPenDataLineStyle");
  98
  99         if (flags & EmfPlusPenDataDashedLineCap)
 100             sFlags.append("\nEMF+\t\t\tEmfPlusPenDataDashedLineCap");
 101
 102         if (flags & EmfPlusPenDataDashedLineOffset)
 103             sFlags.append("\nEMF+\t\t\tEmfPlusPenDataDashedLineOffset");
 104
 105         if (flags & EmfPlusPenDataDashedLine)
 106             sFlags.append("\nEMF+\t\t\tEmfPlusPenDataDashedLine");
 107
 108         if (flags & EmfPlusPenDataAlignment)
 109             sFlags.append("\nEMF+\t\t\tEmfPlusPenDataAlignment");
 110
 111         if (flags & EmfPlusPenDataCompoundLine)
 112             sFlags.append("\nEMF+\t\t\tEmfPlusPenDataCompoundLine");
 113
 114         if (flags & EmfPlusPenDataCustomStartCap)
 115             sFlags.append("\nEMF+\t\t\tEmfPlusPenDataCustomStartCap");
 116
 117         if (flags & EmfPlusPenDataCustomEndCap)
 118             sFlags.append("\nEMF+\t\t\tEmfPlusPenDataCustomEndCap");
 119
 120         return sFlags.makeStringAndClear();
 121     }
 122
 123     static OUString LineCapTypeToString(sal_uInt32 linecap)
 124     {
 125         switch (linecap)
 126         {
 127             case LineCapTypeFlat: return "LineCapTypeFlat";
 128             case LineCapTypeSquare: return "LineCapTypeSquare";
 129             case LineCapTypeRound: return "LineCapTypeRound";
 130             case LineCapTypeTriangle: return "LineCapTypeTriangle";
 131             case LineCapTypeNoAnchor: return "LineCapTypeNoAnchor";
 132             case LineCapTypeSquareAnchor: return "LineCapTypeSquareAnchor";
 133             case LineCapTypeRoundAnchor: return "LineCapTypeRoundAchor";
 134             case LineCapTypeDiamondAnchor: return "LineCapTypeDiamondAnchor";
 135             case LineCapTypeArrowAnchor: return "LineCapTypeArrowAnchor";
 136             case LineCapTypeAnchorMask: return "LineCapTypeAnchorMask";
 137             case LineCapTypeCustom: return "LineCapTypeCustom";
 138         }
 139         return "";
 140     }
 141
 142     static OUString LineJoinTypeToString(sal_uInt32 jointype)
 143     {
 144         switch (jointype)
 145         {
 146             case LineJoinTypeMiter: return "LineJoinTypeMiter";
 147             case LineJoinTypeBevel: return "LineJoinTypeBevel";
 148             case LineJoinTypeRound: return "LineJoinTypeRound";
 149             case LineJoinTypeMiterClipped: return "LineJoinTypeMiterClipped";
 150         }
 151         return "";
 152     }
 153
 154     static OUString DashedLineCapTypeToString(sal_uInt32 dashedlinecaptype)
 155     {
 156         switch (dashedlinecaptype)
 157         {
 158             case DashedLineCapTypeFlat: return "DashedLineCapTypeFlat";
 159             case DashedLineCapTypeRound: return "DashedLineCapTypeRound";
 160             case DashedLineCapTypeTriangle: return "DashedLineCapTypeTriangle";
 161         }
 162         return "";
 163     }
 164
 165     static OUString PenAlignmentToString(sal_uInt32 alignment)
 166     {
 167         switch (alignment)
 168         {
 169             case PenAlignmentCenter: return "PenAlignmentCenter";
 170             case PenAlignmentInset: return "PenAlignmentInset";
 171             case PenAlignmentLeft: return "PenAlignmentLeft";
 172             case PenAlignmentOutset: return "PenAlignmentOutset";
 173             case PenAlignmentRight: return "PenAlignmentRight";
 174         }
 175         return "";
 176     }
 177
 178     /// Convert stroke caps between EMF+ and rendering API
 179     sal_Int8 EMFPPen::lcl_convertStrokeCap(sal_uInt32 nEmfStroke)
 180     {
 181         switch (nEmfStroke)
 182         {
 183             case EmfPlusLineCapTypeSquare: return rendering::PathCapType::SQUARE;
 184             case EmfPlusLineCapTypeRound:  return rendering::PathCapType::ROUND;
 185         }
 186
 187         // we have no mapping for EmfPlusLineCapTypeTriangle = 0x00000003,
 188         // so return BUTT always
 189         return rendering::PathCapType::BUTT;
 190     }
 191
 192     sal_Int8 EMFPPen::lcl_convertLineJoinType(sal_uInt32 nEmfLineJoin)
 193     {
 194         switch (nEmfLineJoin)
 195         {
 196             case EmfPlusLineJoinTypeMiter:        // fall-through
 197             case EmfPlusLineJoinTypeMiterClipped: return rendering::PathJoinType::MITER;
 198             case EmfPlusLineJoinTypeBevel:        return rendering::PathJoinType::BEVEL;
 199             case EmfPlusLineJoinTypeRound:        return rendering::PathJoinType::ROUND;
 200         }
 201
 202         assert(false); // Line Join type isn't in specification.
 203         return 0;
 204     }
 205
 206     void EMFPPen::Read(SvStream& s, EmfPlusHelperData const & rR)
 207     {
 208         sal_uInt32 graphicsVersion, penType;
 209         int i;
 210         s.ReadUInt32(graphicsVersion).ReadUInt32(penType).ReadUInt32(penDataFlags).ReadUInt32(penUnit).ReadFloat(penWidth);
 211         SAL_INFO("drawinglayer", "EMF+\t\tGraphics version: 0x" << std::hex << graphicsVersion);
 212         SAL_INFO("drawinglayer", "EMF+\t\tType: " << penType);
 213         SAL_INFO("drawinglayer", "EMF+\t\tPen data flags: 0x" << penDataFlags << PenDataFlagsToString(penDataFlags));
 214         SAL_INFO("drawinglayer", "EMF+\t\tUnit: " << UnitTypeToString(penUnit));
 215         SAL_INFO("drawinglayer", "EMF+\t\tWidth: " << std::dec << penWidth);
 216
 217         // If a zero width is specified, a minimum value must be used, which is determined by the units
 218         if (penWidth == 0.0)
 219         { //TODO Check if these values is correct
 220             penWidth = penUnit == 0 ? 0.18f
 221                 : 0.05f;  // 0.05f is taken from old EMF+ implementation (case of Unit == Pixel etc.)
 222         }
 223
 224         if (penDataFlags & PenDataTransform)
 225         {
 226             EmfPlusHelperData::readXForm(s, pen_transformation);
 227             SAL_WARN("drawinglayer", "EMF+\t\t TODO PenDataTransform: " << pen_transformation);
 228         }
 229
 230         if (penDataFlags & PenDataStartCap)
 231         {
 232             s.ReadInt32(startCap);
 233             SAL_INFO("drawinglayer", "EMF+\t\tstartCap: " << LineCapTypeToString(startCap) << " (0x" << std::hex << startCap << ")");
 234         }
 235         else
 236         {
 237             startCap = 0;
 238         }
 239
 240         if (penDataFlags & PenDataEndCap)
 241         {
 242             s.ReadInt32(endCap);
 243             SAL_INFO("drawinglayer", "EMF+\t\tendCap: " << LineCapTypeToString(endCap) << " (0x" << std::hex << startCap << ")");
 244         }
 245         else
 246         {
 247             endCap = 0;
 248         }
 249
 250         if (penDataFlags & PenDataJoin)
 251         {
 252             s.ReadInt32(lineJoin);
 253             SAL_WARN("drawinglayer", "EMF+\t\tTODO PenDataJoin: " << LineJoinTypeToString(lineJoin) << " (0x" << std::hex << lineJoin << ")");
 254         }
 255         else
 256         {
 257             lineJoin = 0;
 258         }
 259
 260         if (penDataFlags & PenDataMiterLimit)
 261         {
 262             s.ReadFloat(miterLimit);
 263             SAL_WARN("drawinglayer", "EMF+\t\tTODO PenDataMiterLimit: " << std::dec << miterLimit);
 264         }
 265         else
 266         {
 267             miterLimit = 0;
 268         }
 269
 270         if (penDataFlags & PenDataLineStyle)
 271         {
 272             s.ReadInt32(dashStyle);
 273             SAL_INFO("drawinglayer", "EMF+\t\tdashStyle: " << DashedLineCapTypeToString(dashStyle) << " (0x" << std::hex << dashStyle << ")");
 274         }
 275         else
 276         {
 277             dashStyle = 0;
 278         }
 279
 280         if (penDataFlags & PenDataDashedLineCap)
 281         {
 282             s.ReadInt32(dashCap);
 283             SAL_WARN("drawinglayer", "EMF+\t\t TODO PenDataDashedLineCap: 0x" << std::hex << dashCap);
 284         }
 285         else
 286         {
 287             dashCap = 0;
 288         }
 289
 290         if (penDataFlags & PenDataDashedLineOffset)
 291         {
 292             s.ReadFloat(dashOffset);
 293             SAL_WARN("drawinglayer", "EMF+\t\t TODO PenDataDashedLineOffset: 0x" << std::hex << dashOffset);
 294         }
 295         else
 296         {
 297             dashOffset = 0;
 298         }
 299
 300         if (penDataFlags & PenDataDashedLine)
 301         {
 302             dashStyle = EmfPlusLineStyleCustom;
 303             sal_Int32 dashPatternLen;
 304
 305             s.ReadInt32(dashPatternLen);
 306             SAL_INFO("drawinglayer", "EMF+\t\t\tdashPatternLen: " << dashPatternLen);
 307
 308             if (dashPatternLen<0 || o3tl::make_unsigned(dashPatternLen)>SAL_MAX_INT32 / sizeof(float))
 309             {
 310                 dashPatternLen = SAL_MAX_INT32 / sizeof(float);
 311             }
 312
 313             dashPattern.resize( dashPatternLen );
 314
 315             for (i = 0; i < dashPatternLen; i++)
 316             {
 317                 s.ReadFloat(dashPattern[i]);
 318                 SAL_INFO("drawinglayer", "EMF+\t\t\t\tdashPattern[" << i << "]: " << dashPattern[i]);
 319             }
 320         }
 321
 322         if (penDataFlags & PenDataAlignment)
 323         {
 324             s.ReadInt32(alignment);
 325             SAL_WARN("drawinglayer", "EMF+\t\t\tTODO PenDataAlignment: " << PenAlignmentToString(alignment) << " (0x" << std::hex << alignment << ")");
 326         }
 327         else
 328         {
 329             alignment = 0;
 330         }
 331
 332         if (penDataFlags & PenDataCompoundLine)
 333         {
 334             SAL_WARN("drawinglayer", "EMF+\t\t\tTODO PenDataCompoundLine");
 335             sal_Int32 compoundArrayLen;
 336             s.ReadInt32(compoundArrayLen);
 337
 338             if (compoundArrayLen<0 || o3tl::make_unsigned(compoundArrayLen)>SAL_MAX_INT32 / sizeof(float))
 339             {
 340                 compoundArrayLen = SAL_MAX_INT32 / sizeof(float);
 341             }
 342
 343             compoundArray.resize(compoundArrayLen);
 344
 345             for (i = 0; i < compoundArrayLen; i++)
 346             {
 347                 s.ReadFloat(compoundArray[i]);
 348                 SAL_INFO("drawinglayer", "EMF+\t\t\t\tcompoundArray[" << i << "]: " << compoundArray[i]);
 349             }
 350         }
 351
 352         if (penDataFlags & PenDataCustomStartCap)
 353         {
 354             s.ReadInt32(customStartCapLen);
 355             SAL_INFO("drawinglayer", "EMF+\t\t\tcustomStartCapLen: " << customStartCapLen);
 356             sal_uInt64 const pos = s.Tell();
 357
 358             customStartCap.reset( new EMFPCustomLineCap() );
 359             customStartCap->Read(s, rR);
 360
 361             // maybe we don't read everything yet, play it safe ;-)
 362             s.Seek(pos + customStartCapLen);
 363         }
 364         else
 365         {
 366             customStartCapLen = 0;
 367         }
 368
 369         if (penDataFlags & PenDataCustomEndCap)
 370         {
 371             s.ReadInt32(customEndCapLen);
 372             SAL_INFO("drawinglayer", "EMF+\t\t\tcustomEndCapLen: " << customEndCapLen);
 373             sal_uInt64 const pos = s.Tell();
 374
 375             customEndCap.reset( new EMFPCustomLineCap() );
 376             customEndCap->Read(s, rR);
 377
 378             // maybe we don't read everything yet, play it safe ;-)
 379             s.Seek(pos + customEndCapLen);
 380         }
 381         else
 382         {
 383             customEndCapLen = 0;
 384         }
 385
 386         EMFPBrush::Read(s, rR);
 387     }
 388 }
 389
 390 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */