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, 743 insertions, 0 deletions

diff --git a/svx/source/dialog/imapwnd.cxx b/svx/source/dialog/imapwnd.cxx
new file mode 100644
index 000000000..0e7b85131
--- /dev/null
+++ b/svx/source/dialog/imapwnd.cxx
@@ -0,0 +1,743 @@
+/* -*- 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 <vcl/commandevent.hxx>
+#include <vcl/imaprect.hxx>
+#include <vcl/imapcirc.hxx>
+#include <vcl/imappoly.hxx>
+#include <vcl/svapp.hxx>
+#include <svl/urlbmk.hxx>
+
+#include <svx/svxids.hrc>
+#include "imapwnd.hxx"
+#include <svx/svdpage.hxx>
+#include <svx/svdorect.hxx>
+#include <svx/svdocirc.hxx>
+#include <svx/svdopath.hxx>
+#include <svx/xfltrit.hxx>
+#include <svx/svdpagv.hxx>
+#include <svx/xfillit0.hxx>
+#include <svx/xflclit.hxx>
+#include <svx/xlnclit.hxx>
+
+#include <sfx2/evntconf.hxx>
+
+#include <sot/formats.hxx>
+
+#include <svx/svxdlg.hxx>
+#include <basegfx/polygon/b2dpolygon.hxx>
+#include <memory>
+
+using namespace com::sun::star;
+using ::com::sun::star::frame::XFrame;
+using ::com::sun::star::uno::Reference;
+
+#define TRANSCOL COL_WHITE
+
+IMapWindow::IMapWindow(const Reference< XFrame >& rxDocumentFrame, weld::Dialog* pDialog)
+    : GraphCtrl(pDialog)
+    , mxDocumentFrame(rxDocumentFrame)
+{
+    pIMapPool = new SfxItemPool( "IMapItemPool",
+                                 SID_ATTR_MACROITEM, SID_ATTR_MACROITEM, maItemInfos );
+    pIMapPool->FreezeIdRanges();
+}
+
+IMapWindow::~IMapWindow()
+{
+}
+
+void IMapWindow::SetDrawingArea(weld::DrawingArea* pDrawingArea)
+{
+    Size aSize(pDrawingArea->get_ref_device().LogicToPixel(Size(270, 170), MapMode(MapUnit::MapAppFont)));
+    pDrawingArea->set_size_request(aSize.Width(), aSize.Height());
+    SetOutputSizePixel(aSize);
+    weld::CustomWidgetController::SetDrawingArea(pDrawingArea);
+
+    SetSdrMode(true);
+
+    mxDropTargetHelper.reset(new IMapDropTargetHelper(*this));
+}
+
+void IMapWindow::SetImageMap( const ImageMap& rImageMap )
+{
+    ReplaceImageMap( rImageMap );
+}
+
+void IMapWindow::ReplaceImageMap( const ImageMap& rImageMap )
+{
+    SdrPage* pPage = nullptr;
+    aIMap = rImageMap;
+
+    if(GetSdrModel())
+    {
+        // try to access page
+        pPage = GetSdrModel()->GetPage(0);
+    }
+
+    if(pPage)
+    {
+        // clear SdrObjects with broadcasting
+        pPage->ClearSdrObjList();
+    }
+
+    if(GetSdrView())
+    {
+        // #i63762# reset selection at view
+        GetSdrView()->UnmarkAllObj();
+    }
+
+    // create new drawing objects
+    const sal_uInt16 nCount(rImageMap.GetIMapObjectCount());
+
+    for ( sal_uInt16 i(nCount); i > 0; i-- )
+    {
+        SdrObject* pNewObj = CreateObj( rImageMap.GetIMapObject( i - 1 ) );
+
+        if (pNewObj && pPage)
+        {
+            pPage->InsertObject( pNewObj );
+        }
+    }
+}
+
+void IMapWindow::ReplaceActualIMapInfo( const NotifyInfo& rNewInfo )
+{
+    const SdrObject*    pSdrObj = GetSelectedSdrObject();
+
+    if ( pSdrObj )
+    {
+        IMapObject* pIMapObj = GetIMapObj( pSdrObj );
+        if (pIMapObj)
+        {
+            pIMapObj->SetURL( rNewInfo.aMarkURL );
+            pIMapObj->SetAltText( rNewInfo.aMarkAltText );
+            pIMapObj->SetTarget( rNewInfo.aMarkTarget );
+            pModel->SetChanged();
+            UpdateInfo( false );
+        }
+    }
+}
+
+const ImageMap& IMapWindow::GetImageMap()
+{
+    if ( pModel->IsChanged() )
+    {
+        SdrPage* pPage = pModel->GetPage( 0 );
+
+        if ( pPage )
+        {
+            const size_t nCount = pPage->GetObjCount();
+
+            aIMap.ClearImageMap();
+
+            for ( size_t i = nCount; i; )
+            {
+                --i;
+                aIMap.InsertIMapObject( *( static_cast<IMapUserData*>( pPage->GetObj( i )->GetUserData( 0 ) )->GetObject() ) );
+            }
+        }
+
+        pModel->SetChanged( false );
+    }
+
+    return aIMap;
+}
+
+void IMapWindow::SetTargetList( const TargetList& rTargetList )
+{
+    // Delete old List
+    // Fill with the provided list
+    aTargetList = rTargetList;
+
+    pModel->SetChanged( false );
+}
+
+SdrObject* IMapWindow::CreateObj( const IMapObject* pIMapObj )
+{
+    tools::Rectangle   aClipRect( Point(), GetGraphicSize() );
+    SdrObject*  pSdrObj = nullptr;
+    IMapObjectPtr pCloneIMapObj;
+
+    switch( pIMapObj->GetType() )
+    {
+        case IMapObjectType::Rectangle:
+        {
+            const IMapRectangleObject* pIMapRectObj = static_cast<const IMapRectangleObject*>(pIMapObj);
+            tools::Rectangle               aDrawRect( pIMapRectObj->GetRectangle( false ) );
+
+            // clipped on CanvasPane
+            aDrawRect.Intersection( aClipRect );
+
+            pSdrObj = new SdrRectObj(*pModel, aDrawRect);
+            pCloneIMapObj.reset(static_cast<IMapObject*>(new IMapRectangleObject( *pIMapRectObj )));
+        }
+        break;
+
+        case IMapObjectType::Circle:
+        {
+            const IMapCircleObject*   pIMapCircleObj = static_cast<const IMapCircleObject*>(pIMapObj);
+            const Point         aCenter( pIMapCircleObj->GetCenter( false ) );
+            const tools::Long          nRadius = pIMapCircleObj->GetRadius( false );
+            const Point         aOffset( nRadius, nRadius );
+            tools::Rectangle           aCircle( aCenter - aOffset, aCenter + aOffset );
+
+            // limited to CanvasPane
+            aCircle.Intersection( aClipRect );
+
+            pSdrObj = new SdrCircObj(
+                    *pModel,
+                    SdrCircKind::Full,
+                    aCircle,
+                    0_deg100,
+                    36000_deg100);
+            pCloneIMapObj.reset(static_cast<IMapObject*>(new IMapCircleObject( *pIMapCircleObj )));
+        }
+        break;
+
+        case IMapObjectType::Polygon:
+        {
+            const IMapPolygonObject*  pIMapPolyObj = static_cast<const IMapPolygonObject*>(pIMapObj);
+
+            // If it actually is an ellipse, then another ellipse is created again
+            if ( pIMapPolyObj->HasExtraEllipse() )
+            {
+                tools::Rectangle aDrawRect( pIMapPolyObj->GetExtraEllipse() );
+
+                // clipped on CanvasPane
+                aDrawRect.Intersection( aClipRect );
+
+                pSdrObj = new SdrCircObj(
+                        *pModel,
+                        SdrCircKind::Full,
+                        aDrawRect,
+                        0_deg100,
+                        36000_deg100);
+            }
+            else
+            {
+                const tools::Polygon& rPoly = pIMapPolyObj->GetPolygon( false );
+                tools::Polygon aDrawPoly( rPoly );
+
+                // clipped on CanvasPane
+                aDrawPoly.Clip( aClipRect );
+
+                basegfx::B2DPolygon aPolygon;
+                aPolygon.append(aDrawPoly.getB2DPolygon());
+                pSdrObj = new SdrPathObj(
+                        *pModel,
+                        SdrObjKind::Polygon,
+                        basegfx::B2DPolyPolygon(aPolygon));
+            }
+
+            pCloneIMapObj.reset(static_cast<IMapObject*>(new IMapPolygonObject( *pIMapPolyObj )));
+        }
+        break;
+
+        default:
+        break;
+    }
+
+    if ( pSdrObj )
+    {
+        SfxItemSet aSet( pModel->GetItemPool() );
+
+        aSet.Put( XFillStyleItem( drawing::FillStyle_SOLID ) );
+        aSet.Put( XFillColorItem( "", TRANSCOL ) );
+
+        if ( !pIMapObj->IsActive() )
+        {
+            aSet.Put( XFillTransparenceItem( 100 ) );
+            aSet.Put( XLineColorItem( "", COL_RED ) );
+        }
+        else
+        {
+            aSet.Put( XFillTransparenceItem( 50 ) );
+            aSet.Put( XLineColorItem( "", COL_BLACK ) );
+        }
+
+        pSdrObj->SetMergedItemSetAndBroadcast(aSet);
+
+        pSdrObj->AppendUserData( std::unique_ptr<SdrObjUserData>(new IMapUserData( pCloneIMapObj )) );
+        pSdrObj->SetUserCall( GetSdrUserCall() );
+    }
+
+    return pSdrObj;
+}
+
+void IMapWindow::InitSdrModel()
+{
+    GraphCtrl::InitSdrModel();
+
+    SfxItemSet aSet( pModel->GetItemPool() );
+
+    aSet.Put( XFillColorItem( "", TRANSCOL ) );
+    aSet.Put( XFillTransparenceItem( 50 ) );
+    pView->SetAttributes( aSet );
+    pView->SetFrameDragSingles();
+}
+
+void IMapWindow::SdrObjCreated( const SdrObject& rObj )
+{
+    switch( rObj.GetObjIdentifier() )
+    {
+        case SdrObjKind::Rectangle:
+        {
+            SdrRectObj*    pRectObj = const_cast<SdrRectObj*>(static_cast<const SdrRectObj*>(&rObj));
+            auto pObj = std::make_shared<IMapRectangleObject>( pRectObj->GetLogicRect(), "", "", "", "", "", true, false );
+
+            pRectObj->AppendUserData( std::unique_ptr<SdrObjUserData>(new IMapUserData( pObj )) );
+        }
+        break;
+
+        case SdrObjKind::CircleOrEllipse:
+        {
+            SdrCircObj* pCircObj = const_cast<SdrCircObj*>( static_cast<const SdrCircObj*>(&rObj) );
+            SdrPathObj* pPathObj = static_cast<SdrPathObj*>( pCircObj->ConvertToPolyObj( false, false ).release() );
+            tools::Polygon aPoly(pPathObj->GetPathPoly().getB2DPolygon(0));
+
+            // always use SdrObject::Free(...) for SdrObjects (!)
+            SdrObject* pTemp(pPathObj);
+            SdrObject::Free(pTemp);
+
+            auto pObj = std::make_shared<IMapPolygonObject>( aPoly, "", "", "", "", "", true, false );
+            pObj->SetExtraEllipse( aPoly.GetBoundRect() );
+            pCircObj->AppendUserData( std::unique_ptr<SdrObjUserData>(new IMapUserData( pObj )) );
+        }
+        break;
+
+        case SdrObjKind::Polygon:
+        case SdrObjKind::FreehandFill:
+        case SdrObjKind::PathPoly:
+        case SdrObjKind::PathFill:
+        {
+            SdrPathObj* pPathObj = const_cast<SdrPathObj*>( static_cast<const SdrPathObj*>(&rObj) );
+            const basegfx::B2DPolyPolygon& rXPolyPoly = pPathObj->GetPathPoly();
+
+            if ( rXPolyPoly.count() )
+            {
+                tools::Polygon aPoly(rXPolyPoly.getB2DPolygon(0));
+                auto pObj = std::make_shared<IMapPolygonObject>( aPoly, "", "", "", "", "", true, false );
+                pPathObj->AppendUserData( std::unique_ptr<SdrObjUserData>(new IMapUserData( pObj )) );
+            }
+        }
+        break;
+
+        default:
+        break;
+    }
+}
+
+void IMapWindow::SdrObjChanged( const SdrObject& rObj )
+{
+    IMapUserData* pUserData = static_cast<IMapUserData*>( rObj.GetUserData( 0 ) );
+
+    if ( !pUserData )
+        return;
+
+    OUString        aURL;
+    OUString        aAltText;
+    OUString        aDesc;
+    OUString        aTarget;
+    IMapObjectPtr   pIMapObj = pUserData->GetObject();
+    bool        bActive = true;
+
+    if ( pIMapObj )
+    {
+        aURL = pIMapObj->GetURL();
+        aAltText = pIMapObj->GetAltText();
+        aDesc = pIMapObj->GetDesc();
+        aTarget = pIMapObj->GetTarget();
+        bActive = pIMapObj->IsActive();
+    }
+
+    switch( rObj.GetObjIdentifier() )
+    {
+        case SdrObjKind::Rectangle:
+        {
+            pUserData->ReplaceObject( std::make_shared<IMapRectangleObject>( static_cast<const SdrRectObj&>(rObj).GetLogicRect(),
+                      aURL, aAltText, aDesc, aTarget, "", bActive, false ) );
+        }
+        break;
+
+        case SdrObjKind::CircleOrEllipse:
+        {
+            const SdrCircObj& rCircObj = static_cast<const SdrCircObj&>(rObj);
+            SdrPathObj* pPathObj = static_cast<SdrPathObj*>( rCircObj.ConvertToPolyObj( false, false ).release() );
+            tools::Polygon aPoly(pPathObj->GetPathPoly().getB2DPolygon(0));
+
+            auto pObj = std::make_shared<IMapPolygonObject>( aPoly, aURL, aAltText, aDesc, aTarget, "", bActive, false );
+            pObj->SetExtraEllipse( aPoly.GetBoundRect() );
+
+            // was only created by us temporarily
+            // always use SdrObject::Free(...) for SdrObjects (!)
+            SdrObject* pTemp(pPathObj);
+            SdrObject::Free(pTemp);
+
+            pUserData->ReplaceObject( pObj );
+        }
+        break;
+
+        case SdrObjKind::Polygon:
+        case SdrObjKind::FreehandFill:
+        case SdrObjKind::PathPoly:
+        case SdrObjKind::PathFill:
+        {
+            const SdrPathObj& rPathObj = static_cast<const SdrPathObj&>(rObj);
+            const basegfx::B2DPolyPolygon& rXPolyPoly = rPathObj.GetPathPoly();
+
+            if ( rXPolyPoly.count() )
+            {
+                tools::Polygon aPoly(rPathObj.GetPathPoly().getB2DPolygon(0));
+                auto pObj = std::make_shared<IMapPolygonObject>( aPoly, aURL, aAltText, aDesc, aTarget, "", bActive, false );
+                pUserData->ReplaceObject( pObj );
+            }
+        }
+        break;
+
+        default:
+        break;
+    }
+}
+
+bool IMapWindow::MouseButtonUp(const MouseEvent& rMEvt)
+{
+    bool bRet = GraphCtrl::MouseButtonUp( rMEvt );
+    UpdateInfo( true );
+    return bRet;
+}
+
+void IMapWindow::MarkListHasChanged()
+{
+    GraphCtrl::MarkListHasChanged();
+    UpdateInfo( false );
+}
+
+SdrObject* IMapWindow::GetHitSdrObj( const Point& rPosPixel ) const
+{
+    OutputDevice& rDevice = GetDrawingArea()->get_ref_device();
+
+    SdrObject*  pObj = nullptr;
+    Point       aPt = rDevice.PixelToLogic( rPosPixel );
+
+    if ( tools::Rectangle( Point(), GetGraphicSize() ).Contains( aPt ) )
+    {
+        SdrPage* pPage = pModel->GetPage( 0 );
+        if ( pPage )
+        {
+            for ( size_t i = pPage->GetObjCount(); i > 0; )
+            {
+                --i;
+                SdrObject*  pTestObj = pPage->GetObj( i );
+                IMapObject* pIMapObj = GetIMapObj( pTestObj );
+
+                if ( pIMapObj && pIMapObj->IsHit( aPt ) )
+                {
+                    pObj = pTestObj;
+                    break;
+                }
+            }
+        }
+    }
+
+    return pObj;
+}
+
+IMapObject* IMapWindow::GetIMapObj( const SdrObject* pSdrObj )
+{
+    IMapObject* pIMapObj = nullptr;
+
+    if ( pSdrObj )
+    {
+        IMapUserData* pUserData = static_cast<IMapUserData*>( pSdrObj->GetUserData( 0 ) );
+
+        if ( pUserData )
+            pIMapObj = pUserData->GetObject().get();
+    }
+
+    return pIMapObj;
+}
+
+bool IMapWindow::Command(const CommandEvent& rCEvt)
+{
+    if ( rCEvt.GetCommand() == CommandEventId::ContextMenu )
+    {
+        std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(GetDrawingArea(), "svx/ui/imapmenu.ui"));
+        mxPopupMenu = xBuilder->weld_menu("menu");
+        const SdrMarkList&  rMarkList = pView->GetMarkedObjectList();
+        const size_t nMarked = rMarkList.GetMarkCount();
+
+        mxPopupMenu->set_sensitive("url", false);
+        mxPopupMenu->set_sensitive("active", false);
+        mxPopupMenu->set_sensitive("macro", false);
+        mxPopupMenu->set_sensitive("selectall", pModel->GetPage(0)->GetObjCount() != pView->GetMarkedObjectCount());
+
+        if ( !nMarked )
+        {
+            mxPopupMenu->set_sensitive("arrange", false);
+            mxPopupMenu->set_sensitive("delete", false);
+        }
+        else
+        {
+            if ( nMarked == 1 )
+            {
+                SdrObject*  pSdrObj = GetSelectedSdrObject();
+
+                mxPopupMenu->set_sensitive("url", true);
+                mxPopupMenu->set_sensitive("active", true);
+                mxPopupMenu->set_sensitive("macro", true);
+                mxPopupMenu->set_active("active", GetIMapObj(pSdrObj)->IsActive());
+            }
+
+            mxPopupMenu->set_sensitive("arrange", true);
+            mxPopupMenu->set_sensitive("delete", true);
+        }
+
+        MenuSelectHdl(mxPopupMenu->popup_at_rect(GetDrawingArea(), tools::Rectangle(rCEvt.GetMousePosPixel(), Size(1,1))));
+
+        mxPopupMenu.reset();
+
+        return true;
+    }
+    return CustomWidgetController::Command(rCEvt);
+}
+
+IMapDropTargetHelper::IMapDropTargetHelper(IMapWindow& rImapWindow)
+    : DropTargetHelper(rImapWindow.GetDrawingArea()->get_drop_target())
+    , m_rImapWindow(rImapWindow)
+{
+}
+
+sal_Int8 IMapDropTargetHelper::AcceptDrop( const AcceptDropEvent& rEvt )
+{
+    return m_rImapWindow.AcceptDrop(rEvt);
+}
+
+sal_Int8 IMapDropTargetHelper::ExecuteDrop( const ExecuteDropEvent& rEvt )
+{
+    return m_rImapWindow.ExecuteDrop(rEvt);
+}
+
+sal_Int8 IMapWindow::AcceptDrop( const AcceptDropEvent& rEvt )
+{
+    return( ( GetHitSdrObj( rEvt.maPosPixel ) != nullptr ) ? rEvt.mnAction : DND_ACTION_NONE );
+}
+
+sal_Int8 IMapWindow::ExecuteDrop( const ExecuteDropEvent& rEvt )
+{
+    sal_Int8 nRet = DND_ACTION_NONE;
+
+    if (mxDropTargetHelper->IsDropFormatSupported(SotClipboardFormatId::NETSCAPE_BOOKMARK))
+    {
+        INetBookmark    aBookMark( "", "" );
+        SdrObject*      pSdrObj = GetHitSdrObj( rEvt.maPosPixel );
+
+        if( pSdrObj && TransferableDataHelper( rEvt.maDropEvent.Transferable ).GetINetBookmark( SotClipboardFormatId::NETSCAPE_BOOKMARK, aBookMark ) )
+        {
+            IMapObject* pIMapObj = GetIMapObj( pSdrObj );
+
+            pIMapObj->SetURL( aBookMark.GetURL() );
+            pIMapObj->SetAltText( aBookMark.GetDescription() );
+            pModel->SetChanged();
+            pView->UnmarkAll();
+            pView->MarkObj( pSdrObj, pView->GetSdrPageView() );
+            UpdateInfo( true );
+            nRet =  rEvt.mnAction;
+        }
+    }
+
+    return nRet;
+}
+
+OUString IMapWindow::RequestHelp(tools::Rectangle& rHelpArea)
+{
+    OutputDevice& rDevice = GetDrawingArea()->get_ref_device();
+
+    Point aPos = rDevice.PixelToLogic(rHelpArea.TopLeft());
+
+    SdrPageView* pPageView = nullptr;
+    SdrObject* pSdrObj = pView->PickObj(aPos, pView->getHitTolLog(), pPageView);
+    if (pSdrObj)
+    {
+        const IMapObject*   pIMapObj = GetIMapObj( pSdrObj );
+        if ( pIMapObj )
+        {
+            OUString aStr = pIMapObj->GetURL();
+            if ( !aStr.isEmpty() )
+            {
+                rHelpArea = rDevice.LogicToPixel(tools::Rectangle( Point(), GetGraphicSize()));
+                return aStr;
+            }
+        }
+    }
+
+    return OUString();
+}
+
+void IMapWindow::SetCurrentObjState( bool bActive )
+{
+    SdrObject* pObj = GetSelectedSdrObject();
+
+    if ( !pObj )
+        return;
+
+    SfxItemSet aSet( pModel->GetItemPool() );
+
+    GetIMapObj( pObj )->SetActive( bActive );
+
+    aSet.Put( XFillColorItem( "", TRANSCOL ) );
+
+    if ( !bActive )
+    {
+        aSet.Put( XFillTransparenceItem( 100 ) );
+        aSet.Put( XLineColorItem( "", COL_RED ) );
+    }
+    else
+    {
+        aSet.Put( XFillTransparenceItem( 50 ) );
+        aSet.Put( XLineColorItem( "", COL_BLACK ) );
+    }
+
+    pView->SetAttributes( aSet );
+}
+
+void IMapWindow::UpdateInfo( bool bNewObj )
+{
+    if ( !aInfoLink.IsSet() )
+        return;
+
+    const SdrObject*    pSdrObj = GetSelectedSdrObject();
+    const IMapObject*   pIMapObj = pSdrObj ? GetIMapObj( pSdrObj ) : nullptr;
+
+    aInfo.bNewObj = bNewObj;
+
+    if ( pIMapObj )
+    {
+        aInfo.bOneMarked = true;
+        aInfo.aMarkURL = pIMapObj->GetURL();
+        aInfo.aMarkAltText = pIMapObj->GetAltText();
+        aInfo.aMarkTarget = pIMapObj->GetTarget();
+        aInfo.bActivated = pIMapObj->IsActive();
+        aInfoLink.Call( *this );
+    }
+    else
+    {
+        aInfo.aMarkURL.clear();
+        aInfo.aMarkAltText.clear();
+        aInfo.aMarkTarget.clear();
+        aInfo.bOneMarked = false;
+        aInfo.bActivated = false;
+    }
+
+    aInfoLink.Call( *this );
+}
+
+void IMapWindow::DoMacroAssign()
+{
+    SdrObject*  pSdrObj = GetSelectedSdrObject();
+
+    if ( !pSdrObj )
+        return;
+
+    SfxItemSetFixed<SID_ATTR_MACROITEM, SID_ATTR_MACROITEM, SID_EVENTCONFIG, SID_EVENTCONFIG>
+        aSet(*pIMapPool);
+
+    SfxEventNamesItem aNamesItem(SID_EVENTCONFIG);
+    aNamesItem.AddEvent( "MouseOver", "", SvMacroItemId::OnMouseOver );
+    aNamesItem.AddEvent( "MouseOut", "", SvMacroItemId::OnMouseOut );
+    aSet.Put( aNamesItem );
+
+    SvxMacroItem    aMacroItem(SID_ATTR_MACROITEM);
+    IMapObject*     pIMapObj = GetIMapObj( pSdrObj );
+    aMacroItem.SetMacroTable( pIMapObj->GetMacroTable() );
+    aSet.Put( aMacroItem );
+
+    SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
+    ScopedVclPtr<SfxAbstractDialog> pMacroDlg(pFact->CreateEventConfigDialog(GetDrawingArea(), aSet, mxDocumentFrame));
+
+    if ( pMacroDlg->Execute() == RET_OK )
+    {
+        const SfxItemSet* pOutSet = pMacroDlg->GetOutputItemSet();
+        pIMapObj->SetMacroTable( pOutSet->Get( SID_ATTR_MACROITEM ).GetMacroTable() );
+        pModel->SetChanged();
+        UpdateInfo( false );
+    }
+}
+
+void IMapWindow::DoPropertyDialog()
+{
+    SdrObject*  pSdrObj = GetSelectedSdrObject();
+
+    if ( !pSdrObj )
+        return;
+
+    IMapObject* pIMapObj = GetIMapObj( pSdrObj );
+    SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
+    ScopedVclPtr<AbstractURLDlg> aDlg(pFact->CreateURLDialog(GetDrawingArea(), pIMapObj->GetURL(), pIMapObj->GetAltText(), pIMapObj->GetDesc(),
+                                    pIMapObj->GetTarget(), pIMapObj->GetName(), aTargetList));
+    if ( aDlg->Execute() != RET_OK )
+        return;
+
+    const OUString aURLText( aDlg->GetURL() );
+
+    if ( !aURLText.isEmpty() )
+    {
+        INetURLObject aObj( aURLText, INetProtocol::File );
+        DBG_ASSERT( aObj.GetProtocol() != INetProtocol::NotValid, "Invalid URL" );
+        pIMapObj->SetURL( aObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ) );
+    }
+    else
+        pIMapObj->SetURL( aURLText );
+
+    pIMapObj->SetAltText( aDlg->GetAltText() );
+    pIMapObj->SetDesc( aDlg->GetDesc() );
+    pIMapObj->SetTarget( aDlg->GetTarget() );
+    pIMapObj->SetName( aDlg->GetName() );
+    pModel->SetChanged();
+    UpdateInfo( true );
+}
+
+void IMapWindow::MenuSelectHdl(const OString& rId)
+{
+    if (rId == "url")
+        DoPropertyDialog();
+    else if (rId == "macro")
+        DoMacroAssign();
+    else if (rId == "active")
+    {
+        const bool bNewState = !mxPopupMenu->get_active(rId);
+        SetCurrentObjState(bNewState);
+        UpdateInfo( false );
+    }
+    else if (rId == "front")
+        pView->PutMarkedToTop();
+    else if (rId == "forward")
+        pView->MovMarkedToTop();
+    else if (rId == "backward")
+        pView->MovMarkedToBtm();
+    else if (rId == "back")
+        pView->PutMarkedToBtm();
+    else if (rId == "selectall")
+        pView->MarkAll();
+    else if (rId == "delete")
+        pView->DeleteMarked();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */