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