vcl/source/gdi/mapmod.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 <vcl/mapmod.hxx>
  21
  22 #include <tools/gen.hxx>
  23 #include <tools/fract.hxx>
  24 #include <tools/stream.hxx>
  25 #include <tools/vcompat.hxx>
  26 #include <tools/debug.hxx>
  27
  28
  29 // - ImplMapMode -
  30
  31 struct MapMode::ImplMapMode
  32 {
  33     sal_uLong       mnRefCount;
  34     MapUnit         meUnit;
  35     Point           maOrigin;
  36     // NOTE: these Fraction must NOT have more than 32 bits precision
  37     // because ReadFraction / WriteFraction do only 32 bits, so more than
  38     // that cannot be stored in MetaFiles!
  39     // => call ReduceInaccurate whenever setting these
  40     Fraction        maScaleX;
  41     Fraction        maScaleY;
  42     bool            mbSimple;
  43
  44     friend SvStream& ReadImplMapMode(SvStream& rIStm, ImplMapMode& rMapMode);
  45     friend SvStream& WriteImplMapMode(SvStream& rOStm, const ImplMapMode& rMapMode);
  46
  47     static ImplMapMode* ImplGetStaticMapMode( MapUnit eUnit );
  48
  49     ImplMapMode();
  50     ImplMapMode(const ImplMapMode& rImpMapMode);
  51 };
  52
  53 MapMode::ImplMapMode::ImplMapMode() :
  54     maOrigin( 0, 0 ),
  55     maScaleX( 1, 1 ),
  56     maScaleY( 1, 1 )
  57 {
  58     mnRefCount  = 1;
  59     meUnit      = MAP_PIXEL;
  60     mbSimple    = false;
  61 }
  62
  63 MapMode::ImplMapMode::ImplMapMode( const ImplMapMode& rImplMapMode ) :
  64     maOrigin( rImplMapMode.maOrigin ),
  65     maScaleX( rImplMapMode.maScaleX ),
  66     maScaleY( rImplMapMode.maScaleY )
  67 {
  68     mnRefCount      = 1;
  69     meUnit          = rImplMapMode.meUnit;
  70     mbSimple        = false;
  71 }
  72
  73 SvStream& ReadImplMapMode(SvStream& rIStm, MapMode::ImplMapMode& rImplMapMode)
  74 {
  75     VersionCompat   aCompat( rIStm, StreamMode::READ );
  76     sal_uInt16          nTmp16;
  77
  78     rIStm.ReadUInt16( nTmp16 ); rImplMapMode.meUnit = (MapUnit) nTmp16;
  79     ReadPair( rIStm, rImplMapMode.maOrigin );
  80     ReadFraction( rIStm, rImplMapMode.maScaleX );
  81     ReadFraction( rIStm, rImplMapMode.maScaleY );
  82     rIStm.ReadCharAsBool( rImplMapMode.mbSimple );
  83
  84     return rIStm;
  85 }
  86
  87 SvStream& WriteImplMapMode(SvStream& rOStm, const MapMode::ImplMapMode& rImplMapMode)
  88 {
  89     VersionCompat aCompat( rOStm, StreamMode::WRITE, 1 );
  90
  91     rOStm.WriteUInt16( rImplMapMode.meUnit );
  92     WritePair( rOStm, rImplMapMode.maOrigin );
  93     WriteFraction( rOStm, rImplMapMode.maScaleX );
  94     WriteFraction( rOStm, rImplMapMode.maScaleY );
  95     rOStm.WriteBool( rImplMapMode.mbSimple );
  96
  97     return rOStm;
  98 }
  99
 100 MapMode::ImplMapMode *
 101 MapMode::ImplMapMode::ImplGetStaticMapMode(MapUnit eUnit)
 102 {
 103     static long aStaticImplMapModeAry[(MAP_LASTENUMDUMMY)*sizeof(ImplMapMode)/sizeof(long)];
 104
 105     // #i19496 check for out-of-bounds
 106      if( eUnit >= MAP_LASTENUMDUMMY )
 107         return reinterpret_cast<ImplMapMode*>(aStaticImplMapModeAry);
 108
 109     ImplMapMode* pImplMapMode = reinterpret_cast<ImplMapMode*>(aStaticImplMapModeAry)+eUnit;
 110     if ( !pImplMapMode->mbSimple )
 111     {
 112         Fraction aDefFraction( 1, 1 );
 113         pImplMapMode->maScaleX  = aDefFraction;
 114         pImplMapMode->maScaleY  = aDefFraction;
 115         pImplMapMode->meUnit    = eUnit;
 116         pImplMapMode->mbSimple  = true;
 117     }
 118
 119     return pImplMapMode;
 120 }
 121
 122 inline void MapMode::ImplMakeUnique()
 123 {
 124     // If there are other references, copy
 125     if ( mpImplMapMode->mnRefCount != 1 )
 126     {
 127         if ( mpImplMapMode->mnRefCount )
 128             mpImplMapMode->mnRefCount--;
 129         mpImplMapMode = new ImplMapMode( *mpImplMapMode );
 130     }
 131 }
 132
 133 MapMode::MapMode()
 134 {
 135
 136     mpImplMapMode = ImplMapMode::ImplGetStaticMapMode( MAP_PIXEL );
 137 }
 138
 139 MapMode::MapMode( const MapMode& rMapMode )
 140 {
 141     DBG_ASSERT( rMapMode.mpImplMapMode->mnRefCount < 0xFFFFFFFE, "MapMode: RefCount overflow" );
 142
 143     // Take over Shared Instance Data and increment refcount
 144     mpImplMapMode = rMapMode.mpImplMapMode;
 145     // RefCount == 0 for static objects
 146     if ( mpImplMapMode->mnRefCount )
 147         mpImplMapMode->mnRefCount++;
 148 }
 149
 150 MapMode::MapMode( MapUnit eUnit )
 151 {
 152
 153     mpImplMapMode = ImplMapMode::ImplGetStaticMapMode( eUnit );
 154 }
 155
 156 MapMode::MapMode( MapUnit eUnit, const Point& rLogicOrg,
 157                   const Fraction& rScaleX, const Fraction& rScaleY )
 158 {
 159
 160     mpImplMapMode           = new ImplMapMode;
 161     mpImplMapMode->meUnit   = eUnit;
 162     mpImplMapMode->maOrigin = rLogicOrg;
 163     mpImplMapMode->maScaleX = rScaleX;
 164     mpImplMapMode->maScaleY = rScaleY;
 165     mpImplMapMode->maScaleX.ReduceInaccurate(32);
 166     mpImplMapMode->maScaleY.ReduceInaccurate(32);
 167 }
 168
 169 MapMode::~MapMode()
 170 {
 171
 172     // If it's not static ImpData and it's the last reference, delete it,
 173     // else decrement refcounter
 174     if ( mpImplMapMode->mnRefCount )
 175     {
 176         if ( mpImplMapMode->mnRefCount == 1 )
 177             delete mpImplMapMode;
 178         else
 179             mpImplMapMode->mnRefCount--;
 180     }
 181 }
 182
 183 void MapMode::SetMapUnit( MapUnit eUnit )
 184 {
 185
 186     ImplMakeUnique();
 187     mpImplMapMode->meUnit = eUnit;
 188 }
 189
 190 void MapMode::SetOrigin( const Point& rLogicOrg )
 191 {
 192
 193     ImplMakeUnique();
 194     mpImplMapMode->maOrigin = rLogicOrg;
 195 }
 196
 197 void MapMode::SetScaleX( const Fraction& rScaleX )
 198 {
 199
 200     ImplMakeUnique();
 201     mpImplMapMode->maScaleX = rScaleX;
 202     mpImplMapMode->maScaleX.ReduceInaccurate(32);
 203 }
 204
 205 void MapMode::SetScaleY( const Fraction& rScaleY )
 206 {
 207
 208     ImplMakeUnique();
 209     mpImplMapMode->maScaleY = rScaleY;
 210     mpImplMapMode->maScaleY.ReduceInaccurate(32);
 211 }
 212
 213 MapMode& MapMode::operator=( const MapMode& rMapMode )
 214 {
 215     DBG_ASSERT( rMapMode.mpImplMapMode->mnRefCount < 0xFFFFFFFE, "MapMode: RefCount overflow" );
 216
 217     // First increment refcount so that we can reference ourselves
 218     // RefCount == 0 for static objects
 219     if ( rMapMode.mpImplMapMode->mnRefCount )
 220         rMapMode.mpImplMapMode->mnRefCount++;
 221
 222     // If it's not static ImpData and it's the last reference, delete it,
 223     // else decrement refcounter
 224     if ( mpImplMapMode->mnRefCount )
 225     {
 226         if ( mpImplMapMode->mnRefCount == 1 )
 227             delete mpImplMapMode;
 228         else
 229             mpImplMapMode->mnRefCount--;
 230     }
 231
 232     mpImplMapMode = rMapMode.mpImplMapMode;
 233
 234     return *this;
 235 }
 236
 237 bool MapMode::operator==( const MapMode& rMapMode ) const
 238 {
 239
 240     if ( mpImplMapMode == rMapMode.mpImplMapMode )
 241         return true;
 242
 243     if ( (mpImplMapMode->meUnit   == rMapMode.mpImplMapMode->meUnit)   &&
 244          (mpImplMapMode->maOrigin == rMapMode.mpImplMapMode->maOrigin) &&
 245          (mpImplMapMode->maScaleX == rMapMode.mpImplMapMode->maScaleX) &&
 246          (mpImplMapMode->maScaleY == rMapMode.mpImplMapMode->maScaleY) )
 247         return true;
 248     else
 249         return false;
 250 }
 251
 252 bool MapMode::IsDefault() const
 253 {
 254
 255     ImplMapMode* pDefMapMode = ImplMapMode::ImplGetStaticMapMode( MAP_PIXEL );
 256     if ( mpImplMapMode == pDefMapMode )
 257         return true;
 258
 259     if ( (mpImplMapMode->meUnit   == pDefMapMode->meUnit)   &&
 260          (mpImplMapMode->maOrigin == pDefMapMode->maOrigin) &&
 261          (mpImplMapMode->maScaleX == pDefMapMode->maScaleX) &&
 262          (mpImplMapMode->maScaleY == pDefMapMode->maScaleY) )
 263         return true;
 264     else
 265         return false;
 266 }
 267
 268 SvStream& ReadMapMode( SvStream& rIStm, MapMode& rMapMode )
 269 {
 270     rMapMode.ImplMakeUnique();
 271     return ReadImplMapMode( rIStm, *rMapMode.mpImplMapMode );
 272 }
 273
 274 SvStream& WriteMapMode( SvStream& rOStm, const MapMode& rMapMode )
 275 {
 276     return WriteImplMapMode( rOStm, *rMapMode.mpImplMapMode );
 277 }
 278
 279
 280 MapUnit MapMode::GetMapUnit() const { return mpImplMapMode->meUnit; }
 281
 282 const Point& MapMode::GetOrigin() const { return mpImplMapMode->maOrigin; }
 283
 284 const Fraction& MapMode::GetScaleX() const { return mpImplMapMode->maScaleX; }
 285
 286 const Fraction& MapMode::GetScaleY() const { return mpImplMapMode->maScaleY; }
 287
 288 bool MapMode::IsSimple() const { return mpImplMapMode->mbSimple; }
 289
 290 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */