svtools/source/misc/imap.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/urlobj.hxx>
  22 #include <vcl/svapp.hxx>
  23 #include <vcl/mapmod.hxx>
  24 #include <vcl/window.hxx>
  25
  26 #include "svl/urihelper.hxx"
  27 #include <svtools/imap.hxx>
  28 #include <svtools/imapobj.hxx>
  29 #include <svtools/imapcirc.hxx>
  30 #include <svtools/imaprect.hxx>
  31 #include <svtools/imappoly.hxx>
  32
  33 #include <string.h>
  34 #include <math.h>
  35
  36 DBG_NAME( ImageMap )
  37
  38
  39 #define SCALEPOINT(aPT,aFracX,aFracY) (aPT).X()=((aPT).X()*(aFracX).GetNumerator())/(aFracX).GetDenominator();  \
  40                                       (aPT).Y()=((aPT).Y()*(aFracY).GetNumerator())/(aFracY).GetDenominator();
  41
  42
  43 /******************************************************************************/
  44
  45 sal_uInt16 IMapObject::nActualTextEncoding = (sal_uInt16) RTL_TEXTENCODING_DONTKNOW;
  46
  47 /******************************************************************************/
  48
  49
  50 IMapObject::IMapObject()
  51     : bActive( false )
  52     , nReadVersion( 0 )
  53 {
  54 }
  55
  56 IMapObject::IMapObject( const String& rURL, const String& rAltText, const String& rDesc,
  57                         const String& rTarget, const String& rName, sal_Bool bURLActive )
  58 : aURL( rURL )
  59 , aAltText( rAltText )
  60 , aDesc( rDesc )
  61 , aTarget( rTarget )
  62 , aName( rName )
  63 , bActive( bURLActive )
  64 , nReadVersion( 0 )
  65 {
  66 }
  67
  68
  69 /******************************************************************************
  70 |*
  71 |* Freigabe des internen Speichers
  72 |*
  73 \******************************************************************************/
  74
  75 sal_uInt16 IMapObject::GetVersion() const
  76 {
  77     return IMAP_OBJ_VERSION;
  78 }
  79
  80 void IMapObject::Write( SvStream& rOStm, const String& rBaseURL ) const
  81 {
  82     IMapCompat*             pCompat;
  83     const rtl_TextEncoding  eEncoding = osl_getThreadTextEncoding();
  84
  85     rOStm << GetType();
  86     rOStm << GetVersion();
  87     rOStm << ( (sal_uInt16) eEncoding );
  88
  89     const OString aRelURL = OUStringToOString(
  90         URIHelper::simpleNormalizedMakeRelative(rBaseURL, aURL), eEncoding);
  91     write_lenPrefixed_uInt8s_FromOString<sal_uInt16>(rOStm, aRelURL);
  92     write_lenPrefixed_uInt8s_FromOUString<sal_uInt16>(rOStm, aAltText, eEncoding);
  93     rOStm << bActive;
  94     write_lenPrefixed_uInt8s_FromOUString<sal_uInt16>(rOStm, aTarget, eEncoding);
  95
  96     pCompat = new IMapCompat( rOStm, STREAM_WRITE );
  97
  98     WriteIMapObject( rOStm );
  99     aEventList.Write( rOStm );                                      // V4
 100     write_lenPrefixed_uInt8s_FromOUString<sal_uInt16>(rOStm, aName, eEncoding); // V5
 101
 102     delete pCompat;
 103 }
 104
 105
 106 /******************************************************************************
 107 |*
 108 |*  Binaer-Import
 109 |*
 110 \******************************************************************************/
 111
 112 void IMapObject::Read( SvStream& rIStm, const String& rBaseURL )
 113 {
 114     IMapCompat*         pCompat;
 115     rtl_TextEncoding    nTextEncoding;
 116
 117     // Typ und Version ueberlesen wir
 118     rIStm.SeekRel( 2 );
 119     rIStm >> nReadVersion;
 120     rIStm >> nTextEncoding;
 121     aURL = read_lenPrefixed_uInt8s_ToOUString<sal_uInt16>(rIStm, nTextEncoding);
 122     aAltText = read_lenPrefixed_uInt8s_ToOUString<sal_uInt16>(rIStm, nTextEncoding);
 123     rIStm >> bActive;
 124     aTarget = read_lenPrefixed_uInt8s_ToOUString<sal_uInt16>(rIStm, nTextEncoding);
 125
 126     // URL absolut machen
 127     aURL = URIHelper::SmartRel2Abs( INetURLObject(rBaseURL), aURL, URIHelper::GetMaybeFileHdl(), true, false, INetURLObject::WAS_ENCODED, INetURLObject::DECODE_UNAMBIGUOUS );
 128     pCompat = new IMapCompat( rIStm, STREAM_READ );
 129
 130     ReadIMapObject( rIStm );
 131
 132     // ab Version 4 lesen wir eine EventListe
 133     if ( nReadVersion >= 0x0004 )
 134     {
 135         aEventList.Read(rIStm);
 136
 137         // ab Version 5 kann ein Objektname vorhanden sein
 138         if ( nReadVersion >= 0x0005 )
 139             aName = read_lenPrefixed_uInt8s_ToOUString<sal_uInt16>(rIStm, nTextEncoding);
 140     }
 141
 142     delete pCompat;
 143 }
 144
 145 sal_Bool IMapObject::IsEqual( const IMapObject& rEqObj )
 146 {
 147     return ( ( aURL == rEqObj.aURL ) &&
 148              ( aAltText == rEqObj.aAltText ) &&
 149              ( aDesc == rEqObj.aDesc ) &&
 150              ( aTarget == rEqObj.aTarget ) &&
 151              ( aName == rEqObj.aName ) &&
 152              ( bActive == rEqObj.bActive ) );
 153 }
 154
 155 IMapRectangleObject::IMapRectangleObject( const Rectangle& rRect,
 156                                           const String& rURL,
 157                                           const String& rAltText,
 158                                           const String& rDesc,
 159                                           const String& rTarget,
 160                                           const String& rName,
 161                                           sal_Bool bURLActive,
 162                                           sal_Bool bPixelCoords ) :
 163             IMapObject  ( rURL, rAltText, rDesc, rTarget, rName, bURLActive )
 164 {
 165     ImpConstruct( rRect, bPixelCoords );
 166 }
 167
 168 void IMapRectangleObject::ImpConstruct( const Rectangle& rRect, sal_Bool bPixel )
 169 {
 170     if ( bPixel )
 171         aRect = Application::GetDefaultDevice()->PixelToLogic( rRect, MapMode( MAP_100TH_MM ) );
 172     else
 173         aRect = rRect;
 174 }
 175
 176
 177 /******************************************************************************
 178 |*
 179 |* Binaer-Export
 180 |*
 181 \******************************************************************************/
 182
 183 void IMapRectangleObject::WriteIMapObject( SvStream& rOStm ) const
 184 {
 185     rOStm << aRect;
 186 }
 187
 188
 189 /******************************************************************************
 190 |*
 191 |* Binaer-Import
 192 |*
 193 \******************************************************************************/
 194
 195 void IMapRectangleObject::ReadIMapObject( SvStream& rIStm )
 196 {
 197     rIStm >> aRect;
 198 }
 199
 200
 201 /******************************************************************************
 202 |*
 203 |* Typ-Rueckgabe
 204 |*
 205 \******************************************************************************/
 206
 207 sal_uInt16 IMapRectangleObject::GetType() const
 208 {
 209     return IMAP_OBJ_RECTANGLE;
 210 }
 211
 212
 213 /******************************************************************************
 214 |*
 215 |* Hit-Test
 216 |*
 217 \******************************************************************************/
 218
 219 sal_Bool IMapRectangleObject::IsHit( const Point& rPoint ) const
 220 {
 221     return aRect.IsInside( rPoint );
 222 }
 223
 224 Rectangle IMapRectangleObject::GetRectangle( sal_Bool bPixelCoords ) const
 225 {
 226     Rectangle   aNewRect;
 227
 228     if ( bPixelCoords )
 229         aNewRect = Application::GetDefaultDevice()->LogicToPixel( aRect, MapMode( MAP_100TH_MM ) );
 230     else
 231         aNewRect = aRect;
 232
 233     return aNewRect;
 234 }
 235
 236 void IMapRectangleObject::Scale( const Fraction& rFracX, const Fraction& rFracY )
 237 {
 238     Point   aTL( aRect.TopLeft() );
 239     Point   aBR( aRect.BottomRight() );
 240
 241     if ( rFracX.GetDenominator() && rFracY.GetDenominator() )
 242     {
 243         SCALEPOINT( aTL, rFracX, rFracY );
 244         SCALEPOINT( aBR, rFracX, rFracY );
 245     }
 246
 247     aRect = Rectangle( aTL, aBR );
 248 }
 249
 250 sal_Bool IMapRectangleObject::IsEqual( const IMapRectangleObject& rEqObj )
 251 {
 252     return ( IMapObject::IsEqual( rEqObj ) && ( aRect == rEqObj.aRect ) );
 253 }
 254
 255 IMapCircleObject::IMapCircleObject( const Point& rCenter, sal_uLong nCircleRadius,
 256                                     const String& rURL,
 257                                     const String& rAltText,
 258                                     const String& rDesc,
 259                                     const String& rTarget,
 260                                     const String& rName,
 261                                     sal_Bool bURLActive,
 262                                     sal_Bool bPixelCoords ) :
 263             IMapObject  ( rURL, rAltText, rDesc, rTarget, rName, bURLActive )
 264 {
 265     ImpConstruct( rCenter, nCircleRadius, bPixelCoords );
 266 }
 267
 268 void IMapCircleObject::ImpConstruct( const Point& rCenter, sal_uLong nRad, sal_Bool bPixel )
 269 {
 270     if ( bPixel )
 271     {
 272         MapMode aMap100( MAP_100TH_MM );
 273
 274         aCenter = Application::GetDefaultDevice()->PixelToLogic( rCenter, aMap100 );
 275         nRadius = Application::GetDefaultDevice()->PixelToLogic( Size( nRad, 0 ), aMap100 ).Width();
 276     }
 277     else
 278     {
 279         aCenter = rCenter;
 280         nRadius = nRad;
 281     }
 282 }
 283
 284
 285 /******************************************************************************
 286 |*
 287 |* Binaer-Export
 288 |*
 289 \******************************************************************************/
 290
 291 void IMapCircleObject::WriteIMapObject( SvStream& rOStm ) const
 292 {
 293     sal_uInt32 nTmp = nRadius;
 294
 295     rOStm << aCenter;
 296     rOStm << nTmp;
 297 }
 298
 299
 300 /******************************************************************************
 301 |*
 302 |* Binaer-Import
 303 |*
 304 \******************************************************************************/
 305
 306 void IMapCircleObject::ReadIMapObject( SvStream& rIStm )
 307 {
 308     sal_uInt32 nTmp;
 309
 310     rIStm >> aCenter;
 311     rIStm >> nTmp;
 312
 313     nRadius = nTmp;
 314 }
 315
 316
 317 /******************************************************************************
 318 |*
 319 |* Typ-Rueckgabe
 320 |*
 321 \******************************************************************************/
 322
 323 sal_uInt16 IMapCircleObject::GetType() const
 324 {
 325     return IMAP_OBJ_CIRCLE;
 326 }
 327
 328
 329 /******************************************************************************
 330 |*
 331 |* Hit-Test
 332 |*
 333 \******************************************************************************/
 334
 335 sal_Bool IMapCircleObject::IsHit( const Point& rPoint ) const
 336 {
 337     const Point aPoint( aCenter - rPoint );
 338     sal_Bool        bRet = sal_False;
 339
 340     if ( (sal_Int32) sqrt( (double) aPoint.X() * aPoint.X() +
 341                        aPoint.Y() * aPoint.Y() ) <= nRadius )
 342     {
 343         bRet = sal_True;
 344     }
 345
 346     return bRet;
 347 }
 348
 349 Point IMapCircleObject::GetCenter( sal_Bool bPixelCoords ) const
 350 {
 351     Point aNewPoint;
 352
 353     if ( bPixelCoords )
 354         aNewPoint = Application::GetDefaultDevice()->LogicToPixel( aCenter, MapMode( MAP_100TH_MM ) );
 355     else
 356         aNewPoint = aCenter;
 357
 358     return aNewPoint;
 359 }
 360
 361 sal_uLong IMapCircleObject::GetRadius( sal_Bool bPixelCoords ) const
 362 {
 363     sal_uLong nNewRadius;
 364
 365     if ( bPixelCoords )
 366         nNewRadius = Application::GetDefaultDevice()->LogicToPixel( Size( nRadius, 0 ), MapMode( MAP_100TH_MM ) ).Width();
 367     else
 368         nNewRadius = nRadius;
 369
 370     return nNewRadius;
 371 }
 372
 373 Rectangle IMapCircleObject::GetBoundRect() const
 374 {
 375     long nWidth = nRadius << 1;
 376
 377     return Rectangle( Point(  aCenter.X() - nRadius, aCenter.Y() - nRadius ),
 378                       Size( nWidth, nWidth ) );
 379 }
 380
 381 void IMapCircleObject::Scale( const Fraction& rFracX, const Fraction& rFracY )
 382 {
 383     Fraction aAverage( rFracX );
 384
 385     aAverage += rFracY;
 386     aAverage *= Fraction( 1, 2 );
 387
 388     if ( rFracX.GetDenominator() && rFracY.GetDenominator() )
 389     {
 390         SCALEPOINT( aCenter, rFracX, rFracY );
 391     }
 392
 393     nRadius = ( nRadius * aAverage.GetNumerator() ) / aAverage.GetDenominator();
 394 }
 395
 396 sal_Bool IMapCircleObject::IsEqual( const IMapCircleObject& rEqObj )
 397 {
 398     return ( IMapObject::IsEqual( rEqObj ) &&
 399              ( aCenter == rEqObj.aCenter ) &&
 400              ( nRadius == rEqObj.nRadius ) );
 401 }
 402
 403 IMapPolygonObject::IMapPolygonObject( const Polygon& rPoly,
 404                                       const String& rURL,
 405                                       const String& rAltText,
 406                                       const String& rDesc,
 407                                       const String& rTarget,
 408                                       const String& rName,
 409                                       sal_Bool bURLActive,
 410                                       sal_Bool bPixelCoords ) :
 411             IMapObject  ( rURL, rAltText, rDesc, rTarget, rName, bURLActive ),
 412             bEllipse    ( sal_False )
 413 {
 414     ImpConstruct( rPoly, bPixelCoords );
 415 }
 416
 417 void IMapPolygonObject::ImpConstruct( const Polygon& rPoly, sal_Bool bPixel )
 418 {
 419     if ( bPixel )
 420         aPoly = Application::GetDefaultDevice()->PixelToLogic( rPoly, MapMode( MAP_100TH_MM ) );
 421     else
 422         aPoly = rPoly;
 423 }
 424
 425
 426 /******************************************************************************
 427 |*
 428 |* Binaer-Export
 429 |*
 430 \******************************************************************************/
 431
 432 void IMapPolygonObject::WriteIMapObject( SvStream& rOStm ) const
 433 {
 434     rOStm << aPoly;
 435     rOStm << bEllipse;  // >= Version 2
 436     rOStm << aEllipse;  // >= Version 2
 437 }
 438
 439
 440 /******************************************************************************
 441 |*
 442 |* Binaer-Import
 443 |*
 444 \******************************************************************************/
 445
 446 void IMapPolygonObject::ReadIMapObject( SvStream& rIStm )
 447 {
 448     rIStm >> aPoly;
 449
 450     // Version >= 2 hat zusaetzlich Ellipsen-Information
 451     if ( nReadVersion >= 2 )
 452     {
 453         rIStm >> bEllipse;
 454         rIStm >> aEllipse;
 455     }
 456 }
 457
 458
 459 /******************************************************************************
 460 |*
 461 |* Typ-Rueckgabe
 462 |*
 463 \******************************************************************************/
 464
 465 sal_uInt16 IMapPolygonObject::GetType() const
 466 {
 467     return IMAP_OBJ_POLYGON;
 468 }
 469
 470
 471 /******************************************************************************
 472 |*
 473 |* Hit-Test
 474 |*
 475 \******************************************************************************/
 476
 477 sal_Bool IMapPolygonObject::IsHit( const Point& rPoint ) const
 478 {
 479     return aPoly.IsInside( rPoint );
 480 }
 481
 482 Polygon IMapPolygonObject::GetPolygon( sal_Bool bPixelCoords ) const
 483 {
 484     Polygon aNewPoly;
 485
 486     if ( bPixelCoords )
 487         aNewPoly = Application::GetDefaultDevice()->LogicToPixel( aPoly, MapMode( MAP_100TH_MM ) );
 488     else
 489         aNewPoly = aPoly;
 490
 491     return aNewPoly;
 492 }
 493
 494 void IMapPolygonObject::SetExtraEllipse( const Rectangle& rEllipse )
 495 {
 496     if ( aPoly.GetSize() )
 497     {
 498         bEllipse = sal_True;
 499         aEllipse = rEllipse;
 500     }
 501 }
 502
 503 void IMapPolygonObject::Scale( const Fraction& rFracX, const Fraction& rFracY )
 504 {
 505     sal_uInt16 nCount = aPoly.GetSize();
 506
 507     for ( sal_uInt16 i = 0; i < nCount; i++ )
 508     {
 509         Point aScaledPt( aPoly[ i ] );
 510
 511         if ( rFracX.GetDenominator() && rFracY.GetDenominator() )
 512         {
 513             SCALEPOINT( aScaledPt, rFracX, rFracY );
 514         }
 515
 516         aPoly[ i ] = aScaledPt;
 517     }
 518
 519     if ( bEllipse )
 520     {
 521         Point   aTL( aEllipse.TopLeft() );
 522         Point   aBR( aEllipse.BottomRight() );
 523
 524         if ( rFracX.GetDenominator() && rFracY.GetDenominator() )
 525         {
 526             SCALEPOINT( aTL, rFracX, rFracY );
 527             SCALEPOINT( aBR, rFracX, rFracY );
 528         }
 529
 530         aEllipse = Rectangle( aTL, aBR );
 531     }
 532 }
 533
 534 sal_Bool IMapPolygonObject::IsEqual( const IMapPolygonObject& rEqObj )
 535 {
 536     sal_Bool bRet = sal_False;
 537
 538     if ( IMapObject::IsEqual( rEqObj ) )
 539     {
 540         const Polygon&  rEqPoly = rEqObj.aPoly;
 541         const sal_uInt16    nCount = aPoly.GetSize();
 542         const sal_uInt16    nEqCount = rEqPoly.GetSize();
 543         sal_Bool            bDifferent = sal_False;
 544
 545         if ( nCount == nEqCount )
 546         {
 547             for ( sal_uInt16 i = 0; i < nCount; i++ )
 548             {
 549                 if ( aPoly[ i ] != rEqPoly[ i ] )
 550                 {
 551                     bDifferent = sal_True;
 552                     break;
 553                 }
 554             }
 555
 556             if ( !bDifferent )
 557                 bRet = sal_True;
 558         }
 559     }
 560
 561     return bRet;
 562 }
 563
 564 /******************************************************************************
 565 |*
 566 |* Ctor
 567 |*
 568 \******************************************************************************/
 569
 570 ImageMap::ImageMap( const String& rName )
 571 :   aName( rName )
 572 {
 573 }
 574
 575
 576 /******************************************************************************
 577 |*
 578 |* Copy-Ctor
 579 |*
 580 \******************************************************************************/
 581
 582 ImageMap::ImageMap( const ImageMap& rImageMap )
 583 {
 584     DBG_CTOR( ImageMap, NULL );
 585
 586     size_t nCount = rImageMap.GetIMapObjectCount();
 587
 588     for ( size_t i = 0; i < nCount; i++ )
 589     {
 590         IMapObject* pCopyObj = rImageMap.GetIMapObject( i );
 591
 592         switch( pCopyObj->GetType() )
 593         {
 594             case( IMAP_OBJ_RECTANGLE ):
 595                 maList.push_back( new IMapRectangleObject( *(IMapRectangleObject*) pCopyObj ) );
 596             break;
 597
 598             case( IMAP_OBJ_CIRCLE ):
 599                 maList.push_back( new IMapCircleObject( *(IMapCircleObject*) pCopyObj ) );
 600             break;
 601
 602             case( IMAP_OBJ_POLYGON ):
 603                 maList.push_back( new IMapPolygonObject( *(IMapPolygonObject*) pCopyObj ) );
 604             break;
 605
 606             default:
 607             break;
 608         }
 609     }
 610
 611     aName = rImageMap.aName;
 612 }
 613
 614
 615 /******************************************************************************
 616 |*
 617 |* Dtor
 618 |*
 619 \******************************************************************************/
 620
 621 ImageMap::~ImageMap()
 622 {
 623     DBG_DTOR( ImageMap, NULL );
 624
 625     ClearImageMap();
 626 }
 627
 628
 629 /******************************************************************************
 630 |*
 631 |* Freigabe des internen Speichers
 632 |*
 633 \******************************************************************************/
 634
 635 void ImageMap::ClearImageMap()
 636 {
 637     for( size_t i = 0, n = maList.size(); i < n; ++i )
 638         delete maList[ i ];
 639     maList.clear();
 640
 641     aName = String();
 642 }
 643
 644
 645 /******************************************************************************
 646 |*
 647 |* Zuweisungsoperator
 648 |*
 649 \******************************************************************************/
 650
 651 ImageMap& ImageMap::operator=( const ImageMap& rImageMap )
 652 {
 653     size_t nCount = rImageMap.GetIMapObjectCount();
 654
 655     ClearImageMap();
 656
 657     for ( size_t i = 0; i < nCount; i++ )
 658     {
 659         IMapObject* pCopyObj = rImageMap.GetIMapObject( i );
 660
 661         switch( pCopyObj->GetType() )
 662         {
 663             case( IMAP_OBJ_RECTANGLE ):
 664                 maList.push_back( new IMapRectangleObject( *(IMapRectangleObject*) pCopyObj ) );
 665             break;
 666
 667             case( IMAP_OBJ_CIRCLE ):
 668                 maList.push_back( new IMapCircleObject( *(IMapCircleObject*) pCopyObj ) );
 669             break;
 670
 671             case( IMAP_OBJ_POLYGON ):
 672                 maList.push_back( new IMapPolygonObject( *(IMapPolygonObject*) pCopyObj ) );
 673             break;
 674
 675             default:
 676             break;
 677         }
 678     }
 679
 680     aName = rImageMap.aName;
 681
 682     return *this;
 683 }
 684
 685
 686 /******************************************************************************
 687 |*
 688 |* Vergleichsoperator I
 689 |*
 690 \******************************************************************************/
 691
 692 sal_Bool ImageMap::operator==( const ImageMap& rImageMap )
 693 {
 694     const size_t    nCount = maList.size();
 695     const size_t    nEqCount = rImageMap.GetIMapObjectCount();
 696     sal_Bool        bRet = sal_False;
 697
 698     if ( nCount == nEqCount )
 699     {
 700         sal_Bool bDifferent = ( aName != rImageMap.aName );
 701
 702         for ( size_t i = 0; ( i < nCount ) && !bDifferent; i++ )
 703         {
 704             IMapObject* pObj = maList[ i ];
 705             IMapObject* pEqObj = rImageMap.GetIMapObject( i );
 706
 707             if ( pObj->GetType() == pEqObj->GetType() )
 708             {
 709                 switch( pObj->GetType() )
 710                 {
 711                     case( IMAP_OBJ_RECTANGLE ):
 712                     {
 713                         if ( !( (IMapRectangleObject*) pObj )->IsEqual( *(IMapRectangleObject*) pEqObj ) )
 714                             bDifferent = sal_True;
 715                     }
 716                     break;
 717
 718                     case( IMAP_OBJ_CIRCLE ):
 719                     {
 720                         if ( !( (IMapCircleObject*) pObj )->IsEqual( *(IMapCircleObject*) pEqObj ) )
 721                             bDifferent = sal_True;
 722                     }
 723                     break;
 724
 725                     case( IMAP_OBJ_POLYGON ):
 726                     {
 727                         if ( !( (IMapPolygonObject*) pObj )->IsEqual( *(IMapPolygonObject*) pEqObj ) )
 728                             bDifferent = sal_True;
 729                     }
 730                     break;
 731
 732                     default:
 733                     break;
 734                 }
 735             }
 736             else
 737                 bDifferent = sal_True;
 738         }
 739
 740         if ( !bDifferent )
 741             bRet = sal_True;
 742     }
 743
 744     return bRet;
 745 }
 746
 747
 748 /******************************************************************************
 749 |*
 750 |* Vergleichsoperator II
 751 |*
 752 \******************************************************************************/
 753
 754 sal_Bool ImageMap::operator!=( const ImageMap& rImageMap )
 755 {
 756     return !( *this == rImageMap );
 757 }
 758
 759
 760 /******************************************************************************
 761 |*
 762 |* Freigabe des internen Speichers
 763 |*
 764 \******************************************************************************/
 765
 766 sal_uInt16 ImageMap::GetVersion() const
 767 {
 768     return IMAGE_MAP_VERSION;
 769 }
 770
 771
 772 /******************************************************************************
 773 |*
 774 |* Einfuegen eines neuen Objekts
 775 |*
 776 \******************************************************************************/
 777
 778 void ImageMap::InsertIMapObject( const IMapObject& rIMapObject )
 779 {
 780     switch( rIMapObject.GetType() )
 781     {
 782         case( IMAP_OBJ_RECTANGLE ):
 783             maList.push_back( new IMapRectangleObject( (IMapRectangleObject&) rIMapObject ) );
 784         break;
 785
 786         case( IMAP_OBJ_CIRCLE ):
 787             maList.push_back( new IMapCircleObject( (IMapCircleObject&) rIMapObject ) );
 788         break;
 789
 790         case( IMAP_OBJ_POLYGON ):
 791             maList.push_back( new IMapPolygonObject( (IMapPolygonObject&) rIMapObject ) );
 792         break;
 793
 794         default:
 795         break;
 796     }
 797 }
 798
 799
 800 /******************************************************************************
 801 |*
 802 |* Hit-Test
 803 |*
 804 \******************************************************************************/
 805
 806 IMapObject* ImageMap::GetHitIMapObject( const Size& rTotalSize,
 807                                         const Size& rDisplaySize,
 808                                         const Point& rRelHitPoint,
 809                                         sal_uLong nFlags )
 810 {
 811     Point aRelPoint( rTotalSize.Width() * rRelHitPoint.X() / rDisplaySize.Width(),
 812                      rTotalSize.Height() * rRelHitPoint.Y() / rDisplaySize.Height() );
 813
 814     // Falls Flags zur Spiegelung etc. angegeben sind, wird
 815     // der zu pruefende Punkt vor der Pruefung entspr. transformiert
 816     if ( nFlags )
 817     {
 818         if ( nFlags & IMAP_MIRROR_HORZ )
 819             aRelPoint.X() = rTotalSize.Width() - aRelPoint.X();
 820
 821         if ( nFlags & IMAP_MIRROR_VERT )
 822             aRelPoint.Y() = rTotalSize.Height() - aRelPoint.Y();
 823     }
 824
 825     // Alle Objekte durchlaufen und HitTest ausfuehren
 826     IMapObject* pObj = NULL;
 827     for( size_t i = 0, n = maList.size(); i < n; ++i ) {
 828         if ( maList[ i ]->IsHit( aRelPoint ) ) {
 829             pObj = maList[ i ];
 830             break;
 831         }
 832     }
 833
 834     return( pObj ? ( pObj->IsActive() ? pObj : NULL ) : NULL );
 835 }
 836
 837 void ImageMap::Scale( const Fraction& rFracX, const Fraction& rFracY )
 838 {
 839     size_t nCount = maList.size();
 840
 841     for ( size_t i = 0; i < nCount; i++ )
 842     {
 843         IMapObject* pObj = maList[ i ];
 844
 845         switch( pObj->GetType() )
 846         {
 847             case( IMAP_OBJ_RECTANGLE ):
 848                 ( (IMapRectangleObject*) pObj )->Scale( rFracX, rFracY );
 849             break;
 850
 851             case( IMAP_OBJ_CIRCLE ):
 852                 ( (IMapCircleObject*) pObj )->Scale( rFracX, rFracY );
 853             break;
 854
 855             case( IMAP_OBJ_POLYGON ):
 856                 ( (IMapPolygonObject*) pObj )->Scale( rFracX, rFracY );
 857             break;
 858
 859             default:
 860             break;
 861         }
 862     }
 863 }
 864
 865
 866 /******************************************************************************
 867 |*
 868 |* Objekte nacheinander wegschreiben
 869 |*
 870 \******************************************************************************/
 871
 872 void ImageMap::ImpWriteImageMap( SvStream& rOStm, const String& rBaseURL ) const
 873 {
 874     IMapObject* pObj;
 875     size_t      nCount = maList.size();
 876
 877     for ( size_t i = 0; i < nCount; i++ )
 878     {
 879         pObj = maList[ i ];
 880         pObj->Write( rOStm, rBaseURL );
 881     }
 882 }
 883
 884
 885 /******************************************************************************
 886 |*
 887 |* Objekte nacheinander lesen
 888 |*
 889 \******************************************************************************/
 890
 891 void ImageMap::ImpReadImageMap( SvStream& rIStm, size_t nCount, const String& rBaseURL )
 892 {
 893     // neue Objekte einlesen
 894     for ( size_t i = 0; i < nCount; i++ )
 895     {
 896         sal_uInt16 nType;
 897
 898         rIStm >> nType;
 899         rIStm.SeekRel( -2 );
 900
 901         switch( nType )
 902         {
 903             case ( IMAP_OBJ_RECTANGLE ):
 904             {
 905                 IMapRectangleObject* pObj = new IMapRectangleObject;
 906                 pObj->Read( rIStm, rBaseURL );
 907                 maList.push_back( pObj );
 908             }
 909             break;
 910
 911             case ( IMAP_OBJ_CIRCLE ):
 912             {
 913                 IMapCircleObject* pObj = new IMapCircleObject;
 914                 pObj->Read( rIStm, rBaseURL );
 915                 maList.push_back( pObj );
 916             }
 917             break;
 918
 919             case ( IMAP_OBJ_POLYGON ):
 920             {
 921                 IMapPolygonObject* pObj = new IMapPolygonObject;
 922                 pObj->Read( rIStm, rBaseURL );
 923                 maList.push_back( pObj );
 924             }
 925             break;
 926
 927             default:
 928             break;
 929         }
 930     }
 931 }
 932
 933
 934 /******************************************************************************
 935 |*
 936 |* Binaer speichern
 937 |*
 938 \******************************************************************************/
 939
 940 void ImageMap::Write( SvStream& rOStm, const String& rBaseURL ) const
 941 {
 942     IMapCompat*             pCompat;
 943     String                  aImageName( GetName() );
 944     sal_uInt16                  nOldFormat = rOStm.GetNumberFormatInt();
 945     sal_uInt16                  nCount = (sal_uInt16) GetIMapObjectCount();
 946     const rtl_TextEncoding  eEncoding = osl_getThreadTextEncoding(); //vomit!
 947
 948     rOStm.SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );
 949
 950     // MagicCode schreiben
 951     rOStm << IMAPMAGIC;
 952     rOStm << GetVersion();
 953     write_lenPrefixed_uInt8s_FromOUString<sal_uInt16>(rOStm, aImageName, eEncoding);
 954     write_lenPrefixed_uInt8s_FromOString<sal_uInt16>(rOStm, OString()); //dummy
 955     rOStm << nCount;
 956     write_lenPrefixed_uInt8s_FromOUString<sal_uInt16>(rOStm, aImageName, eEncoding);
 957
 958     pCompat = new IMapCompat( rOStm, STREAM_WRITE );
 959
 960     // hier kann in neueren Versionen eingefuegt werden
 961
 962     delete pCompat;
 963
 964     ImpWriteImageMap( rOStm, rBaseURL );
 965
 966     rOStm.SetNumberFormatInt( nOldFormat );
 967 }
 968
 969
 970 /******************************************************************************
 971 |*
 972 |* Binaer laden
 973 |*
 974 \******************************************************************************/
 975
 976 void ImageMap::Read( SvStream& rIStm, const String& rBaseURL )
 977 {
 978     char        cMagic[6];
 979     sal_uInt16      nOldFormat = rIStm.GetNumberFormatInt();
 980     sal_uInt16      nCount;
 981
 982     rIStm.SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );
 983     rIStm.Read( cMagic, sizeof( cMagic ) );
 984
 985     if ( !memcmp( cMagic, IMAPMAGIC, sizeof( cMagic ) ) )
 986     {
 987         IMapCompat* pCompat;
 988
 989         // alten Inhalt loeschen
 990         ClearImageMap();
 991
 992         // Version ueberlesen wir
 993         rIStm.SeekRel( 2 );
 994
 995         aName = read_lenPrefixed_uInt8s_ToOUString<sal_uInt16>(rIStm, osl_getThreadTextEncoding());
 996         read_lenPrefixed_uInt8s_ToOString<sal_uInt16>(rIStm); // Dummy
 997         rIStm >> nCount;
 998         read_lenPrefixed_uInt8s_ToOString<sal_uInt16>(rIStm); // Dummy
 999
1000         pCompat = new IMapCompat( rIStm, STREAM_READ );
1001
1002         // hier kann in neueren Versionen gelesen werden
1003
1004         delete pCompat;
1005         ImpReadImageMap( rIStm, nCount, rBaseURL );
1006
1007     }
1008     else
1009         rIStm.SetError( SVSTREAM_GENERALERROR );
1010
1011     rIStm.SetNumberFormatInt( nOldFormat );
1012 }
1013
1014
1015 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */