vmlformatting.hxx

Go to the documentation of this file.

/* -*- 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_OOX_VML_VMLFORMATTING_HXX
#define INCLUDED_OOX_VML_VMLFORMATTING_HXX
 
#include <sal/config.h>
 
#include <string_view>
#include <utility>
#include <vector>
 
#include <com/sun/star/drawing/PolygonFlags.hpp>
#include <com/sun/star/uno/Reference.hxx>
#include <oox/dllapi.h>
#include <oox/helper/helper.hxx>
#include <rtl/ustring.hxx>
#include <sal/types.h>
#include <tools/degree.hxx>
 
namespace com::sun::star {
    namespace awt { struct Point; }
    namespace drawing { class XShape; }
}
 
namespace oox {
    class GraphicHelper;
    namespace drawingml { class Color; }
    namespace drawingml { class ShapePropertyMap; }
}
 
namespace oox::vml {
 
 
typedef ::std::pair< sal_Int32, sal_Int32 > Int32Pair;
typedef ::std::pair< double, double >       DoublePair;
 
 
namespace ConversionHelper
{
    OOX_DLLPUBLIC bool         separatePair(
                            std::u16string_view& orValue1, std::u16string_view& orValue2,
                            std::u16string_view rValue, sal_Unicode cSep );
 
    OOX_DLLPUBLIC bool         decodeBool( std::u16string_view rValue );
 
    OOX_DLLPUBLIC double       decodePercent(
                            std::u16string_view rValue,
                            double fDefValue );
 
    OOX_DLLPUBLIC Degree100 decodeRotation( std::u16string_view rValue );
 
    OOX_DLLPUBLIC sal_Int64    decodeMeasureToEmu(
                            const GraphicHelper& rGraphicHelper,
                            std::u16string_view rValue,
                            sal_Int32 nRefValue,
                            bool bPixelX,
                            bool bDefaultAsPixel );
 
    OOX_DLLPUBLIC sal_Int32    decodeMeasureToHmm(
                            const GraphicHelper& rGraphicHelper,
                            std::u16string_view rValue,
                            sal_Int32 nRefValue,
                            bool bPixelX,
                            bool bDefaultAsPixel );
 
OOX_DLLPUBLIC sal_Int32 decodeMeasureToTwip(const GraphicHelper& rGraphicHelper,
                                            std::u16string_view rValue, sal_Int32 nRefValue,
                                            bool bPixelX, bool bDefaultAsPixel);
 
    OOX_DLLPUBLIC ::oox::drawingml::Color decodeColor(
                            const GraphicHelper& rGraphicHelper,
                            const std::optional< OUString >& roVmlColor,
                            const std::optional< double >& roVmlOpacity,
                            ::Color nDefaultRgb,
                            ::Color nPrimaryRgb = API_RGB_TRANSPARENT );
 
    OOX_DLLPUBLIC void         decodeVmlPath(
                            ::std::vector< ::std::vector< css::awt::Point > >& rPoints,
                            ::std::vector< ::std::vector< css::drawing::PolygonFlags > >& rFlags,
                            std::u16string_view rPath );
}
 
 
struct StrokeArrowModel
{
    std::optional< sal_Int32 > moArrowType;
    std::optional< sal_Int32 > moArrowWidth;
    std::optional< sal_Int32 > moArrowLength;
 
    void                assignUsed( const StrokeArrowModel& rSource );
};
 
 
struct StrokeModel
{
    std::optional< bool >    moStroked;              
    StrokeArrowModel    maStartArrow;           
    StrokeArrowModel    maEndArrow;             
    std::optional< OUString > moColor;        
    std::optional< double > moOpacity;               
    std::optional< OUString > moWeight;       
    std::optional< OUString > moDashStyle;    
    std::optional< sal_Int32 > moLineStyle;          
    std::optional< sal_Int32 > moEndCap;             
    std::optional< sal_Int32 > moJoinStyle;          
 
    void                assignUsed( const StrokeModel& rSource );
 
    void                pushToPropMap(
                            ::oox::drawingml::ShapePropertyMap& rPropMap,
                            const GraphicHelper& rGraphicHelper ) const;
};
 
 
struct OOX_DLLPUBLIC FillModel
{
    std::optional< bool >    moFilled;               
    std::optional< OUString > moColor;        
    std::optional< double >  moOpacity;              
    std::optional< OUString > moColor2;       
    std::optional< double >  moOpacity2;             
    std::optional< sal_Int32 > moType;               
    std::optional< sal_Int32 > moAngle;              
    std::optional< double >  moFocus;                
    std::optional< DoublePair > moFocusPos;          
    std::optional< DoublePair > moFocusSize;         
    std::optional< OUString > moBitmapPath;   
    std::optional< bool >    moRotate;               
 
    void                assignUsed( const FillModel& rSource );
 
    void                pushToPropMap(
                            ::oox::drawingml::ShapePropertyMap& rPropMap,
                            const GraphicHelper& rGraphicHelper ) const;
};
 
 
struct OOX_DLLPUBLIC ShadowModel
{
    bool               mbHasShadow;               
    std::optional<bool>     moShadowOn;                
    std::optional<OUString> moColor;                   
    std::optional<OUString> moOffset;                  
    std::optional<double>   moOpacity;                 
 
    ShadowModel();
 
    void pushToPropMap(oox::drawingml::ShapePropertyMap& rPropMap, const GraphicHelper& rGraphicHelper) const;
};
 
struct TextpathModel
{
    std::optional<OUString> moString;                  
    std::optional<OUString> moStyle;                   
    std::optional<bool>     moTrim;                    
 
    TextpathModel();
 
    void pushToPropMap(oox::drawingml::ShapePropertyMap& rPropMap, const css::uno::Reference<css::drawing::XShape>& xShape,
                       const GraphicHelper& rGraphicHelper) const;
};
 
} // namespace oox::vml
 
#endif
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */