vcl/source/gdi/graph.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: graph.cxx,v $
  10  * $Revision: 1.16 $
  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_vcl.hxx"
  33 #include <vcl/impgraph.hxx>
  34 #include <vcl/outdev.hxx>
  35 #include <vcl/svapp.hxx>
  36 #include <vcl/graph.hxx>
  37 #include <comphelper/processfactory.hxx>
  38 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  39 #include <com/sun/star/graphic/XGraphicProvider.hpp>
  40 #include <com/sun/star/lang/XUnoTunnel.hpp>
  41 #include <com/sun/star/lang/XTypeProvider.hpp>
  42 #include <com/sun/star/graphic/XGraphic.hpp>
  43
  44 // -----------------------
  45 // - Compression defines -
  46 // -----------------------
  47
  48 #define COMPRESS_OWN                ('S'|('D'<<8UL))
  49 #define COMPRESS_NONE               ( 0UL )
  50 #define RLE_8                       ( 1UL )
  51 #define RLE_4                       ( 2UL )
  52 #define BITFIELDS                   ( 3UL )
  53 #define ZCOMPRESS                   ( COMPRESS_OWN | 0x01000000UL ) /* == 'SD01' (binary) */
  54
  55 using namespace ::com::sun::star;
  56
  57 // -----------------------
  58 // - Default-Drawmethode -
  59 // -----------------------
  60
  61 static void ImplDrawDefault( OutputDevice* pOutDev, const UniString* pText,
  62                              Font* pFont, const Bitmap* pBitmap, const BitmapEx* pBitmapEx,
  63                              const Point& rDestPt, const Size& rDestSize )
  64 {
  65     USHORT      nPixel = (USHORT) pOutDev->PixelToLogic( Size( 1, 1 ) ).Width();
  66     USHORT      nPixelWidth = nPixel;
  67     Point       aPoint( rDestPt.X() + nPixelWidth, rDestPt.Y() + nPixelWidth );
  68     Size        aSize( rDestSize.Width() - ( nPixelWidth << 1 ), rDestSize.Height() - ( nPixelWidth << 1 ) );
  69     BOOL        bFilled = ( pBitmap != NULL || pBitmapEx != NULL || pFont != NULL );
  70     Rectangle   aBorderRect( aPoint, aSize );
  71
  72     pOutDev->Push();
  73
  74     pOutDev->SetFillColor();
  75
  76     // Auf dem Drucker ein schwarzes Rechteck und auf dem Bildschirm eins mit 3D-Effekt
  77     if ( pOutDev->GetOutDevType() == OUTDEV_PRINTER )
  78         pOutDev->SetLineColor( COL_BLACK );
  79     else
  80     {
  81         aBorderRect.Left() += nPixel;
  82         aBorderRect.Top() += nPixel;
  83
  84         pOutDev->SetLineColor( COL_LIGHTGRAY );
  85         pOutDev->DrawRect( aBorderRect );
  86
  87         aBorderRect.Left() -= nPixel;
  88         aBorderRect.Top() -= nPixel;
  89         aBorderRect.Right() -= nPixel;
  90         aBorderRect.Bottom() -= nPixel;
  91         pOutDev->SetLineColor( COL_GRAY );
  92     }
  93
  94     pOutDev->DrawRect( aBorderRect );
  95
  96     aPoint.X() += nPixelWidth + 2*nPixel;
  97     aPoint.Y() += nPixelWidth + 2*nPixel;
  98     aSize.Width() -= 2*nPixelWidth + 4*nPixel;
  99     aSize.Height() -= 2*nPixelWidth + 4*nPixel;
 100
 101     if( aSize.Width() > 0 && aSize.Height() > 0
 102         && (  ( pBitmap && !!*pBitmap ) || ( pBitmapEx && !!*pBitmapEx ) ) )
 103     {
 104         Size aBitmapSize( pOutDev->PixelToLogic( pBitmap ? pBitmap->GetSizePixel() : pBitmapEx->GetSizePixel() ) );
 105
 106         if( aSize.Height() > aBitmapSize.Height() && aSize.Width() > aBitmapSize.Width() )
 107         {
 108             if ( pBitmap )
 109                 pOutDev->DrawBitmap( aPoint, *pBitmap );
 110             else
 111                 pOutDev->DrawBitmapEx( aPoint, *pBitmapEx );
 112             aPoint.X() += aBitmapSize.Width() + 2*nPixel;
 113             aSize.Width() -= aBitmapSize.Width() + 2*nPixel;
 114         }
 115     }
 116
 117     if ( aSize.Width() > 0 && aSize.Height() > 0 && pFont && pText && pText->Len()
 118          && !(!pOutDev->IsOutputEnabled() /*&& pOutDev->GetConnectMetaFile() */) )
 119     {
 120         MapMode aMapMode( MAP_POINT );
 121         Size    aSz = pOutDev->LogicToLogic( Size( 0, 12 ), &aMapMode, NULL );
 122         long    nThreshold = aSz.Height() / 2;
 123         long    nStep = nThreshold / 3;
 124
 125         if ( !nStep )
 126             nStep = aSz.Height() - nThreshold;
 127
 128         for(;; aSz.Height() -= nStep )
 129         {
 130             pFont->SetSize( aSz );
 131             pOutDev->SetFont( *pFont );
 132
 133             long nTextHeight = pOutDev->GetTextHeight();
 134             long nTextWidth = pOutDev->GetTextWidth( *pText );
 135             if ( nTextHeight )
 136             {
 137                 // Die N"aherung ber"ucksichtigt keine Ungenauigkeiten durch
 138                 // Wortumbr"uche
 139                 long nLines = aSize.Height() / nTextHeight;
 140                 long nWidth = aSize.Width() * nLines; // N"aherung!!!
 141
 142                 if ( nTextWidth <= nWidth || aSz.Height() <= nThreshold )
 143                 {
 144                     USHORT nStart = 0;
 145                     USHORT nLen = 0;
 146
 147                     while( nStart < pText->Len() && pText->GetChar( nStart ) == ' ' )
 148                         nStart++;
 149                     while( nStart+nLen < pText->Len() && pText->GetChar( nStart+nLen ) != ' ' )
 150                         nLen++;
 151                     while( nStart < pText->Len() && nLines-- )
 152                     {
 153                         USHORT nNext = nLen;
 154                         do
 155                         {
 156                             while ( nStart+nNext < pText->Len() && pText->GetChar( nStart+nNext ) == ' ' )
 157                                 nNext++;
 158                             while ( nStart+nNext < pText->Len() && pText->GetChar( nStart+nNext ) != ' ' )
 159                                 nNext++;
 160                             nTextWidth = pOutDev->GetTextWidth( *pText, nStart, nNext );
 161                             if ( nTextWidth > aSize.Width() )
 162                                 break;
 163                             nLen = nNext;
 164                         }
 165                         while ( nStart+nNext < pText->Len() );
 166
 167                         USHORT n = nLen;
 168                         nTextWidth = pOutDev->GetTextWidth( *pText, nStart, n );
 169                         while( nTextWidth > aSize.Width() )
 170                             nTextWidth = pOutDev->GetTextWidth( *pText, nStart, --n );
 171                         pOutDev->DrawText( aPoint, *pText, nStart, n );
 172
 173                         aPoint.Y() += nTextHeight;
 174                         nStart      = sal::static_int_cast<USHORT>(nStart + nLen);
 175                         nLen        = nNext-nLen;
 176                         while( nStart < pText->Len() && pText->GetChar( nStart ) == ' ' )
 177                         {
 178                             nStart++;
 179                             nLen--;
 180                         }
 181                     }
 182                     break;
 183                 }
 184             }
 185             else
 186                 break;
 187         }
 188     }
 189
 190     // Falls die Default-Graphik keinen Inhalt hat,
 191     // malen wir ein rotes Kreuz
 192     if( !bFilled )
 193     {
 194         aBorderRect.Left()++;
 195         aBorderRect.Top()++;
 196         aBorderRect.Right()--;
 197         aBorderRect.Bottom()--;
 198
 199         pOutDev->SetLineColor( COL_LIGHTRED );
 200         pOutDev->DrawLine( aBorderRect.TopLeft(), aBorderRect.BottomRight() );
 201         pOutDev->DrawLine( aBorderRect.TopRight(), aBorderRect.BottomLeft() );
 202     }
 203
 204     pOutDev->Pop();
 205 }
 206
 207 // -----------
 208 // - Graphic -
 209 // -----------
 210
 211 TYPEINIT1_AUTOFACTORY( Graphic, SvDataCopyStream );
 212
 213 // ------------------------------------------------------------------------
 214
 215 Graphic::Graphic()
 216 {
 217     mpImpGraphic = new ImpGraphic;
 218 }
 219
 220 // ------------------------------------------------------------------------
 221
 222 Graphic::Graphic( const Graphic& rGraphic ) :
 223 SvDataCopyStream()
 224 {
 225     if( rGraphic.IsAnimated() )
 226         mpImpGraphic = new ImpGraphic( *rGraphic.mpImpGraphic );
 227     else
 228     {
 229         mpImpGraphic = rGraphic.mpImpGraphic;
 230         mpImpGraphic->mnRefCount++;
 231     }
 232 }
 233
 234 // ------------------------------------------------------------------------
 235
 236 Graphic::Graphic( const Bitmap& rBmp )
 237 {
 238     mpImpGraphic = new ImpGraphic( rBmp );
 239 }
 240
 241 // ------------------------------------------------------------------------
 242
 243 Graphic::Graphic( const BitmapEx& rBmpEx )
 244 {
 245     mpImpGraphic = new ImpGraphic( rBmpEx );
 246 }
 247
 248 // ------------------------------------------------------------------------
 249
 250 Graphic::Graphic( const Animation& rAnimation )
 251 {
 252     mpImpGraphic = new ImpGraphic( rAnimation );
 253 }
 254
 255 // ------------------------------------------------------------------------
 256
 257 Graphic::Graphic( const GDIMetaFile& rMtf )
 258 {
 259     mpImpGraphic = new ImpGraphic( rMtf );
 260 }
 261
 262 // ------------------------------------------------------------------------
 263
 264 Graphic::Graphic( const ::com::sun::star::uno::Reference< ::com::sun::star::graphic::XGraphic >& rxGraphic )
 265 {
 266     uno::Reference< lang::XUnoTunnel >          xTunnel( rxGraphic, uno::UNO_QUERY );
 267     uno::Reference< lang::XTypeProvider >       xProv( rxGraphic, uno::UNO_QUERY );
 268     const ::Graphic*                                            pGraphic = ( ( xTunnel.is() && xProv.is() ) ?
 269                                                          reinterpret_cast< ::Graphic* >( xTunnel->getSomething( xProv->getImplementationId() ) ) :
 270                                                           NULL );
 271
 272     if( pGraphic )
 273     {
 274         if( pGraphic->IsAnimated() )
 275             mpImpGraphic = new ImpGraphic( *pGraphic->mpImpGraphic );
 276         else
 277         {
 278             mpImpGraphic = pGraphic->mpImpGraphic;
 279             mpImpGraphic->mnRefCount++;
 280         }
 281     }
 282     else
 283         mpImpGraphic = new ImpGraphic;
 284 }
 285
 286 // ------------------------------------------------------------------------
 287
 288 Graphic::~Graphic()
 289 {
 290     if( mpImpGraphic->mnRefCount == 1UL )
 291         delete mpImpGraphic;
 292     else
 293         mpImpGraphic->mnRefCount--;
 294 }
 295
 296 // ------------------------------------------------------------------------
 297
 298 void Graphic::ImplTestRefCount()
 299 {
 300     if( mpImpGraphic->mnRefCount > 1UL )
 301     {
 302         mpImpGraphic->mnRefCount--;
 303         mpImpGraphic = new ImpGraphic( *mpImpGraphic );
 304     }
 305 }
 306
 307 // ------------------------------------------------------------------------
 308
 309 Graphic& Graphic::operator=( const Graphic& rGraphic )
 310 {
 311     if( &rGraphic != this )
 312     {
 313         if( rGraphic.IsAnimated() )
 314         {
 315             if( mpImpGraphic->mnRefCount == 1UL )
 316                 delete mpImpGraphic;
 317             else
 318                 mpImpGraphic->mnRefCount--;
 319
 320             mpImpGraphic = new ImpGraphic( *rGraphic.mpImpGraphic );
 321         }
 322         else
 323         {
 324             rGraphic.mpImpGraphic->mnRefCount++;
 325
 326             if( mpImpGraphic->mnRefCount == 1UL )
 327                 delete mpImpGraphic;
 328             else
 329                 mpImpGraphic->mnRefCount--;
 330
 331             mpImpGraphic = rGraphic.mpImpGraphic;
 332         }
 333     }
 334
 335     return *this;
 336 }
 337
 338 // ------------------------------------------------------------------------
 339
 340 BOOL Graphic::operator==( const Graphic& rGraphic ) const
 341 {
 342     return( *mpImpGraphic == *rGraphic.mpImpGraphic );
 343 }
 344
 345 // ------------------------------------------------------------------------
 346
 347 BOOL Graphic::operator!=( const Graphic& rGraphic ) const
 348 {
 349     return( *mpImpGraphic != *rGraphic.mpImpGraphic );
 350 }
 351
 352 // ------------------------------------------------------------------------
 353
 354 BOOL Graphic::operator!() const
 355 {
 356     return( GRAPHIC_NONE == mpImpGraphic->ImplGetType() );
 357 }
 358
 359 // ------------------------------------------------------------------------
 360
 361 void Graphic::Load( SvStream& rIStm )
 362 {
 363     rIStm >> *this;
 364 }
 365
 366 // ------------------------------------------------------------------------
 367
 368 void Graphic::Save( SvStream& rOStm )
 369 {
 370     rOStm << *this;
 371 }
 372
 373 // ------------------------------------------------------------------------
 374
 375 void Graphic::Assign( const SvDataCopyStream& rCopyStream )
 376 {
 377     *this = (const Graphic& ) rCopyStream;
 378 }
 379
 380 // ------------------------------------------------------------------------
 381
 382 void Graphic::Clear()
 383 {
 384     ImplTestRefCount();
 385     mpImpGraphic->ImplClear();
 386 }
 387
 388 // ------------------------------------------------------------------------
 389
 390 GraphicType Graphic::GetType() const
 391 {
 392     return mpImpGraphic->ImplGetType();
 393 }
 394
 395 // ------------------------------------------------------------------------
 396
 397 void Graphic::SetDefaultType()
 398 {
 399     ImplTestRefCount();
 400     mpImpGraphic->ImplSetDefaultType();
 401 }
 402
 403 // ------------------------------------------------------------------------
 404
 405 BOOL Graphic::IsSupportedGraphic() const
 406 {
 407     return mpImpGraphic->ImplIsSupportedGraphic();
 408 }
 409
 410 // ------------------------------------------------------------------------
 411
 412 BOOL Graphic::IsTransparent() const
 413 {
 414     return mpImpGraphic->ImplIsTransparent();
 415 }
 416
 417 // ------------------------------------------------------------------------
 418
 419 BOOL Graphic::IsAlpha() const
 420 {
 421     return mpImpGraphic->ImplIsAlpha();
 422 }
 423
 424 // ------------------------------------------------------------------------
 425
 426 BOOL Graphic::IsAnimated() const
 427 {
 428     return mpImpGraphic->ImplIsAnimated();
 429 }
 430
 431 // ------------------------------------------------------------------------
 432
 433 Bitmap Graphic::GetBitmap(const GraphicConversionParameters& rParameters) const
 434 {
 435     return mpImpGraphic->ImplGetBitmap(rParameters);
 436 }
 437
 438 // ------------------------------------------------------------------------
 439
 440 BitmapEx Graphic::GetBitmapEx(const GraphicConversionParameters& rParameters) const
 441 {
 442     return mpImpGraphic->ImplGetBitmapEx(rParameters);
 443 }
 444
 445 // ------------------------------------------------------------------------
 446
 447 Animation Graphic::GetAnimation() const
 448 {
 449     return mpImpGraphic->ImplGetAnimation();
 450 }
 451
 452 // ------------------------------------------------------------------------
 453
 454 const GDIMetaFile& Graphic::GetGDIMetaFile() const
 455 {
 456     return mpImpGraphic->ImplGetGDIMetaFile();
 457 }
 458
 459 // ------------------------------------------------------------------------
 460
 461 uno::Reference< graphic::XGraphic > Graphic::GetXGraphic() const
 462 {
 463     uno::Reference< graphic::XGraphic > xRet;
 464
 465     if( GetType() != GRAPHIC_NONE )
 466     {
 467         uno::Reference < lang::XMultiServiceFactory > xMSF( ::comphelper::getProcessServiceFactory() );
 468
 469         if( xMSF.is() )
 470         {
 471             uno::Reference< graphic::XGraphicProvider > xProv( xMSF->createInstance(
 472                 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.graphic.GraphicProvider" ) ) ),
 473                 uno::UNO_QUERY );
 474
 475             if( xProv.is() )
 476             {
 477                 uno::Sequence< beans::PropertyValue >   aLoadProps( 1 );
 478                 ::rtl::OUString                                                 aURL( RTL_CONSTASCII_USTRINGPARAM( "private:memorygraphic/" ) );
 479
 480                 aLoadProps[ 0 ].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "URL" ) );
 481                 aLoadProps[ 0 ].Value <<= ( aURL += ::rtl::OUString::valueOf( reinterpret_cast< sal_Int64 >( this ) ) );
 482
 483                 xRet = xProv->queryGraphic( aLoadProps );
 484             }
 485         }
 486     }
 487
 488     return xRet;
 489 }
 490
 491 // ------------------------------------------------------------------------
 492
 493 Size Graphic::GetPrefSize() const
 494 {
 495     return mpImpGraphic->ImplGetPrefSize();
 496 }
 497
 498 // ------------------------------------------------------------------------
 499
 500 void Graphic::SetPrefSize( const Size& rPrefSize )
 501 {
 502     ImplTestRefCount();
 503     mpImpGraphic->ImplSetPrefSize( rPrefSize );
 504 }
 505
 506 // ------------------------------------------------------------------------
 507
 508 MapMode Graphic::GetPrefMapMode() const
 509 {
 510     return mpImpGraphic->ImplGetPrefMapMode();
 511 }
 512
 513 // ------------------------------------------------------------------------
 514
 515 void Graphic::SetPrefMapMode( const MapMode& rPrefMapMode )
 516 {
 517     ImplTestRefCount();
 518     mpImpGraphic->ImplSetPrefMapMode( rPrefMapMode );
 519 }
 520
 521 // ------------------------------------------------------------------
 522
 523 Size Graphic::GetSizePixel( const OutputDevice* pRefDevice ) const
 524 {
 525     Size aRet;
 526
 527     if( GRAPHIC_BITMAP == mpImpGraphic->ImplGetType() )
 528         aRet = mpImpGraphic->ImplGetBitmapEx(GraphicConversionParameters()).GetSizePixel();
 529     else
 530         aRet = ( pRefDevice ? pRefDevice : Application::GetDefaultDevice() )->LogicToPixel( GetPrefSize(), GetPrefMapMode() );
 531
 532     return aRet;
 533 }
 534
 535 // ------------------------------------------------------------------
 536
 537 ULONG Graphic::GetSizeBytes() const
 538 {
 539     return mpImpGraphic->ImplGetSizeBytes();
 540 }
 541
 542 // ------------------------------------------------------------------------
 543
 544 void Graphic::Draw( OutputDevice* pOutDev, const Point& rDestPt ) const
 545 {
 546     mpImpGraphic->ImplDraw( pOutDev, rDestPt );
 547 }
 548
 549 // ------------------------------------------------------------------------
 550
 551 void Graphic::Draw( OutputDevice* pOutDev,
 552                     const Point& rDestPt, const Size& rDestSz ) const
 553 {
 554     if( GRAPHIC_DEFAULT == mpImpGraphic->ImplGetType() )
 555         ImplDrawDefault( pOutDev, NULL, NULL, NULL, NULL, rDestPt, rDestSz );
 556     else
 557         mpImpGraphic->ImplDraw( pOutDev, rDestPt, rDestSz );
 558 }
 559
 560 // ------------------------------------------------------------------------
 561
 562 void Graphic::Draw( OutputDevice* pOutDev, const String& rText,
 563                     Font& rFont, const Bitmap& rBitmap,
 564                     const Point& rDestPt, const Size& rDestSz )
 565 {
 566     ImplDrawDefault( pOutDev, &rText, &rFont, &rBitmap, NULL, rDestPt, rDestSz );
 567 }
 568
 569 // ------------------------------------------------------------------------
 570
 571 void Graphic::DrawEx( OutputDevice* pOutDev, const String& rText,
 572                     Font& rFont, const BitmapEx& rBitmap,
 573                     const Point& rDestPt, const Size& rDestSz )
 574 {
 575     ImplDrawDefault( pOutDev, &rText, &rFont, NULL, &rBitmap, rDestPt, rDestSz );
 576 }
 577
 578 // ------------------------------------------------------------------------
 579
 580 void Graphic::StartAnimation( OutputDevice* pOutDev, const Point& rDestPt, long nExtraData,
 581                               OutputDevice* pFirstFrameOutDev )
 582 {
 583     ImplTestRefCount();
 584     mpImpGraphic->ImplStartAnimation( pOutDev, rDestPt, nExtraData, pFirstFrameOutDev );
 585 }
 586
 587 // ------------------------------------------------------------------------
 588
 589 void Graphic::StartAnimation( OutputDevice* pOutDev, const Point& rDestPt,
 590                               const Size& rDestSz, long nExtraData,
 591                               OutputDevice* pFirstFrameOutDev )
 592 {
 593     ImplTestRefCount();
 594     mpImpGraphic->ImplStartAnimation( pOutDev, rDestPt, rDestSz, nExtraData, pFirstFrameOutDev );
 595 }
 596
 597 // ------------------------------------------------------------------------
 598
 599 void Graphic::StopAnimation( OutputDevice* pOutDev, long nExtraData )
 600 {
 601     ImplTestRefCount();
 602     mpImpGraphic->ImplStopAnimation( pOutDev, nExtraData );
 603 }
 604
 605 // ------------------------------------------------------------------------
 606
 607 void Graphic::SetAnimationNotifyHdl( const Link& rLink )
 608 {
 609     mpImpGraphic->ImplSetAnimationNotifyHdl( rLink );
 610 }
 611
 612 // ------------------------------------------------------------------------
 613
 614 Link Graphic::GetAnimationNotifyHdl() const
 615 {
 616     return mpImpGraphic->ImplGetAnimationNotifyHdl();
 617 }
 618
 619 // ------------------------------------------------------------------------
 620
 621 ULONG Graphic::GetAnimationLoopCount() const
 622 {
 623     return mpImpGraphic->ImplGetAnimationLoopCount();
 624 }
 625
 626 // ------------------------------------------------------------------------
 627
 628 void Graphic::ResetAnimationLoopCount()
 629 {
 630     mpImpGraphic->ImplResetAnimationLoopCount();
 631 }
 632
 633 // ------------------------------------------------------------------------
 634
 635 List* Graphic::GetAnimationInfoList() const
 636 {
 637     return mpImpGraphic->ImplGetAnimationInfoList();
 638 }
 639
 640 // ------------------------------------------------------------------------
 641
 642 GraphicReader* Graphic::GetContext()
 643 {
 644     return mpImpGraphic->ImplGetContext();
 645 }
 646
 647 // ------------------------------------------------------------------------
 648
 649 void Graphic::SetContext( GraphicReader* pReader )
 650 {
 651     mpImpGraphic->ImplSetContext( pReader );
 652 }
 653
 654 // ------------------------------------------------------------------------
 655
 656 USHORT Graphic::GetGraphicsCompressMode( SvStream& rIStm )
 657 {
 658     const ULONG     nPos = rIStm.Tell();
 659     const USHORT    nOldFormat = rIStm.GetNumberFormatInt();
 660     UINT32          nTmp32;
 661     UINT16          nTmp16;
 662     USHORT          nCompressMode = COMPRESSMODE_NONE;
 663
 664     rIStm.SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );
 665
 666     rIStm >> nTmp32;
 667
 668     // is it a swapped graphic with a bitmap?
 669     rIStm.SeekRel( (nTmp32 == (UINT32) GRAPHIC_BITMAP ) ? 40 : -4 );
 670
 671     // try to read bitmap id
 672     rIStm >> nTmp16;
 673
 674     // check id of BitmapFileHeader
 675     if( 0x4D42 == nTmp16 )
 676     {
 677         // seek to compress field of BitmapInfoHeader
 678         rIStm.SeekRel( 28 );
 679         rIStm >> nTmp32;
 680
 681         // Compare with our own compressmode
 682         if( ZCOMPRESS == nTmp32 )
 683             nCompressMode = COMPRESSMODE_ZBITMAP;
 684     }
 685
 686     rIStm.SetNumberFormatInt( nOldFormat );
 687     rIStm.Seek( nPos );
 688
 689     return nCompressMode;
 690 }
 691
 692 // ------------------------------------------------------------------------
 693
 694 void Graphic::SetDocFileName( const String& rName, ULONG nFilePos )
 695 {
 696     mpImpGraphic->ImplSetDocFileName( rName, nFilePos );
 697 }
 698
 699 // ------------------------------------------------------------------------
 700
 701 const String& Graphic::GetDocFileName() const
 702 {
 703     return mpImpGraphic->ImplGetDocFileName();
 704 }
 705
 706 // ------------------------------------------------------------------------
 707
 708 ULONG Graphic::GetDocFilePos() const
 709 {
 710     return mpImpGraphic->ImplGetDocFilePos();
 711 }
 712
 713 // ------------------------------------------------------------------------
 714
 715 BOOL Graphic::ReadEmbedded( SvStream& rIStream, BOOL bSwap )
 716 {
 717     ImplTestRefCount();
 718     return mpImpGraphic->ImplReadEmbedded( rIStream, bSwap );
 719 }
 720
 721 // ------------------------------------------------------------------------
 722
 723 BOOL Graphic::WriteEmbedded( SvStream& rOStream )
 724 {
 725     ImplTestRefCount();
 726     return mpImpGraphic->ImplWriteEmbedded( rOStream );
 727 }
 728
 729 // ------------------------------------------------------------------------
 730
 731 BOOL Graphic::SwapOut()
 732 {
 733     ImplTestRefCount();
 734     return mpImpGraphic->ImplSwapOut();
 735 }
 736
 737 // ------------------------------------------------------------------------
 738
 739 BOOL Graphic::SwapOut( SvStream* pOStream )
 740 {
 741     ImplTestRefCount();
 742     return mpImpGraphic->ImplSwapOut( pOStream );
 743 }
 744
 745 // ------------------------------------------------------------------------
 746
 747 BOOL Graphic::SwapIn()
 748 {
 749     ImplTestRefCount();
 750     return mpImpGraphic->ImplSwapIn();
 751 }
 752
 753 // ------------------------------------------------------------------------
 754
 755 BOOL Graphic::SwapIn( SvStream* pStrm )
 756 {
 757     ImplTestRefCount();
 758     return mpImpGraphic->ImplSwapIn( pStrm );
 759 }
 760
 761 // ------------------------------------------------------------------------
 762
 763 BOOL Graphic::IsSwapOut() const
 764 {
 765     return mpImpGraphic->ImplIsSwapOut();
 766 }
 767
 768 // ------------------------------------------------------------------------
 769
 770 void Graphic::SetLink( const GfxLink& rGfxLink )
 771 {
 772     ImplTestRefCount();
 773     mpImpGraphic->ImplSetLink( rGfxLink );
 774 }
 775
 776 // ------------------------------------------------------------------------
 777
 778 GfxLink Graphic::GetLink() const
 779 {
 780     return mpImpGraphic->ImplGetLink();
 781 }
 782
 783 // ------------------------------------------------------------------------
 784
 785 BOOL Graphic::IsLink() const
 786 {
 787     return mpImpGraphic->ImplIsLink();
 788 }
 789
 790 // ------------------------------------------------------------------------
 791
 792 ULONG Graphic::GetChecksum() const
 793 {
 794     return mpImpGraphic->ImplGetChecksum();
 795 }
 796
 797 // ------------------------------------------------------------------------
 798
 799 BOOL Graphic::ExportNative( SvStream& rOStream ) const
 800 {
 801     return mpImpGraphic->ImplExportNative( rOStream );
 802 }
 803
 804 // ------------------------------------------------------------------------
 805
 806 SvStream& operator>>( SvStream& rIStream, Graphic& rGraphic )
 807 {
 808     rGraphic.ImplTestRefCount();
 809     return rIStream >> *rGraphic.mpImpGraphic;
 810 }
 811
 812 // ------------------------------------------------------------------------
 813
 814 SvStream& operator<<( SvStream& rOStream, const Graphic& rGraphic )
 815 {
 816     return rOStream << *rGraphic.mpImpGraphic;
 817 }