office-gobmx/drawinglayer/source/primitive2d/textlineprimitive2d.cxx
Bogdan Buzea 0488beff8b tdf#163486: PVS: Identical branches
V1037 Two or more case-branches perform the same actions. Check lines: 94, 99

Change-Id: I406b94c79426cebbd4813a019389d0cac0616bbf
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/175226
Tested-by: Jenkins
Reviewed-by: David Gilbert <freedesktop@treblig.org>
2024-11-10 01:07:48 +01:00

289 lines
10 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 <primitive2d/textlineprimitive2d.hxx>
#include <drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx>
#include <drawinglayer/attribute/strokeattribute.hxx>
#include <drawinglayer/attribute/lineattribute.hxx>
#include <basegfx/matrix/b2dhommatrixtools.hxx>
#include <drawinglayer/primitive2d/transformprimitive2d.hxx>
#include <drawinglayer/primitive2d/PolygonWavePrimitive2D.hxx>
#include <utility>
namespace drawinglayer::primitive2d
{
Primitive2DReference TextLinePrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
{
if(TEXT_LINE_NONE == getTextLine())
return nullptr;
bool bDoubleLine(false);
bool bWaveLine(false);
bool bBoldLine(false);
const int* pDotDashArray(nullptr);
basegfx::B2DLineJoin eLineJoin(basegfx::B2DLineJoin::NONE);
double fOffset(getOffset());
double fHeight(getHeight());
static const int aDottedArray[] = { 1, 1, 0}; // DOTTED LINE
static const int aDotDashArray[] = { 1, 1, 4, 1, 0}; // DASHDOT
static const int aDashDotDotArray[] = { 1, 1, 1, 1, 4, 1, 0}; // DASHDOTDOT
static const int aDashedArray[] = { 5, 2, 0}; // DASHED LINE
static const int aLongDashArray[] = { 7, 2, 0}; // LONGDASH
// get decomposition
basegfx::B2DVector aScale, aTranslate;
double fRotate, fShearX;
getObjectTransformation().decompose(aScale, aTranslate, fRotate, fShearX);
switch(getTextLine())
{
default: // case TEXT_LINE_SINGLE:
{
break;
}
case TEXT_LINE_DOUBLE:
{
bDoubleLine = true;
break;
}
case TEXT_LINE_DOTTED:
{
pDotDashArray = aDottedArray;
break;
}
case TEXT_LINE_DASH:
{
pDotDashArray = aDashedArray;
break;
}
case TEXT_LINE_LONGDASH:
{
pDotDashArray = aLongDashArray;
break;
}
case TEXT_LINE_DASHDOT:
{
pDotDashArray = aDotDashArray;
break;
}
case TEXT_LINE_DASHDOTDOT:
{
pDotDashArray = aDashDotDotArray;
break;
}
case TEXT_LINE_SMALLWAVE:
case TEXT_LINE_WAVE:
{
bWaveLine = true;
break;
}
case TEXT_LINE_DOUBLEWAVE:
{
bDoubleLine = true;
bWaveLine = true;
break;
}
case TEXT_LINE_BOLD:
{
bBoldLine = true;
break;
}
case TEXT_LINE_BOLDDOTTED:
{
bBoldLine = true;
pDotDashArray = aDottedArray;
break;
}
case TEXT_LINE_BOLDDASH:
{
bBoldLine = true;
pDotDashArray = aDashedArray;
break;
}
case TEXT_LINE_BOLDLONGDASH:
{
bBoldLine = true;
pDotDashArray = aLongDashArray;
break;
}
case TEXT_LINE_BOLDDASHDOT:
{
bBoldLine = true;
pDotDashArray = aDotDashArray;
break;
}
case TEXT_LINE_BOLDDASHDOTDOT:
{
bBoldLine = true;
pDotDashArray = aDashDotDotArray;
break;
}
case TEXT_LINE_BOLDWAVE:
{
bWaveLine = true;
bBoldLine = true;
break;
}
}
if(bBoldLine)
{
fHeight *= 2.0;
}
if(bDoubleLine)
{
fOffset -= 0.50 * fHeight;
fHeight *= 0.64;
}
if(bWaveLine)
{
eLineJoin = basegfx::B2DLineJoin::Round;
fHeight *= 0.25;
}
// prepare Line and Stroke Attributes
const attribute::LineAttribute aLineAttribute(getLineColor(), fHeight, eLineJoin);
attribute::StrokeAttribute aStrokeAttribute;
if(pDotDashArray)
{
std::vector< double > aDoubleArray;
for(const int* p = pDotDashArray; *p; ++p)
{
aDoubleArray.push_back(static_cast<double>(*p) * fHeight);
}
aStrokeAttribute = attribute::StrokeAttribute(std::move(aDoubleArray));
}
// create base polygon and new primitive
basegfx::B2DPolygon aLine;
Primitive2DReference aNewPrimitive;
aLine.append(basegfx::B2DPoint(0.0, fOffset));
aLine.append(basegfx::B2DPoint(getWidth(), fOffset));
const basegfx::B2DHomMatrix aUnscaledTransform(
basegfx::utils::createShearXRotateTranslateB2DHomMatrix(
fShearX, fRotate, aTranslate));
aLine.transform(aUnscaledTransform);
if(bWaveLine)
{
double fWaveWidth(10.6 * fHeight);
if(TEXT_LINE_SMALLWAVE == getTextLine())
{
fWaveWidth *= 0.7;
}
else if(TEXT_LINE_WAVE == getTextLine())
{
// extra multiply to get the same WaveWidth as with the bold version
fWaveWidth *= 2.0;
}
aNewPrimitive = new PolygonWavePrimitive2D(aLine, aLineAttribute, aStrokeAttribute, fWaveWidth, fWaveWidth * 0.5);
}
else
{
aNewPrimitive = new PolygonStrokePrimitive2D(std::move(aLine), aLineAttribute, std::move(aStrokeAttribute));
}
if(!bDoubleLine)
return aNewPrimitive;
// add primitive
Primitive2DContainer aContainer;
aContainer.push_back(aNewPrimitive);
// double line, create 2nd primitive with offset using TransformPrimitive based on
// already created NewPrimitive
double fLineDist(2.3 * fHeight);
if(bWaveLine)
{
fLineDist = 6.3 * fHeight;
}
// move base point of text to 0.0 and de-rotate
basegfx::B2DHomMatrix aTransform(basegfx::utils::createTranslateB2DHomMatrix(
-aTranslate.getX(), -aTranslate.getY()));
aTransform.rotate(-fRotate);
// translate in Y by offset
aTransform.translate(0.0, fLineDist);
// move back and rotate
aTransform.rotate(fRotate);
aTransform.translate(aTranslate.getX(), aTranslate.getY());
// add transform primitive
Primitive2DContainer aContent { aNewPrimitive };
aContainer.push_back(new TransformPrimitive2D(aTransform, std::move(aContent)));
return new GroupPrimitive2D(std::move(aContainer));
}
TextLinePrimitive2D::TextLinePrimitive2D(
basegfx::B2DHomMatrix aObjectTransformation,
double fWidth,
double fOffset,
double fHeight,
TextLine eTextLine,
const basegfx::BColor& rLineColor)
: maObjectTransformation(std::move(aObjectTransformation)),
mfWidth(fWidth),
mfOffset(fOffset),
mfHeight(fHeight),
meTextLine(eTextLine),
maLineColor(rLineColor)
{
}
bool TextLinePrimitive2D::operator==( const BasePrimitive2D& rPrimitive ) const
{
if(BufferedDecompositionPrimitive2D::operator==(rPrimitive))
{
const TextLinePrimitive2D& rCompare = static_cast<const TextLinePrimitive2D&>(rPrimitive);
return (getObjectTransformation() == rCompare.getObjectTransformation()
&& getWidth() == rCompare.getWidth()
&& getOffset() == rCompare.getOffset()
&& getHeight() == rCompare.getHeight()
&& getTextLine() == rCompare.getTextLine()
&& getLineColor() == rCompare.getLineColor());
}
return false;
}
// provide unique ID
sal_uInt32 TextLinePrimitive2D::getPrimitive2DID() const
{
return PRIMITIVE2D_ID_TEXTLINEPRIMITIVE2D;
}
} // end of namespace
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */