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/msgbox.hxx>
  22 #include <vcl/help.hxx>
  23 #include <sfx2/sfxsids.hrc>
  24 #include <svtools/imaprect.hxx>
  25 #include <svtools/imapcirc.hxx>
  26 #include <svtools/imappoly.hxx>
  27 #include <svl/urlbmk.hxx>
  28
  29 #include <svx/xoutbmp.hxx>
  30 #include <svx/dialmgr.hxx>
  31 #include <svx/dialogs.hrc>
  32 #include <svx/svxids.hrc>
  33 #include <imapdlg.hrc>
  34 #include <imapwnd.hxx>
  35 #include <svx/svdpage.hxx>
  36 #include <svx/svdorect.hxx>
  37 #include <svx/svdocirc.hxx>
  38 #include <svx/svdopath.hxx>
  39 #include <svx/xfltrit.hxx>
  40 #include <svx/svdpagv.hxx>
  41 #include <svl/urihelper.hxx>
  42 #include <svx/xfillit.hxx>
  43 #include <svx/xlineit.hxx>
  44 #include <sfx2/evntconf.hxx>
  45
  46 #include <sot/formats.hxx>
  47
  48 #include <svx/svxdlg.hxx>
  49 #include <basegfx/point/b2dpoint.hxx>
  50 #include <basegfx/polygon/b2dpolygon.hxx>
  51
  52 using ::com::sun::star::frame::XFrame;
  53 using ::com::sun::star::uno::Reference;
  54
  55 #define TRANSCOL Color( COL_WHITE )
  56
  57 IMapWindow::IMapWindow( Window* pParent, const ResId& rResId, const Reference< XFrame >& rxDocumentFrame ) :
  58             GraphCtrl( pParent, rResId ),
  59             DropTargetHelper( this ),
  60             mxDocumentFrame( rxDocumentFrame )
  61 {
  62     SetWinStyle( WB_SDRMODE );
  63
  64     pItemInfo = new SfxItemInfo[ 1 ];
  65     memset( pItemInfo, 0, sizeof( SfxItemInfo ) );
  66     pIMapPool = new SfxItemPool( OUString("IMapItemPool"),
  67                                  SID_ATTR_MACROITEM, SID_ATTR_MACROITEM, pItemInfo );
  68     pIMapPool->FreezeIdRanges();
  69 }
  70
  71 IMapWindow::~IMapWindow()
  72 {
  73     SfxItemPool::Free(pIMapPool);
  74     delete[] pItemInfo;
  75 }
  76
  77 void IMapWindow::SetImageMap( const ImageMap& rImageMap )
  78 {
  79     ReplaceImageMap( rImageMap, false );
  80 }
  81
  82 void IMapWindow::ReplaceImageMap( const ImageMap& rImageMap, bool /*bScaleToGraphic*/ )
  83 {
  84     SdrPage* pPage = 0;
  85     aIMap = rImageMap;
  86
  87     if(GetSdrModel())
  88     {
  89         // try to access page
  90         pPage = GetSdrModel()->GetPage(0L);
  91     }
  92
  93     if(pPage)
  94     {
  95         // clear all draw objects
  96         pPage->Clear();
  97     }
  98
  99     if(GetSdrView())
 100     {
 101         // #i63762# reset selection at view
 102         GetSdrView()->UnmarkAllObj();
 103     }
 104
 105     // create new drawing objects
 106     const sal_uInt16 nCount(rImageMap.GetIMapObjectCount());
 107
 108     for ( sal_uInt16 i(nCount); i > 0; i-- )
 109     {
 110         SdrObject* pNewObj = CreateObj( rImageMap.GetIMapObject( i - 1 ) );
 111
 112         if (pNewObj && pPage)
 113         {
 114             pPage->InsertObject( pNewObj );
 115         }
 116     }
 117 }
 118
 119 bool IMapWindow::ReplaceActualIMapInfo( const NotifyInfo& rNewInfo )
 120 {
 121     const SdrObject*    pSdrObj = GetSelectedSdrObject();
 122     IMapObject*         pIMapObj;
 123     bool                bRet = false;
 124
 125     if ( pSdrObj && ( ( pIMapObj = GetIMapObj( pSdrObj ) ) != NULL ) )
 126     {
 127         pIMapObj->SetURL( rNewInfo.aMarkURL );
 128         pIMapObj->SetAltText( rNewInfo.aMarkAltText );
 129         pIMapObj->SetTarget( rNewInfo.aMarkTarget );
 130         pModel->SetChanged( true );
 131         UpdateInfo( false );
 132
 133         bRet = true;
 134     }
 135
 136     return bRet;
 137 }
 138
 139 const ImageMap& IMapWindow::GetImageMap()
 140 {
 141     if ( pModel->IsChanged() )
 142     {
 143         SdrPage* pPage = (SdrPage*) pModel->GetPage( 0 );
 144
 145         if ( pPage )
 146         {
 147             const long nCount = pPage->GetObjCount();
 148
 149             aIMap.ClearImageMap();
 150
 151             for ( long i = nCount - 1; i > -1; i-- )
 152                 aIMap.InsertIMapObject( *( ( (IMapUserData*) pPage->GetObj( i )->GetUserData( 0 ) )->GetObject() ) );
 153         }
 154
 155         pModel->SetChanged( false );
 156     }
 157
 158     return aIMap;
 159 }
 160
 161 void IMapWindow::SetTargetList( TargetList& rTargetList )
 162 {
 163     // Delete old List
 164     aTargetList.clear();
 165
 166     // Fill with the provided list
 167     for( size_t i = 0, n = rTargetList.size(); i < n; ++i )
 168         aTargetList.push_back( rTargetList[ i ] );
 169
 170     pModel->SetChanged( false );
 171 }
 172
 173 SdrObject* IMapWindow::CreateObj( const IMapObject* pIMapObj )
 174 {
 175     Point       aPoint;
 176     Rectangle   aClipRect( aPoint, GetGraphicSize() );
 177     SdrObject*  pSdrObj = NULL;
 178     IMapObjectPtr pCloneIMapObj;
 179
 180     switch( pIMapObj->GetType() )
 181     {
 182         case( IMAP_OBJ_RECTANGLE ):
 183         {
 184             IMapRectangleObject*    pIMapRectObj = (IMapRectangleObject*) pIMapObj;
 185             Rectangle               aDrawRect( pIMapRectObj->GetRectangle( false ) );
 186
 187             // clipped on CanvasPane
 188             aDrawRect.Intersection( aClipRect );
 189
 190             pSdrObj = (SdrObject*) new SdrRectObj( aDrawRect );
 191             pCloneIMapObj.reset((IMapObject*) new IMapRectangleObject( *pIMapRectObj ));
 192         }
 193         break;
 194
 195         case( IMAP_OBJ_CIRCLE ):
 196         {
 197             IMapCircleObject*   pIMapCircleObj = (IMapCircleObject*) pIMapObj;
 198             const Point         aCenter( pIMapCircleObj->GetCenter( false ) );
 199             const long          nRadius = pIMapCircleObj->GetRadius( false );
 200             const Point         aOffset( nRadius, nRadius );
 201             Rectangle           aCircle( aCenter - aOffset, aCenter + aOffset );
 202
 203             // limited to CanvasPane
 204             aCircle.Intersection( aClipRect );
 205
 206             pSdrObj = (SdrObject*) new SdrCircObj( OBJ_CIRC, aCircle, 0, 36000 );
 207             pCloneIMapObj.reset((IMapObject*) new IMapCircleObject( *pIMapCircleObj ));
 208         }
 209         break;
 210
 211         case( IMAP_OBJ_POLYGON ):
 212         {
 213             IMapPolygonObject*  pIMapPolyObj = (IMapPolygonObject*) pIMapObj;
 214
 215             // If it actually is an ellipse, then another ellipse is created again
 216             if ( pIMapPolyObj->HasExtraEllipse() )
 217             {
 218                 Rectangle aDrawRect( pIMapPolyObj->GetExtraEllipse() );
 219
 220                 // clipped on CanvasPane
 221                 aDrawRect.Intersection( aClipRect );
 222
 223                 pSdrObj = (SdrObject*) new SdrCircObj( OBJ_CIRC, aDrawRect, 0, 36000 );
 224             }
 225             else
 226             {
 227                 const Polygon&  rPoly = pIMapPolyObj->GetPolygon( false );
 228                 Polygon         aDrawPoly( rPoly );
 229
 230                 // clipped on CanvasPane
 231                 aDrawPoly.Clip( aClipRect );
 232
 233                 basegfx::B2DPolygon aPolygon;
 234                 aPolygon.append(aDrawPoly.getB2DPolygon());
 235                 pSdrObj = (SdrObject*)new SdrPathObj(OBJ_POLY, basegfx::B2DPolyPolygon(aPolygon));
 236             }
 237
 238             pCloneIMapObj.reset((IMapObject*) new IMapPolygonObject( *pIMapPolyObj ));
 239         }
 240         break;
 241
 242         default:
 243         break;
 244     }
 245
 246     if ( pSdrObj )
 247     {
 248         SfxItemSet aSet( pModel->GetItemPool() );
 249
 250         aSet.Put( XFillStyleItem( XFILL_SOLID ) );
 251         aSet.Put( XFillColorItem( "", TRANSCOL ) );
 252
 253         if ( !pIMapObj->IsActive() )
 254         {
 255             aSet.Put( XFillTransparenceItem( 100 ) );
 256             aSet.Put( XLineColorItem( "", Color( COL_RED ) ) );
 257         }
 258         else
 259         {
 260             aSet.Put( XFillTransparenceItem( 50 ) );
 261             aSet.Put( XLineColorItem( "", Color( COL_BLACK ) ) );
 262         }
 263
 264         pSdrObj->SetMergedItemSetAndBroadcast(aSet);
 265
 266         pSdrObj->AppendUserData( new IMapUserData( pCloneIMapObj ) );
 267         pSdrObj->SetUserCall( GetSdrUserCall() );
 268     }
 269
 270     return pSdrObj;
 271 }
 272
 273 void IMapWindow::InitSdrModel()
 274 {
 275     GraphCtrl::InitSdrModel();
 276
 277     SfxItemSet aSet( pModel->GetItemPool() );
 278
 279     aSet.Put( XFillColorItem( "", TRANSCOL ) );
 280     aSet.Put( XFillTransparenceItem( 50 ) );
 281     pView->SetAttributes( aSet );
 282     pView->SetFrameDragSingles( true );
 283 }
 284
 285 void IMapWindow::SdrObjCreated( const SdrObject& rObj )
 286 {
 287     switch( rObj.GetObjIdentifier() )
 288     {
 289         case( OBJ_RECT ):
 290         {
 291             SdrRectObj*          pRectObj = (SdrRectObj*) &rObj;
 292             IMapRectangleObject* pObj = new IMapRectangleObject( pRectObj->GetLogicRect(), "", "", "", "", "", true, false );
 293
 294             pRectObj->AppendUserData( new IMapUserData( IMapObjectPtr(pObj) ) );
 295         }
 296         break;
 297
 298         case( OBJ_CIRC ):
 299         {
 300             SdrCircObj* pCircObj = (SdrCircObj*) &rObj;
 301             SdrPathObj* pPathObj = (SdrPathObj*) pCircObj->ConvertToPolyObj( false, false );
 302             Polygon aPoly(pPathObj->GetPathPoly().getB2DPolygon(0L));
 303             delete pPathObj;
 304
 305             IMapPolygonObject* pObj = new IMapPolygonObject( Polygon(aPoly), "", "", "", "", "", true, false );
 306             pObj->SetExtraEllipse( aPoly.GetBoundRect() );
 307             pCircObj->AppendUserData( new IMapUserData( IMapObjectPtr(pObj) ) );
 308         }
 309         break;
 310
 311         case( OBJ_POLY ):
 312         case( OBJ_FREEFILL ):
 313         case( OBJ_PATHPOLY ):
 314         case( OBJ_PATHFILL ):
 315         {
 316             SdrPathObj* pPathObj = (SdrPathObj*) &rObj;
 317             const basegfx::B2DPolyPolygon& rXPolyPoly = pPathObj->GetPathPoly();
 318
 319             if ( rXPolyPoly.count() )
 320             {
 321                 Polygon aPoly(rXPolyPoly.getB2DPolygon(0L));
 322                 IMapPolygonObject* pObj = new IMapPolygonObject( aPoly, "", "", "", "", "", true, false );
 323                 pPathObj->AppendUserData( new IMapUserData( IMapObjectPtr(pObj) ) );
 324             }
 325         }
 326         break;
 327
 328         default:
 329         break;
 330     }
 331 }
 332
 333 void IMapWindow::SdrObjChanged( const SdrObject& rObj )
 334 {
 335     IMapUserData* pUserData = (IMapUserData*) rObj.GetUserData( 0 );
 336
 337     if ( pUserData )
 338     {
 339         OUString        aURL;
 340         OUString        aAltText;
 341         OUString        aDesc;
 342         OUString        aTarget;
 343         IMapObjectPtr   pIMapObj = pUserData->GetObject();
 344         bool        bActive = true;
 345
 346         if ( pIMapObj.get() )
 347         {
 348             aURL = pIMapObj->GetURL();
 349             aAltText = pIMapObj->GetAltText();
 350             aDesc = pIMapObj->GetDesc();
 351             aTarget = pIMapObj->GetTarget();
 352             bActive = pIMapObj->IsActive();
 353         }
 354
 355         switch( rObj.GetObjIdentifier() )
 356         {
 357             case( OBJ_RECT ):
 358             {
 359                 pUserData->ReplaceObject( IMapObjectPtr(new IMapRectangleObject( ( (const SdrRectObj&) rObj ).GetLogicRect(),
 360                           aURL, aAltText, aDesc, aTarget, "", bActive, false ) ) );
 361             }
 362             break;
 363
 364             case( OBJ_CIRC ):
 365             {
 366                 const SdrCircObj& rCircObj = (const SdrCircObj&) rObj;
 367                 SdrPathObj* pPathObj = (SdrPathObj*) rCircObj.ConvertToPolyObj( false, false );
 368                 Polygon aPoly(pPathObj->GetPathPoly().getB2DPolygon(0L));
 369
 370                 IMapPolygonObject* pObj = new IMapPolygonObject( aPoly, aURL, aAltText, aDesc, aTarget, "", bActive, false );
 371                 pObj->SetExtraEllipse( aPoly.GetBoundRect() );
 372
 373                 // was only created by us temporarily
 374                 delete pPathObj;
 375                 pUserData->ReplaceObject( IMapObjectPtr(pObj) );
 376             }
 377             break;
 378
 379             case( OBJ_POLY ):
 380             case( OBJ_FREEFILL ):
 381             case( OBJ_PATHPOLY ):
 382             case( OBJ_PATHFILL ):
 383             {
 384                 const SdrPathObj& rPathObj = (const SdrPathObj&) rObj;
 385                 const basegfx::B2DPolyPolygon& rXPolyPoly = rPathObj.GetPathPoly();
 386
 387                 if ( rXPolyPoly.count() )
 388                 {
 389                     Polygon aPoly(rPathObj.GetPathPoly().getB2DPolygon(0L));
 390                     IMapPolygonObject*  pObj = new IMapPolygonObject( aPoly, aURL, aAltText, aDesc, aTarget, "", bActive, false );
 391                     pUserData->ReplaceObject( IMapObjectPtr(pObj) );
 392                 }
 393             }
 394             break;
 395
 396             default:
 397             break;
 398         }
 399     }
 400 }
 401
 402 void IMapWindow::MouseButtonUp(const MouseEvent& rMEvt)
 403 {
 404     GraphCtrl::MouseButtonUp( rMEvt );
 405     UpdateInfo( true );
 406 }
 407
 408 void IMapWindow::MarkListHasChanged()
 409 {
 410     GraphCtrl::MarkListHasChanged();
 411     UpdateInfo( false );
 412 }
 413
 414 SdrObject* IMapWindow::GetHitSdrObj( const Point& rPosPixel ) const
 415 {
 416     SdrObject*  pObj = NULL;
 417     Point       aPt = PixelToLogic( rPosPixel );
 418
 419     if ( Rectangle( Point(), GetGraphicSize() ).IsInside( aPt ) )
 420     {
 421         SdrPage* pPage = (SdrPage*) pModel->GetPage( 0 );
 422         sal_uIntPtr  nCount;
 423
 424         if ( pPage && ( ( nCount = pPage->GetObjCount() ) > 0 ) )
 425         {
 426             for ( long i = nCount - 1; i >= 0; i-- )
 427             {
 428                 SdrObject*  pTestObj = pPage->GetObj( i );
 429                 IMapObject* pIMapObj = GetIMapObj( pTestObj );
 430
 431                 if ( pIMapObj && pIMapObj->IsHit( aPt ) )
 432                 {
 433                     pObj = pTestObj;
 434                     break;
 435                 }
 436             }
 437         }
 438     }
 439
 440     return pObj;
 441 }
 442
 443 IMapObject* IMapWindow::GetIMapObj( const SdrObject* pSdrObj ) const
 444 {
 445     IMapObject* pIMapObj = NULL;
 446
 447     if ( pSdrObj )
 448     {
 449         IMapUserData* pUserData = (IMapUserData*) pSdrObj->GetUserData( 0 );
 450
 451         if ( pUserData )
 452             pIMapObj = pUserData->GetObject().get();
 453     }
 454
 455     return pIMapObj;
 456 }
 457
 458 void IMapWindow::Command(const CommandEvent& rCEvt)
 459 {
 460     Region  aRegion;
 461
 462     if ( rCEvt.GetCommand() == COMMAND_CONTEXTMENU )
 463     {
 464         PopupMenu           aMenu( SVX_RES( RID_SVXMN_IMAP ) );
 465         const SdrMarkList&  rMarkList = pView->GetMarkedObjectList();
 466         sal_uIntPtr             nMarked = rMarkList.GetMarkCount();
 467
 468         aMenu.EnableItem( MN_URL, false );
 469         aMenu.EnableItem( MN_ACTIVATE, false );
 470         aMenu.EnableItem( MN_MACRO, false );
 471         aMenu.EnableItem( MN_MARK_ALL, pModel->GetPage( 0 )->GetObjCount() != pView->GetMarkedObjectCount() );
 472
 473         if ( !nMarked )
 474         {
 475             aMenu.EnableItem( MN_POSITION, false );
 476             aMenu.EnableItem( MN_FRAME_TO_TOP, false );
 477             aMenu.EnableItem( MN_MOREFRONT, false );
 478             aMenu.EnableItem( MN_MOREBACK, false );
 479             aMenu.EnableItem( MN_FRAME_TO_BOTTOM, false );
 480             aMenu.EnableItem( MN_DELETE1, false );
 481         }
 482         else
 483         {
 484             if ( nMarked == 1 )
 485             {
 486                 SdrObject*  pSdrObj = GetSelectedSdrObject();
 487
 488                 aMenu.EnableItem( MN_URL, true );
 489                 aMenu.EnableItem( MN_ACTIVATE, true );
 490                 aMenu.EnableItem( MN_MACRO, true );
 491                 aMenu.CheckItem( MN_ACTIVATE, GetIMapObj( pSdrObj )->IsActive() );
 492             }
 493
 494             aMenu.EnableItem( MN_POSITION, true );
 495             aMenu.EnableItem( MN_FRAME_TO_TOP, true );
 496             aMenu.EnableItem( MN_MOREFRONT, true );
 497             aMenu.EnableItem( MN_MOREBACK, true );
 498             aMenu.EnableItem( MN_FRAME_TO_BOTTOM, true );
 499             aMenu.EnableItem( MN_DELETE1, true );
 500         }
 501
 502         aMenu.SetSelectHdl( LINK( this, IMapWindow, MenuSelectHdl ) );
 503         aMenu.Execute( this, rCEvt.GetMousePosPixel() );
 504     }
 505     else
 506         Window::Command(rCEvt);
 507 }
 508
 509 sal_Int8 IMapWindow::AcceptDrop( const AcceptDropEvent& rEvt )
 510 {
 511     return( ( GetHitSdrObj( rEvt.maPosPixel ) != NULL ) ? rEvt.mnAction : DND_ACTION_NONE );
 512 }
 513
 514 sal_Int8 IMapWindow::ExecuteDrop( const ExecuteDropEvent& rEvt )
 515 {
 516     sal_Int8 nRet = DND_ACTION_NONE;
 517
 518     if( IsDropFormatSupported( SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK ) )
 519     {
 520         const OUString  aString;
 521         INetBookmark    aBookMark( aString, aString );
 522         SdrObject*      pSdrObj = GetHitSdrObj( rEvt.maPosPixel );
 523
 524         if( pSdrObj && TransferableDataHelper( rEvt.maDropEvent.Transferable ).GetINetBookmark( SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK, aBookMark ) )
 525         {
 526             IMapObject* pIMapObj = GetIMapObj( pSdrObj );
 527
 528             pIMapObj->SetURL( aBookMark.GetURL() );
 529             pIMapObj->SetAltText( aBookMark.GetDescription() );
 530             pModel->SetChanged( true );
 531             pView->UnmarkAll();
 532             pView->MarkObj( pSdrObj, pView->GetSdrPageView() );
 533             UpdateInfo( true );
 534             nRet =  rEvt.mnAction;
 535         }
 536     }
 537
 538     return nRet;
 539 }
 540
 541 void IMapWindow::RequestHelp( const HelpEvent& rHEvt )
 542 {
 543     Point               aPos = PixelToLogic( ScreenToOutputPixel( rHEvt.GetMousePosPixel() ) );
 544
 545     if ( Help::IsBalloonHelpEnabled() || Help::IsQuickHelpEnabled() )
 546     {
 547         SdrObject*          pSdrObj = NULL;
 548         SdrPageView*        pPageView = NULL;
 549         if ( pView->PickObj( aPos, pView->getHitTolLog(), pSdrObj, pPageView ) )
 550         {
 551             const IMapObject*   pIMapObj = GetIMapObj( pSdrObj );
 552             OUString            aStr;
 553
 554             if ( pIMapObj && !( aStr = pIMapObj->GetURL() ).isEmpty() )
 555             {
 556                 Rectangle   aLogicPix( LogicToPixel( Rectangle( Point(), GetGraphicSize() ) ) );
 557                 Rectangle   aScreenRect( OutputToScreenPixel( aLogicPix.TopLeft() ),
 558                                          OutputToScreenPixel( aLogicPix.BottomRight() ) );
 559
 560                 if ( Help::IsBalloonHelpEnabled() )
 561                     Help::ShowBalloon( this, rHEvt.GetMousePosPixel(), aScreenRect, aStr );
 562                 else if ( Help::IsQuickHelpEnabled() )
 563                     Help::ShowQuickHelp( this, aScreenRect, aStr );
 564             }
 565         }
 566         else
 567             Window::RequestHelp( rHEvt );
 568     }
 569 }
 570
 571 void IMapWindow::SetCurrentObjState( bool bActive )
 572 {
 573     SdrObject* pObj = GetSelectedSdrObject();
 574
 575     if ( pObj )
 576     {
 577         SfxItemSet aSet( pModel->GetItemPool() );
 578
 579         GetIMapObj( pObj )->SetActive( bActive );
 580
 581         aSet.Put( XFillColorItem( "", TRANSCOL ) );
 582
 583         if ( !bActive )
 584         {
 585             aSet.Put( XFillTransparenceItem( 100 ) );
 586             aSet.Put( XLineColorItem( "", Color( COL_RED ) ) );
 587         }
 588         else
 589         {
 590             aSet.Put( XFillTransparenceItem( 50 ) );
 591             aSet.Put( XLineColorItem( "", Color( COL_BLACK ) ) );
 592         }
 593
 594         pView->SetAttributes( aSet, false );
 595     }
 596 }
 597
 598 void IMapWindow::UpdateInfo( bool bNewObj )
 599 {
 600     if ( aInfoLink.IsSet() )
 601     {
 602         const SdrObject*    pSdrObj = GetSelectedSdrObject();
 603         const IMapObject*   pIMapObj = pSdrObj ? GetIMapObj( pSdrObj ) : NULL;
 604
 605         aInfo.bNewObj = bNewObj;
 606
 607         if ( pIMapObj )
 608         {
 609             aInfo.bOneMarked = true;
 610             aInfo.aMarkURL = pIMapObj->GetURL();
 611             aInfo.aMarkAltText = pIMapObj->GetAltText();
 612             aInfo.aMarkTarget = pIMapObj->GetTarget();
 613             aInfo.bActivated = pIMapObj->IsActive();
 614             aInfoLink.Call( this );
 615         }
 616         else
 617         {
 618             aInfo.aMarkURL = aInfo.aMarkAltText = aInfo.aMarkTarget = "";
 619             aInfo.bOneMarked = false;
 620             aInfo.bActivated = false;
 621         }
 622
 623         aInfoLink.Call( this );
 624     }
 625 }
 626
 627 void IMapWindow::DoMacroAssign()
 628 {
 629     SdrObject*  pSdrObj = GetSelectedSdrObject();
 630
 631     if ( pSdrObj )
 632     {
 633         SfxItemSet      aSet( *pIMapPool, SID_ATTR_MACROITEM, SID_ATTR_MACROITEM, SID_EVENTCONFIG, SID_EVENTCONFIG, 0 );
 634
 635         SfxEventNamesItem aNamesItem(SID_EVENTCONFIG);
 636         aNamesItem.AddEvent( "MouseOver", "", SFX_EVENT_MOUSEOVER_OBJECT );
 637         aNamesItem.AddEvent( "MouseOut", "", SFX_EVENT_MOUSEOUT_OBJECT );
 638         aSet.Put( aNamesItem );
 639
 640         SvxMacroItem    aMacroItem(SID_ATTR_MACROITEM);
 641         IMapObject*     pIMapObj = GetIMapObj( pSdrObj );
 642         aMacroItem.SetMacroTable( pIMapObj->GetMacroTable() );
 643         aSet.Put( aMacroItem, SID_ATTR_MACROITEM );
 644
 645         SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
 646         SfxAbstractDialog* pMacroDlg = pFact->CreateSfxDialog( this, aSet, mxDocumentFrame, SID_EVENTCONFIG );
 647
 648         if ( pMacroDlg && pMacroDlg->Execute() == RET_OK )
 649         {
 650             const SfxItemSet* pOutSet = pMacroDlg->GetOutputItemSet();
 651             pIMapObj->SetMacroTable( ((const SvxMacroItem& )pOutSet->Get( SID_ATTR_MACROITEM )).GetMacroTable() );
 652             pModel->SetChanged( true );
 653             UpdateInfo( false );
 654         }
 655
 656         delete pMacroDlg;
 657     }
 658 }
 659
 660 void IMapWindow::DoPropertyDialog()
 661 {
 662     SdrObject*  pSdrObj = GetSelectedSdrObject();
 663
 664     if ( pSdrObj )
 665     {
 666         IMapObject* pIMapObj = GetIMapObj( pSdrObj );
 667         SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
 668         if(pFact)
 669         {
 670             AbstractURLDlg* aDlg = pFact->CreateURLDialog( this, pIMapObj->GetURL(), pIMapObj->GetAltText(), pIMapObj->GetDesc(),
 671                                             pIMapObj->GetTarget(), pIMapObj->GetName(), aTargetList );
 672             DBG_ASSERT(aDlg, "Dialogdiet fail!");
 673             if ( aDlg->Execute() == RET_OK )
 674             {
 675                 const OUString aURLText( aDlg->GetURL() );
 676
 677                 if ( !aURLText.isEmpty() )
 678                 {
 679                     INetURLObject aObj( aURLText, INET_PROT_FILE );
 680                     DBG_ASSERT( aObj.GetProtocol() != INET_PROT_NOT_VALID, "Invalid URL" );
 681                     pIMapObj->SetURL( aObj.GetMainURL( INetURLObject::NO_DECODE ) );
 682                 }
 683                 else
 684                     pIMapObj->SetURL( aURLText );
 685
 686                 pIMapObj->SetAltText( aDlg->GetAltText() );
 687                 pIMapObj->SetDesc( aDlg->GetDesc() );
 688                 pIMapObj->SetTarget( aDlg->GetTarget() );
 689                 pIMapObj->SetName( aDlg->GetName() );
 690                 pModel->SetChanged( true );
 691                 UpdateInfo( true );
 692             }
 693             delete aDlg;
 694         }
 695     }
 696 }
 697
 698 IMPL_LINK( IMapWindow, MenuSelectHdl, Menu*, pMenu )
 699 {
 700     if (pMenu)
 701     {
 702         sal_uInt16  nId = pMenu->GetCurItemId();
 703
 704         switch(nId)
 705         {
 706             case( MN_URL ):
 707                 DoPropertyDialog();
 708             break;
 709
 710             case( MN_MACRO ):
 711                 DoMacroAssign();
 712             break;
 713
 714             case( MN_ACTIVATE ):
 715             {
 716                 const bool bNewState = !pMenu->IsItemChecked( MN_ACTIVATE );
 717
 718                 pMenu->CheckItem( MN_ACTIVATE, bNewState );
 719                 SetCurrentObjState( bNewState );
 720                 UpdateInfo( false );
 721             }
 722
 723             case( MN_FRAME_TO_TOP ):
 724                 pView->PutMarkedToTop();
 725             break;
 726
 727             case( MN_MOREFRONT ):
 728                 pView->MovMarkedToTop();
 729             break;
 730
 731             case( MN_MOREBACK ):
 732                 pView->MovMarkedToBtm();
 733             break;
 734
 735             case( MN_FRAME_TO_BOTTOM ):
 736                 pView->PutMarkedToBtm();
 737             break;
 738
 739             case( MN_MARK_ALL ):
 740                 pView->MarkAll();
 741             break;
 742
 743             case( MN_DELETE1 ):
 744                 pView->DeleteMarked();
 745
 746             default :
 747             break;
 748         }
 749     }
 750
 751     return 0;
 752 }
 753
 754 void IMapWindow::CreateDefaultObject()
 755 {
 756     SdrPageView* pPageView = pView->GetSdrPageView();
 757
 758     if(pPageView)
 759     {
 760         // calc position and size
 761         Point aPagePos(0, 0); // = pPageView->GetOffset();
 762         Size aPageSize = pPageView->GetPage()->GetSize();
 763         sal_uInt32 nDefaultObjectSizeWidth = aPageSize.Width() / 4;
 764         sal_uInt32 nDefaultObjectSizeHeight = aPageSize.Height() / 4;
 765         aPagePos.X() += (aPageSize.Width() / 2) - (nDefaultObjectSizeWidth / 2);
 766         aPagePos.Y() += (aPageSize.Height() / 2) - (nDefaultObjectSizeHeight / 2);
 767         Rectangle aNewObjectRectangle(aPagePos, Size(nDefaultObjectSizeWidth, nDefaultObjectSizeHeight));
 768
 769         SdrObject* pObj = SdrObjFactory::MakeNewObject( pView->GetCurrentObjInventor(), pView->GetCurrentObjIdentifier(), 0L, pModel);
 770         pObj->SetLogicRect(aNewObjectRectangle);
 771
 772         switch( pObj->GetObjIdentifier() )
 773         {
 774         case OBJ_POLY:
 775         case OBJ_PATHPOLY:
 776             {
 777                 basegfx::B2DPolygon aInnerPoly;
 778                 aInnerPoly.append(basegfx::B2DPoint(aNewObjectRectangle.BottomLeft().X(), aNewObjectRectangle.BottomLeft().Y()));
 779                 aInnerPoly.append(basegfx::B2DPoint(aNewObjectRectangle.TopLeft().X(), aNewObjectRectangle.TopLeft().Y()));
 780                 aInnerPoly.append(basegfx::B2DPoint(aNewObjectRectangle.TopCenter().X(), aNewObjectRectangle.TopCenter().Y()));
 781                 aInnerPoly.append(basegfx::B2DPoint(aNewObjectRectangle.Center().X(), aNewObjectRectangle.Center().Y()));
 782                 aInnerPoly.append(basegfx::B2DPoint(aNewObjectRectangle.RightCenter().X(), aNewObjectRectangle.RightCenter().Y()));
 783                 aInnerPoly.append(basegfx::B2DPoint(aNewObjectRectangle.BottomRight().X(), aNewObjectRectangle.BottomRight().Y()));
 784                 aInnerPoly.setClosed(true);
 785                 ((SdrPathObj*)pObj)->SetPathPoly(basegfx::B2DPolyPolygon(aInnerPoly));
 786                 break;
 787             }
 788         case OBJ_FREEFILL:
 789         case OBJ_PATHFILL:
 790             {
 791                 sal_Int32 nWdt(aNewObjectRectangle.GetWidth() / 2);
 792                 sal_Int32 nHgt(aNewObjectRectangle.GetHeight() / 2);
 793                 basegfx::B2DPolygon aInnerPoly(XPolygon(aNewObjectRectangle.Center(), nWdt, nHgt).getB2DPolygon());
 794                 ((SdrPathObj*)pObj)->SetPathPoly(basegfx::B2DPolyPolygon(aInnerPoly));
 795                 break;
 796             }
 797
 798         }
 799
 800         pView->InsertObjectAtView(pObj, *pPageView);
 801         SdrObjCreated( *pObj );
 802         SetCurrentObjState( true );
 803         pView->MarkObj( pObj, pPageView );
 804     }
 805 }
 806
 807 void IMapWindow::KeyInput( const KeyEvent& rKEvt )
 808 {
 809     GraphCtrl::KeyInput( rKEvt );
 810 }
 811
 812 void IMapWindow::SelectFirstObject()
 813 {
 814     SdrPage*    pPage = (SdrPage*) pModel->GetPage( 0 );
 815     if( pPage->GetObjCount() != 0 )
 816     {
 817         GrabFocus();
 818         pView->UnmarkAllObj();
 819         pView->MarkNextObj(true);
 820     }
 821 }
 822
 823 void IMapWindow::StartPolyEdit()
 824 {
 825     GrabFocus();
 826
 827     if( !pView->AreObjectsMarked() )
 828         pView->MarkNextObj(true);
 829
 830     const SdrHdlList& rHdlList = pView->GetHdlList();
 831     SdrHdl* pHdl = rHdlList.GetFocusHdl();
 832
 833     if(!pHdl)
 834     {
 835         ((SdrHdlList&)rHdlList).TravelFocusHdl(true);
 836     }
 837 }
 838
 839 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */