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