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