svx/source/svdraw/impgrfll.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: impgrfll.cxx,v $
  10  * $Revision: 1.17 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_svx.hxx"
  33 #include <svx/rectenum.hxx>
  34 #include <vcl/svapp.hxx>
  35 #include <vcl/outdev.hxx>
  36 #include <vcl/bitmap.hxx>
  37
  38 ///////////////////////////////////////////////////////////////////////////////
  39
  40 void ImpCalcBmpFillSizes( Size&                    rStartOffset,
  41                           Size&                    rBmpOutputSize,
  42                           const Rectangle& rOutputRect,
  43                           const MapMode&   rOutputMapMode,
  44                           const Bitmap&    rFillBitmap,
  45                           const Size&      rBmpSize,
  46                           const Size&      rBmpPerCent,
  47                           const Size&      rBmpOffPerCent,
  48                           BOOL             bBmpLogSize,
  49                           BOOL             bBmpTile,
  50                           BOOL             bBmpStretch,
  51                           RECT_POINT       eBmpRectPoint )
  52 {
  53     BOOL        bOriginalSize = FALSE, bScaleSize = FALSE;
  54
  55     // Falls keine Groessen gegeben sind ( z.B. alte Dokumente )
  56     // berechnen wir uns die Groesse selber aus der Bitmap
  57     // ==> altes Verhalten;
  58     // wenn nur eine Groesse gegeben ist, wird die andere
  59     // Groesse angepasst berechnet
  60     if( bBmpLogSize )
  61     {
  62         if( !rBmpSize.Width() && !rBmpSize.Height() )
  63             bOriginalSize = TRUE;
  64         else if( !rBmpSize.Width() || !rBmpSize.Height() )
  65             bScaleSize = TRUE;
  66     }
  67     else
  68     {
  69         if( !rBmpPerCent.Width() && !rBmpPerCent.Height() )
  70             bOriginalSize = TRUE;
  71         else if( !rBmpPerCent.Width() || !rBmpPerCent.Height() )
  72             bScaleSize = TRUE;
  73     }
  74
  75     // entweder Originalgroesse oder angepasste Groesse
  76     if( bOriginalSize || bScaleSize )
  77     {
  78         MapMode aBmpPrefMapMode( rFillBitmap.GetPrefMapMode() );
  79         Size    aBmpPrefSize( rFillBitmap.GetPrefSize() );
  80
  81         // Falls keine gesetzt ist, nehmen wir Pixel
  82         if( !aBmpPrefSize.Width() || !aBmpPrefSize.Height() )
  83         {
  84             aBmpPrefSize = rFillBitmap.GetSizePixel();
  85             aBmpPrefMapMode = MAP_PIXEL;
  86         }
  87
  88         if( bOriginalSize )
  89         {
  90             if( MAP_PIXEL == aBmpPrefMapMode.GetMapUnit() )
  91                 rBmpOutputSize = Application::GetDefaultDevice()->PixelToLogic( aBmpPrefSize, rOutputMapMode );
  92             else
  93                 rBmpOutputSize = OutputDevice::LogicToLogic( aBmpPrefSize, aBmpPrefMapMode, rOutputMapMode );
  94         }
  95         else
  96         {
  97             if( bBmpLogSize )
  98             {
  99                 rBmpOutputSize = rBmpSize;
 100
 101                 if( !rBmpSize.Width() )
 102                     rBmpOutputSize.Width() = basegfx::fround( (double) rBmpSize.Height() * aBmpPrefSize.Width() / aBmpPrefSize.Height() );
 103                 else
 104                     rBmpOutputSize.Height() = basegfx::fround( (double) rBmpSize.Width() * aBmpPrefSize.Height() / aBmpPrefSize.Width() );
 105             }
 106             else
 107             {
 108                 if( !rBmpPerCent.Width() )
 109                 {
 110                     rBmpOutputSize.Height() = basegfx::fround( (double) rOutputRect.GetHeight() * rBmpPerCent.Height() / 100. );
 111                     rBmpOutputSize.Width() = basegfx::fround( (double) rBmpOutputSize.Height() * aBmpPrefSize.Width() / aBmpPrefSize.Height() );
 112                 }
 113                 else
 114                 {
 115                     rBmpOutputSize.Width() = basegfx::fround( (double) rOutputRect.GetWidth() * rBmpPerCent.Width() / 100. );
 116                     rBmpOutputSize.Height() = basegfx::fround( (double) rBmpOutputSize.Width() * aBmpPrefSize.Height() / aBmpPrefSize.Width() );
 117                 }
 118             }
 119         }
 120     }
 121     // ansonsten koennen wir die Groesse leicht selber berechnen
 122     else
 123     {
 124         if( bBmpLogSize )
 125             rBmpOutputSize = rBmpSize;
 126         else
 127         {
 128             rBmpOutputSize.Width() = basegfx::fround( (double) rOutputRect.GetWidth() * rBmpPerCent.Width() / 100. );
 129             rBmpOutputSize.Height() = basegfx::fround( (double) rOutputRect.GetHeight() * rBmpPerCent.Height() / 100. );
 130         }
 131     }
 132
 133     // nur bei Kachelung die anderen Positionen berechnen
 134     if( bBmpTile )
 135     {
 136         Point aStartPoint;
 137
 138         // Grundposition der ersten Kachel berechen;
 139         // Diese Position wird spaeter zur Berechnung der absoluten
 140         // Startposition links oberhalb des Objektes benutzt
 141         switch( eBmpRectPoint )
 142         {
 143             case( RP_MT ):
 144             {
 145                 aStartPoint.X() = rOutputRect.Left() + ( ( rOutputRect.GetWidth() - rBmpOutputSize.Width() ) >> 1 );
 146                 aStartPoint.Y() = rOutputRect.Top();
 147             }
 148             break;
 149
 150             case( RP_RT ):
 151             {
 152                 aStartPoint.X() = rOutputRect.Right() - rBmpOutputSize.Width();
 153                 aStartPoint.Y() = rOutputRect.Top();
 154             }
 155             break;
 156
 157             case( RP_LM ):
 158             {
 159                 aStartPoint.X() = rOutputRect.Left();
 160                 aStartPoint.Y() = rOutputRect.Top() + ( ( rOutputRect.GetHeight() - rBmpOutputSize.Height() ) >> 1  );
 161             }
 162             break;
 163
 164             case( RP_MM ):
 165             {
 166                 aStartPoint.X() = rOutputRect.Left() + ( ( rOutputRect.GetWidth() - rBmpOutputSize.Width() ) >> 1 );
 167                 aStartPoint.Y() = rOutputRect.Top() + ( ( rOutputRect.GetHeight() - rBmpOutputSize.Height() ) >> 1 );
 168             }
 169             break;
 170
 171             case( RP_RM ):
 172             {
 173                 aStartPoint.X() = rOutputRect.Right() - rBmpOutputSize.Width();
 174                 aStartPoint.Y() = rOutputRect.Top() + ( ( rOutputRect.GetHeight() - rBmpOutputSize.Height() ) >> 1 );
 175             }
 176             break;
 177
 178             case( RP_LB ):
 179             {
 180                 aStartPoint.X() = rOutputRect.Left();
 181                 aStartPoint.Y() = rOutputRect.Bottom() - rBmpOutputSize.Height();
 182             }
 183             break;
 184
 185             case( RP_MB ):
 186             {
 187                 aStartPoint.X() = rOutputRect.Left() + ( ( rOutputRect.GetWidth() - rBmpOutputSize.Width() ) >> 1 );
 188                 aStartPoint.Y() = rOutputRect.Bottom() - rBmpOutputSize.Height();
 189             }
 190             break;
 191
 192             case( RP_RB ):
 193             {
 194                 aStartPoint.X() = rOutputRect.Right() - rBmpOutputSize.Width();
 195                 aStartPoint.Y() = rOutputRect.Bottom() - rBmpOutputSize.Height();
 196             }
 197             break;
 198
 199             // default linke obere Ecke
 200             default:
 201                 aStartPoint = rOutputRect.TopLeft();
 202             break;
 203         }
 204
 205         // X- oder Y-Positionsoffset beruecksichtigen
 206         if( rBmpOffPerCent.Width() )
 207             aStartPoint.X() += ( rBmpOutputSize.Width() * rBmpOffPerCent.Width() / 100 );
 208
 209         if( rBmpOffPerCent.Height() )
 210             aStartPoint.Y() += ( rBmpOutputSize.Height() * rBmpOffPerCent.Height() / 100 );
 211
 212         // echten Startpunkt berechnen ( links oben )
 213         if( rBmpOutputSize.Width() && rBmpOutputSize.Height() )
 214         {
 215             const long nDiffX = aStartPoint.X() - rOutputRect.Left();
 216             const long nDiffY = aStartPoint.Y() - rOutputRect.Top();
 217
 218             if ( nDiffX )
 219             {
 220                 long nCount = nDiffX / rBmpOutputSize.Width() + 1;
 221
 222                 if ( rBmpOffPerCent.Height() && ( nCount & 1L ) )
 223                     nCount++;
 224
 225                 aStartPoint.X() -= ( nCount * rBmpOutputSize.Width() );
 226             }
 227
 228             if ( nDiffY )
 229             {
 230                 long nCount = nDiffY / rBmpOutputSize.Height() + 1;
 231
 232                 if ( rBmpOffPerCent.Width() && ( nCount & 1L ) )
 233                     nCount++;
 234
 235                 aStartPoint.Y() -= ( nCount * rBmpOutputSize.Height() );
 236             }
 237         }
 238
 239         rStartOffset = Size( aStartPoint.X() - rOutputRect.Left(),
 240                              aStartPoint.Y() - rOutputRect.Top() );
 241     }
 242     else
 243     {
 244         if( bBmpStretch )
 245         {
 246             rStartOffset = Size(0, 0);
 247             rBmpOutputSize = rOutputRect.GetSize();
 248         }
 249         else
 250         {
 251             rStartOffset = Size( ( rOutputRect.GetWidth() - rBmpOutputSize.Width() ) >> 1,
 252                                  ( rOutputRect.GetHeight() - rBmpOutputSize.Height() ) >> 1 );
 253         }
 254     }
 255 }
 256
 257 //////////////////////////////////////////////////////////////////////////////
 258 // eof