Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 994 insertions, 0 deletions

diff --git a/vcl/source/treelist/imap.cxx b/vcl/source/treelist/imap.cxx
new file mode 100644
index 000000000..84a0717c6
--- /dev/null
+++ b/vcl/source/treelist/imap.cxx
@@ -0,0 +1,994 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+
+#include <tools/urlobj.hxx>
+#include <tools/fract.hxx>
+#include <tools/GenericTypeSerializer.hxx>
+#include <vcl/outdev.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/mapmod.hxx>
+#include <o3tl/numeric.hxx>
+#include <svl/urihelper.hxx>
+#include <vcl/imap.hxx>
+#include <vcl/imapobj.hxx>
+#include <vcl/imapcirc.hxx>
+#include <vcl/imaprect.hxx>
+#include <vcl/imappoly.hxx>
+
+#include <string.h>
+#include <math.h>
+#include <memory>
+#include <sal/log.hxx>
+
+
+#define SCALEPOINT(aPT,aFracX,aFracY) (aPT).setX(tools::Long((aPT).X()*aFracX));  \
+                                      (aPT).setY(tools::Long((aPT).Y()*aFracY));
+
+
+/******************************************************************************/
+
+
+IMapObject::IMapObject()
+    : bActive( false )
+    , nReadVersion( 0 )
+{
+}
+
+IMapObject::IMapObject( const OUString& rURL, const OUString& rAltText, const OUString& rDesc,
+                        const OUString& rTarget, const OUString& rName, bool bURLActive )
+: aURL( rURL )
+, aAltText( rAltText )
+, aDesc( rDesc )
+, aTarget( rTarget )
+, aName( rName )
+, bActive( bURLActive )
+, nReadVersion( 0 )
+{
+}
+
+
+void IMapObject::Write( SvStream& rOStm ) const
+{
+    const rtl_TextEncoding  eEncoding = osl_getThreadTextEncoding();
+
+    rOStm.WriteUInt16( static_cast<sal_uInt16>(GetType()) );
+    rOStm.WriteUInt16( IMAP_OBJ_VERSION );
+    rOStm.WriteUInt16( eEncoding  );
+
+    const OString aRelURL = OUStringToOString(
+        URIHelper::simpleNormalizedMakeRelative("", aURL), eEncoding);
+    write_uInt16_lenPrefixed_uInt8s_FromOString(rOStm, aRelURL);
+    write_uInt16_lenPrefixed_uInt8s_FromOUString(rOStm, aAltText, eEncoding);
+    rOStm.WriteBool( bActive );
+    write_uInt16_lenPrefixed_uInt8s_FromOUString(rOStm, aTarget, eEncoding);
+
+    IMapCompat aCompat( rOStm, StreamMode::WRITE );
+
+    WriteIMapObject( rOStm );
+    aEventList.Write( rOStm );                                      // V4
+    write_uInt16_lenPrefixed_uInt8s_FromOUString(rOStm, aName, eEncoding); // V5
+}
+
+
+/******************************************************************************
+|*
+|*  Binary import
+|*
+\******************************************************************************/
+
+void IMapObject::Read( SvStream& rIStm )
+{
+    rtl_TextEncoding    nTextEncoding;
+
+    // read on type and version
+    rIStm.SeekRel( 2 );
+    rIStm.ReadUInt16( nReadVersion );
+    rIStm.ReadUInt16( nTextEncoding );
+    aURL = read_uInt16_lenPrefixed_uInt8s_ToOUString(rIStm, nTextEncoding);
+    aAltText = read_uInt16_lenPrefixed_uInt8s_ToOUString(rIStm, nTextEncoding);
+    rIStm.ReadCharAsBool( bActive );
+    aTarget = read_uInt16_lenPrefixed_uInt8s_ToOUString(rIStm, nTextEncoding);
+
+    // make URL absolute
+    aURL = URIHelper::SmartRel2Abs( INetURLObject(u""), aURL, URIHelper::GetMaybeFileHdl(), true, false, INetURLObject::EncodeMechanism::WasEncoded, INetURLObject::DecodeMechanism::Unambiguous );
+    IMapCompat aCompat( rIStm, StreamMode::READ );
+
+    ReadIMapObject( rIStm );
+
+    // from version 4 onwards we read an eventlist
+    if ( nReadVersion >= 0x0004 )
+    {
+        aEventList.Read(rIStm);
+
+        // from version 5 onwards an objectname could be available
+        if ( nReadVersion >= 0x0005 )
+            aName = read_uInt16_lenPrefixed_uInt8s_ToOUString(rIStm, nTextEncoding);
+    }
+}
+
+bool IMapObject::IsEqual( const IMapObject& rEqObj ) const
+{
+    return ( ( aURL == rEqObj.aURL ) &&
+             ( aAltText == rEqObj.aAltText ) &&
+             ( aDesc == rEqObj.aDesc ) &&
+             ( aTarget == rEqObj.aTarget ) &&
+             ( aName == rEqObj.aName ) &&
+             ( bActive == rEqObj.bActive ) );
+}
+
+IMapRectangleObject::IMapRectangleObject( const tools::Rectangle& rRect,
+                                          const OUString& rURL,
+                                          const OUString& rAltText,
+                                          const OUString& rDesc,
+                                          const OUString& rTarget,
+                                          const OUString& rName,
+                                          bool bURLActive,
+                                          bool bPixelCoords ) :
+            IMapObject  ( rURL, rAltText, rDesc, rTarget, rName, bURLActive )
+{
+    ImpConstruct( rRect, bPixelCoords );
+}
+
+void IMapRectangleObject::ImpConstruct( const tools::Rectangle& rRect, bool bPixel )
+{
+    if ( bPixel )
+        aRect = Application::GetDefaultDevice()->PixelToLogic( rRect, MapMode( MapUnit::Map100thMM ) );
+    else
+        aRect = rRect;
+}
+
+
+/******************************************************************************
+|*
+|* Binary export
+|*
+\******************************************************************************/
+
+void IMapRectangleObject::WriteIMapObject( SvStream& rOStm ) const
+{
+    tools::GenericTypeSerializer aSerializer(rOStm);
+    aSerializer.writeRectangle(aRect);
+}
+
+
+/******************************************************************************
+|*
+|* Binary import
+|*
+\******************************************************************************/
+
+void IMapRectangleObject::ReadIMapObject( SvStream& rIStm )
+{
+    tools::GenericTypeSerializer aSerializer(rIStm);
+    aSerializer.readRectangle(aRect);
+}
+
+
+/******************************************************************************
+|*
+|* return type
+|*
+\******************************************************************************/
+
+IMapObjectType IMapRectangleObject::GetType() const
+{
+    return IMapObjectType::Rectangle;
+}
+
+
+/******************************************************************************
+|*
+|* Hit test
+|*
+\******************************************************************************/
+
+bool IMapRectangleObject::IsHit( const Point& rPoint ) const
+{
+    return aRect.Contains( rPoint );
+}
+
+tools::Rectangle IMapRectangleObject::GetRectangle( bool bPixelCoords ) const
+{
+    tools::Rectangle   aNewRect;
+
+    if ( bPixelCoords )
+        aNewRect = Application::GetDefaultDevice()->LogicToPixel( aRect, MapMode( MapUnit::Map100thMM ) );
+    else
+        aNewRect = aRect;
+
+    return aNewRect;
+}
+
+void IMapRectangleObject::Scale( const Fraction& rFracX, const Fraction& rFracY )
+{
+    Point   aTL( aRect.TopLeft() );
+    Point   aBR( aRect.BottomRight() );
+
+    if ( rFracX.GetDenominator() && rFracY.GetDenominator() )
+    {
+        SCALEPOINT( aTL, rFracX, rFracY );
+        SCALEPOINT( aBR, rFracX, rFracY );
+    }
+
+    aRect = tools::Rectangle( aTL, aBR );
+}
+
+bool IMapRectangleObject::IsEqual( const IMapRectangleObject& rEqObj ) const
+{
+    return ( IMapObject::IsEqual( rEqObj ) && ( aRect == rEqObj.aRect ) );
+}
+
+IMapCircleObject::IMapCircleObject( const Point& rCenter, sal_Int32 nCircleRadius,
+                                    const OUString& rURL,
+                                    const OUString& rAltText,
+                                    const OUString& rDesc,
+                                    const OUString& rTarget,
+                                    const OUString& rName,
+                                    bool bURLActive,
+                                    bool bPixelCoords ) :
+            IMapObject  ( rURL, rAltText, rDesc, rTarget, rName, bURLActive )
+{
+    ImpConstruct( rCenter, nCircleRadius, bPixelCoords );
+}
+
+void IMapCircleObject::ImpConstruct( const Point& rCenter, sal_Int32 nRad, bool bPixel )
+{
+    if ( bPixel )
+    {
+        MapMode aMap100( MapUnit::Map100thMM );
+
+        aCenter = Application::GetDefaultDevice()->PixelToLogic( rCenter, aMap100 );
+        nRadius = Application::GetDefaultDevice()->PixelToLogic( Size( nRad, 0 ), aMap100 ).Width();
+    }
+    else
+    {
+        aCenter = rCenter;
+        nRadius = nRad;
+    }
+}
+
+
+/******************************************************************************
+|*
+|* Binary export
+|*
+\******************************************************************************/
+
+void IMapCircleObject::WriteIMapObject( SvStream& rOStm ) const
+{
+    sal_uInt32 nTmp = nRadius;
+    tools::GenericTypeSerializer aSerializer(rOStm);
+    aSerializer.writePoint(aCenter);
+    rOStm.WriteUInt32( nTmp );
+}
+
+
+/******************************************************************************
+|*
+|* Binary import
+|*
+\******************************************************************************/
+
+void IMapCircleObject::ReadIMapObject( SvStream& rIStm )
+{
+    sal_uInt32 nTmp;
+
+    tools::GenericTypeSerializer aSerializer(rIStm);
+    aSerializer.readPoint(aCenter);
+    rIStm.ReadUInt32( nTmp );
+
+    nRadius = nTmp;
+}
+
+
+/******************************************************************************
+|*
+|* return type
+|*
+\******************************************************************************/
+
+IMapObjectType IMapCircleObject::GetType() const
+{
+    return IMapObjectType::Circle;
+}
+
+
+/******************************************************************************
+|*
+|* Hit-Test
+|*
+\******************************************************************************/
+
+bool IMapCircleObject::IsHit( const Point& rPoint ) const
+{
+    const Point aPoint( aCenter - rPoint );
+    bool        bRet = false;
+
+    if ( static_cast<sal_Int32>(sqrt( static_cast<double>(aPoint.X()) * aPoint.X() +
+                       aPoint.Y() * aPoint.Y() )) <= nRadius )
+    {
+        bRet = true;
+    }
+
+    return bRet;
+}
+
+Point IMapCircleObject::GetCenter( bool bPixelCoords ) const
+{
+    Point aNewPoint;
+
+    if ( bPixelCoords )
+        aNewPoint = Application::GetDefaultDevice()->LogicToPixel( aCenter, MapMode( MapUnit::Map100thMM ) );
+    else
+        aNewPoint = aCenter;
+
+    return aNewPoint;
+}
+
+sal_Int32 IMapCircleObject::GetRadius( bool bPixelCoords ) const
+{
+    sal_Int32 nNewRadius;
+
+    if ( bPixelCoords )
+        nNewRadius = Application::GetDefaultDevice()->LogicToPixel( Size( nRadius, 0 ), MapMode( MapUnit::Map100thMM ) ).Width();
+    else
+        nNewRadius = nRadius;
+
+    return nNewRadius;
+}
+
+void IMapCircleObject::Scale( const Fraction& rFracX, const Fraction& rFracY )
+{
+    Fraction aAverage( rFracX );
+
+    aAverage += rFracY;
+    aAverage *= Fraction( 1, 2 );
+
+    if ( rFracX.GetDenominator() && rFracY.GetDenominator() )
+    {
+        SCALEPOINT( aCenter, rFracX, rFracY );
+    }
+
+    if (!aAverage.GetDenominator())
+        throw o3tl::divide_by_zero();
+
+    nRadius = double(nRadius * aAverage);
+}
+
+bool IMapCircleObject::IsEqual( const IMapCircleObject& rEqObj ) const
+{
+    return ( IMapObject::IsEqual( rEqObj ) &&
+             ( aCenter == rEqObj.aCenter ) &&
+             ( nRadius == rEqObj.nRadius ) );
+}
+
+IMapPolygonObject::IMapPolygonObject( const tools::Polygon& rPoly,
+                                      const OUString& rURL,
+                                      const OUString& rAltText,
+                                      const OUString& rDesc,
+                                      const OUString& rTarget,
+                                      const OUString& rName,
+                                      bool bURLActive,
+                                      bool bPixelCoords ) :
+            IMapObject  ( rURL, rAltText, rDesc, rTarget, rName, bURLActive ),
+            bEllipse    ( false )
+{
+    ImpConstruct( rPoly, bPixelCoords );
+}
+
+void IMapPolygonObject::ImpConstruct( const tools::Polygon& rPoly, bool bPixel )
+{
+    if ( bPixel )
+        aPoly = Application::GetDefaultDevice()->PixelToLogic( rPoly, MapMode( MapUnit::Map100thMM ) );
+    else
+        aPoly = rPoly;
+}
+
+
+/******************************************************************************
+|*
+|* Binary export
+|*
+\******************************************************************************/
+
+void IMapPolygonObject::WriteIMapObject( SvStream& rOStm ) const
+{
+    tools::GenericTypeSerializer aSerializer(rOStm);
+    WritePolygon( rOStm, aPoly );
+    // Version 2
+    rOStm.WriteBool( bEllipse );
+    aSerializer.writeRectangle(aEllipse);
+}
+
+
+/******************************************************************************
+|*
+|* Binary import
+|*
+\******************************************************************************/
+
+void IMapPolygonObject::ReadIMapObject( SvStream& rIStm )
+{
+    ReadPolygon( rIStm, aPoly );
+
+    // Version >= 2 has additional ellipses information
+    if ( nReadVersion >= 2 )
+    {
+        rIStm.ReadCharAsBool( bEllipse );
+        tools::GenericTypeSerializer aSerializer(rIStm);
+        aSerializer.readRectangle(aEllipse);
+    }
+}
+
+
+/******************************************************************************
+|*
+|* return type
+|*
+\******************************************************************************/
+
+IMapObjectType IMapPolygonObject::GetType() const
+{
+    return IMapObjectType::Polygon;
+}
+
+
+/******************************************************************************
+|*
+|* hit test
+|*
+\******************************************************************************/
+
+bool IMapPolygonObject::IsHit( const Point& rPoint ) const
+{
+    return aPoly.Contains( rPoint );
+}
+
+tools::Polygon IMapPolygonObject::GetPolygon( bool bPixelCoords ) const
+{
+    tools::Polygon aNewPoly;
+
+    if ( bPixelCoords )
+        aNewPoly = Application::GetDefaultDevice()->LogicToPixel( aPoly, MapMode( MapUnit::Map100thMM ) );
+    else
+        aNewPoly = aPoly;
+
+    return aNewPoly;
+}
+
+void IMapPolygonObject::SetExtraEllipse( const tools::Rectangle& rEllipse )
+{
+    if ( aPoly.GetSize() )
+    {
+        bEllipse = true;
+        aEllipse = rEllipse;
+    }
+}
+
+void IMapPolygonObject::Scale( const Fraction& rFracX, const Fraction& rFracY )
+{
+    sal_uInt16 nCount = aPoly.GetSize();
+
+    for ( sal_uInt16 i = 0; i < nCount; i++ )
+    {
+        Point aScaledPt( aPoly[ i ] );
+
+        if ( rFracX.GetDenominator() && rFracY.GetDenominator() )
+        {
+            SCALEPOINT( aScaledPt, rFracX, rFracY );
+        }
+
+        aPoly[ i ] = aScaledPt;
+    }
+
+    if ( !bEllipse )
+        return;
+
+    Point   aTL( aEllipse.TopLeft() );
+    Point   aBR( aEllipse.BottomRight() );
+
+    if ( rFracX.GetDenominator() && rFracY.GetDenominator() )
+    {
+        SCALEPOINT( aTL, rFracX, rFracY );
+        SCALEPOINT( aBR, rFracX, rFracY );
+    }
+
+    aEllipse = tools::Rectangle( aTL, aBR );
+}
+
+bool IMapPolygonObject::IsEqual( const IMapPolygonObject& rEqObj )
+{
+    bool bRet = false;
+
+    if ( IMapObject::IsEqual( rEqObj ) )
+    {
+        const tools::Polygon&   rEqPoly = rEqObj.aPoly;
+        const sal_uInt16 nCount = aPoly.GetSize();
+        const sal_uInt16 nEqCount = rEqPoly.GetSize();
+
+        if ( nCount == nEqCount )
+        {
+            bool bDifferent = false;
+
+            for ( sal_uInt16 i = 0; i < nCount; i++ )
+            {
+                if ( aPoly[ i ] != rEqPoly[ i ] )
+                {
+                    bDifferent = true;
+                    break;
+                }
+            }
+
+            if ( !bDifferent )
+                bRet = true;
+        }
+    }
+
+    return bRet;
+}
+
+/******************************************************************************
+|*
+|* Ctor
+|*
+\******************************************************************************/
+
+ImageMap::ImageMap( const OUString& rName )
+:   aName( rName )
+{
+}
+
+
+/******************************************************************************
+|*
+|* Copy-Ctor
+|*
+\******************************************************************************/
+
+ImageMap::ImageMap( const ImageMap& rImageMap )
+{
+
+    size_t nCount = rImageMap.GetIMapObjectCount();
+
+    for ( size_t i = 0; i < nCount; i++ )
+    {
+        IMapObject* pCopyObj = rImageMap.GetIMapObject( i );
+
+        switch( pCopyObj->GetType() )
+        {
+            case IMapObjectType::Rectangle:
+                maList.emplace_back( new IMapRectangleObject( *static_cast<IMapRectangleObject*>( pCopyObj ) ) );
+            break;
+
+            case IMapObjectType::Circle:
+                maList.emplace_back( new IMapCircleObject( *static_cast<IMapCircleObject*>( pCopyObj ) ) );
+            break;
+
+            case IMapObjectType::Polygon:
+                maList.emplace_back( new IMapPolygonObject( *static_cast<IMapPolygonObject*>( pCopyObj ) ) );
+            break;
+
+            default:
+            break;
+        }
+    }
+
+    aName = rImageMap.aName;
+}
+
+
+/******************************************************************************
+|*
+|* Dtor
+|*
+\******************************************************************************/
+
+ImageMap::~ImageMap()
+{
+}
+
+
+/******************************************************************************
+|*
+|* release internal memory
+|*
+\******************************************************************************/
+
+void ImageMap::ClearImageMap()
+{
+    maList.clear();
+
+    aName.clear();
+}
+
+
+/******************************************************************************
+|*
+|* assignment operator
+|*
+\******************************************************************************/
+
+ImageMap& ImageMap::operator=( const ImageMap& rImageMap )
+{
+    if (this != &rImageMap)
+    {
+        size_t nCount = rImageMap.GetIMapObjectCount();
+
+        ClearImageMap();
+
+        for ( size_t i = 0; i < nCount; i++ )
+        {
+            IMapObject* pCopyObj = rImageMap.GetIMapObject( i );
+
+            switch( pCopyObj->GetType() )
+            {
+                case IMapObjectType::Rectangle:
+                    maList.emplace_back( new IMapRectangleObject( *static_cast<IMapRectangleObject*>(pCopyObj) ) );
+                break;
+
+                case IMapObjectType::Circle:
+                    maList.emplace_back( new IMapCircleObject( *static_cast<IMapCircleObject*>(pCopyObj) ) );
+                break;
+
+                case IMapObjectType::Polygon:
+                    maList.emplace_back( new IMapPolygonObject( *static_cast<IMapPolygonObject*>(pCopyObj) ) );
+                break;
+
+                default:
+                break;
+            }
+        }
+
+        aName = rImageMap.aName;
+    }
+    return *this;
+}
+
+
+/******************************************************************************
+|*
+|* compare operator I
+|*
+\******************************************************************************/
+
+bool ImageMap::operator==( const ImageMap& rImageMap )
+{
+    const size_t    nCount = maList.size();
+    const size_t    nEqCount = rImageMap.GetIMapObjectCount();
+    bool            bRet = false;
+
+    if ( nCount == nEqCount )
+    {
+        bool bDifferent = ( aName != rImageMap.aName );
+
+        for ( size_t i = 0; ( i < nCount ) && !bDifferent; i++ )
+        {
+            IMapObject* pObj = maList[ i ].get();
+            IMapObject* pEqObj = rImageMap.GetIMapObject( i );
+
+            if ( pObj->GetType() == pEqObj->GetType() )
+            {
+                switch( pObj->GetType() )
+                {
+                    case IMapObjectType::Rectangle:
+                    {
+                        if ( ! static_cast<IMapRectangleObject*>(pObj)->IsEqual( *static_cast<IMapRectangleObject*>(pEqObj) ) )
+                            bDifferent = true;
+                    }
+                    break;
+
+                    case IMapObjectType::Circle:
+                    {
+                        if ( ! static_cast<IMapCircleObject*>(pObj)->IsEqual( *static_cast<IMapCircleObject*>(pEqObj) ) )
+                            bDifferent = true;
+                    }
+                    break;
+
+                    case IMapObjectType::Polygon:
+                    {
+                        if ( ! static_cast<IMapPolygonObject*>(pObj)->IsEqual( *static_cast<IMapPolygonObject*>(pEqObj) ) )
+                            bDifferent = true;
+                    }
+                    break;
+
+                    default:
+                    break;
+                }
+            }
+            else
+                bDifferent = true;
+        }
+
+        if ( !bDifferent )
+            bRet = true;
+    }
+
+    return bRet;
+}
+
+
+/******************************************************************************
+|*
+|* compare operator II
+|*
+\******************************************************************************/
+
+bool ImageMap::operator!=( const ImageMap& rImageMap )
+{
+    return !( *this == rImageMap );
+}
+
+
+/******************************************************************************
+|*
+|* insert new object
+|*
+\******************************************************************************/
+
+void ImageMap::InsertIMapObject( const IMapObject& rIMapObject )
+{
+    switch( rIMapObject.GetType() )
+    {
+        case IMapObjectType::Rectangle:
+            maList.emplace_back( new IMapRectangleObject( static_cast<const IMapRectangleObject&>( rIMapObject ) ) );
+        break;
+
+        case IMapObjectType::Circle:
+            maList.emplace_back( new IMapCircleObject( static_cast<const IMapCircleObject&>( rIMapObject ) ) );
+        break;
+
+        case IMapObjectType::Polygon:
+            maList.emplace_back( new IMapPolygonObject( static_cast<const IMapPolygonObject&>( rIMapObject ) ) );
+        break;
+
+        default:
+        break;
+    }
+}
+
+void ImageMap::InsertIMapObject( std::unique_ptr<IMapObject> pNewObject )
+{
+    maList.emplace_back( std::move(pNewObject) );
+}
+
+/******************************************************************************
+|*
+|* hit test
+|*
+\******************************************************************************/
+
+IMapObject* ImageMap::GetHitIMapObject( const Size& rTotalSize,
+                                        const Size& rDisplaySize,
+                                        const Point& rRelHitPoint,
+                                        sal_uLong nFlags )
+{
+    Point aRelPoint( rTotalSize.Width() * rRelHitPoint.X() / rDisplaySize.Width(),
+                     rTotalSize.Height() * rRelHitPoint.Y() / rDisplaySize.Height() );
+
+    // transform point to check before checking if flags to mirror etc. are set,
+    if ( nFlags )
+    {
+        if ( nFlags & IMAP_MIRROR_HORZ )
+            aRelPoint.setX( rTotalSize.Width() - aRelPoint.X() );
+
+        if ( nFlags & IMAP_MIRROR_VERT )
+            aRelPoint.setY( rTotalSize.Height() - aRelPoint.Y() );
+    }
+
+    // walk over all objects and execute HitTest
+    IMapObject* pObj = nullptr;
+    for(const auto& i : maList) {
+        if ( i->IsHit( aRelPoint ) ) {
+            pObj = i.get();
+            break;
+        }
+    }
+
+    return( pObj ? ( pObj->IsActive() ? pObj : nullptr ) : nullptr );
+}
+
+void ImageMap::Scale( const Fraction& rFracX, const Fraction& rFracY )
+{
+    size_t nCount = maList.size();
+
+    for ( size_t i = 0; i < nCount; i++ )
+    {
+        IMapObject* pObj = maList[ i ].get();
+
+        switch( pObj->GetType() )
+        {
+            case IMapObjectType::Rectangle:
+                static_cast<IMapRectangleObject*>( pObj )->Scale( rFracX, rFracY );
+            break;
+
+            case IMapObjectType::Circle:
+                static_cast<IMapCircleObject*>( pObj )->Scale( rFracX, rFracY );
+            break;
+
+            case IMapObjectType::Polygon:
+                static_cast<IMapPolygonObject*>( pObj )->Scale( rFracX, rFracY );
+            break;
+
+            default:
+            break;
+        }
+    }
+}
+
+
+/******************************************************************************
+|*
+|* sequentially write objects
+|*
+\******************************************************************************/
+
+void ImageMap::ImpWriteImageMap( SvStream& rOStm ) const
+{
+    size_t      nCount = maList.size();
+
+    for ( size_t i = 0; i < nCount; i++ )
+    {
+        auto& pObj = maList[ i ];
+        pObj->Write( rOStm );
+    }
+}
+
+
+/******************************************************************************
+|*
+|* sequentially read objects
+|*
+\******************************************************************************/
+
+void ImageMap::ImpReadImageMap( SvStream& rIStm, size_t nCount )
+{
+    const size_t nMinRecordSize = 12; //circle, three 32bit numbers
+    const size_t nMaxRecords = rIStm.remainingSize() / nMinRecordSize;
+
+    if (nCount > nMaxRecords)
+    {
+        SAL_WARN("svtools.misc", "Parsing error: " << nMaxRecords << " max possible entries, but " <<
+                 nCount << " claimed, truncating");
+        nCount = nMaxRecords;
+    }
+
+    // read new objects
+    for (size_t i = 0; i < nCount; ++i)
+    {
+        sal_uInt16 nType;
+
+        rIStm.ReadUInt16( nType );
+        rIStm.SeekRel( -2 );
+
+        switch( static_cast<IMapObjectType>(nType) )
+        {
+            case IMapObjectType::Rectangle:
+            {
+                IMapRectangleObject* pObj = new IMapRectangleObject;
+                pObj->Read( rIStm );
+                maList.emplace_back( pObj );
+            }
+            break;
+
+            case IMapObjectType::Circle:
+            {
+                IMapCircleObject* pObj = new IMapCircleObject;
+                pObj->Read( rIStm );
+                maList.emplace_back( pObj );
+            }
+            break;
+
+            case IMapObjectType::Polygon:
+            {
+                IMapPolygonObject* pObj = new IMapPolygonObject;
+                pObj->Read( rIStm );
+                maList.emplace_back( pObj );
+            }
+            break;
+
+            default:
+            break;
+        }
+    }
+}
+
+
+/******************************************************************************
+|*
+|* store binary
+|*
+\******************************************************************************/
+
+void ImageMap::Write( SvStream& rOStm ) const
+{
+    IMapCompat*             pCompat;
+    OUString                aImageName( GetName() );
+    SvStreamEndian          nOldFormat = rOStm.GetEndian();
+    sal_uInt16              nCount = static_cast<sal_uInt16>(GetIMapObjectCount());
+    const rtl_TextEncoding  eEncoding = osl_getThreadTextEncoding(); //vomit!
+
+    rOStm.SetEndian( SvStreamEndian::LITTLE );
+
+    // write MagicCode
+    rOStm.WriteCharPtr( IMAPMAGIC );
+    rOStm.WriteUInt16( IMAGE_MAP_VERSION );
+    write_uInt16_lenPrefixed_uInt8s_FromOUString(rOStm, aImageName, eEncoding);
+    write_uInt16_lenPrefixed_uInt8s_FromOString(rOStm, ""); //dummy
+    rOStm.WriteUInt16( nCount );
+    write_uInt16_lenPrefixed_uInt8s_FromOUString(rOStm, aImageName, eEncoding);
+
+    pCompat = new IMapCompat( rOStm, StreamMode::WRITE );
+
+    // here one can insert in newer versions
+
+    delete pCompat;
+
+    ImpWriteImageMap( rOStm );
+
+    rOStm.SetEndian( nOldFormat );
+}
+
+
+/******************************************************************************
+|*
+|* load binary
+|*
+\******************************************************************************/
+
+void ImageMap::Read( SvStream& rIStm )
+{
+    char            cMagic[6];
+    SvStreamEndian  nOldFormat = rIStm.GetEndian();
+
+    rIStm.SetEndian( SvStreamEndian::LITTLE );
+    rIStm.ReadBytes(cMagic, sizeof(cMagic));
+
+    if ( !memcmp( cMagic, IMAPMAGIC, sizeof( cMagic ) ) )
+    {
+        IMapCompat* pCompat;
+        sal_uInt16  nCount;
+
+        // delete old content
+        ClearImageMap();
+
+        // read on version
+        rIStm.SeekRel( 2 );
+
+        aName = read_uInt16_lenPrefixed_uInt8s_ToOUString(rIStm, osl_getThreadTextEncoding());
+        read_uInt16_lenPrefixed_uInt8s_ToOString(rIStm); // Dummy
+        rIStm.ReadUInt16( nCount );
+        read_uInt16_lenPrefixed_uInt8s_ToOString(rIStm); // Dummy
+
+        pCompat = new IMapCompat( rIStm, StreamMode::READ );
+
+        // here one can read in newer versions
+
+        delete pCompat;
+        ImpReadImageMap( rIStm, nCount );
+
+    }
+    else
+        rIStm.SetError( SVSTREAM_GENERALERROR );
+
+    rIStm.SetEndian( nOldFormat );
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */