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