LCOV - code coverage report
Current view: top level - sd/source/ui/annotations - annotationmanager.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 104 566 18.4 %
Date: 2014-11-03 Functions: 19 50 38.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10