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