drawinglayer/source/primitive2d/fillhatchprimitive2d.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 <drawinglayer/primitive2d/fillhatchprimitive2d.hxx>
  21 #include <drawinglayer/texture/texture.hxx>
  22 #include <drawinglayer/primitive2d/polypolygonprimitive2d.hxx>
  23 #include <basegfx/polygon/b2dpolygontools.hxx>
  24 #include <basegfx/polygon/b2dpolygon.hxx>
  25 #include <basegfx/utils/canvastools.hxx>
  26 #include <drawinglayer/primitive2d/polygonprimitive2d.hxx>
  27 #include <drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx>
  28 #include <drawinglayer/geometry/viewinformation2d.hxx>
  29
  30
  31 using namespace com::sun::star;
  32
  33
  34 namespace drawinglayer
  35 {
  36     namespace primitive2d
  37     {
  38         void FillHatchPrimitive2D::create2DDecomposition(Primitive2DContainer& rContainer, const geometry::ViewInformation2D& /*rViewInformation*/) const
  39         {
  40             if(!getFillHatch().isDefault())
  41             {
  42                 // create hatch
  43                 const basegfx::BColor aHatchColor(getFillHatch().getColor());
  44                 const double fAngle(getFillHatch().getAngle());
  45                 std::vector< basegfx::B2DHomMatrix > aMatrices;
  46                 double fDistance(getFillHatch().getDistance());
  47                 const bool bAdaptDistance(0 != getFillHatch().getMinimalDiscreteDistance());
  48
  49                 // #i120230# evtl. adapt distance
  50                 if(bAdaptDistance)
  51                 {
  52                     const double fDiscreteDistance(getFillHatch().getDistance() / getDiscreteUnit());
  53
  54                     if(fDiscreteDistance < static_cast<double>(getFillHatch().getMinimalDiscreteDistance()))
  55                     {
  56                         fDistance = static_cast<double>(getFillHatch().getMinimalDiscreteDistance()) * getDiscreteUnit();
  57                     }
  58                 }
  59
  60                 // get hatch transformations
  61                 switch(getFillHatch().getStyle())
  62                 {
  63                     case attribute::HatchStyle::Triple:
  64                     {
  65                         // rotated 45 degrees
  66                         texture::GeoTexSvxHatch aHatch(
  67                             getDefinitionRange(),
  68                             getOutputRange(),
  69                             fDistance,
  70                             fAngle - F_PI4);
  71
  72                         aHatch.appendTransformations(aMatrices);
  73
  74                         [[fallthrough]];
  75                     }
  76                     case attribute::HatchStyle::Double:
  77                     {
  78                         // rotated 90 degrees
  79                         texture::GeoTexSvxHatch aHatch(
  80                             getDefinitionRange(),
  81                             getOutputRange(),
  82                             fDistance,
  83                             fAngle - F_PI2);
  84
  85                         aHatch.appendTransformations(aMatrices);
  86
  87                         [[fallthrough]];
  88                     }
  89                     case attribute::HatchStyle::Single:
  90                     {
  91                         // angle as given
  92                         texture::GeoTexSvxHatch aHatch(
  93                             getDefinitionRange(),
  94                             getOutputRange(),
  95                             fDistance,
  96                             fAngle);
  97
  98                         aHatch.appendTransformations(aMatrices);
  99                     }
 100                 }
 101
 102                 // prepare return value
 103                 const bool bFillBackground(getFillHatch().isFillBackground());
 104
 105                 // evtl. create filled background
 106                 if(bFillBackground)
 107                 {
 108                     // create primitive for background
 109                     rContainer.push_back(
 110                         new PolyPolygonColorPrimitive2D(
 111                             basegfx::B2DPolyPolygon(
 112                                 basegfx::utils::createPolygonFromRect(getOutputRange())), getBColor()));
 113                 }
 114
 115                 // create primitives
 116                 const basegfx::B2DPoint aStart(0.0, 0.0);
 117                 const basegfx::B2DPoint aEnd(1.0, 0.0);
 118
 119                 for(size_t a(0); a < aMatrices.size(); a++)
 120                 {
 121                     const basegfx::B2DHomMatrix& rMatrix = aMatrices[a];
 122                     basegfx::B2DPolygon aNewLine;
 123
 124                     aNewLine.append(rMatrix * aStart);
 125                     aNewLine.append(rMatrix * aEnd);
 126
 127                     // create hairline
 128                     rContainer.push_back(new PolygonHairlinePrimitive2D(aNewLine, aHatchColor));
 129                 }
 130             }
 131         }
 132
 133         FillHatchPrimitive2D::FillHatchPrimitive2D(
 134             const basegfx::B2DRange& rOutputRange,
 135             const basegfx::BColor& rBColor,
 136             const attribute::FillHatchAttribute& rFillHatch)
 137         :   DiscreteMetricDependentPrimitive2D(),
 138             maOutputRange(rOutputRange),
 139             maDefinitionRange(rOutputRange),
 140             maFillHatch(rFillHatch),
 141             maBColor(rBColor)
 142         {
 143         }
 144
 145         FillHatchPrimitive2D::FillHatchPrimitive2D(
 146             const basegfx::B2DRange& rOutputRange,
 147             const basegfx::B2DRange& rDefinitionRange,
 148             const basegfx::BColor& rBColor,
 149             const attribute::FillHatchAttribute& rFillHatch)
 150         :   DiscreteMetricDependentPrimitive2D(),
 151             maOutputRange(rOutputRange),
 152             maDefinitionRange(rDefinitionRange),
 153             maFillHatch(rFillHatch),
 154             maBColor(rBColor)
 155         {
 156         }
 157
 158         bool FillHatchPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
 159         {
 160             if(DiscreteMetricDependentPrimitive2D::operator==(rPrimitive))
 161             {
 162                 const FillHatchPrimitive2D& rCompare = static_cast<const FillHatchPrimitive2D&>(rPrimitive);
 163
 164                 return (getOutputRange() == rCompare.getOutputRange()
 165                     && getDefinitionRange() == rCompare.getDefinitionRange()
 166                     && getFillHatch() == rCompare.getFillHatch()
 167                     && getBColor() == rCompare.getBColor());
 168             }
 169
 170             return false;
 171         }
 172
 173         basegfx::B2DRange FillHatchPrimitive2D::getB2DRange(const geometry::ViewInformation2D& /*rViewInformation*/) const
 174         {
 175             // return the geometrically visible area
 176             return getOutputRange();
 177         }
 178
 179         void FillHatchPrimitive2D::get2DDecomposition(Primitive2DDecompositionVisitor& rVisitor, const geometry::ViewInformation2D& rViewInformation) const
 180         {
 181             ::osl::MutexGuard aGuard( m_aMutex );
 182             bool bAdaptDistance(0 != getFillHatch().getMinimalDiscreteDistance());
 183
 184             if(bAdaptDistance)
 185             {
 186                 // behave view-dependent
 187                 DiscreteMetricDependentPrimitive2D::get2DDecomposition(rVisitor, rViewInformation);
 188             }
 189             else
 190             {
 191                 // behave view-independent
 192                 BufferedDecompositionPrimitive2D::get2DDecomposition(rVisitor, rViewInformation);
 193             }
 194         }
 195
 196         // provide unique ID
 197         ImplPrimitive2DIDBlock(FillHatchPrimitive2D, PRIMITIVE2D_ID_FILLHATCHPRIMITIVE2D)
 198
 199     } // end of namespace primitive2d
 200 } // end of namespace drawinglayer
 201
 202 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */