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