sd/source/ui/annotations/annotationtag.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: motionpathtag.cxx,v $
  10  * $Revision: 1.3 $
  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_sd.hxx"
  33
  34 #include <com/sun/star/util/XChangesNotifier.hpp>
  35
  36 #include <vcl/help.hxx>
  37 #include <vcl/svapp.hxx>
  38
  39 #include <sfx2/viewfrm.hxx>
  40 #include <sfx2/dispatch.hxx>
  41
  42 #include <svx/sdr/overlay/overlaymanager.hxx>
  43 #include <svx/sdr/overlay/overlayanimatedbitmapex.hxx>
  44 #include <svx/sdr/overlay/overlaybitmapex.hxx>
  45 #include <svx/svdpagv.hxx>
  46 #include <svx/sdrpagewindow.hxx>
  47 #include <svx/sdrpaintwindow.hxx>
  48 #include <svx/svddrgmt.hxx>
  49
  50 #include "View.hxx"
  51 #include "sdresid.hxx"
  52 #include "annotations.hrc"
  53 #include "annotationmanagerimpl.hxx"
  54 #include "annotationwindow.hxx"
  55 #include "annotationtag.hxx"
  56 #include "sdpage.hxx"
  57 #include "ViewShell.hxx"
  58 #include "app.hrc"
  59 #include "Window.hxx"
  60 #include "drawdoc.hxx"
  61
  62 using ::rtl::OUString;
  63 using namespace ::com::sun::star::uno;
  64 using namespace ::com::sun::star::lang;
  65 //using namespace ::com::sun::star::util;
  66 using namespace ::com::sun::star::drawing;
  67 using namespace ::com::sun::star::office;
  68 using namespace ::com::sun::star::geometry;
  69
  70 namespace sd
  71 {
  72
  73 const sal_uInt32 SMART_TAG_HDL_NUM = SAL_MAX_UINT32;
  74 static const int DRGPIX     = 2;                               // Drag MinMove in Pixel
  75
  76 // --------------------------------------------------------------------
  77
  78 static OUString getInitials( const OUString& rName )
  79 {
  80     OUString sInitials;
  81
  82     const sal_Unicode * pStr = rName.getStr();
  83     sal_Int32 nLength = rName.getLength();
  84
  85     while( nLength )
  86     {
  87         // skip whitespace
  88         while( nLength && (*pStr <= ' ') )
  89         {
  90             nLength--; pStr++;
  91         }
  92
  93         // take letter
  94         if( nLength )
  95         {
  96             sInitials += OUString( *pStr );
  97             nLength--; pStr++;
  98         }
  99
 100         // skip letters until whitespace
 101         while( nLength && (*pStr > ' ') )
 102         {
 103             nLength--; pStr++;
 104         }
 105     }
 106
 107     return sInitials;
 108 }
 109
 110 // --------------------------------------------------------------------
 111
 112 // --------------------------------------------------------------------
 113
 114 class AnnotationDragMove : public SdrDragMove
 115 {
 116 public:
 117     AnnotationDragMove(SdrDragView& rNewView, const rtl::Reference <AnnotationTag >& xTag);
 118     virtual bool BeginSdrDrag();
 119     virtual bool EndSdrDrag(bool bCopy);
 120     virtual void MoveSdrDrag(const Point& rNoSnapPnt);
 121     virtual void CancelSdrDrag();
 122
 123 private:
 124     rtl::Reference <AnnotationTag > mxTag;
 125     Point maOrigin;
 126 };
 127
 128 AnnotationDragMove::AnnotationDragMove(SdrDragView& rNewView, const rtl::Reference <AnnotationTag >& xTag)
 129 : SdrDragMove(rNewView)
 130 , mxTag( xTag )
 131 {
 132 }
 133
 134 bool AnnotationDragMove::BeginSdrDrag()
 135 {
 136     DragStat().Ref1()=GetDragHdl()->GetPos();
 137     DragStat().SetShown(!DragStat().IsShown());
 138
 139     maOrigin = GetDragHdl()->GetPos();
 140     DragStat().SetActionRect(Rectangle(maOrigin,maOrigin));
 141
 142     return true;
 143 }
 144
 145 void AnnotationDragMove::MoveSdrDrag(const Point& rNoSnapPnt)
 146 {
 147     Point aPnt(rNoSnapPnt);
 148
 149     if (DragStat().CheckMinMoved(rNoSnapPnt))
 150     {
 151         if (aPnt!=DragStat().GetNow())
 152         {
 153             Hide();
 154             DragStat().NextMove(aPnt);
 155             GetDragHdl()->SetPos( maOrigin + Point( DragStat().GetDX(), DragStat().GetDY() ) );
 156             Show();
 157             DragStat().SetActionRect(Rectangle(aPnt,aPnt));
 158         }
 159     }
 160 }
 161
 162 bool AnnotationDragMove::EndSdrDrag(bool /*bCopy*/)
 163 {
 164     Hide();
 165     if( mxTag.is() )
 166         mxTag->Move( DragStat().GetDX(), DragStat().GetDY() );
 167     return TRUE;
 168 }
 169
 170 void AnnotationDragMove::CancelSdrDrag()
 171 {
 172     Hide();
 173 }
 174
 175 // --------------------------------------------------------------------
 176
 177 class AnnotationHdl : public SmartHdl
 178 {
 179 public:
 180     AnnotationHdl( const SmartTagReference& xTag, const Reference< XAnnotation >& xAnnotation, const Point& rPnt );
 181     virtual ~AnnotationHdl();
 182     virtual void CreateB2dIAObject();
 183     virtual BOOL IsFocusHdl() const;
 184     virtual Pointer GetSdrDragPointer() const;
 185     virtual bool isMarkable() const;
 186
 187
 188 private:
 189     Reference< XAnnotation > mxAnnotation;
 190     rtl::Reference< AnnotationTag > mxTag;
 191 };
 192
 193 // --------------------------------------------------------------------
 194
 195 AnnotationHdl::AnnotationHdl( const SmartTagReference& xTag, const Reference< XAnnotation >& xAnnotation, const Point& rPnt )
 196 : SmartHdl( xTag, rPnt )
 197 , mxAnnotation( xAnnotation )
 198 , mxTag( dynamic_cast< AnnotationTag* >( xTag.get() ) )
 199 {
 200 }
 201
 202 // --------------------------------------------------------------------
 203
 204 AnnotationHdl::~AnnotationHdl()
 205 {
 206 }
 207
 208 // --------------------------------------------------------------------
 209
 210 void AnnotationHdl::CreateB2dIAObject()
 211 {
 212     // first throw away old one
 213     GetRidOfIAObject();
 214
 215     if( mxAnnotation.is() )
 216     {
 217         const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
 218
 219         const Point aTagPos( GetPos() );
 220         basegfx::B2DPoint aPosition( aTagPos.X(), aTagPos.Y() );
 221
 222         const bool bFocused = IsFocusHdl() && pHdlList && (pHdlList->GetFocusHdl() == this);
 223
 224         BitmapEx aBitmapEx( mxTag->CreateAnnotationBitmap(mxTag->isSelected()) );
 225         BitmapEx aBitmapEx2;
 226         if( bFocused )
 227             aBitmapEx2 = mxTag->CreateAnnotationBitmap(!mxTag->isSelected() );
 228
 229         if(pHdlList)
 230         {
 231             SdrMarkView* pView = pHdlList->GetView();
 232
 233             if(pView && !pView->areMarkHandlesHidden())
 234             {
 235                 SdrPageView* pPageView = pView->GetSdrPageView();
 236
 237                 if(pPageView)
 238                 {
 239                     for(sal_uInt32 b = 0; b < pPageView->PageWindowCount(); b++)
 240                     {
 241                         // const SdrPageViewWinRec& rPageViewWinRec = rPageViewWinList[b];
 242                         const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(b);
 243
 244                         SdrPaintWindow& rPaintWindow = rPageWindow.GetPaintWindow();
 245                         if(rPaintWindow.OutputToWindow() && rPageWindow.GetOverlayManager() )
 246                         {
 247                             ::sdr::overlay::OverlayObject* pOverlayObject = 0;
 248
 249                             // animate focused handles
 250                             if(bFocused)
 251                             {
 252                                 const sal_uInt32 nBlinkTime = sal::static_int_cast<sal_uInt32>(rStyleSettings.GetCursorBlinkTime());
 253
 254                                 pOverlayObject = new ::sdr::overlay::OverlayAnimatedBitmapEx(aPosition, aBitmapEx, aBitmapEx2, nBlinkTime, 0, 0, 0, 0 );
 255 /*
 256                                     (UINT16)(aBitmapEx.GetSizePixel().Width() - 1) >> 1,
 257                                     (UINT16)(aBitmapEx.GetSizePixel().Height() - 1) >> 1,
 258                                     (UINT16)(aBitmapEx2.GetSizePixel().Width() - 1) >> 1,
 259                                     (UINT16)(aBitmapEx2.GetSizePixel().Height() - 1) >> 1);
 260 */
 261                             }
 262                             else
 263                             {
 264                                 pOverlayObject = new ::sdr::overlay::OverlayBitmapEx( aPosition, aBitmapEx, 0, 0 );
 265                             }
 266
 267                             rPageWindow.GetOverlayManager()->add(*pOverlayObject);
 268                             maOverlayGroup.append(*pOverlayObject);
 269                         }
 270                     }
 271                 }
 272             }
 273         }
 274     }
 275 }
 276
 277 // --------------------------------------------------------------------
 278
 279 BOOL AnnotationHdl::IsFocusHdl() const
 280 {
 281     return TRUE;
 282 }
 283
 284 // --------------------------------------------------------------------
 285
 286 bool AnnotationHdl::isMarkable() const
 287 {
 288     return false;
 289 }
 290
 291 // --------------------------------------------------------------------
 292
 293 Pointer AnnotationHdl::GetSdrDragPointer() const
 294 {
 295     PointerStyle eStyle = POINTER_NOTALLOWED;
 296     if( mxTag.is() )
 297     {
 298         if( mxTag->isSelected() )
 299         {
 300             eStyle = POINTER_MOVE;
 301         }
 302         else
 303         {
 304             eStyle = POINTER_ARROW;
 305
 306         }
 307     }
 308     return Pointer( eStyle );
 309 }
 310
 311 // ====================================================================
 312
 313 AnnotationTag::AnnotationTag( AnnotationManagerImpl& rManager, ::sd::View& rView, const Reference< XAnnotation >& xAnnotation, Color& rColor, int nIndex, const Font& rFont )
 314 : SmartTag( rView )
 315 , mrManager( rManager )
 316 , mxAnnotation( xAnnotation )
 317 , maColor( rColor )
 318 , mnIndex( nIndex )
 319 , mrFont( rFont )
 320 , mnClosePopupEvent( 0 )
 321 , mpListenWindow( 0 )
 322 {
 323 }
 324
 325 // --------------------------------------------------------------------
 326
 327 AnnotationTag::~AnnotationTag()
 328 {
 329     DBG_ASSERT( !mxAnnotation.is(), "sd::AnnotationTag::~AnnotationTag(), dispose me first!" );
 330     Dispose();
 331 }
 332
 333 // --------------------------------------------------------------------
 334
 335 /** returns true if the AnnotationTag handled the event. */
 336 bool AnnotationTag::MouseButtonDown( const MouseEvent& rMEvt, SmartHdl& /*rHdl*/ )
 337 {
 338     if( !mxAnnotation.is() )
 339         return false;
 340
 341     bool bRet = false;
 342     if( !isSelected() )
 343     {
 344         SmartTagReference xTag( this );
 345         mrView.getSmartTags().select( xTag );
 346         bRet = true;
 347     }
 348     /*
 349     if( rMEvt.IsLeft() && (rMEvt.GetClicks() == 2) )
 350     {
 351         // double click;
 352         return true;
 353     }
 354     else */
 355     if( rMEvt.IsLeft() && !rMEvt.IsRight() )
 356     {
 357         Window* pWindow = mrView.GetViewShell()->GetActiveWindow();
 358         if( pWindow )
 359         {
 360             maMouseDownPos = pWindow->PixelToLogic( rMEvt.GetPosPixel() );
 361
 362             if( mpListenWindow )
 363                 mpListenWindow->RemoveEventListener( LINK(this, AnnotationTag, WindowEventHandler));
 364
 365             mpListenWindow = pWindow;
 366             mpListenWindow->AddEventListener( LINK(this, AnnotationTag, WindowEventHandler));
 367         }
 368
 369         bRet = true;
 370     }
 371
 372     return bRet;
 373 }
 374
 375 // --------------------------------------------------------------------
 376
 377 /** returns true if the SmartTag consumes this event. */
 378 bool AnnotationTag::KeyInput( const KeyEvent& rKEvt )
 379 {
 380     if( !mxAnnotation.is() )
 381         return false;
 382
 383     USHORT nCode = rKEvt.GetKeyCode().GetCode();
 384     switch( nCode )
 385     {
 386     case KEY_DELETE:
 387         mrManager.DeleteAnnotation( mxAnnotation );
 388         return true;
 389
 390     case KEY_DOWN:
 391     case KEY_UP:
 392     case KEY_LEFT:
 393     case KEY_RIGHT:
 394         return OnMove( rKEvt );
 395
 396     case KEY_ESCAPE:
 397     {
 398         SmartTagReference xThis( this );
 399         mrView.getSmartTags().deselect();
 400         return true;
 401     }
 402
 403     case KEY_TAB:
 404         mrManager.SelectNextAnnotation(!rKEvt.GetKeyCode().IsShift());
 405         return true;
 406
 407     case KEY_RETURN:
 408        case KEY_SPACE:
 409            OpenPopup( true );
 410            return true;
 411
 412     default:
 413         return false;
 414     }
 415 }
 416
 417 /** returns true if the SmartTag consumes this event. */
 418 bool AnnotationTag::RequestHelp( const HelpEvent& /*rHEvt*/ )
 419 {
 420 /*
 421     ::Window* pWindow = mrView.GetViewShell()->GetActiveWindow();
 422     if( mxAnnotation.is() && pWindow )
 423     {
 424         OUString aHelpText( mrManager.GetHelpText( mxAnnotation ) );
 425
 426         RealPoint2D aPosition( mxAnnotation->getPosition() );
 427         Point aPos( pWindow->LogicToPixel( Point( static_cast<long>(aPosition.X * 100.0), static_cast<long>(aPosition.Y * 100.0) ) ) );
 428
 429         Rectangle aRect( aPos, maSize );
 430
 431         if (Help::IsBalloonHelpEnabled())
 432             Help::ShowBalloon( pWindow, aPos, aRect, aHelpText);
 433         else if (Help::IsQuickHelpEnabled())
 434             Help::ShowQuickHelp( pWindow, aRect, aHelpText);
 435
 436         return true;
 437    }
 438 */
 439    return false;
 440 }
 441
 442 /** returns true if the SmartTag consumes this event. */
 443 bool AnnotationTag::Command( const CommandEvent& rCEvt )
 444 {
 445     if ( rCEvt.GetCommand() == COMMAND_CONTEXTMENU )
 446     {
 447         ::Window* pWindow = mrView.GetViewShell()->GetActiveWindow();
 448         if( pWindow )
 449         {
 450             Rectangle aContextRect(rCEvt.GetMousePosPixel(),Size(1,1));
 451                mrManager.ExecuteAnnotationContextMenu( mxAnnotation, pWindow, aContextRect );
 452             return true;
 453         }
 454     }
 455
 456     return false;
 457 }
 458
 459 void AnnotationTag::Move( int nDX, int nDY )
 460 {
 461     if( mxAnnotation.is() )
 462     {
 463         if( mrManager.GetDoc()->IsUndoEnabled() )
 464             mrManager.GetDoc()->BegUndo( String( SdResId( STR_ANNOTATION_UNDO_MOVE ) ) );
 465
 466         RealPoint2D aPosition( mxAnnotation->getPosition() );
 467         aPosition.X += (double)nDX / 100.0;
 468         aPosition.Y += (double)nDY / 100.0;
 469         mxAnnotation->setPosition( aPosition );
 470
 471         if( mrManager.GetDoc()->IsUndoEnabled() )
 472             mrManager.GetDoc()->EndUndo();
 473
 474         mrView.updateHandles();
 475     }
 476 }
 477
 478 bool AnnotationTag::OnMove( const KeyEvent& rKEvt )
 479 {
 480     long nX = 0;
 481     long nY = 0;
 482
 483     switch( rKEvt.GetKeyCode().GetCode() )
 484     {
 485     case KEY_UP:        nY = -1; break;
 486     case KEY_DOWN:      nY =  1; break;
 487     case KEY_LEFT:      nX = -1; break;
 488     case KEY_RIGHT:     nX =  1; break;
 489     default: break;
 490     }
 491
 492     if(rKEvt.GetKeyCode().IsMod2())
 493     {
 494         OutputDevice* pOut = mrView.GetViewShell()->GetActiveWindow();
 495         Size aLogicSizeOnePixel = (pOut) ? pOut->PixelToLogic(Size(1,1)) : Size(100, 100);
 496         nX *= aLogicSizeOnePixel.Width();
 497         nY *= aLogicSizeOnePixel.Height();
 498     }
 499     else
 500     {
 501         // old, fixed move distance
 502         nX *= 100;
 503         nY *= 100;
 504     }
 505
 506     if( nX || nY )
 507     {
 508         // move the annotation
 509         Move( nX, nY );
 510     }
 511
 512     return true;
 513 }
 514
 515 // --------------------------------------------------------------------
 516
 517 void AnnotationTag::CheckPossibilities()
 518 {
 519 }
 520
 521 // --------------------------------------------------------------------
 522
 523 ULONG AnnotationTag::GetMarkablePointCount() const
 524 {
 525     return 0;
 526 }
 527
 528 // --------------------------------------------------------------------
 529
 530 ULONG AnnotationTag::GetMarkedPointCount() const
 531 {
 532     return 0;
 533 }
 534
 535 // --------------------------------------------------------------------
 536
 537 BOOL AnnotationTag::MarkPoint(SdrHdl& /*rHdl*/, BOOL /*bUnmark*/ )
 538 {
 539     BOOL bRet=FALSE;
 540     return bRet;
 541 }
 542
 543 // --------------------------------------------------------------------
 544
 545 BOOL AnnotationTag::MarkPoints(const Rectangle* /*pRect*/, BOOL /*bUnmark*/ )
 546 {
 547     BOOL bChgd=FALSE;
 548     return bChgd;
 549 }
 550
 551 // --------------------------------------------------------------------
 552
 553 bool AnnotationTag::getContext( SdrViewContext& /*rContext*/ )
 554 {
 555     return false;
 556 }
 557
 558 // --------------------------------------------------------------------
 559
 560 void AnnotationTag::addCustomHandles( SdrHdlList& rHandlerList )
 561 {
 562     if( mxAnnotation.is() )
 563     {
 564         SmartTagReference xThis( this );
 565         Point aPoint;
 566         AnnotationHdl* pHdl = new AnnotationHdl( xThis, mxAnnotation, aPoint );
 567         pHdl->SetObjHdlNum( SMART_TAG_HDL_NUM );
 568         pHdl->SetPageView( mrView.GetSdrPageView() );
 569
 570         RealPoint2D aPosition( mxAnnotation->getPosition() );
 571         Point aBasePos( static_cast<long>(aPosition.X * 100.0), static_cast<long>(aPosition.Y * 100.0) );
 572         pHdl->SetPos( aBasePos );
 573
 574         rHandlerList.AddHdl( pHdl );
 575     }
 576 }
 577
 578 // --------------------------------------------------------------------
 579
 580 void AnnotationTag::disposing()
 581 {
 582     if( mpListenWindow )
 583     {
 584         mpListenWindow->RemoveEventListener( LINK(this, AnnotationTag, WindowEventHandler));
 585     }
 586
 587     if( mnClosePopupEvent )
 588     {
 589         Application::RemoveUserEvent( mnClosePopupEvent );
 590         mnClosePopupEvent = 0;
 591     }
 592
 593     mxAnnotation.clear();
 594     ClosePopup();
 595     SmartTag::disposing();
 596 }
 597
 598 // --------------------------------------------------------------------
 599
 600 void AnnotationTag::select()
 601 {
 602     SmartTag::select();
 603
 604     mrManager.onTagSelected( *this );
 605
 606     Window* pWindow = mrView.GetViewShell()->GetActiveWindow();
 607     if( pWindow )
 608     {
 609         RealPoint2D aPosition( mxAnnotation->getPosition() );
 610         Point aPos( static_cast<long>(aPosition.X * 100.0), static_cast<long>(aPosition.Y * 100.0) );
 611
 612         Rectangle aVisRect( aPos, pWindow->PixelToLogic(maSize) );
 613         mrView.MakeVisible(aVisRect, *pWindow);
 614     }
 615 }
 616
 617 // --------------------------------------------------------------------
 618
 619 void AnnotationTag::deselect()
 620 {
 621     SmartTag::deselect();
 622
 623     ClosePopup();
 624
 625     mrManager.onTagDeselected( *this );
 626 }
 627
 628 // --------------------------------------------------------------------
 629
 630 BitmapEx AnnotationTag::CreateAnnotationBitmap( bool bSelected )
 631 {
 632     VirtualDevice aVDev;
 633
 634     OUString sAuthor( getInitials( mxAnnotation->getAuthor() ) );
 635     sAuthor += OUString( sal_Unicode( ' ' ) );
 636     sAuthor += OUString::valueOf( (sal_Int32)mnIndex );
 637
 638     aVDev.SetFont( mrFont );
 639
 640     const int BORDER_X = 4; // pixels
 641     const int BORDER_Y = 4; // pixels
 642
 643     maSize = Size( aVDev.GetTextWidth( sAuthor ) + 2*BORDER_X, aVDev.GetTextHeight() + 2*BORDER_Y );
 644     aVDev.SetOutputSizePixel( maSize, FALSE );
 645
 646     Color aBorderColor( maColor );
 647
 648     if( bSelected )
 649     {
 650         aBorderColor.Invert();
 651     }
 652     else
 653     {
 654         if( maColor.IsDark() )
 655         {
 656             aBorderColor.IncreaseLuminance( 32 );
 657         }
 658         else
 659         {
 660             aBorderColor.DecreaseLuminance( 32 );
 661         }
 662     }
 663
 664     Point aPos;
 665     Rectangle aBorderRect( aPos, maSize );
 666     aVDev.SetLineColor(aBorderColor);
 667     aVDev.SetFillColor(maColor);
 668     aVDev.DrawRect( aBorderRect );
 669
 670     aVDev.SetTextColor( maColor.IsDark() ? COL_WHITE : COL_BLACK );
 671     aVDev.DrawText( Point( BORDER_X, BORDER_Y ), sAuthor );
 672
 673     return aVDev.GetBitmapEx( aPos, maSize );
 674 }
 675
 676 void AnnotationTag::OpenPopup( bool bEdit )
 677 {
 678     if( !mxAnnotation.is() )
 679         return;
 680
 681     if( !mpAnnotationWindow.get() )
 682     {
 683            ::Window* pWindow = dynamic_cast< ::Window* >( getView().GetFirstOutputDevice() );
 684            if( pWindow )
 685            {
 686             RealPoint2D aPosition( mxAnnotation->getPosition() );
 687             Point aPos( pWindow->OutputToScreenPixel( pWindow->LogicToPixel( Point( static_cast<long>(aPosition.X * 100.0), static_cast<long>(aPosition.Y * 100.0) ) ) ) );
 688
 689             aPos.X() += 4; // magic!
 690             aPos.Y() += 1;
 691
 692             Rectangle aRect( aPos, maSize );
 693
 694             mpAnnotationWindow.reset( new AnnotationWindow( mrManager, mrView.GetDocSh(), pWindow->GetWindow(WINDOW_FRAME) ) );
 695             mpAnnotationWindow->InitControls();
 696             mpAnnotationWindow->setAnnotation(mxAnnotation);
 697
 698             USHORT nArrangeIndex = 0;
 699             Point aPopupPos( FloatingWindow::CalcFloatingPosition( mpAnnotationWindow.get(), aRect, FLOATWIN_POPUPMODE_RIGHT, nArrangeIndex ) );
 700             Size aPopupSize( 320, 240 );
 701
 702             mpAnnotationWindow->SetPosSizePixel( aPopupPos, aPopupSize );
 703             mpAnnotationWindow->DoResize();
 704
 705             mpAnnotationWindow->Show();
 706             mpAnnotationWindow->GrabFocus();
 707             mpAnnotationWindow->AddEventListener( LINK(this, AnnotationTag, WindowEventHandler));
 708         }
 709     }
 710
 711     if( bEdit && mpAnnotationWindow.get() )
 712         mpAnnotationWindow->StartEdit();
 713 }
 714
 715 void AnnotationTag::ClosePopup()
 716 {
 717     if( mpAnnotationWindow.get() )
 718     {
 719         mpAnnotationWindow->RemoveEventListener( LINK(this, AnnotationTag, WindowEventHandler));
 720         mpAnnotationWindow->Deactivate();
 721         mpAnnotationWindow.reset();
 722     }
 723 }
 724
 725 IMPL_LINK(AnnotationTag, WindowEventHandler, VclWindowEvent*, pEvent)
 726 {
 727     if( pEvent != NULL )
 728     {
 729         ::Window* pWindow = pEvent->GetWindow();
 730
 731         if( pWindow )
 732         {
 733             if( pWindow == mpAnnotationWindow.get() )
 734             {
 735                 if( pEvent->GetId() == VCLEVENT_WINDOW_DEACTIVATE )
 736                 {
 737                     if( mnClosePopupEvent )
 738                         Application::RemoveUserEvent( mnClosePopupEvent );
 739
 740                     mnClosePopupEvent = Application::PostUserEvent( LINK( this, AnnotationTag, ClosePopupHdl ) );
 741                 }
 742             }
 743             else if( pWindow == mpListenWindow )
 744             {
 745                 switch( pEvent->GetId() )
 746                 {
 747                 case VCLEVENT_WINDOW_MOUSEBUTTONUP:
 748                     {
 749                         // if we stop pressing the button without a mouse move we open the popup
 750                         mpListenWindow->RemoveEventListener( LINK(this, AnnotationTag, WindowEventHandler));
 751                         mpListenWindow = 0;
 752                         if( mpAnnotationWindow.get() == 0 )
 753                             OpenPopup(false);
 754                     }
 755                     break;
 756                 case VCLEVENT_WINDOW_MOUSEMOVE:
 757                     {
 758                         // if we move the mouse after a button down we wan't to start draging
 759                         mpListenWindow->RemoveEventListener( LINK(this, AnnotationTag, WindowEventHandler));
 760                         mpListenWindow = 0;
 761
 762                         SdrHdl* pHdl = mrView.PickHandle(maMouseDownPos);
 763                         if( pHdl )
 764                         {
 765                             mrView.BrkAction();
 766                             const USHORT nDrgLog = (USHORT)pWindow->PixelToLogic(Size(DRGPIX,0)).Width();
 767
 768                             rtl::Reference< AnnotationTag > xTag( this );
 769
 770                             SdrDragMethod* pDragMethod = new AnnotationDragMove( mrView, xTag );
 771                             mrView.BegDragObj(maMouseDownPos, NULL, pHdl, nDrgLog, pDragMethod );
 772                         }
 773                     }
 774                     break;
 775                 case VCLEVENT_OBJECT_DYING:
 776                     mpListenWindow = 0;
 777                     break;
 778                 }
 779             }
 780         }
 781     }
 782     return TRUE;
 783 }
 784
 785 IMPL_LINK( AnnotationTag, ClosePopupHdl, void *, EMPTYARG )
 786 {
 787     mnClosePopupEvent = 0;
 788     ClosePopup();
 789     return 0;
 790 }
 791
 792 } // end of namespace sd
 793