sd/source/ui/annotations/annotationmanager.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 "sddll.hxx"
  22
  23 #include <com/sun/star/beans/XMultiPropertyStates.hpp>
  24 #include <com/sun/star/frame/XController.hpp>
  25 #include <com/sun/star/frame/XModel.hpp>
  26 #include <com/sun/star/view/XSelectionSupplier.hpp>
  27 #include <com/sun/star/geometry/RealPoint2D.hpp>
  28 #include <com/sun/star/text/XText.hpp>
  29 #include <com/sun/star/document/XEventBroadcaster.hpp>
  30 #include <comphelper/string.hxx>
  31 #include <svx/svxids.hrc>
  32 #include <vcl/menu.hxx>
  33 #include <vcl/msgbox.hxx>
  34
  35 #include <sal/macros.h>
  36 #include <svl/style.hxx>
  37 #include <svl/itempool.hxx>
  38 #include <unotools/useroptions.hxx>
  39 #include <unotools/syslocale.hxx>
  40 #include <unotools/saveopt.hxx>
  41
  42 #include <tools/datetime.hxx>
  43
  44 #include <sfx2/imagemgr.hxx>
  45 #include <sfx2/viewfrm.hxx>
  46 #include <sfx2/bindings.hxx>
  47 #include <sfx2/app.hxx>
  48 #include <sfx2/request.hxx>
  49 #include <sfx2/dispatch.hxx>
  50 #include <sfx2/objface.hxx>
  51
  52 #include <editeng/editeng.hxx>
  53 #include <editeng/eeitem.hxx>
  54 #include <editeng/fontitem.hxx>
  55 #include <editeng/fhgtitem.hxx>
  56 #include <editeng/outlobj.hxx>
  57 #include <editeng/postitem.hxx>
  58 #include <editeng/wghtitem.hxx>
  59 #include <editeng/udlnitem.hxx>
  60 #include <editeng/crossedoutitem.hxx>
  61
  62 #include <svx/svdetc.hxx>
  63
  64 #include "annotationmanager.hxx"
  65 #include "annotationmanagerimpl.hxx"
  66 #include "annotationwindow.hxx"
  67 #include "annotations.hrc"
  68
  69 #include "ToolBarManager.hxx"
  70 #include "DrawDocShell.hxx"
  71 #include "DrawViewShell.hxx"
  72 #include "DrawController.hxx"
  73 #include "glob.hrc"
  74 #include "sdresid.hxx"
  75 #include "EventMultiplexer.hxx"
  76 #include "ViewShellManager.hxx"
  77 #include "helpids.h"
  78 #include "sdpage.hxx"
  79 #include "drawdoc.hxx"
  80 #include "textapi.hxx"
  81 #include "optsitem.hxx"
  82
  83 using namespace ::com::sun::star;
  84 using namespace ::com::sun::star::uno;
  85 using namespace ::com::sun::star::drawing;
  86 using namespace ::com::sun::star::document;
  87 using namespace ::com::sun::star::geometry;
  88 using namespace ::com::sun::star::container;
  89 using namespace ::com::sun::star::beans;
  90 using namespace ::com::sun::star::text;
  91 using namespace ::com::sun::star::view;
  92 using namespace ::com::sun::star::style;
  93 using namespace ::com::sun::star::frame;
  94 using namespace ::com::sun::star::lang;
  95 using namespace ::com::sun::star::ui;
  96 using namespace ::com::sun::star::task;
  97 using namespace ::com::sun::star::office;
  98
  99 namespace sd {
 100
 101 // --------------------------------------------------------------------
 102
 103 extern TextApiObject* getTextApiObject( const Reference< XAnnotation >& xAnnotation );
 104
 105 // --------------------------------------------------------------------
 106
 107 SfxItemPool* GetAnnotationPool()
 108 {
 109     static SfxItemPool* mpAnnotationPool = 0;
 110     if( mpAnnotationPool == 0 )
 111     {
 112         mpAnnotationPool = EditEngine::CreatePool( sal_False );
 113         mpAnnotationPool->SetPoolDefaultItem(SvxFontHeightItem(423,100,EE_CHAR_FONTHEIGHT));
 114
 115         Font aAppFont( Application::GetSettings().GetStyleSettings().GetAppFont() );
 116         String EMPTYSTRING;
 117         mpAnnotationPool->SetPoolDefaultItem(SvxFontItem(aAppFont.GetFamily(),aAppFont.GetName(), EMPTYSTRING,PITCH_DONTKNOW,RTL_TEXTENCODING_DONTKNOW,EE_CHAR_FONTINFO));
 118     }
 119
 120     return mpAnnotationPool;
 121 }
 122
 123 // --------------------------------------------------------------------
 124
 125 static SfxBindings* getBindings( ViewShellBase& rBase )
 126 {
 127     if( rBase.GetMainViewShell().get() && rBase.GetMainViewShell()->GetViewFrame() )
 128         return &rBase.GetMainViewShell()->GetViewFrame()->GetBindings();
 129
 130     return 0;
 131 }
 132
 133 // --------------------------------------------------------------------
 134
 135 static SfxDispatcher* getDispatcher( ViewShellBase& rBase )
 136 {
 137     if( rBase.GetMainViewShell().get() && rBase.GetMainViewShell()->GetViewFrame() )
 138         return rBase.GetMainViewShell()->GetViewFrame()->GetDispatcher();
 139
 140     return 0;
 141 }
 142
 143 com::sun::star::util::DateTime getCurrentDateTime()
 144 {
 145     DateTime aCurrentDate( DateTime::SYSTEM );
 146     return com::sun::star::util::DateTime( 0, aCurrentDate.GetSec(),
 147             aCurrentDate.GetMin(), aCurrentDate.GetHour(),
 148             aCurrentDate.GetDay(), aCurrentDate.GetMonth(),
 149             aCurrentDate.GetYear(), false );
 150 }
 151
 152 OUString getAnnotationDateTimeString( const Reference< XAnnotation >& xAnnotation )
 153 {
 154     OUString sRet;
 155     if( xAnnotation.is() )
 156     {
 157         const SvtSysLocale aSysLocale;
 158         const LocaleDataWrapper& rLocalData = aSysLocale.GetLocaleData();
 159
 160         com::sun::star::util::DateTime aDateTime( xAnnotation->getDateTime() );
 161
 162         Date aSysDate( Date::SYSTEM );
 163         Date aDate = Date( aDateTime.Day, aDateTime.Month, aDateTime.Year );
 164         if (aDate==aSysDate)
 165             sRet = SdResId(STR_ANNOTATION_TODAY);
 166         else if (aDate == Date(aSysDate-1))
 167             sRet = SdResId(STR_ANNOTATION_YESTERDAY);
 168         else if (aDate.IsValidAndGregorian() )
 169             sRet = rLocalData.getDate(aDate);
 170
 171         Time aTime( aDateTime.Hours, aDateTime.Minutes, aDateTime.Seconds, aDateTime.NanoSeconds );
 172         if(aTime.GetTime() != 0)
 173             sRet = sRet + " "  + rLocalData.getTime( aTime,false );
 174     }
 175     return sRet;
 176 }
 177
 178 // --------------------------------------------------------------------
 179
 180 AnnotationManagerImpl::AnnotationManagerImpl( ViewShellBase& rViewShellBase )
 181 : AnnotationManagerImplBase( m_aMutex )
 182 , mrBase( rViewShellBase )
 183 , mpDoc( rViewShellBase.GetDocument() )
 184 , mbShowAnnotations( true )
 185 , mnUpdateTagsEvent( 0 )
 186 {
 187     SdOptions* pOptions = SD_MOD()->GetSdOptions(mpDoc->GetDocumentType());
 188     if( pOptions )
 189         mbShowAnnotations = pOptions->IsShowComments() == sal_True;
 190 }
 191
 192 // --------------------------------------------------------------------
 193
 194 void AnnotationManagerImpl::init()
 195 {
 196     // get current controller and initialize listeners
 197     try
 198     {
 199         addListener();
 200         mxView = Reference< XDrawView >::query(mrBase.GetController());
 201     }
 202     catch( Exception& )
 203     {
 204         OSL_FAIL( "sd::AnnotationManagerImpl::AnnotationManagerImpl(), Exception caught!" );
 205     }
 206
 207     try
 208     {
 209         Reference<XEventBroadcaster> xModel (mrBase.GetDocShell()->GetModel(), UNO_QUERY_THROW );
 210         Reference<XEventListener> xListener( this );
 211         xModel->addEventListener( xListener );
 212     }
 213     catch( Exception& )
 214     {
 215     }
 216 }
 217
 218 // --------------------------------------------------------------------
 219
 220 // WeakComponentImplHelper1
 221 void SAL_CALL AnnotationManagerImpl::disposing ()
 222 {
 223     try
 224     {
 225         Reference<XEventBroadcaster> xModel (mrBase.GetDocShell()->GetModel(), UNO_QUERY_THROW );
 226         Reference<XEventListener> xListener( this );
 227         xModel->removeEventListener( xListener );
 228     }
 229     catch( Exception& )
 230     {
 231     }
 232
 233     removeListener();
 234     DisposeTags();
 235
 236     if( mnUpdateTagsEvent )
 237     {
 238         Application::RemoveUserEvent( mnUpdateTagsEvent );
 239         mnUpdateTagsEvent = 0;
 240     }
 241
 242     mxView.clear();
 243     mxCurrentPage.clear();
 244 }
 245
 246 // --------------------------------------------------------------------
 247
 248 // XEventListener
 249 void SAL_CALL AnnotationManagerImpl::notifyEvent( const ::com::sun::star::document::EventObject& aEvent ) throw (::com::sun::star::uno::RuntimeException)
 250 {
 251     if( aEvent.EventName == "OnAnnotationInserted" || aEvent.EventName == "OnAnnotationRemoved" || aEvent.EventName == "OnAnnotationChanged" )
 252     {
 253         UpdateTags();
 254     }
 255 }
 256
 257 void SAL_CALL AnnotationManagerImpl::disposing( const ::com::sun::star::lang::EventObject& /*Source*/ ) throw (::com::sun::star::uno::RuntimeException)
 258 {
 259 }
 260
 261 void AnnotationManagerImpl::ShowAnnotations( bool bShow )
 262 {
 263     // enforce show annotations if a new annotation is inserted
 264     if( mbShowAnnotations != bShow )
 265     {
 266         mbShowAnnotations = bShow;
 267
 268         SdOptions* pOptions = SD_MOD()->GetSdOptions(mpDoc->GetDocumentType());
 269         if( pOptions )
 270             pOptions->SetShowComments( mbShowAnnotations ? sal_True : sal_False );
 271
 272         UpdateTags();
 273     }
 274 }
 275
 276 // --------------------------------------------------------------------
 277
 278 void AnnotationManagerImpl::ExecuteAnnotation(SfxRequest& rReq )
 279 {
 280     switch( rReq.GetSlot() )
 281     {
 282     case SID_INSERT_POSTIT:
 283         ExecuteInsertAnnotation( rReq );
 284         break;
 285     case SID_DELETE_POSTIT:
 286     case SID_DELETEALL_POSTIT:
 287     case SID_DELETEALLBYAUTHOR_POSTIT:
 288         ExecuteDeleteAnnotation( rReq );
 289         break;
 290     case SID_PREVIOUS_POSTIT:
 291     case SID_NEXT_POSTIT:
 292         SelectNextAnnotation( rReq.GetSlot() == SID_NEXT_POSTIT );
 293         break;
 294     case SID_REPLYTO_POSTIT:
 295         ExecuteReplyToAnnotation( rReq );
 296         break;
 297     case SID_SHOW_POSTIT:
 298         ShowAnnotations( !mbShowAnnotations );
 299         break;
 300     }
 301 }
 302
 303 // --------------------------------------------------------------------
 304
 305 void AnnotationManagerImpl::ExecuteInsertAnnotation(SfxRequest& /*rReq*/)
 306 {
 307     ShowAnnotations(true);
 308     InsertAnnotation();
 309 }
 310
 311 // --------------------------------------------------------------------
 312
 313 void AnnotationManagerImpl::ExecuteDeleteAnnotation(SfxRequest& rReq)
 314 {
 315     ShowAnnotations( true );
 316
 317     const SfxItemSet* pArgs = rReq.GetArgs();
 318
 319     switch( rReq.GetSlot() )
 320     {
 321     case SID_DELETEALL_POSTIT:
 322         DeleteAllAnnotations();
 323         break;
 324     case SID_DELETEALLBYAUTHOR_POSTIT:
 325         if( pArgs )
 326         {
 327             const SfxPoolItem*  pPoolItem = NULL;
 328             if( SFX_ITEM_SET == pArgs->GetItemState( SID_DELETEALLBYAUTHOR_POSTIT, sal_True, &pPoolItem ) )
 329             {
 330                 OUString sAuthor( (( const SfxStringItem* ) pPoolItem )->GetValue() );
 331                 DeleteAnnotationsByAuthor( sAuthor );
 332             }
 333         }
 334         break;
 335     case SID_DELETE_POSTIT:
 336         {
 337             Reference< XAnnotation > xAnnotation;
 338
 339             if( rReq.GetSlot() == SID_DELETE_POSTIT )
 340             {
 341                 if( pArgs )
 342                 {
 343                     const SfxPoolItem*  pPoolItem = NULL;
 344                     if( SFX_ITEM_SET == pArgs->GetItemState( SID_DELETE_POSTIT, sal_True, &pPoolItem ) )
 345                         ( ( const SfxUnoAnyItem* ) pPoolItem )->GetValue() >>= xAnnotation;
 346                 }
 347             }
 348
 349             if( !xAnnotation.is() )
 350                 GetSelectedAnnotation( xAnnotation );
 351
 352             DeleteAnnotation( xAnnotation );
 353         }
 354         break;
 355     }
 356
 357     UpdateTags();
 358 }
 359
 360 // --------------------------------------------------------------------
 361
 362 void AnnotationManagerImpl::InsertAnnotation()
 363 {
 364     SdPage* pPage = GetCurrentPage();
 365     if( pPage )
 366     {
 367         if( mpDoc->IsUndoEnabled() )
 368             mpDoc->BegUndo( String( SdResId( STR_ANNOTATION_UNDO_INSERT ) ) );
 369
 370         // find free space for new annotation
 371         int y = 0, x = 0;
 372
 373         AnnotationVector aAnnotations( pPage->getAnnotations() );
 374         if( !aAnnotations.empty() )
 375         {
 376             const int page_width = pPage->GetSize().Width();
 377             const int width = 1000;
 378             const int height = 800;
 379             Rectangle aTagRect;
 380
 381             while( true )
 382             {
 383                 Rectangle aNewRect( x, y, x + width - 1, y + height - 1 );
 384                 bool bFree = true;
 385
 386                 for( AnnotationVector::iterator iter = aAnnotations.begin(); iter != aAnnotations.end(); ++iter )
 387                 {
 388                     RealPoint2D aPoint( (*iter)->getPosition() );
 389                     aTagRect.Left()   = sal::static_int_cast< long >( aPoint.X * 100.0 );
 390                     aTagRect.Top()    = sal::static_int_cast< long >( aPoint.Y * 100.0 );
 391                     aTagRect.Right()  = aTagRect.Left() + width - 1;
 392                     aTagRect.Bottom() = aTagRect.Top() + height - 1;
 393
 394                     if( aNewRect.IsOver( aTagRect ) )
 395                     {
 396                         bFree = false;
 397                         break;
 398                     }
 399                 }
 400
 401                 if( bFree == false)
 402                 {
 403                     x += width;
 404                     if( x > page_width )
 405                     {
 406                         x = 0;
 407                         y += height;
 408                     }
 409                 }
 410                 else
 411                 {
 412                     break;
 413                 }
 414             }
 415         }
 416
 417         Reference< XAnnotation > xAnnotation;
 418         pPage->createAnnotation( xAnnotation );
 419
 420         // set current author to new annotation
 421         SvtUserOptions aUserOptions;
 422         xAnnotation->setAuthor( aUserOptions.GetFullName() );
 423
 424         // set current time to new annotation
 425         xAnnotation->setDateTime( getCurrentDateTime() );
 426
 427         // set position
 428         RealPoint2D aPos( ((double)x) / 100.0, ((double)y) / 100.0 );
 429         xAnnotation->setPosition( aPos );
 430
 431         if( mpDoc->IsUndoEnabled() )
 432             mpDoc->EndUndo();
 433
 434         UpdateTags(true);
 435         SelectAnnotation( xAnnotation, true );
 436     }
 437 }
 438
 439 // --------------------------------------------------------------------
 440
 441 void AnnotationManagerImpl::ExecuteReplyToAnnotation( SfxRequest& rReq )
 442 {
 443     Reference< XAnnotation > xAnnotation;
 444     const SfxItemSet* pArgs = rReq.GetArgs();
 445     if( pArgs )
 446     {
 447         const SfxPoolItem*  pPoolItem = NULL;
 448         if( SFX_ITEM_SET == pArgs->GetItemState( rReq.GetSlot(), sal_True, &pPoolItem ) )
 449             ( ( const SfxUnoAnyItem* ) pPoolItem )->GetValue() >>= xAnnotation;
 450     }
 451
 452
 453     TextApiObject* pTextApi = getTextApiObject( xAnnotation );
 454     if( pTextApi )
 455     {
 456         std::auto_ptr< ::Outliner > pOutliner( new ::Outliner(GetAnnotationPool(),OUTLINERMODE_TEXTOBJECT) );
 457
 458         mpDoc->SetCalcFieldValueHdl( pOutliner.get() );
 459         pOutliner->SetUpdateMode( sal_True );
 460
 461         String aStr(SdResId(STR_ANNOTATION_REPLY));
 462         OUString sAuthor( xAnnotation->getAuthor() );
 463         if( sAuthor.isEmpty() )
 464             sAuthor = String( SdResId( STR_ANNOTATION_NOAUTHOR ) );
 465
 466         aStr.SearchAndReplaceAscii("%1", sAuthor);
 467
 468         aStr.Append( OUString(" (") );
 469         aStr.Append( OUString( getAnnotationDateTimeString( xAnnotation ) ) );
 470         aStr.Append( OUString("): \"") );
 471
 472         String sQuote( pTextApi->GetText() );
 473
 474         if( sQuote.Len() == 0 )
 475             sQuote = OUString( "..." );
 476         aStr.Append( sQuote );
 477         aStr.Append( OUString("\"\n") );
 478
 479         sal_Int32 nParaCount = comphelper::string::getTokenCount(aStr, '\n');
 480         for( sal_Int32 nPara = 0; nPara < nParaCount; nPara++ )
 481             pOutliner->Insert( aStr.GetToken( nPara, '\n' ), EE_PARA_APPEND, -1 );
 482
 483         if( pOutliner->GetParagraphCount() > 1 )
 484         {
 485             SfxItemSet aAnswerSet( pOutliner->GetEmptyItemSet() );
 486             aAnswerSet.Put(SvxPostureItem(ITALIC_NORMAL,EE_CHAR_ITALIC));
 487
 488             ESelection aSel;
 489             aSel.nEndPara = pOutliner->GetParagraphCount()-2;
 490             aSel.nEndPos = pOutliner->GetText( pOutliner->GetParagraph( aSel.nEndPara ) ).Len();
 491
 492             pOutliner->QuickSetAttribs( aAnswerSet, aSel );
 493         }
 494
 495         std::auto_ptr< OutlinerParaObject > pOPO( pOutliner->CreateParaObject() );
 496         pTextApi->SetText( *pOPO.get() );
 497
 498         SvtUserOptions aUserOptions;
 499         xAnnotation->setAuthor( aUserOptions.GetFullName() );
 500
 501         // set current time to reply
 502         xAnnotation->setDateTime( getCurrentDateTime() );
 503
 504         UpdateTags(true);
 505         SelectAnnotation( xAnnotation, true );
 506     }
 507 }
 508
 509 // --------------------------------------------------------------------
 510
 511 void AnnotationManagerImpl::DeleteAnnotation( Reference< XAnnotation > xAnnotation )
 512 {
 513     SdPage* pPage = GetCurrentPage();
 514
 515     if( xAnnotation.is() && pPage )
 516     {
 517         if( mpDoc->IsUndoEnabled() )
 518             mpDoc->BegUndo( String( SdResId( STR_ANNOTATION_UNDO_DELETE ) ) );
 519
 520         pPage->removeAnnotation( xAnnotation );
 521
 522         if( mpDoc->IsUndoEnabled() )
 523             mpDoc->EndUndo();
 524
 525         UpdateTags();
 526     }
 527 }
 528
 529 void AnnotationManagerImpl::DeleteAnnotationsByAuthor( const OUString& sAuthor )
 530 {
 531     if( mpDoc->IsUndoEnabled() )
 532         mpDoc->BegUndo( String( SdResId( STR_ANNOTATION_UNDO_DELETE ) ) );
 533
 534     SdPage* pPage = 0;
 535     do
 536     {
 537         pPage = GetNextPage( pPage, true );
 538
 539         if( pPage && !pPage->getAnnotations().empty() )
 540         {
 541             AnnotationVector aAnnotations( pPage->getAnnotations() );
 542             for( AnnotationVector::iterator iter = aAnnotations.begin(); iter != aAnnotations.end(); ++iter )
 543             {
 544                 Reference< XAnnotation > xAnnotation( *iter );
 545                 if( xAnnotation->getAuthor() == sAuthor )
 546                 {
 547                     if( mxSelectedAnnotation == xAnnotation )
 548                         mxSelectedAnnotation.clear();
 549                     pPage->removeAnnotation( xAnnotation );
 550                 }
 551             }
 552         }
 553     } while( pPage );
 554
 555     if( mpDoc->IsUndoEnabled() )
 556         mpDoc->EndUndo();
 557 }
 558
 559 void AnnotationManagerImpl::DeleteAllAnnotations()
 560 {
 561     if( mpDoc->IsUndoEnabled() )
 562         mpDoc->BegUndo( String( SdResId( STR_ANNOTATION_UNDO_DELETE ) ) );
 563
 564     SdPage* pPage = 0;
 565     do
 566     {
 567         pPage = GetNextPage( pPage, true );
 568
 569         if( pPage && !pPage->getAnnotations().empty() )
 570         {
 571
 572             AnnotationVector aAnnotations( pPage->getAnnotations() );
 573             for( AnnotationVector::iterator iter = aAnnotations.begin(); iter != aAnnotations.end(); ++iter )
 574             {
 575                 pPage->removeAnnotation( (*iter) );
 576             }
 577         }
 578     }
 579     while( pPage );
 580
 581     mxSelectedAnnotation.clear();
 582
 583     if( mpDoc->IsUndoEnabled() )
 584         mpDoc->EndUndo();
 585 }
 586
 587 // --------------------------------------------------------------------
 588
 589 void AnnotationManagerImpl::GetAnnotationState(SfxItemSet& rSet)
 590 {
 591     SdPage* pCurrentPage = GetCurrentPage();
 592
 593     const bool bReadOnly = mrBase.GetDocShell()->IsReadOnly();
 594     const bool bWrongPageKind = (pCurrentPage == 0) || (pCurrentPage->GetPageKind() != PK_STANDARD);
 595
 596     const SvtSaveOptions::ODFDefaultVersion nCurrentODFVersion( SvtSaveOptions().GetODFDefaultVersion() );
 597
 598     if( bReadOnly || bWrongPageKind || (nCurrentODFVersion <= SvtSaveOptions::ODFVER_012) )
 599         rSet.DisableItem( SID_INSERT_POSTIT );
 600
 601     rSet.Put(SfxBoolItem(SID_SHOW_POSTIT, mbShowAnnotations));
 602
 603     Reference< XAnnotation > xAnnotation;
 604     GetSelectedAnnotation( xAnnotation );
 605
 606     if( !xAnnotation.is() || bReadOnly )
 607         rSet.DisableItem( SID_DELETE_POSTIT );
 608
 609     SdPage* pPage = 0;
 610
 611     bool bHasAnnotations = false;
 612     do
 613     {
 614         pPage = GetNextPage( pPage, true );
 615
 616         if( pPage && !pPage->getAnnotations().empty() )
 617             bHasAnnotations = true;
 618     }
 619     while( pPage && !bHasAnnotations );
 620
 621     if( !bHasAnnotations || bReadOnly )
 622     {
 623         rSet.DisableItem( SID_DELETEALL_POSTIT );
 624     }
 625
 626     if( bWrongPageKind || !bHasAnnotations )
 627     {
 628         rSet.DisableItem( SID_PREVIOUS_POSTIT );
 629         rSet.DisableItem( SID_NEXT_POSTIT );
 630     }
 631 }
 632
 633 // --------------------------------------------------------------------
 634
 635 void AnnotationManagerImpl::SelectNextAnnotation(bool bForeward)
 636 {
 637     ShowAnnotations( true );
 638
 639     Reference< XAnnotation > xCurrent;
 640     GetSelectedAnnotation( xCurrent );
 641     SdPage* pPage = GetCurrentPage();
 642     if( !pPage )
 643         return;
 644
 645     AnnotationVector aAnnotations( pPage->getAnnotations() );
 646
 647     if( bForeward )
 648     {
 649         if( xCurrent.is() )
 650         {
 651             for( AnnotationVector::iterator iter = aAnnotations.begin(); iter != aAnnotations.end(); ++iter )
 652             {
 653                 if( (*iter) == xCurrent )
 654                 {
 655                     ++iter;
 656                     if( iter != aAnnotations.end() )
 657                     {
 658                         SelectAnnotation( (*iter) );
 659                         return;
 660                     }
 661                     break;
 662                 }
 663             }
 664         }
 665         else if( !aAnnotations.empty() )
 666         {
 667             SelectAnnotation( *(aAnnotations.begin()) );
 668             return;
 669         }
 670     }
 671     else
 672     {
 673         if( xCurrent.is() )
 674         {
 675             for( AnnotationVector::iterator iter = aAnnotations.begin(); iter != aAnnotations.end(); ++iter )
 676             {
 677                 if( (*iter) == xCurrent )
 678                 {
 679                     if( iter != aAnnotations.begin() )
 680                     {
 681                         --iter;
 682                         SelectAnnotation( (*iter) );
 683                         return;
 684                     }
 685                     break;
 686                 }
 687             }
 688         }
 689         else if( !aAnnotations.empty() )
 690         {
 691             AnnotationVector::iterator iter( aAnnotations.end() );
 692             SelectAnnotation( *(--iter) );
 693             return;
 694         }
 695     }
 696
 697     mxSelectedAnnotation.clear();
 698     do
 699     {
 700         do
 701         {
 702             pPage = GetNextPage( pPage, bForeward );
 703
 704             if( pPage && !pPage->getAnnotations().empty() )
 705             {
 706                 // switch to next/previous slide with annotations
 707                 ::boost::shared_ptr<DrawViewShell> pDrawViewShell(::boost::dynamic_pointer_cast<DrawViewShell>(mrBase.GetMainViewShell()));
 708                 if (pDrawViewShell.get() != NULL)
 709                 {
 710                     pDrawViewShell->ChangeEditMode(pPage->IsMasterPage() ? EM_MASTERPAGE : EM_PAGE, sal_False);
 711                     pDrawViewShell->SwitchPage((pPage->GetPageNum() - 1) >> 1);
 712
 713                     SfxDispatcher* pDispatcher = getDispatcher( mrBase );
 714                     if( pDispatcher )
 715                         pDispatcher->Execute( bForeward ? SID_NEXT_POSTIT : SID_PREVIOUS_POSTIT );
 716
 717                     return;
 718                 }
 719             }
 720         }
 721         while( pPage );
 722
 723         // The question text depends on the search direction.
 724         bool bImpress = mpDoc->GetDocumentType() == DOCUMENT_TYPE_IMPRESS;
 725         sal_uInt16 nStringId;
 726         if(bForeward)
 727             nStringId = bImpress ? STR_ANNOTATION_WRAP_FORWARD : STR_ANNOTATION_WRAP_FORWARD_DRAW;
 728         else
 729             nStringId = bImpress ? STR_ANNOTATION_WRAP_BACKWARD : STR_ANNOTATION_WRAP_BACKWARD_DRAW;
 730
 731         // Pop up question box that asks the user whether to wrap arround.
 732         // The dialog is made modal with respect to the whole application.
 733         QueryBox aQuestionBox ( NULL, (WB_YES_NO | WB_DEF_YES), String(SdResId(nStringId)));
 734         aQuestionBox.SetImage (QueryBox::GetStandardImage());
 735         short nBoxResult = aQuestionBox.Execute();
 736         if (nBoxResult != RET_YES)
 737             break;
 738     }
 739     while( true );
 740 }
 741
 742 // --------------------------------------------------------------------
 743
 744 void AnnotationManagerImpl::onTagSelected( AnnotationTag& rTag )
 745 {
 746     mxSelectedAnnotation = rTag.GetAnnotation();
 747     invalidateSlots();
 748 }
 749
 750 // --------------------------------------------------------------------
 751
 752 void AnnotationManagerImpl::onTagDeselected( AnnotationTag& rTag )
 753 {
 754     if( rTag.GetAnnotation() == mxSelectedAnnotation )
 755     {
 756         mxSelectedAnnotation.clear();
 757         invalidateSlots();
 758     }
 759 }
 760
 761 // --------------------------------------------------------------------
 762
 763 void AnnotationManagerImpl::SelectAnnotation( ::com::sun::star::uno::Reference< ::com::sun::star::office::XAnnotation > xAnnotation, bool bEdit /* = sal_False */ )
 764 {
 765     mxSelectedAnnotation = xAnnotation;
 766
 767     const AnnotationTagVector::const_iterator aEnd( maTagVector.end() );
 768     for( AnnotationTagVector::const_iterator iter( maTagVector.begin() );
 769         iter != aEnd; ++iter)
 770     {
 771         if( (*iter)->GetAnnotation() == xAnnotation )
 772         {
 773             SmartTagReference xTag( (*iter).get() );
 774             mrBase.GetMainViewShell()->GetView()->getSmartTags().select( xTag );
 775             (*iter)->OpenPopup( bEdit );
 776             break;
 777         }
 778     }
 779 }
 780
 781 // --------------------------------------------------------------------
 782
 783 void AnnotationManagerImpl::GetSelectedAnnotation( ::com::sun::star::uno::Reference< ::com::sun::star::office::XAnnotation >& xAnnotation )
 784 {
 785     xAnnotation = mxSelectedAnnotation;
 786 }
 787
 788 void AnnotationManagerImpl::invalidateSlots()
 789 {
 790     SfxBindings* pBindings = getBindings( mrBase );
 791     if( pBindings )
 792     {
 793         pBindings->Invalidate( SID_INSERT_POSTIT );
 794         pBindings->Invalidate( SID_DELETE_POSTIT );
 795         pBindings->Invalidate( SID_DELETEALL_POSTIT );
 796         pBindings->Invalidate( SID_PREVIOUS_POSTIT );
 797         pBindings->Invalidate( SID_NEXT_POSTIT );
 798         pBindings->Invalidate( SID_UNDO );
 799         pBindings->Invalidate( SID_REDO );
 800     }
 801 }
 802
 803 // --------------------------------------------------------------------
 804
 805 void AnnotationManagerImpl::onSelectionChanged()
 806 {
 807     if( mxView.is() && mrBase.GetDrawView() ) try
 808     {
 809         Reference< XAnnotationAccess > xPage( mxView->getCurrentPage(), UNO_QUERY );
 810
 811         if( xPage != mxCurrentPage )
 812         {
 813             mxCurrentPage = xPage;
 814
 815             UpdateTags(true);
 816         }
 817     }
 818     catch( Exception& )
 819     {
 820         OSL_FAIL( "sd::AnnotationManagerImpl::onSelectionChanged(), exception caught!" );
 821     }
 822 }
 823
 824 void AnnotationManagerImpl::UpdateTags( bool bSynchron )
 825 {
 826     if( bSynchron )
 827     {
 828         if( mnUpdateTagsEvent )
 829             Application::RemoveUserEvent( mnUpdateTagsEvent );
 830
 831         UpdateTagsHdl(0);
 832     }
 833     else
 834     {
 835         if( !mnUpdateTagsEvent && mxView.is() )
 836             mnUpdateTagsEvent = Application::PostUserEvent( LINK( this, AnnotationManagerImpl, UpdateTagsHdl ) );
 837     }
 838 }
 839
 840 IMPL_LINK_NOARG(AnnotationManagerImpl, UpdateTagsHdl)
 841 {
 842     mnUpdateTagsEvent  = 0;
 843     DisposeTags();
 844
 845     if( mbShowAnnotations )
 846         CreateTags();
 847
 848     if( mrBase.GetDrawView() )
 849         static_cast< ::sd::View* >( mrBase.GetDrawView() )->updateHandles();
 850
 851     invalidateSlots();
 852
 853     return 0;
 854 }
 855
 856 void AnnotationManagerImpl::CreateTags()
 857 {
 858
 859     if( mxCurrentPage.is() && mpDoc ) try
 860     {
 861         int nIndex = 1;
 862         maFont = Application::GetSettings().GetStyleSettings().GetAppFont();
 863
 864         rtl::Reference< AnnotationTag > xSelectedTag;
 865
 866         Reference< XAnnotationEnumeration > xEnum( mxCurrentPage->createAnnotationEnumeration() );
 867         while( xEnum->hasMoreElements() )
 868         {
 869             Reference< XAnnotation > xAnnotation( xEnum->nextElement() );
 870             Color aColor( GetColorLight( mpDoc->GetAnnotationAuthorIndex( xAnnotation->getAuthor() ) ) );
 871             rtl::Reference< AnnotationTag > xTag( new AnnotationTag( *this, *mrBase.GetMainViewShell()->GetView(), xAnnotation, aColor, nIndex++, maFont ) );
 872             maTagVector.push_back(xTag);
 873
 874             if( xAnnotation == mxSelectedAnnotation )
 875             {
 876                 xSelectedTag = xTag;
 877             }
 878         }
 879
 880         if( xSelectedTag.is() )
 881         {
 882             SmartTagReference xTag( xSelectedTag.get() );
 883             mrBase.GetMainViewShell()->GetView()->getSmartTags().select( xTag );
 884         }
 885         else
 886         {
 887             // no tag, no selection!
 888             mxSelectedAnnotation.clear();
 889         }
 890     }
 891     catch( Exception& )
 892     {
 893         OSL_FAIL( "sd::AnnotationManagerImpl::onSelectionChanged(), exception caught!" );
 894     }
 895 }
 896
 897 // --------------------------------------------------------------------
 898
 899 void AnnotationManagerImpl::DisposeTags()
 900 {
 901     if( !maTagVector.empty() )
 902     {
 903         AnnotationTagVector::iterator iter = maTagVector.begin();
 904         do
 905         {
 906             (*iter++)->Dispose();
 907         }
 908         while( iter != maTagVector.end() );
 909
 910         maTagVector.clear();
 911     }
 912 }
 913
 914 // --------------------------------------------------------------------
 915
 916 void AnnotationManagerImpl::addListener()
 917 {
 918     Link aLink( LINK(this,AnnotationManagerImpl,EventMultiplexerListener) );
 919     mrBase.GetEventMultiplexer()->AddEventListener (
 920         aLink,
 921         tools::EventMultiplexerEvent::EID_EDIT_VIEW_SELECTION
 922         | tools::EventMultiplexerEvent::EID_CURRENT_PAGE
 923         | tools::EventMultiplexerEvent::EID_MAIN_VIEW_REMOVED
 924         | tools::EventMultiplexerEvent::EID_MAIN_VIEW_ADDED);
 925 }
 926
 927 // --------------------------------------------------------------------
 928
 929 void AnnotationManagerImpl::removeListener()
 930 {
 931     Link aLink( LINK(this,AnnotationManagerImpl,EventMultiplexerListener) );
 932     mrBase.GetEventMultiplexer()->RemoveEventListener( aLink );
 933 }
 934
 935 // --------------------------------------------------------------------
 936
 937 IMPL_LINK(AnnotationManagerImpl,EventMultiplexerListener,
 938     tools::EventMultiplexerEvent*,pEvent)
 939 {
 940     switch (pEvent->meEventId)
 941     {
 942         case tools::EventMultiplexerEvent::EID_CURRENT_PAGE:
 943         case tools::EventMultiplexerEvent::EID_EDIT_VIEW_SELECTION:
 944             onSelectionChanged();
 945             break;
 946
 947         case tools::EventMultiplexerEvent::EID_MAIN_VIEW_REMOVED:
 948             mxView = Reference<XDrawView>();
 949             onSelectionChanged();
 950             break;
 951
 952         case tools::EventMultiplexerEvent::EID_MAIN_VIEW_ADDED:
 953             mxView = Reference<XDrawView>::query( mrBase.GetController() );
 954             onSelectionChanged();
 955             break;
 956     }
 957     return 0;
 958 }
 959
 960 void AnnotationManagerImpl::ExecuteAnnotationContextMenu( Reference< XAnnotation > xAnnotation, ::Window* pParent, const Rectangle& rContextRect, bool bButtonMenu /* = false */ )
 961 {
 962     SfxDispatcher* pDispatcher( getDispatcher( mrBase ) );
 963     if( !pDispatcher )
 964         return;
 965
 966     const bool bReadOnly = mrBase.GetDocShell()->IsReadOnly();
 967
 968     AnnotationWindow* pAnnotationWindow = bButtonMenu ? 0 : dynamic_cast< AnnotationWindow* >( pParent );
 969
 970     if( bReadOnly && !pAnnotationWindow )
 971         return;
 972
 973     std::auto_ptr< PopupMenu > pMenu( new PopupMenu( SdResId( pAnnotationWindow ? RID_ANNOTATION_CONTEXTMENU : RID_ANNOTATION_TAG_CONTEXTMENU ) ) );
 974
 975     SvtUserOptions aUserOptions;
 976     OUString sCurrentAuthor( aUserOptions.GetFullName() );
 977     OUString sAuthor( xAnnotation->getAuthor() );
 978
 979     String aStr( pMenu->GetItemText( SID_DELETEALLBYAUTHOR_POSTIT ) ), aReplace( sAuthor );
 980     if( aReplace.Len() == 0 )
 981         aReplace = String( SdResId( STR_ANNOTATION_NOAUTHOR ) );
 982     aStr.SearchAndReplaceAscii("%1", aReplace);
 983     pMenu->SetItemText( SID_DELETEALLBYAUTHOR_POSTIT, aStr );
 984     pMenu->EnableItem( SID_REPLYTO_POSTIT, (sAuthor != sCurrentAuthor) && !bReadOnly );
 985     pMenu->EnableItem( SID_DELETE_POSTIT, (xAnnotation.is() && !bReadOnly) ? sal_True : sal_False );
 986     pMenu->EnableItem( SID_DELETEALLBYAUTHOR_POSTIT, !bReadOnly );
 987     pMenu->EnableItem( SID_DELETEALL_POSTIT, !bReadOnly );
 988
 989     if( pAnnotationWindow )
 990     {
 991         if( pAnnotationWindow->IsProtected() || bReadOnly )
 992         {
 993             pMenu->EnableItem( SID_ATTR_CHAR_WEIGHT, sal_False );
 994             pMenu->EnableItem( SID_ATTR_CHAR_POSTURE, sal_False );
 995             pMenu->EnableItem( SID_ATTR_CHAR_UNDERLINE, sal_False );
 996             pMenu->EnableItem( SID_ATTR_CHAR_STRIKEOUT, sal_False );
 997             pMenu->EnableItem( SID_PASTE, sal_False );
 998         }
 999         else
1000         {
1001             SfxItemSet aSet(pAnnotationWindow->getView()->GetAttribs());
1002
1003             if ( aSet.GetItemState( EE_CHAR_WEIGHT ) == SFX_ITEM_ON )
1004             {
1005                 if( ((const SvxWeightItem&)aSet.Get( EE_CHAR_WEIGHT )).GetWeight() == WEIGHT_BOLD )
1006                     pMenu->CheckItem( SID_ATTR_CHAR_WEIGHT );
1007             }
1008
1009             if ( aSet.GetItemState( EE_CHAR_ITALIC ) == SFX_ITEM_ON )
1010             {
1011                 if( ((const SvxPostureItem&)aSet.Get( EE_CHAR_ITALIC )).GetPosture() != ITALIC_NONE )
1012                     pMenu->CheckItem( SID_ATTR_CHAR_POSTURE );
1013
1014             }
1015             if ( aSet.GetItemState( EE_CHAR_UNDERLINE ) == SFX_ITEM_ON )
1016             {
1017                 if( ((const SvxUnderlineItem&)aSet.Get( EE_CHAR_UNDERLINE )).GetLineStyle() != UNDERLINE_NONE )
1018                     pMenu->CheckItem( SID_ATTR_CHAR_UNDERLINE );
1019             }
1020
1021             if ( aSet.GetItemState( EE_CHAR_STRIKEOUT ) == SFX_ITEM_ON )
1022             {
1023                 if( ((const SvxCrossedOutItem&)aSet.Get( EE_CHAR_STRIKEOUT )).GetStrikeout() != STRIKEOUT_NONE )
1024                     pMenu->CheckItem( SID_ATTR_CHAR_STRIKEOUT );
1025             }
1026             TransferableDataHelper aDataHelper( TransferableDataHelper::CreateFromSystemClipboard( pAnnotationWindow ) );
1027             pMenu->EnableItem( SID_PASTE, aDataHelper.GetFormatCount() != 0 );
1028         }
1029
1030         pMenu->EnableItem( SID_COPY, pAnnotationWindow->getView()->HasSelection() );
1031     }
1032
1033     sal_uInt16 nId = 0;
1034
1035     // set slot images
1036     Reference< ::com::sun::star::frame::XFrame > xFrame( mrBase.GetMainViewShell()->GetViewFrame()->GetFrame().GetFrameInterface() );
1037     if( xFrame.is() )
1038     {
1039         for( sal_uInt16 nPos = 0; nPos < pMenu->GetItemCount(); nPos++ )
1040         {
1041             nId = pMenu->GetItemId( nPos );
1042             if( pMenu->IsItemEnabled( nId ) )
1043             {
1044                 OUString sSlotURL( "slot:" );
1045                 sSlotURL += OUString::valueOf( sal_Int32( nId ));
1046
1047                 Image aImage( GetImage( xFrame, sSlotURL, false ) );
1048                 if( !!aImage )
1049                     pMenu->SetItemImage( nId, aImage );
1050             }
1051         }
1052     }
1053
1054     nId = pMenu->Execute( pParent, rContextRect, POPUPMENU_EXECUTE_DOWN|POPUPMENU_NOMOUSEUPCLOSE );
1055     switch( nId )
1056     {
1057     case SID_REPLYTO_POSTIT:
1058     {
1059         const SfxUnoAnyItem aItem( SID_REPLYTO_POSTIT, Any( xAnnotation ) );
1060         pDispatcher->Execute( SID_REPLYTO_POSTIT, SFX_CALLMODE_ASYNCHRON, &aItem, 0 );
1061         break;
1062     }
1063     case SID_DELETE_POSTIT:
1064     {
1065         const SfxUnoAnyItem aItem( SID_DELETE_POSTIT, Any( xAnnotation ) );
1066         pDispatcher->Execute( SID_DELETE_POSTIT, SFX_CALLMODE_ASYNCHRON, &aItem, 0 );
1067         break;
1068     }
1069     case SID_DELETEALLBYAUTHOR_POSTIT:
1070     {
1071         const SfxStringItem aItem( SID_DELETEALLBYAUTHOR_POSTIT, sAuthor );
1072         pDispatcher->Execute( SID_DELETEALLBYAUTHOR_POSTIT, SFX_CALLMODE_ASYNCHRON, &aItem, 0 );
1073         break;
1074     }
1075     case SID_DELETEALL_POSTIT:
1076         pDispatcher->Execute( SID_DELETEALL_POSTIT );
1077         break;
1078     case SID_COPY:
1079     case SID_PASTE:
1080     case SID_ATTR_CHAR_WEIGHT:
1081     case SID_ATTR_CHAR_POSTURE:
1082     case SID_ATTR_CHAR_UNDERLINE:
1083     case SID_ATTR_CHAR_STRIKEOUT:
1084         if( pAnnotationWindow )
1085             pAnnotationWindow->ExecuteSlot( nId );
1086         break;
1087     }
1088 }
1089
1090 // ====================================================================
1091
1092 Color AnnotationManagerImpl::GetColor(sal_uInt16 aAuthorIndex)
1093 {
1094     if (!Application::GetSettings().GetStyleSettings().GetHighContrastMode())
1095     {
1096         static const Color aArrayNormal[] = {
1097             COL_AUTHOR1_NORMAL,     COL_AUTHOR2_NORMAL,     COL_AUTHOR3_NORMAL,
1098             COL_AUTHOR4_NORMAL,     COL_AUTHOR5_NORMAL,     COL_AUTHOR6_NORMAL,
1099             COL_AUTHOR7_NORMAL,     COL_AUTHOR8_NORMAL,     COL_AUTHOR9_NORMAL };
1100
1101         return Color( aArrayNormal[ aAuthorIndex % (sizeof( aArrayNormal )/ sizeof( aArrayNormal[0] ))]);
1102     }
1103
1104     return Color(COL_WHITE);
1105 }
1106
1107 Color AnnotationManagerImpl::GetColorLight(sal_uInt16 aAuthorIndex)
1108 {
1109     if (!Application::GetSettings().GetStyleSettings().GetHighContrastMode())
1110     {
1111         static const Color aArrayLight[] = {
1112             COL_AUTHOR1_LIGHT,      COL_AUTHOR2_LIGHT,      COL_AUTHOR3_LIGHT,
1113             COL_AUTHOR4_LIGHT,      COL_AUTHOR5_LIGHT,      COL_AUTHOR6_LIGHT,
1114             COL_AUTHOR7_LIGHT,      COL_AUTHOR8_LIGHT,      COL_AUTHOR9_LIGHT };
1115
1116         return Color( aArrayLight[ aAuthorIndex % (sizeof( aArrayLight )/ sizeof( aArrayLight[0] ))]);
1117     }
1118
1119     return Color(COL_WHITE);
1120 }
1121
1122 Color AnnotationManagerImpl::GetColorDark(sal_uInt16 aAuthorIndex)
1123 {
1124     if (!Application::GetSettings().GetStyleSettings().GetHighContrastMode())
1125     {
1126         static const Color aArrayAnkor[] = {
1127             COL_AUTHOR1_DARK,       COL_AUTHOR2_DARK,       COL_AUTHOR3_DARK,
1128             COL_AUTHOR4_DARK,       COL_AUTHOR5_DARK,       COL_AUTHOR6_DARK,
1129             COL_AUTHOR7_DARK,       COL_AUTHOR8_DARK,       COL_AUTHOR9_DARK };
1130
1131         return Color( aArrayAnkor[  aAuthorIndex % (sizeof( aArrayAnkor )   / sizeof( aArrayAnkor[0] ))]);
1132     }
1133
1134     return Color(COL_WHITE);
1135 }
1136
1137 SdPage* AnnotationManagerImpl::GetNextPage( SdPage* pPage, bool bForeward )
1138 {
1139     if( pPage == 0 )
1140         return bForeward ? GetFirstPage() : GetLastPage();
1141
1142     sal_uInt16 nPageNum = (pPage->GetPageNum() - 1) >> 1;
1143
1144     // first all non master pages
1145     if( !pPage->IsMasterPage() )
1146     {
1147         if( bForeward )
1148         {
1149             if( nPageNum >= mpDoc->GetSdPageCount(PK_STANDARD)-1 )
1150             {
1151                 // we reached end of draw pages, start with master pages (skip handout master for draw)
1152                 return mpDoc->GetMasterSdPage( (mpDoc->GetDocumentType() == DOCUMENT_TYPE_IMPRESS) ? 0 : 1, PK_STANDARD );
1153             }
1154             nPageNum++;
1155         }
1156         else
1157         {
1158             if( nPageNum == 0 )
1159                 return 0; // we are already on the first draw page, finished
1160
1161             nPageNum--;
1162         }
1163         return mpDoc->GetSdPage(nPageNum, PK_STANDARD);
1164     }
1165     else
1166     {
1167         if( bForeward )
1168         {
1169             if( nPageNum >= mpDoc->GetMasterSdPageCount(PK_STANDARD)-1 )
1170             {
1171                 return 0;   // we reached the end, there is nothing more to see here
1172             }
1173             nPageNum++;
1174         }
1175         else
1176         {
1177             if( nPageNum == (mpDoc->GetDocumentType() == DOCUMENT_TYPE_IMPRESS) ? 0 : 1 )
1178             {
1179                 // we reached beginning of master pages, start with end if pages
1180                 return mpDoc->GetSdPage( mpDoc->GetSdPageCount(PK_STANDARD)-1, PK_STANDARD );
1181             }
1182
1183             nPageNum--;
1184         }
1185         return mpDoc->GetMasterSdPage(nPageNum,PK_STANDARD);
1186     }
1187 }
1188
1189 SdPage* AnnotationManagerImpl::GetFirstPage()
1190 {
1191     // return first drawing page
1192     return mpDoc->GetSdPage(0, PK_STANDARD );
1193 }
1194
1195 SdPage* AnnotationManagerImpl::GetLastPage()
1196 {
1197     return mpDoc->GetMasterSdPage( mpDoc->GetMasterSdPageCount(PK_STANDARD) - 1, PK_STANDARD );
1198 }
1199
1200 SdPage* AnnotationManagerImpl::GetCurrentPage()
1201 {
1202     return mrBase.GetMainViewShell()->getCurrentPage();
1203 }
1204
1205 // ====================================================================
1206
1207 AnnotationManager::AnnotationManager( ViewShellBase& rViewShellBase )
1208 : mxImpl( new AnnotationManagerImpl( rViewShellBase ) )
1209 {
1210     mxImpl->init();
1211 }
1212
1213 AnnotationManager::~AnnotationManager()
1214 {
1215     mxImpl->dispose();
1216 }
1217
1218 void AnnotationManager::ExecuteAnnotation(SfxRequest& rRequest)
1219 {
1220     mxImpl->ExecuteAnnotation( rRequest );
1221 }
1222
1223 void AnnotationManager::GetAnnotationState(SfxItemSet& rItemSet)
1224 {
1225     mxImpl->GetAnnotationState(rItemSet);
1226 }
1227
1228 }
1229
1230 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */