drawinglayer/source/attribute/sdrfillbitmapattribute.cxx

   1 /*************************************************************************
   2  *
   3  *  OpenOffice.org - a multi-platform office productivity suite
   4  *
   5  *  $RCSfile: sdrfillbitmapattribute.cxx,v $
   6  *
   7  *  $Revision: 1.4 $
   8  *
   9  *  last change: $Author: aw $ $Date: 2008-05-27 14:11:19 $
  10  *
  11  *  The Contents of this file are made available subject to
  12  *  the terms of GNU Lesser General Public License Version 2.1.
  13  *
  14  *
  15  *    GNU Lesser General Public License Version 2.1
  16  *    =============================================
  17  *    Copyright 2005 by Sun Microsystems, Inc.
  18  *    901 San Antonio Road, Palo Alto, CA 94303, USA
  19  *
  20  *    This library is free software; you can redistribute it and/or
  21  *    modify it under the terms of the GNU Lesser General Public
  22  *    License version 2.1, as published by the Free Software Foundation.
  23  *
  24  *    This library is distributed in the hope that it will be useful,
  25  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  26  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  27  *    Lesser General Public License for more details.
  28  *
  29  *    You should have received a copy of the GNU Lesser General Public
  30  *    License along with this library; if not, write to the Free Software
  31  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  32  *    MA  02111-1307  USA
  33  *
  34  ************************************************************************/
  35
  36 // MARKER(update_precomp.py): autogen include statement, do not remove
  37 #include "precompiled_drawinglayer.hxx"
  38
  39 #include <drawinglayer/attribute/sdrfillbitmapattribute.hxx>
  40 #include <drawinglayer/attribute/fillbitmapattribute.hxx>
  41 #include <basegfx/numeric/ftools.hxx>
  42 #include <basegfx/range/b2drange.hxx>
  43
  44 //////////////////////////////////////////////////////////////////////////////
  45
  46 namespace drawinglayer
  47 {
  48     namespace attribute
  49     {
  50         SdrFillBitmapAttribute::SdrFillBitmapAttribute(
  51             const Bitmap& rBitmap, const basegfx::B2DVector& rSize, const basegfx::B2DVector& rOffset,
  52             const basegfx::B2DVector& rOffsetPosition, const basegfx::B2DVector& rRectPoint,
  53             bool bTiling, bool bStretch, bool bLogSize)
  54         :       maBitmap(rBitmap),
  55             maSize(rSize),
  56             maOffset(rOffset),
  57             maOffsetPosition(rOffsetPosition),
  58             maRectPoint(rRectPoint),
  59             mbTiling(bTiling),
  60             mbStretch(bStretch),
  61             mbLogSize(bLogSize)
  62         {
  63         }
  64
  65         bool SdrFillBitmapAttribute::operator==(const SdrFillBitmapAttribute& rCandidate) const
  66         {
  67             return (maBitmap == rCandidate.maBitmap
  68                 && maSize == rCandidate.maSize
  69                 && maOffset == rCandidate.maOffset
  70                 && maOffsetPosition == rCandidate.maOffsetPosition
  71                 && maRectPoint == rCandidate.maRectPoint
  72                 && mbTiling == rCandidate.mbTiling
  73                 && mbStretch == rCandidate.mbStretch
  74                 && mbLogSize == rCandidate.mbLogSize);
  75         }
  76
  77         FillBitmapAttribute SdrFillBitmapAttribute::getFillBitmapAttribute(const basegfx::B2DRange& rRange) const
  78         {
  79             // get logical size of bitmap (before expanding eventually)
  80             Bitmap aBitmap(maBitmap);
  81             const basegfx::B2DVector aLogicalSize(aBitmap.GetPrefSize().getWidth(), aBitmap.GetPrefSize().getHeight());
  82
  83             // get hor/ver shiftings and apply them eventually to the bitmap, but only
  84             // when tiling is on
  85             bool bExpandWidth(false);
  86             bool bExpandHeight(false);
  87
  88             if(mbTiling)
  89             {
  90                 if(0.0 != maOffset.getX() || 0.0 != maOffset.getY())
  91                 {
  92                     const sal_uInt32 nWidth(aBitmap.GetSizePixel().getWidth());
  93                     const sal_uInt32 nHeight(aBitmap.GetSizePixel().getHeight());
  94
  95                     if(0.0 != maOffset.getX())
  96                     {
  97                         bExpandHeight = true;
  98                         const sal_uInt32 nOffset(basegfx::fround(((double)nWidth * maOffset.getX()) / 100.0));
  99                         aBitmap.Expand(0L, nHeight);
 100
 101                         const Size aSizeA(nOffset, nHeight);
 102                         const Rectangle aDstA(Point(0L, nHeight), aSizeA);
 103                         const Rectangle aSrcA(Point(nWidth - nOffset, 0L), aSizeA);
 104                         aBitmap.CopyPixel(aDstA, aSrcA);
 105
 106                         const Size aSizeB(nWidth - nOffset, nHeight);
 107                         const Rectangle aDstB(Point(nOffset, nHeight), aSizeB);
 108                         const Rectangle aSrcB(Point(0L, 0L), aSizeB);
 109                         aBitmap.CopyPixel(aDstB, aSrcB);
 110                     }
 111                     else
 112                     {
 113                         bExpandWidth = true;
 114                         const sal_uInt32 nOffset(basegfx::fround(((double)nHeight * maOffset.getY()) / 100.0));
 115                         aBitmap.Expand(nWidth, 0L);
 116
 117                         const Size aSize(nWidth, nHeight);
 118                         const Rectangle aDst(Point(nWidth, 0L), aSize);
 119                         const Rectangle aSrc(Point(0L, 0L), aSize);
 120                         aBitmap.CopyPixel(aDst, aSrc);
 121
 122                         const Size aSizeA(nWidth, nOffset);
 123                         const Rectangle aDstA(Point(0L, 0L), aSizeA);
 124                         const Rectangle aSrcA(Point(nWidth, nHeight - nOffset), aSizeA);
 125                         aBitmap.CopyPixel(aDstA, aSrcA);
 126
 127                         const Size aSizeB(nWidth, nHeight - nOffset);
 128                         const Rectangle aDstB(Point(0L, nOffset), aSizeB);
 129                         const Rectangle aSrcB(Point(nWidth, 0L), aSizeB);
 130                         aBitmap.CopyPixel(aDstB, aSrcB);
 131                     }
 132                 }
 133             }
 134
 135             // init values with defaults
 136             basegfx::B2DPoint aBitmapSize(1.0, 1.0);
 137             basegfx::B2DVector aBitmapTopLeft(0.0, 0.0);
 138
 139             // are canges needed?
 140             if(mbTiling || !mbStretch)
 141             {
 142                 // init values with range sizes
 143                 const double fRangeWidth(0.0 != rRange.getWidth() ? rRange.getWidth() : 1.0);
 144                 const double fRangeHeight(0.0 != rRange.getHeight() ? rRange.getHeight() : 1.0);
 145                 aBitmapSize = basegfx::B2DPoint(fRangeWidth, fRangeHeight);
 146
 147                 // size changes
 148                 if(0.0 != maSize.getX())
 149                 {
 150                     if(maSize.getX() < 0.0)
 151                     {
 152                         aBitmapSize.setX(aBitmapSize.getX() * (maSize.getX() * -0.01));
 153                     }
 154                     else
 155                     {
 156                         aBitmapSize.setX(maSize.getX());
 157                     }
 158                 }
 159                 else
 160                 {
 161                     aBitmapSize.setX(aLogicalSize.getX());
 162                 }
 163
 164                 if(0.0 != maSize.getY())
 165                 {
 166                     if(maSize.getY() < 0.0)
 167                     {
 168                         aBitmapSize.setY(aBitmapSize.getY() * (maSize.getY() * -0.01));
 169                     }
 170                     else
 171                     {
 172                         aBitmapSize.setY(maSize.getY());
 173                     }
 174                 }
 175                 else
 176                 {
 177                     aBitmapSize.setY(aLogicalSize.getY());
 178                 }
 179
 180                 // get values, force to centered if necessary
 181                 const basegfx::B2DVector aRectPoint(mbTiling ? maRectPoint : basegfx::B2DVector(0.0, 0.0));
 182
 183                 // position changes X
 184                 if(0.0 == aRectPoint.getX())
 185                 {
 186                     aBitmapTopLeft.setX((fRangeWidth - aBitmapSize.getX()) * 0.5);
 187                 }
 188                 else if(1.0 == aRectPoint.getX())
 189                 {
 190                     aBitmapTopLeft.setX(fRangeWidth - aBitmapSize.getX());
 191                 }
 192
 193                 if(mbTiling && 0.0 != maOffsetPosition.getX())
 194                 {
 195                     aBitmapTopLeft.setX(aBitmapTopLeft.getX() + (aBitmapSize.getX() * (maOffsetPosition.getX() * 0.01)));
 196                 }
 197
 198                 // position changes Y
 199                 if(0.0 == aRectPoint.getY())
 200                 {
 201                     aBitmapTopLeft.setY((fRangeHeight - aBitmapSize.getY()) * 0.5);
 202                 }
 203                 else if(1.0 == aRectPoint.getY())
 204                 {
 205                     aBitmapTopLeft.setY(fRangeHeight - aBitmapSize.getY());
 206                 }
 207
 208                 if(mbTiling && 0.0 != maOffsetPosition.getY())
 209                 {
 210                     aBitmapTopLeft.setY(aBitmapTopLeft.getY() + (aBitmapSize.getY() * (maOffsetPosition.getY() * 0.01)));
 211                 }
 212
 213                 // apply expand
 214                 if(bExpandWidth)
 215                 {
 216                     aBitmapSize.setX(aBitmapSize.getX() * 2.0);
 217                 }
 218
 219                 if(bExpandHeight)
 220                 {
 221                     aBitmapSize.setY(aBitmapSize.getY() * 2.0);
 222                 }
 223
 224                 // apply bitmap size scaling to unit rectangle
 225                 aBitmapTopLeft.setX(aBitmapTopLeft.getX() / fRangeWidth);
 226                 aBitmapTopLeft.setY(aBitmapTopLeft.getY() / fRangeHeight);
 227                 aBitmapSize.setX(aBitmapSize.getX() / fRangeWidth);
 228                 aBitmapSize.setY(aBitmapSize.getY() / fRangeHeight);
 229             }
 230
 231             return FillBitmapAttribute(aBitmap, aBitmapTopLeft, aBitmapSize, mbTiling);
 232         }
 233     } // end of namespace attribute
 234 } // end of namespace drawinglayer
 235
 236 //////////////////////////////////////////////////////////////////////////////
 237 // eof