svx/source/dialog/imapwnd.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: imapwnd.cxx,v $
  10  * $Revision: 1.26 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_svx.hxx"
  33 #include <tools/urlobj.hxx>
  34 #include <vcl/msgbox.hxx>
  35 #include <vcl/help.hxx>
  36 #include <sfx2/sfxsids.hrc>             // SID_ATTR_MACROITEM
  37 #define _ANIMATION
  38 #include <svtools/imaprect.hxx>
  39 #include <svtools/imapcirc.hxx>
  40 #include <svtools/imappoly.hxx>
  41 #include <svtools/urlbmk.hxx>
  42
  43 #include <xoutbmp.hxx>
  44 #include <svx/dialmgr.hxx>
  45 #include <svx/dialogs.hrc>
  46 #include <svx/svxids.hrc>
  47 #include <imapdlg.hrc>
  48 #include <imapwnd.hxx>
  49 #include <svx/svdpage.hxx>
  50 #include <svx/svdorect.hxx>
  51 #include <svx/svdocirc.hxx>
  52 #include <svx/svdopath.hxx>
  53 #include <svx/xfltrit.hxx>
  54 #include <svx/svdpagv.hxx>
  55 #include <svtools/urihelper.hxx>
  56 #include <svx/xfillit.hxx>
  57 #include <svx/xlineit.hxx>
  58 #include <sfx2/evntconf.hxx>
  59
  60 #include <sot/formats.hxx>
  61
  62 #include <svx/svxdlg.hxx>
  63 #include <svx/dialogs.hrc>
  64 #include <basegfx/point/b2dpoint.hxx>
  65 #include <basegfx/polygon/b2dpolygon.hxx>
  66
  67 using ::com::sun::star::frame::XFrame;
  68 using ::com::sun::star::uno::Reference;
  69
  70 #define TRANSCOL Color( COL_WHITE )
  71
  72 /*************************************************************************
  73 |*
  74 |*
  75 |*
  76 \************************************************************************/
  77
  78 IMapWindow::IMapWindow( Window* pParent, const ResId& rResId, const Reference< XFrame >& rxDocumentFrame ) :
  79             GraphCtrl( pParent, rResId ),
  80             DropTargetHelper( this ),
  81             mxDocumentFrame( rxDocumentFrame )
  82 {
  83     SetWinStyle( WB_SDRMODE );
  84
  85     pItemInfo = new SfxItemInfo[ 1 ];
  86     memset( pItemInfo, 0, sizeof( SfxItemInfo ) );
  87     pIMapPool = new SfxItemPool( String::CreateFromAscii( "IMapItemPool" ),
  88                                  SID_ATTR_MACROITEM, SID_ATTR_MACROITEM, pItemInfo );
  89     pIMapPool->FreezeIdRanges();
  90 }
  91
  92 /*************************************************************************
  93 |*
  94 |*
  95 |*
  96 \************************************************************************/
  97
  98 IMapWindow::~IMapWindow()
  99 {
 100     // Liste loeschen
 101     for( String* pStr = aTargetList.First(); pStr; pStr = aTargetList.Next() )
 102         delete pStr;
 103
 104     SfxItemPool::Free(pIMapPool);
 105     delete[] pItemInfo;
 106 }
 107
 108 /*************************************************************************
 109 |*
 110 |*
 111 |*
 112 \************************************************************************/
 113
 114 void IMapWindow::SetImageMap( const ImageMap& rImageMap )
 115 {
 116     ReplaceImageMap( rImageMap, FALSE );
 117 }
 118
 119 /*************************************************************************
 120 |*
 121 |*
 122 |*
 123 \************************************************************************/
 124
 125 void IMapWindow::ReplaceImageMap( const ImageMap& rImageMap, BOOL /*bScaleToGraphic*/ )
 126 {
 127     SdrPage* pPage = 0;
 128     aIMap = rImageMap;
 129
 130     if(GetSdrModel())
 131     {
 132         // try to access page
 133         pPage = GetSdrModel()->GetPage(0L);
 134     }
 135
 136     if(pPage)
 137     {
 138         // clear all draw objects
 139         pPage->Clear();
 140     }
 141
 142     if(GetSdrView())
 143     {
 144         // #i63762# reset selection at view
 145         GetSdrView()->UnmarkAllObj();
 146     }
 147
 148     // create new drawing objects
 149     const USHORT nCount(rImageMap.GetIMapObjectCount());
 150
 151     for ( USHORT i(nCount); i > 0; i-- )
 152     {
 153         SdrObject* pNewObj = CreateObj( rImageMap.GetIMapObject( i - 1 ) );
 154
 155         if ( pNewObj )
 156         {
 157             pPage->InsertObject( pNewObj );
 158         }
 159     }
 160 }
 161
 162 /*************************************************************************
 163 |*
 164 |*
 165 |*
 166 \************************************************************************/
 167
 168 BOOL IMapWindow::ReplaceActualIMapInfo( const NotifyInfo& rNewInfo )
 169 {
 170     const SdrObject*    pSdrObj = GetSelectedSdrObject();
 171     IMapObject*                 pIMapObj;
 172     BOOL                                bRet = FALSE;
 173
 174     if ( pSdrObj && ( ( pIMapObj = GetIMapObj( pSdrObj ) ) != NULL ) )
 175     {
 176         pIMapObj->SetURL( rNewInfo.aMarkURL );
 177         pIMapObj->SetAltText( rNewInfo.aMarkAltText );
 178         pIMapObj->SetTarget( rNewInfo.aMarkTarget );
 179         pModel->SetChanged( sal_True );
 180         UpdateInfo( FALSE );
 181
 182         bRet = TRUE;
 183     }
 184
 185     return bRet;
 186 }
 187
 188 /*************************************************************************
 189 |*
 190 |*
 191 |*
 192 \************************************************************************/
 193
 194 const ImageMap& IMapWindow::GetImageMap()
 195 {
 196     if ( pModel->IsChanged() )
 197     {
 198         SdrPage* pPage = (SdrPage*) pModel->GetPage( 0 );
 199
 200         if ( pPage )
 201         {
 202             const long nCount = pPage->GetObjCount();
 203
 204             aIMap.ClearImageMap();
 205
 206             for ( long i = nCount - 1; i > -1; i-- )
 207                 aIMap.InsertIMapObject( *( ( (IMapUserData*) pPage->GetObj( i )->GetUserData( 0 ) )->GetObject() ) );
 208         }
 209
 210         pModel->SetChanged( sal_False );
 211     }
 212
 213     return aIMap;
 214 }
 215
 216 /*************************************************************************
 217 |*
 218 |*
 219 |*
 220 \************************************************************************/
 221
 222 void IMapWindow::SetTargetList( TargetList& rTargetList )
 223 {
 224     String* pStr;
 225
 226     // alte Liste loeschen
 227     for( pStr = aTargetList.First(); pStr; pStr = aTargetList.Next() )
 228         delete pStr;
 229
 230     aTargetList.Clear();
 231
 232     // mit uebergebener Liste fuellen
 233     for( pStr = rTargetList.First(); pStr; pStr = rTargetList.Next() )
 234         aTargetList.Insert( new String( *pStr ) );
 235
 236     pModel->SetChanged( sal_False );
 237 }
 238
 239 /*************************************************************************
 240 |*
 241 |*
 242 |*
 243 \************************************************************************/
 244
 245 SdrObject* IMapWindow::CreateObj( const IMapObject* pIMapObj )
 246 {
 247     Point               aPoint;
 248     Rectangle   aClipRect( aPoint, GetGraphicSize() );
 249     SdrObject*  pSdrObj = NULL;
 250     IMapObjectPtr pCloneIMapObj;
 251
 252     switch( pIMapObj->GetType() )
 253     {
 254         case( IMAP_OBJ_RECTANGLE ):
 255         {
 256             IMapRectangleObject*        pIMapRectObj = (IMapRectangleObject*) pIMapObj;
 257             Rectangle                           aDrawRect( pIMapRectObj->GetRectangle( FALSE ) );
 258
 259             // auf Zeichenflaeche clippen
 260             aDrawRect.Intersection( aClipRect );
 261
 262             pSdrObj = (SdrObject*) new SdrRectObj( aDrawRect );
 263             pCloneIMapObj.reset((IMapObject*) new IMapRectangleObject( *pIMapRectObj ));
 264         }
 265         break;
 266
 267         case( IMAP_OBJ_CIRCLE ):
 268         {
 269             IMapCircleObject*   pIMapCircleObj = (IMapCircleObject*) pIMapObj;
 270             const Point                 aCenter( pIMapCircleObj->GetCenter( FALSE ) );
 271             const long                  nRadius = pIMapCircleObj->GetRadius( FALSE );
 272             const Point                 aOffset( nRadius, nRadius );
 273             Rectangle                   aCircle( aCenter - aOffset, aCenter + aOffset );
 274
 275             // auf Zeichenflaeche begrenzen
 276             aCircle.Intersection( aClipRect );
 277
 278             pSdrObj = (SdrObject*) new SdrCircObj( OBJ_CIRC, aCircle, 0, 36000 );
 279             pCloneIMapObj.reset((IMapObject*) new IMapCircleObject( *pIMapCircleObj ));
 280         }
 281         break;
 282
 283         case( IMAP_OBJ_POLYGON ):
 284         {
 285             IMapPolygonObject*  pIMapPolyObj = (IMapPolygonObject*) pIMapObj;
 286
 287             // Falls wir eigentlich eine Ellipse sind,
 288             // erzeugen wir auch wieder eine Ellipse
 289             if ( pIMapPolyObj->HasExtraEllipse() )
 290             {
 291                 Rectangle aDrawRect( pIMapPolyObj->GetExtraEllipse() );
 292
 293                 // auf Zeichenflaeche clippen
 294                 aDrawRect.Intersection( aClipRect );
 295
 296                 pSdrObj = (SdrObject*) new SdrCircObj( OBJ_CIRC, aDrawRect, 0, 36000 );
 297             }
 298             else
 299             {
 300                 const Polygon&  rPoly = pIMapPolyObj->GetPolygon( FALSE );
 301                 Polygon         aDrawPoly( rPoly );
 302
 303                 // auf Zeichenflaeche clippen
 304                 aDrawPoly.Clip( aClipRect );
 305
 306                 basegfx::B2DPolygon aPolygon;
 307                 aPolygon.append(aDrawPoly.getB2DPolygon());
 308                 pSdrObj = (SdrObject*)new SdrPathObj(OBJ_POLY, basegfx::B2DPolyPolygon(aPolygon));
 309             }
 310
 311             pCloneIMapObj.reset((IMapObject*) new IMapPolygonObject( *pIMapPolyObj ));
 312         }
 313         break;
 314
 315         default:
 316         break;
 317     }
 318
 319     if ( pSdrObj )
 320     {
 321         SfxItemSet aSet( pModel->GetItemPool() );
 322
 323         aSet.Put( XFillStyleItem( XFILL_SOLID ) );
 324         aSet.Put( XFillColorItem( String(), TRANSCOL ) );
 325
 326         if ( !pIMapObj->IsActive() )
 327         {
 328             aSet.Put( XFillTransparenceItem( 100 ) );
 329             aSet.Put( XLineColorItem( String(), Color( COL_RED ) ) );
 330         }
 331         else
 332         {
 333             aSet.Put( XFillTransparenceItem( 50 ) );
 334             aSet.Put( XLineColorItem( String(), Color( COL_BLACK ) ) );
 335         }
 336
 337         //pSdrObj->SetItemSetAndBroadcast(aSet);
 338         pSdrObj->SetMergedItemSetAndBroadcast(aSet);
 339
 340         pSdrObj->InsertUserData( new IMapUserData( pCloneIMapObj ) );
 341         pSdrObj->SetUserCall( GetSdrUserCall() );
 342     }
 343
 344     return pSdrObj;
 345 }
 346
 347 /*************************************************************************
 348 |*
 349 |*
 350 |*
 351 \************************************************************************/
 352
 353 void IMapWindow::InitSdrModel()
 354 {
 355     GraphCtrl::InitSdrModel();
 356
 357     SfxItemSet aSet( pModel->GetItemPool() );
 358
 359     aSet.Put( XFillColorItem( String(), TRANSCOL ) );
 360     aSet.Put( XFillTransparenceItem( 50 ) );
 361     pView->SetAttributes( aSet );
 362     pView->SetFrameDragSingles( TRUE );
 363 }
 364
 365 /*************************************************************************
 366 |*
 367 |*
 368 |*
 369 \************************************************************************/
 370
 371 void IMapWindow::SdrObjCreated( const SdrObject& rObj )
 372 {
 373     switch( rObj.GetObjIdentifier() )
 374     {
 375         case( OBJ_RECT ):
 376         {
 377             SdrRectObj*                  pRectObj = (SdrRectObj*) &rObj;
 378             IMapRectangleObject* pObj = new IMapRectangleObject( pRectObj->GetLogicRect(),
 379                 String(), String(), String(), String(), String(), TRUE, FALSE );
 380
 381             pRectObj->InsertUserData( new IMapUserData( IMapObjectPtr(pObj) ) );
 382         }
 383         break;
 384
 385         case( OBJ_CIRC ):
 386         {
 387             SdrCircObj* pCircObj = (SdrCircObj*) &rObj;
 388             SdrPathObj* pPathObj = (SdrPathObj*) pCircObj->ConvertToPolyObj( FALSE, FALSE );
 389             Polygon aPoly(pPathObj->GetPathPoly().getB2DPolygon(0L));
 390             delete pPathObj;
 391
 392             IMapPolygonObject* pObj = new IMapPolygonObject( Polygon(aPoly), String(), String(), String(), String(), String(),  TRUE, FALSE );
 393             pObj->SetExtraEllipse( aPoly.GetBoundRect() );
 394             pCircObj->InsertUserData( new IMapUserData( IMapObjectPtr(pObj) ) );
 395         }
 396         break;
 397
 398         case( OBJ_POLY ):
 399         case( OBJ_FREEFILL ):
 400         case( OBJ_PATHPOLY ):
 401         case( OBJ_PATHFILL ):
 402         {
 403             SdrPathObj* pPathObj = (SdrPathObj*) &rObj;
 404             const basegfx::B2DPolyPolygon& rXPolyPoly = pPathObj->GetPathPoly();
 405
 406             if ( rXPolyPoly.count() )
 407             {
 408                 Polygon aPoly(rXPolyPoly.getB2DPolygon(0L));
 409                 IMapPolygonObject* pObj = new IMapPolygonObject( aPoly, String(), String(), String(), String(), String(),  TRUE, FALSE );
 410                 pPathObj->InsertUserData( new IMapUserData( IMapObjectPtr(pObj) ) );
 411             }
 412         }
 413         break;
 414
 415         default:
 416         break;
 417     }
 418 }
 419
 420 /*************************************************************************
 421 |*
 422 |*
 423 |*
 424 \************************************************************************/
 425
 426 void IMapWindow::SdrObjChanged( const SdrObject& rObj )
 427 {
 428     IMapUserData* pUserData = (IMapUserData*) rObj.GetUserData( 0 );
 429
 430     if ( pUserData )
 431     {
 432         String                  aURL;
 433         String                  aAltText;
 434         String                  aDesc;
 435         String                  aTarget;
 436         IMapObjectPtr   pIMapObj = pUserData->GetObject();
 437         BOOL                    bActive = TRUE;
 438
 439         if ( pIMapObj.get() )
 440         {
 441             aURL = pIMapObj->GetURL();
 442             aAltText = pIMapObj->GetAltText();
 443             aDesc = pIMapObj->GetDesc();
 444             aTarget = pIMapObj->GetTarget();
 445             bActive = pIMapObj->IsActive();
 446         }
 447
 448         switch( rObj.GetObjIdentifier() )
 449         {
 450             case( OBJ_RECT ):
 451             {
 452                 pUserData->ReplaceObject( IMapObjectPtr(new IMapRectangleObject( ( (const SdrRectObj&) rObj ).GetLogicRect(),
 453                           aURL, aAltText, aDesc, aTarget, String(), bActive, FALSE ) ) );
 454             }
 455             break;
 456
 457             case( OBJ_CIRC ):
 458             {
 459                 const SdrCircObj& rCircObj = (const SdrCircObj&) rObj;
 460                 SdrPathObj* pPathObj = (SdrPathObj*) rCircObj.ConvertToPolyObj( FALSE, FALSE );
 461                 Polygon aPoly(pPathObj->GetPathPoly().getB2DPolygon(0L));
 462
 463                 IMapPolygonObject* pObj = new IMapPolygonObject( aPoly, aURL, aAltText, aDesc, aTarget, String(), bActive, FALSE );
 464                 pObj->SetExtraEllipse( aPoly.GetBoundRect() );
 465
 466                 // wurde von uns nur temporaer angelegt
 467                 delete pPathObj;
 468                 pUserData->ReplaceObject( IMapObjectPtr(pObj) );
 469             }
 470             break;
 471
 472             case( OBJ_POLY ):
 473             case( OBJ_FREEFILL ):
 474             case( OBJ_PATHPOLY ):
 475             case( OBJ_PATHFILL ):
 476             {
 477                 const SdrPathObj& rPathObj = (const SdrPathObj&) rObj;
 478                 const basegfx::B2DPolyPolygon& rXPolyPoly = rPathObj.GetPathPoly();
 479
 480                 if ( rXPolyPoly.count() )
 481                 {
 482                     Polygon aPoly(rPathObj.GetPathPoly().getB2DPolygon(0L));
 483                     IMapPolygonObject*  pObj = new IMapPolygonObject( aPoly, aURL, aAltText, aDesc, aTarget, String(), bActive, FALSE );
 484                     pUserData->ReplaceObject( IMapObjectPtr(pObj) );
 485                 }
 486             }
 487             break;
 488
 489             default:
 490             break;
 491         }
 492     }
 493 }
 494
 495 /*************************************************************************
 496 |*
 497 |*
 498 |*
 499 \************************************************************************/
 500
 501 void IMapWindow::MouseButtonUp(const MouseEvent& rMEvt)
 502 {
 503     GraphCtrl::MouseButtonUp( rMEvt );
 504     UpdateInfo( TRUE );
 505 }
 506
 507 /*************************************************************************
 508 |*
 509 |*
 510 |*
 511 \************************************************************************/
 512
 513 void IMapWindow::MarkListHasChanged()
 514 {
 515     GraphCtrl::MarkListHasChanged();
 516     UpdateInfo( FALSE );
 517 }
 518
 519 /*************************************************************************
 520 |*
 521 |*
 522 |*
 523 \************************************************************************/
 524
 525 SdrObject* IMapWindow::GetHitSdrObj( const Point& rPosPixel ) const
 526 {
 527     SdrObject*  pObj = NULL;
 528     Point               aPt = PixelToLogic( rPosPixel );
 529
 530     if ( Rectangle( Point(), GetGraphicSize() ).IsInside( aPt ) )
 531     {
 532         SdrPage* pPage = (SdrPage*) pModel->GetPage( 0 );
 533         ULONG    nCount;
 534
 535         if ( pPage && ( ( nCount = pPage->GetObjCount() ) > 0 ) )
 536         {
 537             for ( long i = nCount - 1; i >= 0; i-- )
 538             {
 539                 SdrObject*      pTestObj = pPage->GetObj( i );
 540                 IMapObject*     pIMapObj = GetIMapObj( pTestObj );
 541
 542                 if ( pIMapObj && pIMapObj->IsHit( aPt ) )
 543                 {
 544                     pObj = pTestObj;
 545                     break;
 546                 }
 547             }
 548         }
 549     }
 550
 551     return pObj;
 552 }
 553
 554 /*************************************************************************
 555 |*
 556 |*
 557 |*
 558 \************************************************************************/
 559
 560 IMapObject* IMapWindow::GetIMapObj( const SdrObject* pSdrObj ) const
 561 {
 562     IMapObject* pIMapObj = NULL;
 563
 564     if ( pSdrObj )
 565     {
 566         IMapUserData* pUserData = (IMapUserData*) pSdrObj->GetUserData( 0 );
 567
 568         if ( pUserData )
 569             pIMapObj = pUserData->GetObject().get();
 570     }
 571
 572     return pIMapObj;
 573 }
 574
 575 /*************************************************************************
 576 |*
 577 |*
 578 |*
 579 \************************************************************************/
 580
 581 SdrObject* IMapWindow::GetSdrObj( const IMapObject* pIMapObj ) const
 582 {
 583     SdrObject*  pSdrObj = NULL;
 584     SdrPage*    pPage = (SdrPage*) pModel->GetPage( 0 );
 585     ULONG               nCount;
 586
 587     if ( pPage && ( ( nCount = pPage->GetObjCount() ) > 0 ) )
 588     {
 589         for ( ULONG i = 0; i < nCount; i++ )
 590         {
 591             SdrObject* pTestObj = pPage->GetObj( i );
 592
 593             if ( pIMapObj == GetIMapObj( pTestObj ) )
 594             {
 595                 pSdrObj = pTestObj;
 596                 break;
 597             }
 598         }
 599     }
 600
 601     return pSdrObj;
 602 }
 603
 604 /*************************************************************************
 605 |*
 606 |*
 607 |*
 608 \************************************************************************/
 609
 610 void IMapWindow::Command(const CommandEvent& rCEvt)
 611 {
 612     Region  aRegion;
 613
 614     if ( rCEvt.GetCommand() == COMMAND_CONTEXTMENU )
 615     {
 616         PopupMenu                       aMenu( SVX_RES( RID_SVXMN_IMAP ) );
 617         const SdrMarkList&      rMarkList = pView->GetMarkedObjectList();
 618         ULONG                           nMarked = rMarkList.GetMarkCount();
 619
 620         aMenu.EnableItem( MN_URL, FALSE );
 621         aMenu.EnableItem( MN_ACTIVATE, FALSE );
 622         aMenu.EnableItem( MN_MACRO, FALSE );
 623         aMenu.EnableItem( MN_MARK_ALL, pModel->GetPage( 0 )->GetObjCount() != pView->GetMarkedObjectCount() );
 624
 625         if ( !nMarked )
 626         {
 627             aMenu.EnableItem( MN_POSITION, FALSE );
 628             aMenu.EnableItem( MN_FRAME_TO_TOP, FALSE );
 629             aMenu.EnableItem( MN_MOREFRONT, FALSE );
 630             aMenu.EnableItem( MN_MOREBACK, FALSE );
 631             aMenu.EnableItem( MN_FRAME_TO_BOTTOM, FALSE );
 632             aMenu.EnableItem( MN_DELETE1, FALSE );
 633         }
 634         else
 635         {
 636             if ( nMarked == 1 )
 637             {
 638                 SdrObject*      pSdrObj = GetSelectedSdrObject();
 639
 640                 aMenu.EnableItem( MN_URL, TRUE );
 641                 aMenu.EnableItem( MN_ACTIVATE, TRUE );
 642                 aMenu.EnableItem( MN_MACRO, TRUE );
 643                 aMenu.CheckItem( MN_ACTIVATE, GetIMapObj( pSdrObj )->IsActive() );
 644             }
 645
 646             aMenu.EnableItem( MN_POSITION, TRUE );
 647             aMenu.EnableItem( MN_FRAME_TO_TOP, TRUE );
 648             aMenu.EnableItem( MN_MOREFRONT, TRUE );
 649             aMenu.EnableItem( MN_MOREBACK, TRUE );
 650             aMenu.EnableItem( MN_FRAME_TO_BOTTOM, TRUE );
 651             aMenu.EnableItem( MN_DELETE1, TRUE );
 652         }
 653
 654         aMenu.SetSelectHdl( LINK( this, IMapWindow, MenuSelectHdl ) );
 655         aMenu.Execute( this, rCEvt.GetMousePosPixel() );
 656     }
 657     else
 658         Window::Command(rCEvt);
 659 }
 660
 661 /*************************************************************************
 662 |*
 663 |*
 664 |*
 665 \************************************************************************/
 666
 667 sal_Int8 IMapWindow::AcceptDrop( const AcceptDropEvent& rEvt )
 668 {
 669     return( ( GetHitSdrObj( rEvt.maPosPixel ) != NULL ) ? rEvt.mnAction : DND_ACTION_NONE );
 670 }
 671
 672 /*************************************************************************
 673 |*
 674 |*
 675 |*
 676 \************************************************************************/
 677
 678 sal_Int8 IMapWindow::ExecuteDrop( const ExecuteDropEvent& rEvt )
 679 {
 680     sal_Int8 nRet = DND_ACTION_NONE;
 681
 682     if( IsDropFormatSupported( SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK ) )
 683     {
 684         const String    aString;
 685         INetBookmark    aBookMark( aString, aString );
 686         SdrObject*              pSdrObj = GetHitSdrObj( rEvt.maPosPixel );
 687
 688         if( pSdrObj && TransferableDataHelper( rEvt.maDropEvent.Transferable ).GetINetBookmark( SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK, aBookMark ) )
 689         {
 690             IMapObject* pIMapObj = GetIMapObj( pSdrObj );
 691
 692             pIMapObj->SetURL( aBookMark.GetURL() );
 693             pIMapObj->SetAltText( aBookMark.GetDescription() );
 694             pModel->SetChanged( sal_True );
 695             pView->UnmarkAll();
 696             pView->MarkObj( pSdrObj, pView->GetSdrPageView() );
 697             UpdateInfo( TRUE );
 698             nRet =  rEvt.mnAction;
 699         }
 700     }
 701
 702     return nRet;
 703 }
 704
 705 /*************************************************************************
 706 |*
 707 |*
 708 |*
 709 \************************************************************************/
 710
 711 void IMapWindow::RequestHelp( const HelpEvent& rHEvt )
 712 {
 713     SdrObject*                  pSdrObj = NULL;
 714     SdrPageView*                pPageView = NULL;
 715     Point                               aPos = PixelToLogic( ScreenToOutputPixel( rHEvt.GetMousePosPixel() ) );
 716
 717     if ( Help::IsBalloonHelpEnabled() || Help::IsQuickHelpEnabled() )
 718     {
 719         if ( pView->PickObj( aPos, pView->getHitTolLog(), pSdrObj, pPageView ) )
 720         {
 721             const IMapObject*   pIMapObj = GetIMapObj( pSdrObj );
 722             String                              aStr;
 723
 724             if ( pIMapObj && ( aStr = pIMapObj->GetURL() ).Len() )
 725             {
 726                 String          aDescr( pIMapObj->GetAltText() );
 727                 Rectangle       aLogicPix( LogicToPixel( Rectangle( Point(), GetGraphicSize() ) ) );
 728                 Rectangle       aScreenRect( OutputToScreenPixel( aLogicPix.TopLeft() ),
 729                                          OutputToScreenPixel( aLogicPix.BottomRight() ) );
 730
 731                 if ( Help::IsBalloonHelpEnabled() )
 732                     Help::ShowBalloon( this, rHEvt.GetMousePosPixel(), aScreenRect, aStr );
 733                 else if ( Help::IsQuickHelpEnabled() )
 734                     Help::ShowQuickHelp( this, aScreenRect, aStr );
 735             }
 736         }
 737         else
 738             Window::RequestHelp( rHEvt );
 739     }
 740 }
 741
 742 /*************************************************************************
 743 |*
 744 |*
 745 |*
 746 \************************************************************************/
 747
 748 void IMapWindow::SetCurrentObjState( BOOL bActive )
 749 {
 750     SdrObject* pObj = GetSelectedSdrObject();
 751
 752     if ( pObj )
 753     {
 754         SfxItemSet aSet( pModel->GetItemPool() );
 755
 756         GetIMapObj( pObj )->SetActive( bActive );
 757
 758         aSet.Put( XFillColorItem( String(), TRANSCOL ) );
 759
 760         if ( !bActive )
 761         {
 762             aSet.Put( XFillTransparenceItem( 100 ) );
 763             aSet.Put( XLineColorItem( String(), Color( COL_RED ) ) );
 764         }
 765         else
 766         {
 767             aSet.Put( XFillTransparenceItem( 50 ) );
 768             aSet.Put( XLineColorItem( String(), Color( COL_BLACK ) ) );
 769         }
 770
 771         pView->SetAttributes( aSet, FALSE );
 772     }
 773 }
 774
 775 /*************************************************************************
 776 |*
 777 |*
 778 |*
 779 \************************************************************************/
 780
 781 void IMapWindow::UpdateInfo( BOOL bNewObj )
 782 {
 783     if ( aInfoLink.IsSet() )
 784     {
 785         const SdrObject*        pSdrObj = GetSelectedSdrObject();
 786         const IMapObject*       pIMapObj = pSdrObj ? GetIMapObj( pSdrObj ) : NULL;
 787
 788         aInfo.bNewObj = bNewObj;
 789
 790         if ( pIMapObj )
 791         {
 792             aInfo.bOneMarked = TRUE;
 793             aInfo.aMarkURL = pIMapObj->GetURL();
 794             aInfo.aMarkAltText = pIMapObj->GetAltText();
 795             aInfo.aMarkTarget = pIMapObj->GetTarget();
 796             aInfo.bActivated = pIMapObj->IsActive();
 797             aInfoLink.Call( this );
 798         }
 799         else
 800         {
 801             aInfo.aMarkURL = aInfo.aMarkAltText = aInfo.aMarkTarget = String();
 802             aInfo.bOneMarked = FALSE;
 803             aInfo.bActivated = FALSE;
 804         }
 805
 806         aInfoLink.Call( this );
 807     }
 808 }
 809
 810 /*************************************************************************
 811 |*
 812 |*
 813 |*
 814 \************************************************************************/
 815
 816 void IMapWindow::DoMacroAssign()
 817 {
 818     SdrObject*  pSdrObj = GetSelectedSdrObject();
 819
 820     if ( pSdrObj )
 821     {
 822         SfxItemSet              aSet( *pIMapPool, SID_ATTR_MACROITEM, SID_ATTR_MACROITEM, SID_EVENTCONFIG, SID_EVENTCONFIG );
 823
 824         SfxEventNamesItem aNamesItem(SID_EVENTCONFIG);
 825         aNamesItem.AddEvent( String::CreateFromAscii( "MouseOver" ), String(), SFX_EVENT_MOUSEOVER_OBJECT );
 826         aNamesItem.AddEvent( String::CreateFromAscii( "MouseOut" ), String(), SFX_EVENT_MOUSEOUT_OBJECT );
 827
 828         SvxMacroItem    aMacroItem(SID_ATTR_MACROITEM);
 829         IMapObject*             pIMapObj = GetIMapObj( pSdrObj );
 830         aMacroItem.SetMacroTable( pIMapObj->GetMacroTable() );
 831         aSet.Put( aMacroItem, SID_ATTR_MACROITEM );
 832
 833         SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
 834         SfxAbstractDialog* pMacroDlg = pFact->CreateSfxDialog( this, aSet, mxDocumentFrame, SID_EVENTCONFIG );
 835
 836         if ( pMacroDlg && pMacroDlg->Execute() == RET_OK )
 837         {
 838             const SfxItemSet* pOutSet = pMacroDlg->GetOutputItemSet();
 839             pIMapObj->SetMacroTable( ((const SvxMacroItem& )pOutSet->Get( SID_ATTR_MACROITEM )).GetMacroTable() );
 840             pModel->SetChanged( sal_True );
 841             UpdateInfo( FALSE );
 842         }
 843
 844         delete pMacroDlg;
 845     }
 846 }
 847
 848 /*************************************************************************
 849 |*
 850 |*
 851 |*
 852 \************************************************************************/
 853
 854 void IMapWindow::DoPropertyDialog()
 855 {
 856     SdrObject*  pSdrObj = GetSelectedSdrObject();
 857
 858     if ( pSdrObj )
 859     {
 860         IMapObject* pIMapObj = GetIMapObj( pSdrObj );
 861         SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
 862         if(pFact)
 863         {
 864             AbstractURLDlg* aDlg = pFact->CreateURLDialog( this, pIMapObj->GetURL(), pIMapObj->GetAltText(), pIMapObj->GetDesc(),
 865                                             pIMapObj->GetTarget(), pIMapObj->GetName(), aTargetList );
 866             DBG_ASSERT(aDlg, "Dialogdiet fail!");
 867             if ( aDlg->Execute() == RET_OK )
 868             {
 869                 const String aURLText( aDlg->GetURL() );
 870
 871                 if ( aURLText.Len() )
 872                 {
 873                     INetURLObject aObj( aURLText, INET_PROT_FILE );
 874                     DBG_ASSERT( aObj.GetProtocol() != INET_PROT_NOT_VALID, "Invalid URL" );
 875                     pIMapObj->SetURL( aObj.GetMainURL( INetURLObject::NO_DECODE ) );
 876                 }
 877                 else
 878                     pIMapObj->SetURL( aURLText );
 879
 880                 pIMapObj->SetAltText( aDlg->GetAltText() );
 881                 pIMapObj->SetDesc( aDlg->GetDesc() );
 882                 pIMapObj->SetTarget( aDlg->GetTarget() );
 883                 pIMapObj->SetName( aDlg->GetName() );
 884                 pModel->SetChanged( sal_True );
 885                 UpdateInfo( TRUE );
 886             }
 887             delete aDlg; //add by CHINA001
 888         }
 889     }
 890 }
 891
 892 /*************************************************************************
 893 |*
 894 |*
 895 |*
 896 \************************************************************************/
 897
 898 IMPL_LINK( IMapWindow, MenuSelectHdl, Menu*, pMenu )
 899 {
 900     if (pMenu)
 901     {
 902         USHORT  nId = pMenu->GetCurItemId();
 903
 904         switch(nId)
 905         {
 906             case( MN_URL ):
 907                 DoPropertyDialog();
 908             break;
 909
 910             case( MN_MACRO ):
 911                 DoMacroAssign();
 912             break;
 913
 914             case( MN_ACTIVATE ):
 915             {
 916                 const BOOL bNewState = !pMenu->IsItemChecked( MN_ACTIVATE );
 917
 918                 pMenu->CheckItem( MN_ACTIVATE, bNewState );
 919                 SetCurrentObjState( bNewState );
 920                 UpdateInfo( FALSE );
 921             }
 922
 923             case( MN_FRAME_TO_TOP ):
 924                 pView->PutMarkedToTop();
 925             break;
 926
 927             case( MN_MOREFRONT ):
 928                 pView->MovMarkedToTop();
 929             break;
 930
 931             case( MN_MOREBACK ):
 932                 pView->MovMarkedToBtm();
 933             break;
 934
 935             case( MN_FRAME_TO_BOTTOM ):
 936                 pView->PutMarkedToBtm();
 937             break;
 938
 939             case( MN_MARK_ALL ):
 940                 pView->MarkAll();
 941             break;
 942
 943             case( MN_DELETE1 ):
 944                 pView->DeleteMarked();
 945
 946             default :
 947             break;
 948         }
 949     }
 950
 951     return 0;
 952 }
 953
 954 void IMapWindow::CreateDefaultObject()
 955 {
 956     SdrPageView* pPageView = pView->GetSdrPageView();
 957
 958     if(pPageView)
 959     {
 960         // calc position and size
 961         Point aPagePos(0, 0); // = pPageView->GetOffset();
 962         Size aPageSize = pPageView->GetPage()->GetSize();
 963         sal_uInt32 nDefaultObjectSizeWidth = aPageSize.Width() / 4;
 964         sal_uInt32 nDefaultObjectSizeHeight = aPageSize.Height() / 4;
 965         aPagePos.X() += (aPageSize.Width() / 2) - (nDefaultObjectSizeWidth / 2);
 966         aPagePos.Y() += (aPageSize.Height() / 2) - (nDefaultObjectSizeHeight / 2);
 967         Rectangle aNewObjectRectangle(aPagePos, Size(nDefaultObjectSizeWidth, nDefaultObjectSizeHeight));
 968
 969         SdrObject* pObj = SdrObjFactory::MakeNewObject( pView->GetCurrentObjInventor(), pView->GetCurrentObjIdentifier(), 0L, pModel);
 970         pObj->SetLogicRect(aNewObjectRectangle);
 971
 972         switch( pObj->GetObjIdentifier() )
 973         {
 974         case OBJ_POLY:
 975         case OBJ_PATHPOLY:
 976             {
 977                 basegfx::B2DPolygon aInnerPoly;
 978                 aInnerPoly.append(basegfx::B2DPoint(aNewObjectRectangle.BottomLeft().X(), aNewObjectRectangle.BottomLeft().Y()));
 979                 aInnerPoly.append(basegfx::B2DPoint(aNewObjectRectangle.TopLeft().X(), aNewObjectRectangle.TopLeft().Y()));
 980                 aInnerPoly.append(basegfx::B2DPoint(aNewObjectRectangle.TopCenter().X(), aNewObjectRectangle.TopCenter().Y()));
 981                 aInnerPoly.append(basegfx::B2DPoint(aNewObjectRectangle.Center().X(), aNewObjectRectangle.Center().Y()));
 982                 aInnerPoly.append(basegfx::B2DPoint(aNewObjectRectangle.RightCenter().X(), aNewObjectRectangle.RightCenter().Y()));
 983                 aInnerPoly.append(basegfx::B2DPoint(aNewObjectRectangle.BottomRight().X(), aNewObjectRectangle.BottomRight().Y()));
 984                 aInnerPoly.setClosed(true);
 985                 ((SdrPathObj*)pObj)->SetPathPoly(basegfx::B2DPolyPolygon(aInnerPoly));
 986                 break;
 987             }
 988         case OBJ_FREEFILL:
 989         case OBJ_PATHFILL:
 990             {
 991                 sal_Int32 nWdt(aNewObjectRectangle.GetWidth() / 2);
 992                 sal_Int32 nHgt(aNewObjectRectangle.GetHeight() / 2);
 993                 basegfx::B2DPolygon aInnerPoly(XPolygon(aNewObjectRectangle.Center(), nWdt, nHgt).getB2DPolygon());
 994                 ((SdrPathObj*)pObj)->SetPathPoly(basegfx::B2DPolyPolygon(aInnerPoly));
 995                 break;
 996             }
 997
 998         }
 999
1000         pView->InsertObjectAtView(pObj, *pPageView);
1001         SdrObjCreated( *pObj );
1002         SetCurrentObjState( true );
1003         pView->MarkObj( pObj, pPageView );
1004     }
1005 }
1006
1007 void IMapWindow::KeyInput( const KeyEvent& rKEvt )
1008 {
1009     KeyCode aCode = rKEvt.GetKeyCode();
1010
1011 /*
1012     switch(aCode.GetCode())
1013     {
1014         case KEY_ESCAPE:
1015         {
1016             if ( pView->IsAction() )
1017             {
1018                 pView->BrkAction();
1019                 return;
1020             }
1021             else if ( pView->AreObjectsMarked() )
1022             {
1023                 const SdrHdlList& rHdlList = pView->GetHdlList();
1024                 SdrHdl* pHdl = rHdlList.GetFocusHdl();
1025
1026                 if(pHdl)
1027                 {
1028                     ((SdrHdlList&)rHdlList).ResetFocusHdl();
1029                 }
1030                 else
1031                 {
1032                     pView->UnmarkAllObj();
1033                     ((Dialog*)GetParent())->GrabFocusToFirstControl();
1034                 }
1035
1036                 return;
1037             }
1038         }
1039         break;
1040
1041     }
1042 */
1043     GraphCtrl::KeyInput( rKEvt );
1044 }
1045
1046 void IMapWindow::SelectFirstObject()
1047 {
1048     SdrPage*    pPage = (SdrPage*) pModel->GetPage( 0 );
1049     if( pPage->GetObjCount() != 0 )
1050     {
1051         GrabFocus();
1052         pView->UnmarkAllObj();
1053         pView->MarkNextObj(TRUE);
1054     }
1055 }
1056
1057 void IMapWindow::StartPolyEdit()
1058 {
1059     GrabFocus();
1060
1061     if( !pView->AreObjectsMarked() )
1062         pView->MarkNextObj(TRUE);
1063
1064     const SdrHdlList& rHdlList = pView->GetHdlList();
1065     SdrHdl* pHdl = rHdlList.GetFocusHdl();
1066
1067     if(!pHdl)
1068     {
1069         ((SdrHdlList&)rHdlList).TravelFocusHdl(true);
1070     }
1071 }