372 lines
15 KiB
C++
372 lines
15 KiB
C++
/* -*- 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 .
|
|
*/
|
|
|
|
#include <sdr/attribute/sdrformtextattribute.hxx>
|
|
#include <basegfx/vector/b2enums.hxx>
|
|
#include <svl/itemset.hxx>
|
|
#include <svx/sdprcitm.hxx>
|
|
#include <svx/svddef.hxx>
|
|
#include <svx/xftdiit.hxx>
|
|
#include <svx/xftstit.hxx>
|
|
#include <svx/xftshxy.hxx>
|
|
#include <xftshtit.hxx>
|
|
#include <svx/xtextit0.hxx>
|
|
#include <svx/xftadit.hxx>
|
|
#include <svx/xftshit.hxx>
|
|
#include <svx/xftshcit.hxx>
|
|
#include <svx/xftmrit.hxx>
|
|
#include <svx/xftouit.hxx>
|
|
#include <svx/xlntrit.hxx>
|
|
#include <svx/xlnclit.hxx>
|
|
#include <svx/xlnwtit.hxx>
|
|
#include <svx/xlinjoit.hxx>
|
|
#include <svx/xlncapit.hxx>
|
|
#include <svx/xlineit0.hxx>
|
|
#include <svx/xdash.hxx>
|
|
#include <svx/xlndsit.hxx>
|
|
#include <drawinglayer/attribute/lineattribute.hxx>
|
|
#include <drawinglayer/attribute/strokeattribute.hxx>
|
|
#include <sdr/attribute/sdrformtextoutlineattribute.hxx>
|
|
#include <com/sun/star/drawing/LineCap.hpp>
|
|
#include <com/sun/star/drawing/LineStyle.hpp>
|
|
|
|
|
|
// helper to get line, stroke and transparence attributes from SfxItemSet
|
|
|
|
namespace
|
|
{
|
|
basegfx::B2DLineJoin impGetB2DLineJoin(css::drawing::LineJoint eLineJoint)
|
|
{
|
|
switch(eLineJoint)
|
|
{
|
|
case css::drawing::LineJoint_BEVEL :
|
|
{
|
|
return basegfx::B2DLineJoin::Bevel;
|
|
}
|
|
case css::drawing::LineJoint_MIDDLE :
|
|
case css::drawing::LineJoint_MITER :
|
|
{
|
|
return basegfx::B2DLineJoin::Miter;
|
|
}
|
|
case css::drawing::LineJoint_ROUND :
|
|
{
|
|
return basegfx::B2DLineJoin::Round;
|
|
}
|
|
default : // css::drawing::LineJoint_NONE
|
|
{
|
|
return basegfx::B2DLineJoin::NONE; // XLINEJOINT_NONE
|
|
}
|
|
}
|
|
}
|
|
|
|
sal_uInt8 impGetStrokeTransparence(bool bShadow, const SfxItemSet& rSet)
|
|
{
|
|
sal_uInt8 nRetval;
|
|
|
|
if(bShadow)
|
|
{
|
|
nRetval = static_cast<sal_uInt8>((rSet.Get(SDRATTR_SHADOWTRANSPARENCE).GetValue() * 255) / 100);
|
|
}
|
|
else
|
|
{
|
|
nRetval = static_cast<sal_uInt8>((rSet.Get(XATTR_LINETRANSPARENCE).GetValue() * 255) / 100);
|
|
}
|
|
|
|
return nRetval;
|
|
}
|
|
|
|
drawinglayer::attribute::LineAttribute impGetLineAttribute(bool bShadow, const SfxItemSet& rSet)
|
|
{
|
|
basegfx::BColor aColorAttribute;
|
|
|
|
if(bShadow)
|
|
{
|
|
const Color aShadowColor(rSet.Get(SDRATTR_SHADOWCOLOR).GetColorValue());
|
|
aColorAttribute = aShadowColor.getBColor();
|
|
}
|
|
else
|
|
{
|
|
const Color aLineColor(rSet.Get(XATTR_LINECOLOR).GetColorValue());
|
|
aColorAttribute = aLineColor.getBColor();
|
|
}
|
|
|
|
const sal_uInt32 nLineWidth = rSet.Get(XATTR_LINEWIDTH).GetValue();
|
|
const css::drawing::LineJoint eLineJoint = rSet.Get(XATTR_LINEJOINT).GetValue();
|
|
const css::drawing::LineCap eLineCap = rSet.Get(XATTR_LINECAP).GetValue();
|
|
|
|
return drawinglayer::attribute::LineAttribute(
|
|
aColorAttribute,
|
|
static_cast<double>(nLineWidth),
|
|
impGetB2DLineJoin(eLineJoint),
|
|
eLineCap);
|
|
}
|
|
|
|
drawinglayer::attribute::StrokeAttribute impGetStrokeAttribute(const SfxItemSet& rSet)
|
|
{
|
|
const css::drawing::LineStyle eLineStyle = rSet.Get(XATTR_LINESTYLE).GetValue();
|
|
double fFullDotDashLen(0.0);
|
|
::std::vector< double > aDotDashArray;
|
|
|
|
if(css::drawing::LineStyle_DASH == eLineStyle)
|
|
{
|
|
const XDash& rDash = rSet.Get(XATTR_LINEDASH).GetDashValue();
|
|
|
|
if(rDash.GetDots() || rDash.GetDashes())
|
|
{
|
|
const sal_uInt32 nLineWidth = rSet.Get(XATTR_LINEWIDTH).GetValue();
|
|
fFullDotDashLen = rDash.CreateDotDashArray(aDotDashArray, static_cast<double>(nLineWidth));
|
|
}
|
|
}
|
|
|
|
return drawinglayer::attribute::StrokeAttribute(std::move(aDotDashArray), fFullDotDashLen);
|
|
}
|
|
} // end of anonymous namespace
|
|
|
|
|
|
namespace drawinglayer::attribute
|
|
{
|
|
class ImpSdrFormTextAttribute
|
|
{
|
|
public:
|
|
// FormText (FontWork) Attributes
|
|
sal_Int32 mnFormTextDistance; // distance from line in upright direction
|
|
sal_Int32 mnFormTextStart; // shift from polygon start
|
|
sal_Int32 mnFormTextShdwXVal; // shadow distance or 10th degrees
|
|
sal_Int32 mnFormTextShdwYVal; // shadow distance or scaling
|
|
sal_uInt16 mnFormTextShdwTransp; // shadow transparence
|
|
XFormTextStyle meFormTextStyle; // on/off and char orientation
|
|
XFormTextAdjust meFormTextAdjust; // adjustment (left/right/center) and scale
|
|
XFormTextShadow meFormTextShadow; // shadow mode
|
|
Color maFormTextShdwColor; // shadow color
|
|
|
|
// outline attributes; used when getFormTextOutline() is true and (for
|
|
// shadow) when getFormTextShadow() != XFormTextShadow::NONE
|
|
SdrFormTextOutlineAttribute maOutline;
|
|
SdrFormTextOutlineAttribute maShadowOutline;
|
|
|
|
bool mbFormTextMirror : 1; // change orientation
|
|
bool mbFormTextOutline : 1; // show contour of objects
|
|
|
|
explicit ImpSdrFormTextAttribute(const SfxItemSet& rSet)
|
|
: mnFormTextDistance(rSet.Get(XATTR_FORMTXTDISTANCE).GetValue()),
|
|
mnFormTextStart(rSet.Get(XATTR_FORMTXTSTART).GetValue()),
|
|
mnFormTextShdwXVal(rSet.Get(XATTR_FORMTXTSHDWXVAL).GetValue()),
|
|
mnFormTextShdwYVal(rSet.Get(XATTR_FORMTXTSHDWYVAL).GetValue()),
|
|
mnFormTextShdwTransp(rSet.Get(XATTR_FORMTXTSHDWTRANSP).GetValue()),
|
|
meFormTextStyle(rSet.Get(XATTR_FORMTXTSTYLE).GetValue()),
|
|
meFormTextAdjust(rSet.Get(XATTR_FORMTXTADJUST).GetValue()),
|
|
meFormTextShadow(rSet.Get(XATTR_FORMTXTSHADOW).GetValue()),
|
|
maFormTextShdwColor(rSet.Get(XATTR_FORMTXTSHDWCOLOR).GetColorValue()),
|
|
mbFormTextMirror(rSet.Get(XATTR_FORMTXTMIRROR).GetValue()),
|
|
mbFormTextOutline(rSet.Get(XATTR_FORMTXTOUTLINE).GetValue())
|
|
{
|
|
if(!getFormTextOutline())
|
|
return;
|
|
|
|
const StrokeAttribute aStrokeAttribute(impGetStrokeAttribute(rSet));
|
|
|
|
// also need to prepare attributes for outlines
|
|
{
|
|
const LineAttribute aLineAttribute(impGetLineAttribute(false, rSet));
|
|
const sal_uInt8 nTransparence(impGetStrokeTransparence(false, rSet));
|
|
|
|
maOutline = SdrFormTextOutlineAttribute(
|
|
aLineAttribute, aStrokeAttribute, nTransparence);
|
|
}
|
|
|
|
if(XFormTextShadow::NONE != getFormTextShadow())
|
|
{
|
|
// also need to prepare attributes for shadow outlines
|
|
const LineAttribute aLineAttribute(impGetLineAttribute(true, rSet));
|
|
const sal_uInt8 nTransparence(impGetStrokeTransparence(true, rSet));
|
|
|
|
maShadowOutline = SdrFormTextOutlineAttribute(
|
|
aLineAttribute, aStrokeAttribute, nTransparence);
|
|
}
|
|
}
|
|
|
|
ImpSdrFormTextAttribute()
|
|
: mnFormTextDistance(0),
|
|
mnFormTextStart(0),
|
|
mnFormTextShdwXVal(0),
|
|
mnFormTextShdwYVal(0),
|
|
mnFormTextShdwTransp(0),
|
|
meFormTextStyle(XFormTextStyle::NONE),
|
|
meFormTextAdjust(XFormTextAdjust::Center),
|
|
meFormTextShadow(XFormTextShadow::NONE),
|
|
mbFormTextMirror(false),
|
|
mbFormTextOutline(false)
|
|
{
|
|
}
|
|
|
|
// data read access
|
|
sal_Int32 getFormTextDistance() const { return mnFormTextDistance; }
|
|
sal_Int32 getFormTextStart() const { return mnFormTextStart; }
|
|
sal_Int32 getFormTextShdwXVal() const { return mnFormTextShdwXVal; }
|
|
sal_Int32 getFormTextShdwYVal() const { return mnFormTextShdwYVal; }
|
|
XFormTextStyle getFormTextStyle() const { return meFormTextStyle; }
|
|
XFormTextAdjust getFormTextAdjust() const { return meFormTextAdjust; }
|
|
XFormTextShadow getFormTextShadow() const { return meFormTextShadow; }
|
|
const Color& getFormTextShdwColor() const { return maFormTextShdwColor; }
|
|
const SdrFormTextOutlineAttribute& getOutline() const { return maOutline; }
|
|
const SdrFormTextOutlineAttribute& getShadowOutline() const { return maShadowOutline; }
|
|
bool getFormTextMirror() const { return mbFormTextMirror; }
|
|
bool getFormTextOutline() const { return mbFormTextOutline; }
|
|
|
|
// compare operator
|
|
bool operator==(const ImpSdrFormTextAttribute& rCandidate) const
|
|
{
|
|
return (getFormTextDistance() == rCandidate.getFormTextDistance()
|
|
&& getFormTextStart() == rCandidate.getFormTextStart()
|
|
&& getFormTextShdwXVal() == rCandidate.getFormTextShdwXVal()
|
|
&& getFormTextShdwYVal() == rCandidate.getFormTextShdwYVal()
|
|
&& mnFormTextShdwTransp == rCandidate.mnFormTextShdwTransp
|
|
&& getFormTextStyle() == rCandidate.getFormTextStyle()
|
|
&& getFormTextAdjust() == rCandidate.getFormTextAdjust()
|
|
&& getFormTextShadow() == rCandidate.getFormTextShadow()
|
|
&& getFormTextShdwColor() == rCandidate.getFormTextShdwColor()
|
|
&& getOutline() == rCandidate.getOutline()
|
|
&& getShadowOutline() == rCandidate.getShadowOutline()
|
|
&& getFormTextMirror() == rCandidate.getFormTextMirror()
|
|
&& getFormTextOutline() == rCandidate.getFormTextOutline());
|
|
}
|
|
};
|
|
|
|
namespace
|
|
{
|
|
SdrFormTextAttribute::ImplType& theGlobalDefault()
|
|
{
|
|
static SdrFormTextAttribute::ImplType SINGLETON;
|
|
return SINGLETON;
|
|
}
|
|
}
|
|
|
|
SdrFormTextAttribute::SdrFormTextAttribute(const SfxItemSet& rSet)
|
|
: mpSdrFormTextAttribute(ImpSdrFormTextAttribute(rSet))
|
|
{
|
|
}
|
|
|
|
SdrFormTextAttribute::SdrFormTextAttribute()
|
|
: mpSdrFormTextAttribute(theGlobalDefault())
|
|
{
|
|
}
|
|
|
|
SdrFormTextAttribute::SdrFormTextAttribute(const SdrFormTextAttribute& rCandidate)
|
|
: mpSdrFormTextAttribute(rCandidate.mpSdrFormTextAttribute)
|
|
{
|
|
}
|
|
|
|
SdrFormTextAttribute::SdrFormTextAttribute(SdrFormTextAttribute&& rCandidate) noexcept
|
|
: mpSdrFormTextAttribute(std::move(rCandidate.mpSdrFormTextAttribute))
|
|
{
|
|
}
|
|
|
|
SdrFormTextAttribute::~SdrFormTextAttribute()
|
|
{
|
|
}
|
|
|
|
bool SdrFormTextAttribute::isDefault() const
|
|
{
|
|
return mpSdrFormTextAttribute.same_object(theGlobalDefault());
|
|
}
|
|
|
|
SdrFormTextAttribute& SdrFormTextAttribute::operator=(const SdrFormTextAttribute& rCandidate)
|
|
{
|
|
mpSdrFormTextAttribute = rCandidate.mpSdrFormTextAttribute;
|
|
return *this;
|
|
}
|
|
|
|
SdrFormTextAttribute& SdrFormTextAttribute::operator=(SdrFormTextAttribute&& rCandidate) noexcept
|
|
{
|
|
mpSdrFormTextAttribute = std::move(rCandidate.mpSdrFormTextAttribute);
|
|
return *this;
|
|
}
|
|
|
|
bool SdrFormTextAttribute::operator==(const SdrFormTextAttribute& rCandidate) const
|
|
{
|
|
// tdf#87509 default attr is always != non-default attr, even with same values
|
|
if(rCandidate.isDefault() != isDefault())
|
|
return false;
|
|
|
|
return rCandidate.mpSdrFormTextAttribute == mpSdrFormTextAttribute;
|
|
}
|
|
|
|
sal_Int32 SdrFormTextAttribute::getFormTextDistance() const
|
|
{
|
|
return mpSdrFormTextAttribute->getFormTextDistance();
|
|
}
|
|
|
|
sal_Int32 SdrFormTextAttribute::getFormTextStart() const
|
|
{
|
|
return mpSdrFormTextAttribute->getFormTextStart();
|
|
}
|
|
|
|
sal_Int32 SdrFormTextAttribute::getFormTextShdwXVal() const
|
|
{
|
|
return mpSdrFormTextAttribute->getFormTextShdwXVal();
|
|
}
|
|
|
|
sal_Int32 SdrFormTextAttribute::getFormTextShdwYVal() const
|
|
{
|
|
return mpSdrFormTextAttribute->getFormTextShdwYVal();
|
|
}
|
|
|
|
XFormTextStyle SdrFormTextAttribute::getFormTextStyle() const
|
|
{
|
|
return mpSdrFormTextAttribute->getFormTextStyle();
|
|
}
|
|
|
|
XFormTextAdjust SdrFormTextAttribute::getFormTextAdjust() const
|
|
{
|
|
return mpSdrFormTextAttribute->getFormTextAdjust();
|
|
}
|
|
|
|
XFormTextShadow SdrFormTextAttribute::getFormTextShadow() const
|
|
{
|
|
return mpSdrFormTextAttribute->getFormTextShadow();
|
|
}
|
|
|
|
Color const & SdrFormTextAttribute::getFormTextShdwColor() const
|
|
{
|
|
return mpSdrFormTextAttribute->getFormTextShdwColor();
|
|
}
|
|
|
|
const SdrFormTextOutlineAttribute& SdrFormTextAttribute::getOutline() const
|
|
{
|
|
return mpSdrFormTextAttribute->getOutline();
|
|
}
|
|
|
|
const SdrFormTextOutlineAttribute& SdrFormTextAttribute::getShadowOutline() const
|
|
{
|
|
return mpSdrFormTextAttribute->getShadowOutline();
|
|
}
|
|
|
|
bool SdrFormTextAttribute::getFormTextMirror() const
|
|
{
|
|
return mpSdrFormTextAttribute->getFormTextMirror();
|
|
}
|
|
|
|
bool SdrFormTextAttribute::getFormTextOutline() const
|
|
{
|
|
return mpSdrFormTextAttribute->getFormTextOutline();
|
|
}
|
|
|
|
} // end of namespace
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|