svx/source/dialog/imapwnd.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 #include <tools/urlobj.hxx>
  21 #include <vcl/commandevent.hxx>
  22 #include <vcl/imaprect.hxx>
  23 #include <vcl/imapcirc.hxx>
  24 #include <vcl/imappoly.hxx>
  25 #include <vcl/svapp.hxx>
  26 #include <svl/urlbmk.hxx>
  27
  28 #include <svx/svxids.hrc>
  29 #include "imapwnd.hxx"
  30 #include <svx/svdpage.hxx>
  31 #include <svx/svdorect.hxx>
  32 #include <svx/svdocirc.hxx>
  33 #include <svx/svdopath.hxx>
  34 #include <svx/xfltrit.hxx>
  35 #include <svx/svdpagv.hxx>
  36 #include <svx/xfillit0.hxx>
  37 #include <svx/xflclit.hxx>
  38 #include <svx/xlnclit.hxx>
  39
  40 #include <sfx2/evntconf.hxx>
  41
  42 #include <sot/formats.hxx>
  43
  44 #include <svx/svxdlg.hxx>
  45 #include <basegfx/polygon/b2dpolygon.hxx>
  46 #include <memory>
  47
  48 using namespace com::sun::star;
  49 using ::com::sun::star::frame::XFrame;
  50 using ::com::sun::star::uno::Reference;
  51
  52 #define TRANSCOL COL_WHITE
  53
  54 IMapWindow::IMapWindow(const Reference< XFrame >& rxDocumentFrame, weld::Dialog* pDialog)
  55     : GraphCtrl(pDialog)
  56     , mxDocumentFrame(rxDocumentFrame)
  57 {
  58     pIMapPool = new SfxItemPool( "IMapItemPool",
  59                                  SID_ATTR_MACROITEM, SID_ATTR_MACROITEM, maItemInfos );
  60     pIMapPool->FreezeIdRanges();
  61 }
  62
  63 IMapWindow::~IMapWindow()
  64 {
  65 }
  66
  67 void IMapWindow::SetDrawingArea(weld::DrawingArea* pDrawingArea)
  68 {
  69     Size aSize(pDrawingArea->get_ref_device().LogicToPixel(Size(270, 170), MapMode(MapUnit::MapAppFont)));
  70     pDrawingArea->set_size_request(aSize.Width(), aSize.Height());
  71     SetOutputSizePixel(aSize);
  72     weld::CustomWidgetController::SetDrawingArea(pDrawingArea);
  73
  74     SetSdrMode(true);
  75
  76     mxDropTargetHelper.reset(new IMapDropTargetHelper(*this));
  77 }
  78
  79 void IMapWindow::SetImageMap( const ImageMap& rImageMap )
  80 {
  81     ReplaceImageMap( rImageMap );
  82 }
  83
  84 void IMapWindow::ReplaceImageMap( const ImageMap& rImageMap )
  85 {
  86     SdrPage* pPage = nullptr;
  87     aIMap = rImageMap;
  88
  89     if(GetSdrModel())
  90     {
  91         // try to access page
  92         pPage = GetSdrModel()->GetPage(0);
  93     }
  94
  95     if(pPage)
  96     {
  97         // clear SdrObjects with broadcasting
  98         pPage->ClearSdrObjList();
  99     }
 100
 101     if(GetSdrView())
 102     {
 103         // #i63762# reset selection at view
 104         GetSdrView()->UnmarkAllObj();
 105     }
 106
 107     // create new drawing objects
 108     const sal_uInt16 nCount(rImageMap.GetIMapObjectCount());
 109
 110     for ( sal_uInt16 i(nCount); i > 0; i-- )
 111     {
 112         rtl::Reference<SdrObject> pNewObj = CreateObj( rImageMap.GetIMapObject( i - 1 ) );
 113
 114         if (pNewObj && pPage)
 115         {
 116             pPage->InsertObject( pNewObj.get() );
 117         }
 118     }
 119 }
 120
 121 void IMapWindow::ReplaceActualIMapInfo( const NotifyInfo& rNewInfo )
 122 {
 123     const SdrObject*    pSdrObj = GetSelectedSdrObject();
 124
 125     if ( pSdrObj )
 126     {
 127         IMapObject* pIMapObj = GetIMapObj( pSdrObj );
 128         if (pIMapObj)
 129         {
 130             pIMapObj->SetURL( rNewInfo.aMarkURL );
 131             pIMapObj->SetAltText( rNewInfo.aMarkAltText );
 132             pIMapObj->SetTarget( rNewInfo.aMarkTarget );
 133             pModel->SetChanged();
 134             UpdateInfo( false );
 135         }
 136     }
 137 }
 138
 139 const ImageMap& IMapWindow::GetImageMap()
 140 {
 141     if ( pModel->IsChanged() )
 142     {
 143         SdrPage* pPage = pModel->GetPage( 0 );
 144
 145         if ( pPage )
 146         {
 147             const size_t nCount = pPage->GetObjCount();
 148
 149             aIMap.ClearImageMap();
 150
 151             for ( size_t i = nCount; i; )
 152             {
 153                 --i;
 154                 aIMap.InsertIMapObject( *( static_cast<IMapUserData*>( pPage->GetObj( i )->GetUserData( 0 ) )->GetObject() ) );
 155             }
 156         }
 157
 158         pModel->SetChanged( false );
 159     }
 160
 161     return aIMap;
 162 }
 163
 164 void IMapWindow::SetTargetList( const TargetList& rTargetList )
 165 {
 166     // Delete old List
 167     // Fill with the provided list
 168     aTargetList = rTargetList;
 169
 170     pModel->SetChanged( false );
 171 }
 172
 173 rtl::Reference<SdrObject> IMapWindow::CreateObj( const IMapObject* pIMapObj )
 174 {
 175     tools::Rectangle   aClipRect( Point(), GetGraphicSize() );
 176     rtl::Reference<SdrObject> pSdrObj;
 177     IMapObjectPtr pCloneIMapObj;
 178
 179     switch( pIMapObj->GetType() )
 180     {
 181         case IMapObjectType::Rectangle:
 182         {
 183             const IMapRectangleObject* pIMapRectObj = static_cast<const IMapRectangleObject*>(pIMapObj);
 184             tools::Rectangle               aDrawRect( pIMapRectObj->GetRectangle( false ) );
 185
 186             // clipped on CanvasPane
 187             aDrawRect.Intersection( aClipRect );
 188
 189             pSdrObj = new SdrRectObj(*pModel, aDrawRect);
 190             pCloneIMapObj.reset(static_cast<IMapObject*>(new IMapRectangleObject( *pIMapRectObj )));
 191         }
 192         break;
 193
 194         case IMapObjectType::Circle:
 195         {
 196             const IMapCircleObject*   pIMapCircleObj = static_cast<const IMapCircleObject*>(pIMapObj);
 197             const Point         aCenter( pIMapCircleObj->GetCenter( false ) );
 198             const tools::Long          nRadius = pIMapCircleObj->GetRadius( false );
 199             const Point         aOffset( nRadius, nRadius );
 200             tools::Rectangle           aCircle( aCenter - aOffset, aCenter + aOffset );
 201
 202             // limited to CanvasPane
 203             aCircle.Intersection( aClipRect );
 204
 205             pSdrObj = new SdrCircObj(
 206                     *pModel,
 207                     SdrCircKind::Full,
 208                     aCircle,
 209                     0_deg100,
 210                     36000_deg100);
 211             pCloneIMapObj.reset(static_cast<IMapObject*>(new IMapCircleObject( *pIMapCircleObj )));
 212         }
 213         break;
 214
 215         case IMapObjectType::Polygon:
 216         {
 217             const IMapPolygonObject*  pIMapPolyObj = static_cast<const IMapPolygonObject*>(pIMapObj);
 218
 219             // If it actually is an ellipse, then another ellipse is created again
 220             if ( pIMapPolyObj->HasExtraEllipse() )
 221             {
 222                 tools::Rectangle aDrawRect( pIMapPolyObj->GetExtraEllipse() );
 223
 224                 // clipped on CanvasPane
 225                 aDrawRect.Intersection( aClipRect );
 226
 227                 pSdrObj = new SdrCircObj(
 228                         *pModel,
 229                         SdrCircKind::Full,
 230                         aDrawRect,
 231                         0_deg100,
 232                         36000_deg100);
 233             }
 234             else
 235             {
 236                 const tools::Polygon& rPoly = pIMapPolyObj->GetPolygon( false );
 237                 tools::Polygon aDrawPoly( rPoly );
 238
 239                 // clipped on CanvasPane
 240                 aDrawPoly.Clip( aClipRect );
 241
 242                 basegfx::B2DPolygon aPolygon;
 243                 aPolygon.append(aDrawPoly.getB2DPolygon());
 244                 pSdrObj = new SdrPathObj(
 245                         *pModel,
 246                         SdrObjKind::Polygon,
 247                         basegfx::B2DPolyPolygon(aPolygon));
 248             }
 249
 250             pCloneIMapObj.reset(static_cast<IMapObject*>(new IMapPolygonObject( *pIMapPolyObj )));
 251         }
 252         break;
 253
 254         default:
 255         break;
 256     }
 257
 258     if ( pSdrObj )
 259     {
 260         SfxItemSet aSet( pModel->GetItemPool() );
 261
 262         aSet.Put( XFillStyleItem( drawing::FillStyle_SOLID ) );
 263         aSet.Put( XFillColorItem( "", TRANSCOL ) );
 264
 265         if ( !pIMapObj->IsActive() )
 266         {
 267             aSet.Put( XFillTransparenceItem( 100 ) );
 268             aSet.Put( XLineColorItem( "", COL_RED ) );
 269         }
 270         else
 271         {
 272             aSet.Put( XFillTransparenceItem( 50 ) );
 273             aSet.Put( XLineColorItem( "", COL_BLACK ) );
 274         }
 275
 276         pSdrObj->SetMergedItemSetAndBroadcast(aSet);
 277
 278         pSdrObj->AppendUserData( std::unique_ptr<SdrObjUserData>(new IMapUserData( pCloneIMapObj )) );
 279         pSdrObj->SetUserCall( GetSdrUserCall() );
 280     }
 281
 282     return pSdrObj;
 283 }
 284
 285 void IMapWindow::InitSdrModel()
 286 {
 287     GraphCtrl::InitSdrModel();
 288
 289     SfxItemSet aSet( pModel->GetItemPool() );
 290
 291     aSet.Put( XFillColorItem( "", TRANSCOL ) );
 292     aSet.Put( XFillTransparenceItem( 50 ) );
 293     pView->SetAttributes( aSet );
 294     pView->SetFrameDragSingles();
 295 }
 296
 297 void IMapWindow::SdrObjCreated( const SdrObject& rObj )
 298 {
 299     switch( rObj.GetObjIdentifier() )
 300     {
 301         case SdrObjKind::Rectangle:
 302         {
 303             SdrRectObj*    pRectObj = const_cast<SdrRectObj*>(static_cast<const SdrRectObj*>(&rObj));
 304             auto pObj = std::make_shared<IMapRectangleObject>( pRectObj->GetLogicRect(), "", "", "", "", "", true, false );
 305
 306             pRectObj->AppendUserData( std::unique_ptr<SdrObjUserData>(new IMapUserData( pObj )) );
 307         }
 308         break;
 309
 310         case SdrObjKind::CircleOrEllipse:
 311         {
 312             SdrCircObj* pCircObj = const_cast<SdrCircObj*>( static_cast<const SdrCircObj*>(&rObj) );
 313             rtl::Reference<SdrPathObj> pPathObj = static_cast<SdrPathObj*>( pCircObj->ConvertToPolyObj( false, false ).get() );
 314             tools::Polygon aPoly(pPathObj->GetPathPoly().getB2DPolygon(0));
 315
 316             pPathObj.clear();
 317
 318             auto pObj = std::make_shared<IMapPolygonObject>( aPoly, "", "", "", "", "", true, false );
 319             pObj->SetExtraEllipse( aPoly.GetBoundRect() );
 320             pCircObj->AppendUserData( std::unique_ptr<SdrObjUserData>(new IMapUserData( pObj )) );
 321         }
 322         break;
 323
 324         case SdrObjKind::Polygon:
 325         case SdrObjKind::FreehandFill:
 326         case SdrObjKind::PathPoly:
 327         case SdrObjKind::PathFill:
 328         {
 329             SdrPathObj* pPathObj = const_cast<SdrPathObj*>( static_cast<const SdrPathObj*>(&rObj) );
 330             const basegfx::B2DPolyPolygon& rXPolyPoly = pPathObj->GetPathPoly();
 331
 332             if ( rXPolyPoly.count() )
 333             {
 334                 tools::Polygon aPoly(rXPolyPoly.getB2DPolygon(0));
 335                 auto pObj = std::make_shared<IMapPolygonObject>( aPoly, "", "", "", "", "", true, false );
 336                 pPathObj->AppendUserData( std::unique_ptr<SdrObjUserData>(new IMapUserData( pObj )) );
 337             }
 338         }
 339         break;
 340
 341         default:
 342         break;
 343     }
 344 }
 345
 346 void IMapWindow::SdrObjChanged( const SdrObject& rObj )
 347 {
 348     IMapUserData* pUserData = static_cast<IMapUserData*>( rObj.GetUserData( 0 ) );
 349
 350     if ( !pUserData )
 351         return;
 352
 353     OUString        aURL;
 354     OUString        aAltText;
 355     OUString        aDesc;
 356     OUString        aTarget;
 357     IMapObjectPtr   pIMapObj = pUserData->GetObject();
 358     bool        bActive = true;
 359
 360     if ( pIMapObj )
 361     {
 362         aURL = pIMapObj->GetURL();
 363         aAltText = pIMapObj->GetAltText();
 364         aDesc = pIMapObj->GetDesc();
 365         aTarget = pIMapObj->GetTarget();
 366         bActive = pIMapObj->IsActive();
 367     }
 368
 369     switch( rObj.GetObjIdentifier() )
 370     {
 371         case SdrObjKind::Rectangle:
 372         {
 373             pUserData->ReplaceObject( std::make_shared<IMapRectangleObject>( static_cast<const SdrRectObj&>(rObj).GetLogicRect(),
 374                       aURL, aAltText, aDesc, aTarget, "", bActive, false ) );
 375         }
 376         break;
 377
 378         case SdrObjKind::CircleOrEllipse:
 379         {
 380             const SdrCircObj& rCircObj = static_cast<const SdrCircObj&>(rObj);
 381             rtl::Reference<SdrPathObj> pPathObj = static_cast<SdrPathObj*>( rCircObj.ConvertToPolyObj( false, false ).get() );
 382             tools::Polygon aPoly(pPathObj->GetPathPoly().getB2DPolygon(0));
 383
 384             auto pObj = std::make_shared<IMapPolygonObject>( aPoly, aURL, aAltText, aDesc, aTarget, "", bActive, false );
 385             pObj->SetExtraEllipse( aPoly.GetBoundRect() );
 386
 387             pPathObj.clear();
 388
 389             pUserData->ReplaceObject( pObj );
 390         }
 391         break;
 392
 393         case SdrObjKind::Polygon:
 394         case SdrObjKind::FreehandFill:
 395         case SdrObjKind::PathPoly:
 396         case SdrObjKind::PathFill:
 397         {
 398             const SdrPathObj& rPathObj = static_cast<const SdrPathObj&>(rObj);
 399             const basegfx::B2DPolyPolygon& rXPolyPoly = rPathObj.GetPathPoly();
 400
 401             if ( rXPolyPoly.count() )
 402             {
 403                 tools::Polygon aPoly(rPathObj.GetPathPoly().getB2DPolygon(0));
 404                 auto pObj = std::make_shared<IMapPolygonObject>( aPoly, aURL, aAltText, aDesc, aTarget, "", bActive, false );
 405                 pUserData->ReplaceObject( pObj );
 406             }
 407         }
 408         break;
 409
 410         default:
 411         break;
 412     }
 413 }
 414
 415 bool IMapWindow::MouseButtonUp(const MouseEvent& rMEvt)
 416 {
 417     bool bRet = GraphCtrl::MouseButtonUp( rMEvt );
 418     UpdateInfo( true );
 419     return bRet;
 420 }
 421
 422 void IMapWindow::MarkListHasChanged()
 423 {
 424     GraphCtrl::MarkListHasChanged();
 425     UpdateInfo( false );
 426 }
 427
 428 SdrObject* IMapWindow::GetHitSdrObj( const Point& rPosPixel ) const
 429 {
 430     OutputDevice& rDevice = GetDrawingArea()->get_ref_device();
 431
 432     SdrObject*  pObj = nullptr;
 433     Point       aPt = rDevice.PixelToLogic( rPosPixel );
 434
 435     if ( tools::Rectangle( Point(), GetGraphicSize() ).Contains( aPt ) )
 436     {
 437         SdrPage* pPage = pModel->GetPage( 0 );
 438         if ( pPage )
 439         {
 440             for ( size_t i = pPage->GetObjCount(); i > 0; )
 441             {
 442                 --i;
 443                 SdrObject*  pTestObj = pPage->GetObj( i );
 444                 IMapObject* pIMapObj = GetIMapObj( pTestObj );
 445
 446                 if ( pIMapObj && pIMapObj->IsHit( aPt ) )
 447                 {
 448                     pObj = pTestObj;
 449                     break;
 450                 }
 451             }
 452         }
 453     }
 454
 455     return pObj;
 456 }
 457
 458 IMapObject* IMapWindow::GetIMapObj( const SdrObject* pSdrObj )
 459 {
 460     IMapObject* pIMapObj = nullptr;
 461
 462     if ( pSdrObj )
 463     {
 464         IMapUserData* pUserData = static_cast<IMapUserData*>( pSdrObj->GetUserData( 0 ) );
 465
 466         if ( pUserData )
 467             pIMapObj = pUserData->GetObject().get();
 468     }
 469
 470     return pIMapObj;
 471 }
 472
 473 bool IMapWindow::Command(const CommandEvent& rCEvt)
 474 {
 475     if ( rCEvt.GetCommand() == CommandEventId::ContextMenu )
 476     {
 477         std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(GetDrawingArea(), "svx/ui/imapmenu.ui"));
 478         mxPopupMenu = xBuilder->weld_menu("menu");
 479         const SdrMarkList&  rMarkList = pView->GetMarkedObjectList();
 480         const size_t nMarked = rMarkList.GetMarkCount();
 481
 482         mxPopupMenu->set_sensitive("url", false);
 483         mxPopupMenu->set_sensitive("active", false);
 484         mxPopupMenu->set_sensitive("macro", false);
 485         mxPopupMenu->set_sensitive("selectall", pModel->GetPage(0)->GetObjCount() != pView->GetMarkedObjectCount());
 486
 487         if ( !nMarked )
 488         {
 489             mxPopupMenu->set_sensitive("arrange", false);
 490             mxPopupMenu->set_sensitive("delete", false);
 491         }
 492         else
 493         {
 494             if ( nMarked == 1 )
 495             {
 496                 SdrObject*  pSdrObj = GetSelectedSdrObject();
 497
 498                 mxPopupMenu->set_sensitive("url", true);
 499                 mxPopupMenu->set_sensitive("active", true);
 500                 mxPopupMenu->set_sensitive("macro", true);
 501                 mxPopupMenu->set_active("active", GetIMapObj(pSdrObj)->IsActive());
 502             }
 503
 504             mxPopupMenu->set_sensitive("arrange", true);
 505             mxPopupMenu->set_sensitive("delete", true);
 506         }
 507
 508         MenuSelectHdl(mxPopupMenu->popup_at_rect(GetDrawingArea(), tools::Rectangle(rCEvt.GetMousePosPixel(), Size(1,1))));
 509
 510         mxPopupMenu.reset();
 511
 512         return true;
 513     }
 514     return CustomWidgetController::Command(rCEvt);
 515 }
 516
 517 IMapDropTargetHelper::IMapDropTargetHelper(IMapWindow& rImapWindow)
 518     : DropTargetHelper(rImapWindow.GetDrawingArea()->get_drop_target())
 519     , m_rImapWindow(rImapWindow)
 520 {
 521 }
 522
 523 sal_Int8 IMapDropTargetHelper::AcceptDrop( const AcceptDropEvent& rEvt )
 524 {
 525     return m_rImapWindow.AcceptDrop(rEvt);
 526 }
 527
 528 sal_Int8 IMapDropTargetHelper::ExecuteDrop( const ExecuteDropEvent& rEvt )
 529 {
 530     return m_rImapWindow.ExecuteDrop(rEvt);
 531 }
 532
 533 sal_Int8 IMapWindow::AcceptDrop( const AcceptDropEvent& rEvt )
 534 {
 535     return( ( GetHitSdrObj( rEvt.maPosPixel ) != nullptr ) ? rEvt.mnAction : DND_ACTION_NONE );
 536 }
 537
 538 sal_Int8 IMapWindow::ExecuteDrop( const ExecuteDropEvent& rEvt )
 539 {
 540     sal_Int8 nRet = DND_ACTION_NONE;
 541
 542     if (mxDropTargetHelper->IsDropFormatSupported(SotClipboardFormatId::NETSCAPE_BOOKMARK))
 543     {
 544         INetBookmark    aBookMark( "", "" );
 545         SdrObject*      pSdrObj = GetHitSdrObj( rEvt.maPosPixel );
 546
 547         if( pSdrObj && TransferableDataHelper( rEvt.maDropEvent.Transferable ).GetINetBookmark( SotClipboardFormatId::NETSCAPE_BOOKMARK, aBookMark ) )
 548         {
 549             IMapObject* pIMapObj = GetIMapObj( pSdrObj );
 550
 551             pIMapObj->SetURL( aBookMark.GetURL() );
 552             pIMapObj->SetAltText( aBookMark.GetDescription() );
 553             pModel->SetChanged();
 554             pView->UnmarkAll();
 555             pView->MarkObj( pSdrObj, pView->GetSdrPageView() );
 556             UpdateInfo( true );
 557             nRet =  rEvt.mnAction;
 558         }
 559     }
 560
 561     return nRet;
 562 }
 563
 564 OUString IMapWindow::RequestHelp(tools::Rectangle& rHelpArea)
 565 {
 566     OutputDevice& rDevice = GetDrawingArea()->get_ref_device();
 567
 568     Point aPos = rDevice.PixelToLogic(rHelpArea.TopLeft());
 569
 570     SdrPageView* pPageView = nullptr;
 571     SdrObject* pSdrObj = pView->PickObj(aPos, pView->getHitTolLog(), pPageView);
 572     if (pSdrObj)
 573     {
 574         const IMapObject*   pIMapObj = GetIMapObj( pSdrObj );
 575         if ( pIMapObj )
 576         {
 577             OUString aStr = pIMapObj->GetURL();
 578             if ( !aStr.isEmpty() )
 579             {
 580                 rHelpArea = rDevice.LogicToPixel(tools::Rectangle( Point(), GetGraphicSize()));
 581                 return aStr;
 582             }
 583         }
 584     }
 585
 586     return OUString();
 587 }
 588
 589 void IMapWindow::SetCurrentObjState( bool bActive )
 590 {
 591     SdrObject* pObj = GetSelectedSdrObject();
 592
 593     if ( !pObj )
 594         return;
 595
 596     SfxItemSet aSet( pModel->GetItemPool() );
 597
 598     GetIMapObj( pObj )->SetActive( bActive );
 599
 600     aSet.Put( XFillColorItem( "", TRANSCOL ) );
 601
 602     if ( !bActive )
 603     {
 604         aSet.Put( XFillTransparenceItem( 100 ) );
 605         aSet.Put( XLineColorItem( "", COL_RED ) );
 606     }
 607     else
 608     {
 609         aSet.Put( XFillTransparenceItem( 50 ) );
 610         aSet.Put( XLineColorItem( "", COL_BLACK ) );
 611     }
 612
 613     pView->SetAttributes( aSet );
 614 }
 615
 616 void IMapWindow::UpdateInfo( bool bNewObj )
 617 {
 618     if ( !aInfoLink.IsSet() )
 619         return;
 620
 621     const SdrObject*    pSdrObj = GetSelectedSdrObject();
 622     const IMapObject*   pIMapObj = pSdrObj ? GetIMapObj( pSdrObj ) : nullptr;
 623
 624     aInfo.bNewObj = bNewObj;
 625
 626     if ( pIMapObj )
 627     {
 628         aInfo.bOneMarked = true;
 629         aInfo.aMarkURL = pIMapObj->GetURL();
 630         aInfo.aMarkAltText = pIMapObj->GetAltText();
 631         aInfo.aMarkTarget = pIMapObj->GetTarget();
 632         aInfo.bActivated = pIMapObj->IsActive();
 633         aInfoLink.Call( *this );
 634     }
 635     else
 636     {
 637         aInfo.aMarkURL.clear();
 638         aInfo.aMarkAltText.clear();
 639         aInfo.aMarkTarget.clear();
 640         aInfo.bOneMarked = false;
 641         aInfo.bActivated = false;
 642     }
 643
 644     aInfoLink.Call( *this );
 645 }
 646
 647 void IMapWindow::DoMacroAssign()
 648 {
 649     SdrObject*  pSdrObj = GetSelectedSdrObject();
 650
 651     if ( !pSdrObj )
 652         return;
 653
 654     SfxItemSetFixed<SID_ATTR_MACROITEM, SID_ATTR_MACROITEM, SID_EVENTCONFIG, SID_EVENTCONFIG>
 655         aSet(*pIMapPool);
 656
 657     SfxEventNamesItem aNamesItem(SID_EVENTCONFIG);
 658     aNamesItem.AddEvent( "MouseOver", "", SvMacroItemId::OnMouseOver );
 659     aNamesItem.AddEvent( "MouseOut", "", SvMacroItemId::OnMouseOut );
 660     aSet.Put( aNamesItem );
 661
 662     SvxMacroItem    aMacroItem(SID_ATTR_MACROITEM);
 663     IMapObject*     pIMapObj = GetIMapObj( pSdrObj );
 664     aMacroItem.SetMacroTable( pIMapObj->GetMacroTable() );
 665     aSet.Put( aMacroItem );
 666
 667     SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
 668     ScopedVclPtr<SfxAbstractDialog> pMacroDlg(pFact->CreateEventConfigDialog(GetDrawingArea(), aSet, mxDocumentFrame));
 669
 670     if ( pMacroDlg->Execute() == RET_OK )
 671     {
 672         const SfxItemSet* pOutSet = pMacroDlg->GetOutputItemSet();
 673         pIMapObj->SetMacroTable( pOutSet->Get( SID_ATTR_MACROITEM ).GetMacroTable() );
 674         pModel->SetChanged();
 675         UpdateInfo( false );
 676     }
 677 }
 678
 679 void IMapWindow::DoPropertyDialog()
 680 {
 681     SdrObject*  pSdrObj = GetSelectedSdrObject();
 682
 683     if ( !pSdrObj )
 684         return;
 685
 686     IMapObject* pIMapObj = GetIMapObj( pSdrObj );
 687     SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
 688     ScopedVclPtr<AbstractURLDlg> aDlg(pFact->CreateURLDialog(GetDrawingArea(), pIMapObj->GetURL(), pIMapObj->GetAltText(), pIMapObj->GetDesc(),
 689                                     pIMapObj->GetTarget(), pIMapObj->GetName(), aTargetList));
 690     if ( aDlg->Execute() != RET_OK )
 691         return;
 692
 693     const OUString aURLText( aDlg->GetURL() );
 694
 695     if ( !aURLText.isEmpty() )
 696     {
 697         INetURLObject aObj( aURLText, INetProtocol::File );
 698         DBG_ASSERT( aObj.GetProtocol() != INetProtocol::NotValid, "Invalid URL" );
 699         pIMapObj->SetURL( aObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ) );
 700     }
 701     else
 702         pIMapObj->SetURL( aURLText );
 703
 704     pIMapObj->SetAltText( aDlg->GetAltText() );
 705     pIMapObj->SetDesc( aDlg->GetDesc() );
 706     pIMapObj->SetTarget( aDlg->GetTarget() );
 707     pIMapObj->SetName( aDlg->GetName() );
 708     pModel->SetChanged();
 709     UpdateInfo( true );
 710 }
 711
 712 void IMapWindow::MenuSelectHdl(const OUString& rId)
 713 {
 714     if (rId == "url")
 715         DoPropertyDialog();
 716     else if (rId == "macro")
 717         DoMacroAssign();
 718     else if (rId == "active")
 719     {
 720         const bool bNewState = !mxPopupMenu->get_active(rId);
 721         SetCurrentObjState(bNewState);
 722         UpdateInfo( false );
 723     }
 724     else if (rId == "front")
 725         pView->PutMarkedToTop();
 726     else if (rId == "forward")
 727         pView->MovMarkedToTop();
 728     else if (rId == "backward")
 729         pView->MovMarkedToBtm();
 730     else if (rId == "back")
 731         pView->PutMarkedToBtm();
 732     else if (rId == "selectall")
 733         pView->MarkAll();
 734     else if (rId == "delete")
 735         pView->DeleteMarked();
 736 }
 737
 738 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */