svx/source/sdr/primitive2d/sdrellipseprimitive2d.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 <sdr/primitive2d/sdrellipseprimitive2d.hxx>
  21 #include <basegfx/polygon/b2dpolygon.hxx>
  22 #include <basegfx/polygon/b2dpolygontools.hxx>
  23 #include <basegfx/polygon/b2dpolypolygon.hxx>
  24 #include <sdr/primitive2d/sdrdecompositiontools.hxx>
  25 #include <svx/sdr/primitive2d/svx_primitivetypes2d.hxx>
  26 #include <basegfx/matrix/b2dhommatrixtools.hxx>
  27 #include <drawinglayer/primitive2d/sdrdecompositiontools2d.hxx>
  28 #include <utility>
  29
  30
  31 using namespace com::sun::star;
  32
  33
  34 namespace drawinglayer::primitive2d
  35 {
  36         void SdrEllipsePrimitive2D::create2DDecomposition(Primitive2DContainer& rContainer, const geometry::ViewInformation2D& /*aViewInformation*/) const
  37         {
  38             Primitive2DContainer aRetval;
  39
  40             // create unit outline polygon
  41             // Do use createPolygonFromUnitCircle, but let create from first quadrant to mimic old geometry creation.
  42             // This is needed to have the same look when stroke is used since the polygon start point defines the
  43             // stroke start, too.
  44             basegfx::B2DPolygon aUnitOutline(basegfx::utils::createPolygonFromUnitCircle(1));
  45
  46             // scale and move UnitEllipse to UnitObject (-1,-1 1,1) -> (0,0 1,1)
  47             const basegfx::B2DHomMatrix aUnitCorrectionMatrix(
  48                 basegfx::utils::createScaleTranslateB2DHomMatrix(0.5, 0.5, 0.5, 0.5));
  49
  50             // apply to the geometry
  51             aUnitOutline.transform(aUnitCorrectionMatrix);
  52
  53             // add fill
  54             if(!getSdrLFSTAttribute().getFill().isDefault())
  55             {
  56                 basegfx::B2DPolyPolygon aTransformed(aUnitOutline);
  57
  58                 aTransformed.transform(getTransform());
  59                 aRetval.push_back(
  60                     createPolyPolygonFillPrimitive(
  61                         aTransformed,
  62                         getSdrLFSTAttribute().getFill(),
  63                         getSdrLFSTAttribute().getFillFloatTransGradient()));
  64             }
  65
  66             // add line
  67             if(getSdrLFSTAttribute().getLine().isDefault())
  68             {
  69                 // create invisible line for HitTest/BoundRect
  70                 aRetval.push_back(
  71                     createHiddenGeometryPrimitives2D(
  72                         false,
  73                         basegfx::B2DPolyPolygon(aUnitOutline),
  74                         getTransform()));
  75             }
  76             else
  77             {
  78                 basegfx::B2DPolygon aTransformed(aUnitOutline);
  79
  80                 aTransformed.transform(getTransform());
  81                 aRetval.push_back(
  82                     createPolygonLinePrimitive(
  83                         aTransformed,
  84                         getSdrLFSTAttribute().getLine(),
  85                         attribute::SdrLineStartEndAttribute()));
  86             }
  87
  88             // add text
  89             if(!getSdrLFSTAttribute().getText().isDefault())
  90             {
  91                 aRetval.push_back(
  92                     createTextPrimitive(
  93                         basegfx::B2DPolyPolygon(aUnitOutline),
  94                         getTransform(),
  95                         getSdrLFSTAttribute().getText(),
  96                         getSdrLFSTAttribute().getLine(),
  97                         false,
  98                         false));
  99             }
 100
 101             // add shadow
 102             if(!getSdrLFSTAttribute().getShadow().isDefault())
 103             {
 104                 aRetval = createEmbeddedShadowPrimitive(
 105                     std::move(aRetval),
 106                     getSdrLFSTAttribute().getShadow());
 107             }
 108
 109             rContainer.append(std::move(aRetval));
 110         }
 111
 112         SdrEllipsePrimitive2D::SdrEllipsePrimitive2D(
 113             basegfx::B2DHomMatrix aTransform,
 114             const attribute::SdrLineFillEffectsTextAttribute& rSdrLFSTAttribute)
 115         :   maTransform(std::move(aTransform)),
 116             maSdrLFSTAttribute(rSdrLFSTAttribute)
 117         {
 118         }
 119
 120         bool SdrEllipsePrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
 121         {
 122             if(BufferedDecompositionPrimitive2D::operator==(rPrimitive))
 123             {
 124                 const SdrEllipsePrimitive2D& rCompare = static_cast<const SdrEllipsePrimitive2D&>(rPrimitive);
 125
 126                 return (getTransform() == rCompare.getTransform()
 127                     && getSdrLFSTAttribute() == rCompare.getSdrLFSTAttribute());
 128             }
 129
 130             return false;
 131         }
 132
 133         // provide unique ID
 134         sal_uInt32 SdrEllipsePrimitive2D::getPrimitive2DID() const
 135         {
 136             return PRIMITIVE2D_ID_SDRELLIPSEPRIMITIVE2D;
 137         }
 138
 139
 140
 141         void SdrEllipseSegmentPrimitive2D::create2DDecomposition(Primitive2DContainer& rContainer, const geometry::ViewInformation2D& /*aViewInformation*/) const
 142         {
 143             Primitive2DContainer aRetval;
 144
 145             // create unit outline polygon
 146             basegfx::B2DPolygon aUnitOutline(basegfx::utils::createPolygonFromUnitEllipseSegment(mfStartAngle, mfEndAngle));
 147
 148             if(mbCloseSegment)
 149             {
 150                 if(mbCloseUsingCenter)
 151                 {
 152                     // for compatibility, insert the center point at polygon start to get the same
 153                     // line stroking pattern as the old painting mechanisms.
 154                     aUnitOutline.insert(0, basegfx::B2DPoint(0.0, 0.0));
 155                 }
 156
 157                 aUnitOutline.setClosed(true);
 158             }
 159
 160             // move and scale UnitEllipse to UnitObject (-1,-1 1,1) -> (0,0 1,1)
 161             const basegfx::B2DHomMatrix aUnitCorrectionMatrix(
 162                 basegfx::utils::createScaleTranslateB2DHomMatrix(0.5, 0.5, 0.5, 0.5));
 163
 164             // apply to the geometry
 165             aUnitOutline.transform(aUnitCorrectionMatrix);
 166
 167             // add fill
 168             if(!getSdrLFSTAttribute().getFill().isDefault() && aUnitOutline.isClosed())
 169             {
 170                 basegfx::B2DPolyPolygon aTransformed(aUnitOutline);
 171
 172                 aTransformed.transform(getTransform());
 173                 aRetval.push_back(
 174                     createPolyPolygonFillPrimitive(
 175                         aTransformed,
 176                         getSdrLFSTAttribute().getFill(),
 177                         getSdrLFSTAttribute().getFillFloatTransGradient()));
 178             }
 179
 180             // add line
 181             if(getSdrLFSTAttribute().getLine().isDefault())
 182             {
 183                 // create invisible line for HitTest/BoundRect
 184                 aRetval.push_back(
 185                     createHiddenGeometryPrimitives2D(
 186                         false,
 187                         basegfx::B2DPolyPolygon(aUnitOutline),
 188                         getTransform()));
 189             }
 190             else
 191             {
 192                 basegfx::B2DPolygon aTransformed(aUnitOutline);
 193
 194                 aTransformed.transform(getTransform());
 195                 aRetval.push_back(
 196                     createPolygonLinePrimitive(
 197                         aTransformed,
 198                         getSdrLFSTAttribute().getLine(),
 199                         getSdrLFSTAttribute().getLineStartEnd()));
 200             }
 201
 202             // add text
 203             if(!getSdrLFSTAttribute().getText().isDefault())
 204             {
 205                 aRetval.push_back(
 206                     createTextPrimitive(
 207                         basegfx::B2DPolyPolygon(aUnitOutline),
 208                         getTransform(),
 209                         getSdrLFSTAttribute().getText(),
 210                         getSdrLFSTAttribute().getLine(),
 211                         false,
 212                         false));
 213             }
 214
 215             // add shadow
 216             if(!getSdrLFSTAttribute().getShadow().isDefault())
 217             {
 218                 aRetval = createEmbeddedShadowPrimitive(
 219                     std::move(aRetval),
 220                     getSdrLFSTAttribute().getShadow());
 221             }
 222
 223             rContainer.append(std::move(aRetval));
 224         }
 225
 226         SdrEllipseSegmentPrimitive2D::SdrEllipseSegmentPrimitive2D(
 227             const basegfx::B2DHomMatrix& rTransform,
 228             const attribute::SdrLineFillEffectsTextAttribute& rSdrLFSTAttribute,
 229             double fStartAngle,
 230             double fEndAngle,
 231             bool bCloseSegment,
 232             bool bCloseUsingCenter)
 233         :   SdrEllipsePrimitive2D(rTransform, rSdrLFSTAttribute),
 234             mfStartAngle(fStartAngle),
 235             mfEndAngle(fEndAngle),
 236             mbCloseSegment(bCloseSegment),
 237             mbCloseUsingCenter(bCloseUsingCenter)
 238         {
 239         }
 240
 241         bool SdrEllipseSegmentPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
 242         {
 243             if(SdrEllipsePrimitive2D::operator==(rPrimitive))
 244             {
 245                 const SdrEllipseSegmentPrimitive2D& rCompare = static_cast<const SdrEllipseSegmentPrimitive2D&>(rPrimitive);
 246
 247                 if( mfStartAngle == rCompare.mfStartAngle
 248                     && mfEndAngle == rCompare.mfEndAngle
 249                     && mbCloseSegment == rCompare.mbCloseSegment
 250                     && mbCloseUsingCenter == rCompare.mbCloseUsingCenter)
 251                 {
 252                     return true;
 253                 }
 254             }
 255
 256             return false;
 257         }
 258
 259         // provide unique ID
 260         sal_uInt32 SdrEllipseSegmentPrimitive2D::getPrimitive2DID() const
 261         {
 262             return PRIMITIVE2D_ID_SDRELLIPSESEGMENTPRIMITIVE2D;
 263         }
 264
 265 } // end of namespace
 266
 267 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */