drawinglayer/source/primitive3d/textureprimitive3d.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * Copyright 2000, 2010 Oracle and/or its affiliates.
   7  *
   8  * OpenOffice.org - a multi-platform office productivity suite
   9  *
  10  * This file is part of OpenOffice.org.
  11  *
  12  * OpenOffice.org is free software: you can redistribute it and/or modify
  13  * it under the terms of the GNU Lesser General Public License version 3
  14  * only, as published by the Free Software Foundation.
  15  *
  16  * OpenOffice.org is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU Lesser General Public License version 3 for more details
  20  * (a copy is included in the LICENSE file that accompanied this code).
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * version 3 along with OpenOffice.org.  If not, see
  24  * <http://www.openoffice.org/license.html>
  25  * for a copy of the LGPLv3 License.
  26  *
  27  ************************************************************************/
  28
  29 #include <drawinglayer/primitive3d/textureprimitive3d.hxx>
  30 #include <drawinglayer/primitive3d/drawinglayer_primitivetypes3d.hxx>
  31 #include <basegfx/color/bcolor.hxx>
  32
  33 //////////////////////////////////////////////////////////////////////////////
  34
  35 using namespace com::sun::star;
  36
  37 //////////////////////////////////////////////////////////////////////////////
  38
  39 namespace drawinglayer
  40 {
  41     namespace primitive3d
  42     {
  43         TexturePrimitive3D::TexturePrimitive3D(
  44             const Primitive3DSequence& rChildren,
  45             const basegfx::B2DVector& rTextureSize,
  46             bool bModulate, bool bFilter)
  47         :   GroupPrimitive3D(rChildren),
  48             maTextureSize(rTextureSize),
  49             mbModulate(bModulate),
  50             mbFilter(bFilter)
  51         {
  52         }
  53
  54         bool TexturePrimitive3D::operator==(const BasePrimitive3D& rPrimitive) const
  55         {
  56             if(GroupPrimitive3D::operator==(rPrimitive))
  57             {
  58                 const TexturePrimitive3D& rCompare = (TexturePrimitive3D&)rPrimitive;
  59
  60                 return (getModulate() == rCompare.getModulate()
  61                     && getFilter() == rCompare.getFilter());
  62             }
  63
  64             return false;
  65         }
  66     } // end of namespace primitive3d
  67 } // end of namespace drawinglayer
  68
  69 //////////////////////////////////////////////////////////////////////////////
  70
  71 namespace drawinglayer
  72 {
  73     namespace primitive3d
  74     {
  75         UnifiedTransparenceTexturePrimitive3D::UnifiedTransparenceTexturePrimitive3D(
  76             double fTransparence,
  77             const Primitive3DSequence& rChildren)
  78         :   TexturePrimitive3D(rChildren, basegfx::B2DVector(), false, false),
  79             mfTransparence(fTransparence)
  80         {
  81         }
  82
  83         bool UnifiedTransparenceTexturePrimitive3D::operator==(const BasePrimitive3D& rPrimitive) const
  84         {
  85             if(TexturePrimitive3D::operator==(rPrimitive))
  86             {
  87                 const UnifiedTransparenceTexturePrimitive3D& rCompare = (UnifiedTransparenceTexturePrimitive3D&)rPrimitive;
  88
  89                 return (getTransparence() == rCompare.getTransparence());
  90             }
  91
  92             return false;
  93         }
  94
  95         basegfx::B3DRange UnifiedTransparenceTexturePrimitive3D::getB3DRange(const geometry::ViewInformation3D& rViewInformation) const
  96         {
  97             // do not use the fallback to decomposition here since for a correct BoundRect we also
  98             // need invisible (1.0 == getTransparence()) geometry; these would be deleted in the decomposition
  99             return getB3DRangeFromPrimitive3DSequence(getChildren(), rViewInformation);
 100         }
 101
 102         Primitive3DSequence UnifiedTransparenceTexturePrimitive3D::get3DDecomposition(const geometry::ViewInformation3D& /*rViewInformation*/) const
 103         {
 104             if(0.0 == getTransparence())
 105             {
 106                 // no transparence used, so just use content
 107                 return getChildren();
 108             }
 109             else if(getTransparence() > 0.0 && getTransparence() < 1.0)
 110             {
 111                 // create TransparenceTexturePrimitive3D with fixed transparence as replacement
 112                 const basegfx::BColor aGray(getTransparence(), getTransparence(), getTransparence());
 113                 const attribute::FillGradientAttribute aFillGradient(attribute::GRADIENTSTYLE_LINEAR, 0.0, 0.0, 0.0, 0.0, aGray, aGray, 1);
 114                 const Primitive3DReference xRef(new TransparenceTexturePrimitive3D(aFillGradient, getChildren(), getTextureSize()));
 115                 return Primitive3DSequence(&xRef, 1L);
 116             }
 117             else
 118             {
 119                 // completely transparent or invalid definition, add nothing
 120                 return Primitive3DSequence();
 121             }
 122         }
 123
 124         // provide unique ID
 125         ImplPrimitrive3DIDBlock(UnifiedTransparenceTexturePrimitive3D, PRIMITIVE3D_ID_UNIFIEDTRANSPARENCETEXTUREPRIMITIVE3D)
 126
 127     } // end of namespace primitive3d
 128 } // end of namespace drawinglayer
 129
 130 //////////////////////////////////////////////////////////////////////////////
 131
 132 namespace drawinglayer
 133 {
 134     namespace primitive3d
 135     {
 136         GradientTexturePrimitive3D::GradientTexturePrimitive3D(
 137             const attribute::FillGradientAttribute& rGradient,
 138             const Primitive3DSequence& rChildren,
 139             const basegfx::B2DVector& rTextureSize,
 140             bool bModulate,
 141             bool bFilter)
 142         :   TexturePrimitive3D(rChildren, rTextureSize, bModulate, bFilter),
 143             maGradient(rGradient)
 144         {
 145         }
 146
 147         bool GradientTexturePrimitive3D::operator==(const BasePrimitive3D& rPrimitive) const
 148         {
 149             if(TexturePrimitive3D::operator==(rPrimitive))
 150             {
 151                 const GradientTexturePrimitive3D& rCompare = (GradientTexturePrimitive3D&)rPrimitive;
 152
 153                 return (getGradient() == rCompare.getGradient());
 154             }
 155
 156             return false;
 157         }
 158
 159         // provide unique ID
 160         ImplPrimitrive3DIDBlock(GradientTexturePrimitive3D, PRIMITIVE3D_ID_GRADIENTTEXTUREPRIMITIVE3D)
 161
 162     } // end of namespace primitive3d
 163 } // end of namespace drawinglayer
 164
 165 //////////////////////////////////////////////////////////////////////////////
 166
 167 namespace drawinglayer
 168 {
 169     namespace primitive3d
 170     {
 171         BitmapTexturePrimitive3D::BitmapTexturePrimitive3D(
 172             const attribute::FillBitmapAttribute& rFillBitmapAttribute,
 173             const Primitive3DSequence& rChildren,
 174             const basegfx::B2DVector& rTextureSize,
 175             bool bModulate, bool bFilter)
 176         :   TexturePrimitive3D(rChildren, rTextureSize, bModulate, bFilter),
 177             maFillBitmapAttribute(rFillBitmapAttribute)
 178         {
 179         }
 180
 181         bool BitmapTexturePrimitive3D::operator==(const BasePrimitive3D& rPrimitive) const
 182         {
 183             if(TexturePrimitive3D::operator==(rPrimitive))
 184             {
 185                 const BitmapTexturePrimitive3D& rCompare = (BitmapTexturePrimitive3D&)rPrimitive;
 186
 187                 return (getFillBitmapAttribute() == rCompare.getFillBitmapAttribute());
 188             }
 189
 190             return false;
 191         }
 192
 193         // provide unique ID
 194         ImplPrimitrive3DIDBlock(BitmapTexturePrimitive3D, PRIMITIVE3D_ID_BITMAPTEXTUREPRIMITIVE3D)
 195
 196     } // end of namespace primitive3d
 197 } // end of namespace drawinglayer
 198
 199 //////////////////////////////////////////////////////////////////////////////
 200
 201 namespace drawinglayer
 202 {
 203     namespace primitive3d
 204     {
 205         TransparenceTexturePrimitive3D::TransparenceTexturePrimitive3D(
 206             const attribute::FillGradientAttribute& rGradient,
 207             const Primitive3DSequence& rChildren,
 208             const basegfx::B2DVector& rTextureSize)
 209         :   GradientTexturePrimitive3D(rGradient, rChildren, rTextureSize, false, false)
 210         {
 211         }
 212
 213         bool TransparenceTexturePrimitive3D::operator==(const BasePrimitive3D& rPrimitive) const
 214         {
 215             return (GradientTexturePrimitive3D::operator==(rPrimitive));
 216         }
 217
 218         // provide unique ID
 219         ImplPrimitrive3DIDBlock(TransparenceTexturePrimitive3D, PRIMITIVE3D_ID_TRANSPARENCETEXTUREPRIMITIVE3D)
 220
 221     } // end of namespace primitive3d
 222 } // end of namespace drawinglayer
 223
 224 //////////////////////////////////////////////////////////////////////////////
 225 // eof
 226
 227 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */