summaryrefslogtreecommitdiffstats
path: root/include/vcl/graphic
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--include/vcl/graphic/GraphicMetadata.hxx68
-rw-r--r--include/vcl/graphicfilter.hxx356
-rw-r--r--include/vcl/graphictools.hxx369
3 files changed, 793 insertions, 0 deletions
diff --git a/include/vcl/graphic/GraphicMetadata.hxx b/include/vcl/graphic/GraphicMetadata.hxx
new file mode 100644
index 0000000000..33ee9d81c3
--- /dev/null
+++ b/include/vcl/graphic/GraphicMetadata.hxx
@@ -0,0 +1,68 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+#ifndef INCLUDED_VCL_GRAPHIC_GRAPHICMETADATA_HXX
+#define INCLUDED_VCL_GRAPHIC_GRAPHICMETADATA_HXX
+
+#include <tools/gen.hxx>
+#include <vcl/mapmod.hxx>
+
+#include <optional>
+
+// Info class for all supported file formats
+enum class GraphicFileFormat
+{
+ NOT = 0x0000,
+ BMP = 0x0001,
+ GIF = 0x0002,
+ JPG = 0x0003,
+ PCD = 0x0004,
+ PCX = 0x0005,
+ PNG = 0x0006,
+ TIF = 0x0007,
+ XBM = 0x0008,
+ XPM = 0x0009,
+ PBM = 0x000a,
+ PGM = 0x000b,
+ PPM = 0x000c,
+ RAS = 0x000d,
+ TGA = 0x000e,
+ PSD = 0x000f,
+ EPS = 0x0010,
+ WEBP = 0x0011,
+ MOV = 0x00e0,
+ PDF = 0x00e1,
+ DXF = 0x00f1,
+ MET = 0x00f2,
+ PCT = 0x00f3,
+ // retired SGF = 0x00f4,
+ SVM = 0x00f5,
+ WMF = 0x00f6,
+ // retired SGV = 0x00f7,
+ EMF = 0x00f8,
+ SVG = 0x00f9,
+ WMZ = 0x00fa,
+ EMZ = 0x00fb,
+ SVGZ = 0x00fc,
+ APNG = 0x00fd
+};
+struct GraphicMetadata
+{
+ Size maPixSize{};
+ Size maLogSize{};
+ std::optional<Size> maPreferredLogSize = std::nullopt;
+ std::optional<MapMode> maPreferredMapMode = std::nullopt;
+ sal_uInt16 mnBitsPerPixel = 0;
+ sal_uInt16 mnPlanes = 0;
+ GraphicFileFormat mnFormat = GraphicFileFormat::NOT;
+ sal_uInt8 mnNumberOfImageComponents = 0;
+ bool mbIsTransparent = false;
+ bool mbIsAlpha = false;
+};
+#endif
+/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */
diff --git a/include/vcl/graphicfilter.hxx b/include/vcl/graphicfilter.hxx
new file mode 100644
index 0000000000..fd6c205bd4
--- /dev/null
+++ b/include/vcl/graphicfilter.hxx
@@ -0,0 +1,356 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_VCL_GRAPHICFILTER_HXX
+#define INCLUDED_VCL_GRAPHICFILTER_HXX
+
+#include <tools/gen.hxx>
+#include <vcl/dllapi.h>
+#include <vcl/graph.hxx>
+#include <comphelper/errcode.hxx>
+#include <o3tl/typed_flags_set.hxx>
+#include <vcl/BinaryDataContainer.hxx>
+#include <vcl/graphic/GraphicMetadata.hxx>
+
+#include <memory>
+
+namespace com::sun::star::beans { struct PropertyValue; }
+namespace com::sun::star::uno { template <class E> class Sequence; }
+
+class INetURLObject;
+
+class FilterConfigCache;
+class SvStream;
+struct WmfExternal;
+struct ConvertData;
+
+#define ERRCODE_GRFILTER_OPENERROR ErrCode(ErrCodeArea::Vcl, ErrCodeClass::General, 1)
+#define ERRCODE_GRFILTER_IOERROR ErrCode(ErrCodeArea::Vcl, ErrCodeClass::General, 2)
+#define ERRCODE_GRFILTER_FORMATERROR ErrCode(ErrCodeArea::Vcl, ErrCodeClass::General, 3)
+#define ERRCODE_GRFILTER_VERSIONERROR ErrCode(ErrCodeArea::Vcl, ErrCodeClass::General, 4)
+#define ERRCODE_GRFILTER_FILTERERROR ErrCode(ErrCodeArea::Vcl, ErrCodeClass::General, 5)
+#define ERRCODE_GRFILTER_TOOBIG ErrCode(ErrCodeArea::Vcl, ErrCodeClass::General, 7)
+
+#define GRFILTER_OUTHINT_GREY 1
+
+#define GRFILTER_FORMAT_NOTFOUND (sal_uInt16(0xFFFF))
+#define GRFILTER_FORMAT_DONTKNOW (sal_uInt16(0xFFFF))
+
+enum class GraphicFilterImportFlags
+{
+ NONE = 0x000,
+ SetLogsizeForJpeg = 0x001,
+ DontSetLogsizeForJpeg = 0x002,
+ /// Only create a bitmap, do not read pixel data.
+ OnlyCreateBitmap = 0x020,
+ /// Read pixel data into an existing bitmap.
+ UseExistingBitmap = 0x040,
+};
+namespace o3tl
+{
+ template<> struct typed_flags<GraphicFilterImportFlags> : is_typed_flags<GraphicFilterImportFlags, 0x0063> {};
+}
+
+#define IMP_BMP "SVBMP"
+#define IMP_MOV "SVMOV"
+#define IMP_SVMETAFILE "SVMETAFILE"
+#define IMP_WMF "SVWMF"
+#define IMP_WMZ "SVWMZ"
+#define IMP_EMF "SVEMF"
+#define IMP_EMZ "SVEMZ"
+#define IMP_GIF "SVIGIF"
+#define IMP_PNG "SVIPNG"
+#define IMP_JPEG "SVIJPEG"
+#define IMP_XBM "SVIXBM"
+#define IMP_XPM "SVIXPM"
+#define IMP_SVG "SVISVG"
+#define IMP_SVGZ "SVISVGZ"
+#define IMP_PDF "SVIPDF"
+#define IMP_TIFF "SVTIFF"
+#define IMP_TGA "SVTGA"
+#define IMP_PICT "SVPICT"
+#define IMP_MET "SVMET"
+#define IMP_RAS "SVRAS"
+#define IMP_PCX "SVPCX"
+#define IMP_EPS "SVIEPS"
+#define IMP_PSD "SVPSD"
+#define IMP_PCD "SVPCD"
+#define IMP_PBM "SVPBM"
+#define IMP_DXF "SVDXF"
+#define IMP_WEBP "SVIWEBP"
+
+#define EXP_BMP "SVBMP"
+#define EXP_SVMETAFILE "SVMETAFILE"
+#define EXP_WMF "SVWMF"
+#define EXP_WMZ "SVWMZ"
+#define EXP_EMF "SVEMF"
+#define EXP_EMZ "SVEMZ"
+#define EXP_JPEG "SVEJPEG"
+#define EXP_SVG "SVESVG"
+#define EXP_SVGZ "SVESVGZ"
+#define EXP_PDF "SVEPDF"
+#define EXP_PNG "SVEPNG"
+#define EXP_APNG "SVEAPNG"
+#define EXP_TIFF "SVTIFF"
+#define EXP_EPS "SVEEPS"
+#define EXP_GIF "SVEGIF"
+#define EXP_WEBP "SVEWEBP"
+
+
+inline constexpr OUString BMP_SHORTNAME = u"BMP"_ustr;
+inline constexpr OUString GIF_SHORTNAME = u"GIF"_ustr;
+inline constexpr OUString JPG_SHORTNAME = u"JPG"_ustr;
+inline constexpr OUString MET_SHORTNAME = u"MET"_ustr;
+inline constexpr OUString PCT_SHORTNAME = u"PCT"_ustr;
+inline constexpr OUString PNG_SHORTNAME = u"PNG"_ustr;
+inline constexpr OUString SVM_SHORTNAME = u"SVM"_ustr;
+inline constexpr OUString TIF_SHORTNAME = u"TIF"_ustr;
+inline constexpr OUString WMF_SHORTNAME = u"WMF"_ustr;
+inline constexpr OUString EMF_SHORTNAME = u"EMF"_ustr;
+inline constexpr OUString SVG_SHORTNAME = u"SVG"_ustr;
+inline constexpr OUString PDF_SHORTNAME = u"PDF"_ustr;
+inline constexpr OUString WEBP_SHORTNAME = u"WEBP"_ustr;
+
+class VCL_DLLPUBLIC GraphicDescriptor final
+{
+ SvStream* pFileStm;
+ OUString aPathExt;
+ GraphicMetadata aMetadata;
+ bool bOwnStream;
+
+ void ImpConstruct();
+
+ bool ImpDetectBMP( SvStream& rStm, bool bExtendedInfo );
+ bool ImpDetectGIF( SvStream& rStm, bool bExtendedInfo );
+ bool ImpDetectJPG( SvStream& rStm, bool bExtendedInfo );
+ bool ImpDetectPCD( SvStream& rStm, bool bExtendedInfo );
+ bool ImpDetectPCX( SvStream& rStm );
+ bool ImpDetectPNG( SvStream& rStm, bool bExtendedInfo );
+ bool ImpDetectTIF( SvStream& rStm, bool bExtendedInfo );
+ bool ImpDetectXBM( SvStream& rStm, bool bExtendedInfo );
+ bool ImpDetectXPM( SvStream& rStm, bool bExtendedInfo );
+ bool ImpDetectPBM( SvStream& rStm, bool bExtendedInfo );
+ bool ImpDetectPGM( SvStream& rStm, bool bExtendedInfo );
+ bool ImpDetectPPM( SvStream& rStm, bool bExtendedInfo );
+ bool ImpDetectRAS( SvStream& rStm, bool bExtendedInfo );
+ bool ImpDetectTGA( SvStream& rStm, bool bExtendedInfo );
+ bool ImpDetectPSD( SvStream& rStm, bool bExtendedInfo );
+ bool ImpDetectEPS( SvStream& rStm, bool bExtendedInfo );
+ bool ImpDetectWEBP( SvStream& rStm, bool bExtendedInfo );
+ bool ImpDetectDXF( SvStream& rStm, bool bExtendedInfo );
+ bool ImpDetectMET( SvStream& rStm, bool bExtendedInfo );
+ bool ImpDetectPCT( SvStream& rStm, bool bExtendedInfo );
+ bool ImpDetectSVM( SvStream& rStm, bool bExtendedInfo );
+ bool ImpDetectWMF( SvStream& rStm, bool bExtendedInfo );
+ bool ImpDetectEMF( SvStream& rStm, bool bExtendedInfo );
+ bool ImpDetectSVG( SvStream& rStm, bool bExtendedInfo );
+ GraphicDescriptor( const GraphicDescriptor& ) = delete;
+ GraphicDescriptor& operator=( const GraphicDescriptor& ) = delete;
+
+public:
+
+ /** Ctor to set a filename
+
+ Detect() must be called to identify the file
+ If the file has no unique header (Mtf's), the format
+ is determined from the extension */
+ GraphicDescriptor( const INetURLObject& rPath );
+
+ /** Ctor using a stream
+
+ Detect() must be called to identify the file
+ As some formats (Mtf's) do not have a unique header, it makes sense
+ to supply the file name (incl. ext.), so that the format can be
+ derived from the extension */
+ GraphicDescriptor( SvStream& rInStream, const OUString* pPath );
+
+ ~GraphicDescriptor();
+
+ /** starts the detection
+
+ if bExtendedInfo == true the file header is used to derive
+ as many properties as possible (size, color, etc.) */
+ bool Detect( bool bExtendedInfo = false );
+
+ /** @return the file format, GraphicFileFormat::NOT if no format was recognized */
+ GraphicFileFormat GetFileFormat() const { return aMetadata.mnFormat; }
+
+ /** @return graphic size in pixels or 0 size */
+ const Size& GetSizePixel() const { return aMetadata.maPixSize; }
+
+ /** @return the logical graphic size in 1/100mm or 0 size */
+ const Size& GetSize_100TH_MM() const { return aMetadata.maLogSize; }
+
+ /**
+ * Returns the logic size, according to the map mode available via GetPreferredMapMode(). Prefer
+ * this size over GetSize_100TH_MM().
+ */
+ const std::optional<Size>& GetPreferredLogSize() const { return aMetadata.maPreferredLogSize; }
+
+ /**
+ * If available, this returns the map mode the graphic prefers, which may be other than pixel or
+ * 100th mm. Prefer this map mode over just assuming MapUnit::Map100thMM.
+ */
+ const std::optional<MapMode>& GetPreferredMapMode() const { return aMetadata.maPreferredMapMode; }
+
+ /** @return bits/pixel or 0 **/
+ sal_uInt16 GetBitsPerPixel() const { return aMetadata.mnBitsPerPixel; }
+
+ /** @return number of color channels */
+ sal_uInt8 GetNumberOfImageComponents() const { return aMetadata.mnNumberOfImageComponents; }
+
+ /** @return whether image supports transparency */
+ bool IsTransparent() const { return aMetadata.mbIsTransparent; }
+
+ /** @return whether image supports alpha values for translucent colours */
+ bool IsAlpha() const { return aMetadata.mbIsAlpha; }
+
+ /** @return filter number that is needed by the GraphFilter to read this format */
+ static OUString GetImportFormatShortName( GraphicFileFormat nFormat );
+};
+
+/** Class to import and export graphic formats. */
+class VCL_DLLPUBLIC GraphicFilter
+{
+public:
+ GraphicFilter( bool bUseConfig = true );
+ ~GraphicFilter();
+
+ sal_uInt16 GetImportFormatCount() const;
+ sal_uInt16 GetImportFormatNumber( std::u16string_view rFormatName );
+ sal_uInt16 GetImportFormatNumberForShortName( std::u16string_view rShortName );
+ sal_uInt16 GetImportFormatNumberForTypeName( std::u16string_view rType );
+ OUString GetImportFormatName( sal_uInt16 nFormat );
+ OUString GetImportFormatTypeName( sal_uInt16 nFormat );
+#ifdef _WIN32
+ OUString GetImportFormatMediaType( sal_uInt16 nFormat );
+#endif
+ OUString GetImportFormatShortName( sal_uInt16 nFormat );
+ OUString GetImportWildcard( sal_uInt16 nFormat, sal_Int32 nEntry );
+
+ sal_uInt16 GetExportFormatCount() const;
+ sal_uInt16 GetExportFormatNumber( std::u16string_view rFormatName );
+ sal_uInt16 GetExportFormatNumberForMediaType( std::u16string_view rShortName );
+ sal_uInt16 GetExportFormatNumberForShortName( std::u16string_view rShortName );
+ OUString GetExportInternalFilterName( sal_uInt16 nFormat );
+ sal_uInt16 GetExportFormatNumberForTypeName( std::u16string_view rType );
+ OUString GetExportFormatName( sal_uInt16 nFormat );
+ OUString GetExportFormatMediaType( sal_uInt16 nFormat );
+ OUString GetExportFormatShortName( sal_uInt16 nFormat );
+ OUString GetExportWildcard( sal_uInt16 nFormat );
+ bool IsExportPixelFormat( sal_uInt16 nFormat );
+
+ ErrCode ExportGraphic( const Graphic& rGraphic, const INetURLObject& rPath,
+ sal_uInt16 nFormat,
+ const css::uno::Sequence< css::beans::PropertyValue >* pFilterData = nullptr );
+ ErrCode ExportGraphic( const Graphic& rGraphic, std::u16string_view rPath,
+ SvStream& rOStm, sal_uInt16 nFormat,
+ const css::uno::Sequence< css::beans::PropertyValue >* pFilterData = nullptr );
+
+ ErrCode CanImportGraphic( const INetURLObject& rPath,
+ sal_uInt16 nFormat,
+ sal_uInt16 * pDeterminedFormat);
+
+ ErrCode ImportGraphic( Graphic& rGraphic, const INetURLObject& rPath,
+ sal_uInt16 nFormat = GRFILTER_FORMAT_DONTKNOW,
+ sal_uInt16 * pDeterminedFormat = nullptr, GraphicFilterImportFlags nImportFlags = GraphicFilterImportFlags::NONE );
+
+ ErrCode CanImportGraphic( std::u16string_view rPath, SvStream& rStream,
+ sal_uInt16 nFormat,
+ sal_uInt16 * pDeterminedFormat);
+
+ ErrCode ImportGraphic( Graphic& rGraphic, std::u16string_view rPath,
+ SvStream& rStream,
+ sal_uInt16 nFormat = GRFILTER_FORMAT_DONTKNOW,
+ sal_uInt16 * pDeterminedFormat = nullptr, GraphicFilterImportFlags nImportFlags = GraphicFilterImportFlags::NONE );
+
+ /// Imports multiple graphics.
+ ///
+ /// The resulting graphic is added to rGraphics on success, nullptr is added on failure.
+ void ImportGraphics(std::vector< std::shared_ptr<Graphic> >& rGraphics, std::vector< std::unique_ptr<SvStream> > vStreams);
+
+ /**
+ Tries to ensure all Graphic objects are available (Graphic::isAvailable()). Only an optimization, may
+ not process all items.
+ */
+ void MakeGraphicsAvailableThreaded(std::vector< Graphic* >& rGraphics);
+
+ // Setting sizeLimit limits how much will be read from the stream.
+ Graphic ImportUnloadedGraphic(SvStream& rIStream, sal_uInt64 sizeLimit = 0, const Size* pSizeHint = nullptr);
+
+ const ErrCode& GetLastError() const { return *mxErrorEx;}
+ void ResetLastError();
+
+ Link<ConvertData&,bool> GetFilterCallback() const;
+ static GraphicFilter& GetGraphicFilter();
+ static ErrCode LoadGraphic( const OUString& rPath, const OUString& rFilter,
+ Graphic& rGraphic,
+ GraphicFilter* pFilter = nullptr,
+ sal_uInt16* pDeterminedFormat = nullptr );
+
+ ErrCode compressAsPNG(const Graphic& rGraphic, SvStream& rOutputStream);
+
+ static ErrCode readGIF(SvStream& rStream, Graphic& rGraphic, GfxLinkType& rLinkType);
+ static ErrCode readPNG(SvStream & rStream, Graphic & rGraphic, GfxLinkType & rLinkType,
+ BinaryDataContainer & rpGraphicContent);
+ static ErrCode readJPEG(SvStream & rStream, Graphic & rGraphic, GfxLinkType & rLinkType,
+ GraphicFilterImportFlags nImportFlags);
+ static ErrCode readSVG(SvStream & rStream, Graphic & rGraphic, GfxLinkType & rLinkType,
+ BinaryDataContainer & rpGraphicContent);
+ static ErrCode readXBM(SvStream & rStream, Graphic & rGraphic);
+ static ErrCode readXPM(SvStream & rStream, Graphic & rGraphic);
+
+ static ErrCode readWMF_EMF(SvStream & rStream, Graphic & rGraphic, GfxLinkType & rLinkType, VectorGraphicDataType eType);
+ static ErrCode readWMF(SvStream & rStream, Graphic & rGraphic, GfxLinkType & rLinkType);
+ static ErrCode readEMF(SvStream & rStream, Graphic & rGraphic, GfxLinkType & rLinkType);
+
+ static ErrCode readPDF(SvStream & rStream, Graphic & rGraphic, GfxLinkType & rLinkType);
+ static ErrCode readTIFF(SvStream & rStream, Graphic & rGraphic, GfxLinkType & rLinkType);
+ static ErrCode readWithTypeSerializer(SvStream & rStream, Graphic & rGraphic, GfxLinkType & rLinkType, std::u16string_view aFilterName);
+ static ErrCode readBMP(SvStream & rStream, Graphic & rGraphic, GfxLinkType & rLinkType);
+ static ErrCode readTGA(SvStream & rStream, Graphic & rGraphic);
+ static ErrCode readPICT(SvStream & rStream, Graphic & rGraphic, GfxLinkType & rLinkType);
+ static ErrCode readMET(SvStream & rStream, Graphic & rGraphic, GfxLinkType & rLinkType);
+ static ErrCode readRAS(SvStream & rStream, Graphic & rGraphic);
+ static ErrCode readPCX(SvStream & rStream, Graphic & rGraphic);
+ static ErrCode readEPS(SvStream & rStream, Graphic & rGraphic);
+ static ErrCode readPSD(SvStream & rStream, Graphic & rGraphic);
+ static ErrCode readPCD(SvStream & rStream, Graphic & rGraphic);
+ static ErrCode readPBM(SvStream & rStream, Graphic & rGraphic);
+ static ErrCode readDXF(SvStream & rStream, Graphic & rGraphic);
+ static ErrCode readWEBP(SvStream & rStream, Graphic & rGraphic, GfxLinkType & rLinkType);
+
+private:
+ OUString aFilterPath;
+ FilterConfigCache* pConfig;
+
+ void ImplInit();
+ ErrCode ImplSetError( ErrCode nError, const SvStream* pStm = nullptr );
+ ErrCode ImpTestOrFindFormat( std::u16string_view rPath, SvStream& rStream, sal_uInt16& rFormat );
+
+ DECL_DLLPRIVATE_LINK( FilterCallback, ConvertData&, bool );
+
+ /** Information about errors during the GraphicFilter operation. */
+ std::optional<ErrCode> mxErrorEx;
+ bool bUseConfig;
+};
+
+#endif // INCLUDED_VCL_GRAPHICFILTER_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/include/vcl/graphictools.hxx b/include/vcl/graphictools.hxx
new file mode 100644
index 0000000000..ab2371bb79
--- /dev/null
+++ b/include/vcl/graphictools.hxx
@@ -0,0 +1,369 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_VCL_GRAPHICTOOLS_HXX
+#define INCLUDED_VCL_GRAPHICTOOLS_HXX
+
+#include <vcl/dllapi.h>
+#include <sal/types.h>
+#include <tools/color.hxx>
+#include <tools/poly.hxx>
+#include <vcl/graph.hxx>
+
+#include <vector>
+
+class SvStream;
+
+/** Encapsulates geometry and associated attributes of a graphical 'pen stroke'
+
+ @attention Widespread use is deprecated. See declarations above
+ for the way to go. Especially the copied enums from svx/xenum.hxx
+ are troublesome.
+
+ Use this class to store geometry and attributes of a graphical
+ 'pen stroke', such as pen width, dashing etc. The geometry is the
+ so-called 'path' along which the stroke is traced, with the given
+ pen width. The cap type determines how the open ends of the path
+ should be drawn. If the geometry consists of more than one
+ segment, the join type determines in which way the segments are
+ joined.
+ */
+class VCL_DLLPUBLIC SvtGraphicStroke
+{
+public:
+ /// Style for open stroke ends
+ enum CapType
+ {
+ /// No additional cap
+ capButt=0,
+ /// Half-round cap at the line end, the center lying at the end point
+ capRound,
+ /// Half-square cap at the line end, the center lying at the end point
+ capSquare
+ };
+ /// Style for joins of individual stroke segments
+ enum JoinType
+ {
+ /// Extend segment edges, until they cross
+ joinMiter=0,
+ /// Connect segments by a filled round arc
+ joinRound,
+ /// Connect segments by a direct straight line
+ joinBevel,
+ /// Perform no join, leads to visible gaps between thick line segments
+ joinNone
+ };
+ typedef ::std::vector< double > DashArray;
+
+ SvtGraphicStroke();
+ /** All in one constructor
+
+ See accessor method descriptions for argument description
+ */
+ SvtGraphicStroke( tools::Polygon aPath,
+ tools::PolyPolygon aStartArrow,
+ tools::PolyPolygon aEndArrow,
+ double fTransparency,
+ double fStrokeWidth,
+ CapType aCap,
+ JoinType aJoin,
+ double fMiterLimit,
+ DashArray&& rDashArray ); // TODO: Dash array offset (position where to start, see PS)
+
+ // accessors
+ /// Query path to stroke
+ void getPath ( tools::Polygon& ) const;
+ /** Get the polygon that is put at the start of the line
+
+ The polygon is in a special normalized position: the center of
+ the stroked path will meet the given polygon at (0,0) from
+ negative y values. Thus, an arrow would have its baseline on
+ the x axis, going upwards to positive y values. Furthermore,
+ the polygon is also scaled in a special way: the width of the
+ joining stroke is defined to be
+ SvtGraphicStroke::normalizedArrowWidth (0x10000), i.e. ranging
+ from x=-0x8000 to x=0x8000. So, if the arrow does have this
+ width, it has to fit every stroke with every stroke width
+ exactly.
+ */
+ void getStartArrow ( tools::PolyPolygon& ) const;
+ /** Get the polygon that is put at the end of the line
+
+ The polygon is in a special normalized position, and already
+ scaled to the desired size: the center of the stroked path
+ will meet the given polygon at (0,0) from negative y
+ values. Thus, an arrow would have its baseline on the x axis,
+ going upwards to positive y values. Furthermore, the polygon
+ is also scaled in a special way: the width of the joining
+ stroke is defined to be SvtGraphicStroke::normalizedArrowWidth
+ (0x10000), i.e. ranging from x=-0x8000 to x=0x8000. So, if the
+ arrow does have this width, it has to fit every stroke with
+ every stroke width exactly.
+ */
+ void getEndArrow ( tools::PolyPolygon& ) const;
+ /** Get stroke transparency
+
+ @return the transparency, ranging from 0.0 (opaque) to 1.0 (fully translucent)
+ */
+ double getTransparency () const { return mfTransparency;}
+ /// Get width of the stroke
+ double getStrokeWidth () const { return mfStrokeWidth;}
+ /// Get the style in which open stroke ends are drawn
+ CapType getCapType () const { return maCapType;}
+ /// Get the style in which the stroke segments are joined
+ JoinType getJoinType () const { return maJoinType;}
+ /// Get the maximum length of mitered joins
+ double getMiterLimit () const { return mfMiterLimit;}
+ /// Get an array of "on" and "off" lengths for stroke dashing
+ void getDashArray ( DashArray& ) const;
+
+ // mutators
+ /// Set path to stroke
+ void setPath ( const tools::Polygon& );
+ /** Set the polygon that is put at the start of the line
+
+ The polygon has to be in a special normalized position, and
+ already scaled to the desired size: the center of the stroked
+ path will meet the given polygon at (0,0) from negative y
+ values. Thus, an arrow would have its baseline on the x axis,
+ going upwards to positive y values. Furthermore, the polygon
+ also has to be scaled appropriately: the width of the joining
+ stroke is defined to be SvtGraphicStroke::normalizedArrowWidth
+ (0x10000), i.e. ranging from x=-0x8000 to x=0x8000. If your
+ arrow does have this width, it will fit every stroke with
+ every stroke width exactly.
+ */
+ void setStartArrow ( const tools::PolyPolygon& );
+ /** Set the polygon that is put at the end of the line
+
+ The polygon has to be in a special normalized position, and
+ already scaled to the desired size: the center of the stroked
+ path will meet the given polygon at (0,0) from negative y
+ values. Thus, an arrow would have its baseline on the x axis,
+ going upwards to positive y values. Furthermore, the polygon
+ also has to be scaled appropriately: the width of the joining
+ stroke is defined to be SvtGraphicStroke::normalizedArrowWidth
+ (0x10000), i.e. ranging from x=-0x8000 to x=0x8000. If your
+ arrow does have this width, it will fit every stroke with
+ every stroke width exactly.
+ */
+ void setEndArrow ( const tools::PolyPolygon& );
+ /// Affine scaling in both X and Y dimensions
+ void scale ( double fScaleX, double fScaleY );
+
+private:
+ // friends
+ VCL_DLLPUBLIC friend SvStream& WriteSvtGraphicStroke( SvStream& rOStm, const SvtGraphicStroke& rClass );
+ VCL_DLLPUBLIC friend SvStream& ReadSvtGraphicStroke( SvStream& rIStm, SvtGraphicStroke& rClass );
+
+ tools::Polygon maPath;
+ tools::PolyPolygon maStartArrow;
+ tools::PolyPolygon maEndArrow;
+ double mfTransparency;
+ double mfStrokeWidth;
+ CapType maCapType;
+ JoinType maJoinType;
+ double mfMiterLimit;
+ DashArray maDashArray;
+};
+
+/** Encapsulates geometry and associated attributes of a filled area
+
+ @attention Widespread use is deprecated. See declarations above
+ for the way to go. Especially the copied enums from svx/xenum.hxx
+ is troublesome.
+
+ Use this class to store geometry and attributes of a filled area,
+ such as fill color, transparency, texture or hatch. The geometry
+ is the so-called 'path', whose inner area will get filled
+ according to the attributes set. If the path is intersecting, or
+ one part of the path is lying fully within another part, then the
+ fill rule determines which parts are filled and which are not.
+ */
+class VCL_DLLPUBLIC SvtGraphicFill
+{
+public:
+ /// Type of fill algorithm used
+ enum FillRule
+ {
+ /** Non-zero winding rule
+
+ Fill shape scanline-wise. Starting at the left, determine
+ the winding number as follows: every segment crossed that
+ runs counter-clockwise adds one to the winding number,
+ every segment crossed that runs clockwise subtracts
+ one. The part of the scanline where the winding number is
+ non-zero gets filled.
+ */
+ fillNonZero=0,
+ /** Even-odd fill rule
+
+ Fill shape scanline-wise. Starting at the left, count the
+ number of segments crossed. If this number is odd, the
+ part of the scanline is filled, otherwise not.
+ */
+ fillEvenOdd
+ };
+ /// Type of filling used
+ enum FillType
+ {
+ /// Fill with a specified solid color
+ fillSolid=0,
+ /// Fill with the specified gradient
+ fillGradient,
+ /// Fill with the specified hatch
+ fillHatch,
+ /// Fill with the specified texture (a Graphic object)
+ fillTexture
+ };
+ /// Type of hatching used
+ enum HatchType
+ {
+ /// horizontal parallel lines, one unit apart
+ hatchSingle=0,
+ /// horizontal and vertical orthogonally crossing lines, one unit apart
+ hatchDouble,
+ /// three crossing lines, like HatchType::hatchDouble, but
+ /// with an additional diagonal line, rising to the upper
+ /// right corner. The first diagonal line goes through the
+ /// upper left corner, the other are each spaced a unit apart.
+ hatchTriple
+ };
+ /// Type of gradient used
+ enum class GradientType {Linear, Radial, Rectangular};
+ /// Special values for gradient step count
+ enum { gradientStepsInfinite=0 };
+ /** Homogeneous 2D transformation matrix
+
+ This is a 2x3 matrix representing an affine transformation on
+ the R^2, in the usual C/C++ row major form. It is structured as follows:
+ <pre>
+ a b t_x
+ c d t_y
+ 0 0 1
+ </pre>
+ where the lowest line is not stored in the matrix, since it is
+ constant. Variables t_x and t_y contain translational
+ components, a to d rotation, scale and shear (for details,
+ look up your favorite linear algebra/computer graphics book).
+ */
+ struct VCL_DLLPUBLIC Transform
+ {
+ enum { MatrixSize=6 };
+ Transform();
+ double matrix[MatrixSize];
+ };
+
+ SvtGraphicFill();
+ /** All in one constructor
+
+ See accessor method descriptions for argument description
+ */
+ SvtGraphicFill( tools::PolyPolygon aPath,
+ Color aFillColor,
+ double fTransparency,
+ FillRule aFillRule,
+ FillType aFillType, // TODO: Multitexturing
+ const Transform& aFillTransform,
+ bool bTiling,
+ HatchType aHatchType, // TODO: vector of directions and start points
+ Color aHatchColor,
+ GradientType aGradientType, // TODO: Transparent gradients (orthogonal to normal ones)
+ Color aGradient1stColor, // TODO: vector of colors and offsets
+ Color aGradient2ndColor,
+ sal_Int32 aGradientStepCount, // numbers of steps to render the gradient. gradientStepsInfinite means infinitely many.
+ Graphic aFillGraphic );
+
+ // accessors
+ /// Query path to fill
+ void getPath ( tools::PolyPolygon& ) const;
+ /// Get color used for solid fills
+ const Color& getFillColor () const { return maFillColor;}
+ /** Get stroke transparency
+
+ @return the transparency, ranging from 0.0 (opaque) to 1.0 (fully translucent)
+ */
+ double getTransparency () const { return mfTransparency;}
+ /// Get fill rule used
+ FillRule getFillRule () const { return maFillRule;}
+ /** Get fill type used
+
+ Currently, only one of the fill types can be used
+ simultaneously. If you specify e.g. FillRule::fillGradient,
+ hatching, texture and solid fill color are ignored.
+ */
+ FillType getFillType () const { return maFillType;}
+ /** Get transformation applied to hatch, gradient or texture during fill
+
+ A fill operation generally starts at the top left position of
+ the object's bounding box. At that position (if tiling is on,
+ also all successive positions), the specified fill graphic is
+ rendered, after applying the fill transformation to it. For
+ example, if the fill transformation contains a translation,
+ the fill graphic is rendered at the object's bounding box's
+ top left corner plus the translation components.
+
+ */
+ void getTransform ( Transform& ) const;
+
+ /** Query state of texture tiling
+
+ @return true, if texture is tiled, false, if output only once.
+ */
+ bool isTiling () const { return mbTiling;}
+ /// Get type of gradient used
+ GradientType getGradientType () const { return maGradientType;}
+
+ /** Get the texture graphic used
+
+ The Graphic object returned is used to fill the geometry, if
+ the FillType is fillTexture. The Graphic object is always
+ assumed to be of size 1x1, the transformation is used to scale
+ it to the appropriate size.
+ */
+ void getGraphic ( Graphic& ) const;
+
+ // mutators
+ /// Set path to fill
+ void setPath ( const tools::PolyPolygon& rPath );
+
+private:
+ // friends
+ VCL_DLLPUBLIC friend SvStream& WriteSvtGraphicFill( SvStream& rOStm, const SvtGraphicFill& rClass );
+ VCL_DLLPUBLIC friend SvStream& ReadSvtGraphicFill( SvStream& rIStm, SvtGraphicFill& rClass );
+
+ tools::PolyPolygon maPath;
+ Color maFillColor;
+ double mfTransparency;
+ FillRule maFillRule;
+ FillType maFillType;
+ Transform maFillTransform;
+ bool mbTiling;
+ HatchType maHatchType;
+ Color maHatchColor;
+ GradientType maGradientType;
+ Color maGradient1stColor;
+ Color maGradient2ndColor;
+ sal_Int32 maGradientStepCount;
+ Graphic maFillGraphic;
+};
+
+#endif // INCLUDED_VCL_GRAPHICTOOLS_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
generated by cgit v1.2.3 (git 2.39.1) at 2025-01-19 20:48:48 +0000