vcl/source/gdi/wall.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
  21 #include <tools/stream.hxx>
  22 #include <tools/vcompat.hxx>
  23 #include <tools/debug.hxx>
  24
  25 #include <vcl/bitmapex.hxx>
  26 #include <vcl/gradient.hxx>
  27 #include <vcl/wall.hxx>
  28 #include <vcl/svapp.hxx>
  29
  30 #include <wall2.hxx>
  31
  32
  33 DBG_NAME( Wallpaper )
  34
  35 // -----------------------------------------------------------------------
  36
  37 ImplWallpaper::ImplWallpaper() :
  38     maColor( COL_TRANSPARENT )
  39 {
  40     mnRefCount      = 1;
  41     mpBitmap        = NULL;
  42     mpCache         = NULL;
  43     mpGradient      = NULL;
  44     mpRect          = NULL;
  45     meStyle         = WALLPAPER_NULL;
  46 }
  47
  48 // -----------------------------------------------------------------------
  49
  50 ImplWallpaper::ImplWallpaper( const ImplWallpaper& rImplWallpaper ) :
  51     maColor( rImplWallpaper.maColor )
  52 {
  53     mnRefCount = 1;
  54     meStyle = rImplWallpaper.meStyle;
  55
  56     if ( rImplWallpaper.mpBitmap )
  57         mpBitmap = new BitmapEx( *rImplWallpaper.mpBitmap );
  58     else
  59         mpBitmap = NULL;
  60     if( rImplWallpaper.mpCache )
  61         mpCache = new BitmapEx( *rImplWallpaper.mpCache );
  62     else
  63         mpCache = NULL;
  64     if ( rImplWallpaper.mpGradient )
  65         mpGradient = new Gradient( *rImplWallpaper.mpGradient );
  66     else
  67         mpGradient = NULL;
  68     if ( rImplWallpaper.mpRect )
  69         mpRect = new Rectangle( *rImplWallpaper.mpRect );
  70     else
  71         mpRect = NULL;
  72 }
  73
  74 // -----------------------------------------------------------------------
  75
  76 ImplWallpaper::~ImplWallpaper()
  77 {
  78     delete mpBitmap;
  79     delete mpCache;
  80     delete mpGradient;
  81     delete mpRect;
  82 }
  83
  84 // -----------------------------------------------------------------------
  85
  86 void ImplWallpaper::ImplSetCachedBitmap( BitmapEx& rBmp )
  87 {
  88     if( !mpCache )
  89         mpCache = new BitmapEx( rBmp );
  90     else
  91         *mpCache = rBmp;
  92 }
  93
  94 // -----------------------------------------------------------------------
  95
  96 void ImplWallpaper::ImplReleaseCachedBitmap()
  97 {
  98     delete mpCache;
  99     mpCache = NULL;
 100 }
 101
 102 // -----------------------------------------------------------------------
 103
 104 SvStream& operator>>( SvStream& rIStm, ImplWallpaper& rImplWallpaper )
 105 {
 106     VersionCompat   aCompat( rIStm, STREAM_READ );
 107     sal_uInt16          nTmp16;
 108
 109     delete rImplWallpaper.mpRect;
 110     rImplWallpaper.mpRect = NULL;
 111
 112     delete rImplWallpaper.mpGradient;
 113     rImplWallpaper.mpGradient = NULL;
 114
 115     delete rImplWallpaper.mpBitmap;
 116     rImplWallpaper.mpBitmap = NULL;
 117
 118     // version 1
 119     rIStm >> rImplWallpaper.maColor;
 120     rIStm >> nTmp16; rImplWallpaper.meStyle = (WallpaperStyle) nTmp16;
 121
 122     // version 2
 123     if( aCompat.GetVersion() >= 2 )
 124     {
 125         sal_Bool bRect, bGrad, bBmp, bDummy;
 126
 127         rIStm >> bRect >> bGrad >> bBmp >> bDummy >> bDummy >> bDummy;
 128
 129         if( bRect )
 130         {
 131             rImplWallpaper.mpRect = new Rectangle;
 132             rIStm >> *rImplWallpaper.mpRect;
 133         }
 134
 135         if( bGrad )
 136         {
 137             rImplWallpaper.mpGradient = new Gradient;
 138             rIStm >> *rImplWallpaper.mpGradient;
 139         }
 140
 141         if( bBmp )
 142         {
 143             rImplWallpaper.mpBitmap = new BitmapEx;
 144             rIStm >> *rImplWallpaper.mpBitmap;
 145         }
 146
 147         // version 3 (new color format)
 148         if( aCompat.GetVersion() >= 3 )
 149         {
 150             rImplWallpaper.maColor.Read( rIStm, sal_True );
 151         }
 152     }
 153
 154     return rIStm;
 155 }
 156
 157 // -----------------------------------------------------------------------
 158
 159 SvStream& operator<<( SvStream& rOStm, const ImplWallpaper& rImplWallpaper )
 160 {
 161     VersionCompat   aCompat( rOStm, STREAM_WRITE, 3 );
 162     sal_Bool            bRect = ( rImplWallpaper.mpRect != NULL );
 163     sal_Bool            bGrad = ( rImplWallpaper.mpGradient != NULL );
 164     sal_Bool            bBmp = ( rImplWallpaper.mpBitmap != NULL );
 165     sal_Bool            bDummy = sal_False;
 166
 167     // version 1
 168     rOStm << rImplWallpaper.maColor << (sal_uInt16) rImplWallpaper.meStyle;
 169
 170     // version 2
 171     rOStm << bRect << bGrad << bBmp << bDummy << bDummy << bDummy;
 172
 173     if( bRect )
 174         rOStm << *rImplWallpaper.mpRect;
 175
 176     if( bGrad )
 177         rOStm << *rImplWallpaper.mpGradient;
 178
 179     if( bBmp )
 180         rOStm << *rImplWallpaper.mpBitmap;
 181
 182     // version 3 (new color format)
 183     ( (Color&) rImplWallpaper.maColor ).Write( rOStm, sal_True );
 184
 185     return rOStm;
 186 }
 187
 188 // -----------------------------------------------------------------------
 189
 190 inline void Wallpaper::ImplMakeUnique( sal_Bool bReleaseCache )
 191 {
 192     // Falls noch andere Referenzen bestehen, dann kopieren
 193     if ( mpImplWallpaper->mnRefCount != 1 )
 194     {
 195         if ( mpImplWallpaper->mnRefCount )
 196             mpImplWallpaper->mnRefCount--;
 197         mpImplWallpaper = new ImplWallpaper( *(mpImplWallpaper) );
 198     }
 199
 200     if( bReleaseCache )
 201         mpImplWallpaper->ImplReleaseCachedBitmap();
 202 }
 203
 204 // -----------------------------------------------------------------------
 205
 206 Wallpaper::Wallpaper()
 207 {
 208     DBG_CTOR( Wallpaper, NULL );
 209
 210     static ImplWallpaper aStaticImplWallpaper;
 211
 212     aStaticImplWallpaper.mnRefCount = 0;
 213     mpImplWallpaper = &aStaticImplWallpaper;
 214 }
 215
 216 // -----------------------------------------------------------------------
 217
 218 Wallpaper::Wallpaper( const Wallpaper& rWallpaper )
 219 {
 220     DBG_CTOR( Wallpaper, NULL );
 221     DBG_CHKOBJ( &rWallpaper, Wallpaper, NULL );
 222     DBG_ASSERT( rWallpaper.mpImplWallpaper->mnRefCount < 0xFFFFFFFE, "Wallpaper: RefCount overflow" );
 223
 224     // Instance Daten uebernehmen und Referenzcounter erhoehen
 225     mpImplWallpaper = rWallpaper.mpImplWallpaper;
 226     // RefCount == 0 fuer statische Objekte
 227     if ( mpImplWallpaper->mnRefCount )
 228         mpImplWallpaper->mnRefCount++;
 229 }
 230
 231 // -----------------------------------------------------------------------
 232
 233 Wallpaper::Wallpaper( const Color& rColor )
 234 {
 235     DBG_CTOR( Wallpaper, NULL );
 236
 237     mpImplWallpaper             = new ImplWallpaper;
 238     mpImplWallpaper->maColor    = rColor;
 239     mpImplWallpaper->meStyle    = WALLPAPER_TILE;
 240 }
 241
 242 // -----------------------------------------------------------------------
 243
 244 Wallpaper::Wallpaper( const BitmapEx& rBmpEx )
 245 {
 246     DBG_CTOR( Wallpaper, NULL );
 247
 248     mpImplWallpaper             = new ImplWallpaper;
 249     mpImplWallpaper->mpBitmap   = new BitmapEx( rBmpEx );
 250     mpImplWallpaper->meStyle    = WALLPAPER_TILE;
 251 }
 252
 253 // -----------------------------------------------------------------------
 254
 255 Wallpaper::Wallpaper( const Gradient& rGradient )
 256 {
 257     DBG_CTOR( Wallpaper, NULL );
 258
 259     mpImplWallpaper             = new ImplWallpaper;
 260     mpImplWallpaper->mpGradient = new Gradient( rGradient );
 261     mpImplWallpaper->meStyle    = WALLPAPER_TILE;
 262 }
 263
 264 // -----------------------------------------------------------------------
 265
 266 Wallpaper::~Wallpaper()
 267 {
 268     DBG_DTOR( Wallpaper, NULL );
 269
 270     // Wenn es keine statischen ImpDaten sind, dann loeschen, wenn es
 271     // die letzte Referenz ist, sonst Referenzcounter decrementieren
 272     if ( mpImplWallpaper->mnRefCount )
 273     {
 274         if ( mpImplWallpaper->mnRefCount == 1 )
 275             delete mpImplWallpaper;
 276         else
 277             mpImplWallpaper->mnRefCount--;
 278     }
 279 }
 280
 281 // -----------------------------------------------------------------------
 282
 283 void Wallpaper::SetColor( const Color& rColor )
 284 {
 285     DBG_CHKTHIS( Wallpaper, NULL );
 286
 287     ImplMakeUnique();
 288     mpImplWallpaper->maColor = rColor;
 289
 290     if( WALLPAPER_NULL == mpImplWallpaper->meStyle || WALLPAPER_APPLICATIONGRADIENT == mpImplWallpaper->meStyle )
 291         mpImplWallpaper->meStyle = WALLPAPER_TILE;
 292 }
 293
 294 // -----------------------------------------------------------------------
 295
 296 const Color& Wallpaper::GetColor() const
 297 {
 298     DBG_CHKTHIS( Wallpaper, NULL );
 299
 300     return mpImplWallpaper->maColor;
 301 }
 302
 303 // -----------------------------------------------------------------------
 304
 305 void Wallpaper::SetStyle( WallpaperStyle eStyle )
 306 {
 307     DBG_CHKTHIS( Wallpaper, NULL );
 308
 309     ImplMakeUnique( sal_False );
 310
 311     if( eStyle == WALLPAPER_APPLICATIONGRADIENT )
 312         // set a dummy gradient, the correct gradient
 313         // will be created dynamically in GetGradient()
 314         SetGradient( ImplGetApplicationGradient() );
 315
 316     mpImplWallpaper->meStyle = eStyle;
 317 }
 318
 319 // -----------------------------------------------------------------------
 320
 321 WallpaperStyle Wallpaper::GetStyle() const
 322 {
 323     DBG_CHKTHIS( Wallpaper, NULL );
 324
 325     return mpImplWallpaper->meStyle;
 326 }
 327
 328 // -----------------------------------------------------------------------
 329
 330 void Wallpaper::SetBitmap( const BitmapEx& rBitmap )
 331 {
 332     DBG_CHKTHIS( Wallpaper, NULL );
 333
 334     if ( !rBitmap )
 335     {
 336         if ( mpImplWallpaper->mpBitmap )
 337         {
 338             ImplMakeUnique();
 339             delete mpImplWallpaper->mpBitmap;
 340             mpImplWallpaper->mpBitmap = NULL;
 341         }
 342     }
 343     else
 344     {
 345         ImplMakeUnique();
 346         if ( mpImplWallpaper->mpBitmap )
 347             *(mpImplWallpaper->mpBitmap) = rBitmap;
 348         else
 349             mpImplWallpaper->mpBitmap = new BitmapEx( rBitmap );
 350     }
 351
 352     if( WALLPAPER_NULL == mpImplWallpaper->meStyle || WALLPAPER_APPLICATIONGRADIENT == mpImplWallpaper->meStyle)
 353         mpImplWallpaper->meStyle = WALLPAPER_TILE;
 354 }
 355
 356 // -----------------------------------------------------------------------
 357
 358 BitmapEx Wallpaper::GetBitmap() const
 359 {
 360     DBG_CHKTHIS( Wallpaper, NULL );
 361
 362     if ( mpImplWallpaper->mpBitmap )
 363         return *(mpImplWallpaper->mpBitmap);
 364     else
 365     {
 366         BitmapEx aBmp;
 367         return aBmp;
 368     }
 369 }
 370
 371 // -----------------------------------------------------------------------
 372
 373 sal_Bool Wallpaper::IsBitmap() const
 374 {
 375     DBG_CHKTHIS( Wallpaper, NULL );
 376
 377     return (mpImplWallpaper->mpBitmap != 0);
 378 }
 379
 380
 381 // -----------------------------------------------------------------------
 382
 383 void Wallpaper::SetGradient( const Gradient& rGradient )
 384 {
 385     DBG_CHKTHIS( Wallpaper, NULL );
 386
 387     ImplMakeUnique();
 388
 389     if ( mpImplWallpaper->mpGradient )
 390         *(mpImplWallpaper->mpGradient) = rGradient;
 391     else
 392         mpImplWallpaper->mpGradient = new Gradient( rGradient );
 393
 394     if( WALLPAPER_NULL == mpImplWallpaper->meStyle || WALLPAPER_APPLICATIONGRADIENT == mpImplWallpaper->meStyle )
 395         mpImplWallpaper->meStyle = WALLPAPER_TILE;
 396 }
 397
 398 // -----------------------------------------------------------------------
 399
 400 Gradient Wallpaper::GetGradient() const
 401 {
 402     DBG_CHKTHIS( Wallpaper, NULL );
 403
 404     if( WALLPAPER_APPLICATIONGRADIENT == mpImplWallpaper->meStyle )
 405         return ImplGetApplicationGradient();
 406     else if ( mpImplWallpaper->mpGradient )
 407         return *(mpImplWallpaper->mpGradient);
 408     else
 409     {
 410         Gradient aGradient;
 411         return aGradient;
 412     }
 413 }
 414
 415 // -----------------------------------------------------------------------
 416
 417 sal_Bool Wallpaper::IsGradient() const
 418 {
 419     DBG_CHKTHIS( Wallpaper, NULL );
 420
 421     return (mpImplWallpaper->mpGradient != 0);
 422 }
 423
 424
 425 // -----------------------------------------------------------------------
 426
 427 Gradient Wallpaper::ImplGetApplicationGradient() const
 428 {
 429     Gradient g;
 430     g.SetAngle( 900 );
 431     g.SetStyle( GradientStyle_LINEAR );
 432     g.SetStartColor( Application::GetSettings().GetStyleSettings().GetFaceColor() );
 433     // no 'extreme' gradient when high contrast
 434     if( Application::GetSettings().GetStyleSettings().GetHighContrastMode() )
 435         g.SetEndColor( Application::GetSettings().GetStyleSettings().GetFaceColor() );
 436     else
 437         g.SetEndColor( Application::GetSettings().GetStyleSettings().GetFaceGradientColor() );
 438     return g;
 439 }
 440
 441 // -----------------------------------------------------------------------
 442
 443 void Wallpaper::SetRect( const Rectangle& rRect )
 444 {
 445     DBG_CHKTHIS( Wallpaper, NULL );
 446
 447     ImplMakeUnique( sal_False );
 448
 449     if ( rRect.IsEmpty() )
 450     {
 451         if ( mpImplWallpaper->mpRect )
 452         {
 453             delete mpImplWallpaper->mpRect;
 454             mpImplWallpaper->mpRect = NULL;
 455         }
 456     }
 457     else
 458     {
 459         if ( mpImplWallpaper->mpRect )
 460             *(mpImplWallpaper->mpRect) = rRect;
 461         else
 462             mpImplWallpaper->mpRect = new Rectangle( rRect );
 463     }
 464 }
 465
 466 // -----------------------------------------------------------------------
 467
 468 Rectangle Wallpaper::GetRect() const
 469 {
 470     DBG_CHKTHIS( Wallpaper, NULL );
 471
 472     if ( mpImplWallpaper->mpRect )
 473         return *(mpImplWallpaper->mpRect);
 474     else
 475     {
 476         Rectangle aRect;
 477         return aRect;
 478     }
 479 }
 480
 481 // -----------------------------------------------------------------------
 482
 483 sal_Bool Wallpaper::IsRect() const
 484 {
 485     DBG_CHKTHIS( Wallpaper, NULL );
 486
 487     return (mpImplWallpaper->mpRect != 0);
 488 }
 489
 490
 491 // -----------------------------------------------------------------------
 492
 493 sal_Bool Wallpaper::IsFixed() const
 494 {
 495     if ( mpImplWallpaper->meStyle == WALLPAPER_NULL )
 496         return sal_False;
 497     else
 498         return (!mpImplWallpaper->mpBitmap && !mpImplWallpaper->mpGradient);
 499 }
 500
 501 // -----------------------------------------------------------------------
 502
 503 sal_Bool Wallpaper::IsScrollable() const
 504 {
 505     if ( mpImplWallpaper->meStyle == WALLPAPER_NULL )
 506         return sal_False;
 507     else if ( !mpImplWallpaper->mpBitmap && !mpImplWallpaper->mpGradient )
 508         return sal_True;
 509     else if ( mpImplWallpaper->mpBitmap )
 510         return (mpImplWallpaper->meStyle == WALLPAPER_TILE);
 511     else
 512         return sal_False;
 513 }
 514
 515 // -----------------------------------------------------------------------
 516
 517 Wallpaper& Wallpaper::operator=( const Wallpaper& rWallpaper )
 518 {
 519     DBG_CHKTHIS( Wallpaper, NULL );
 520     DBG_CHKOBJ( &rWallpaper, Wallpaper, NULL );
 521     DBG_ASSERT( rWallpaper.mpImplWallpaper->mnRefCount < 0xFFFFFFFE, "Wallpaper: RefCount overflow" );
 522
 523     // Zuerst Referenzcounter erhoehen, damit man sich selbst zuweisen kann
 524     if ( rWallpaper.mpImplWallpaper->mnRefCount )
 525         rWallpaper.mpImplWallpaper->mnRefCount++;
 526
 527     // Wenn es keine statischen ImpDaten sind, dann loeschen, wenn es
 528     // die letzte Referenz ist, sonst Referenzcounter decrementieren
 529     if ( mpImplWallpaper->mnRefCount )
 530     {
 531         if ( mpImplWallpaper->mnRefCount == 1 )
 532             delete mpImplWallpaper;
 533         else
 534             mpImplWallpaper->mnRefCount--;
 535     }
 536
 537     mpImplWallpaper = rWallpaper.mpImplWallpaper;
 538
 539     return *this;
 540 }
 541
 542 // -----------------------------------------------------------------------
 543
 544 sal_Bool Wallpaper::operator==( const Wallpaper& rWallpaper ) const
 545 {
 546     DBG_CHKTHIS( Wallpaper, NULL );
 547     DBG_CHKOBJ( &rWallpaper, Wallpaper, NULL );
 548
 549     if ( mpImplWallpaper == rWallpaper.mpImplWallpaper )
 550         return sal_True;
 551
 552     if ( ( mpImplWallpaper->meStyle != rWallpaper.mpImplWallpaper->meStyle ) ||
 553          ( mpImplWallpaper->maColor != rWallpaper.mpImplWallpaper->maColor ) )
 554         return sal_False;
 555
 556     if ( mpImplWallpaper->mpRect != rWallpaper.mpImplWallpaper->mpRect
 557          && ( !mpImplWallpaper->mpRect
 558               || !rWallpaper.mpImplWallpaper->mpRect
 559               || *(mpImplWallpaper->mpRect) != *(rWallpaper.mpImplWallpaper->mpRect) ) )
 560         return sal_False;
 561
 562     if ( mpImplWallpaper->mpBitmap != rWallpaper.mpImplWallpaper->mpBitmap
 563          && ( !mpImplWallpaper->mpBitmap
 564               || !rWallpaper.mpImplWallpaper->mpBitmap
 565               || *(mpImplWallpaper->mpBitmap) != *(rWallpaper.mpImplWallpaper->mpBitmap) ) )
 566         return sal_False;
 567
 568     if ( mpImplWallpaper->mpGradient != rWallpaper.mpImplWallpaper->mpGradient
 569          && ( !mpImplWallpaper->mpGradient
 570               || !rWallpaper.mpImplWallpaper->mpGradient
 571               || *(mpImplWallpaper->mpGradient) != *(rWallpaper.mpImplWallpaper->mpGradient) ) )
 572         return sal_False;
 573
 574     return sal_True;
 575 }
 576
 577 // -----------------------------------------------------------------------
 578
 579 SvStream& operator>>( SvStream& rIStm, Wallpaper& rWallpaper )
 580 {
 581     rWallpaper.ImplMakeUnique();
 582     return( rIStm >> *rWallpaper.mpImplWallpaper );
 583 }
 584
 585 // -----------------------------------------------------------------------
 586
 587 SvStream& operator<<( SvStream& rOStm, const Wallpaper& rWallpaper )
 588 {
 589     return( rOStm << *rWallpaper.mpImplWallpaper );
 590 }
 591
 592 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */