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 "PostItMgr.hxx"
21 : #include <postithelper.hxx>
22 :
23 : #include <SidebarWin.hxx>
24 : #include <AnnotationWin.hxx>
25 : #include <frmsidebarwincontainer.hxx>
26 : #include <accmap.hxx>
27 :
28 : #include <SidebarWindowsConsts.hxx>
29 : #include <AnchorOverlayObject.hxx>
30 : #include <ShadowOverlayObject.hxx>
31 :
32 : #include <vcl/svapp.hxx>
33 : #include <vcl/scrbar.hxx>
34 : #include <vcl/outdev.hxx>
35 : #include <vcl/settings.hxx>
36 :
37 : #include <chrdlgmodes.hxx>
38 : #include <viewopt.hxx>
39 : #include <view.hxx>
40 : #include <docsh.hxx>
41 : #include <wrtsh.hxx>
42 : #include <doc.hxx>
43 : #include <IDocumentSettingAccess.hxx>
44 : #include <IDocumentFieldsAccess.hxx>
45 : #include <fldbas.hxx>
46 : #include <fmtfld.hxx>
47 : #include <docufld.hxx>
48 : #include <edtwin.hxx>
49 : #include <txtfld.hxx>
50 : #include <txtannotationfld.hxx>
51 : #include <ndtxt.hxx>
52 : #include <redline.hxx>
53 : #include <docary.hxx>
54 : #include <SwRewriter.hxx>
55 : #include <tools/color.hxx>
56 :
57 : #include <swmodule.hxx>
58 : #include <annotation.hrc>
59 : #include "cmdid.h"
60 :
61 : #include <sfx2/request.hxx>
62 : #include <sfx2/event.hxx>
63 : #include <svl/srchitem.hxx>
64 :
65 : #include <svl/languageoptions.hxx>
66 : #include <svtools/langtab.hxx>
67 : #include <svl/smplhint.hxx>
68 :
69 : #include <svx/svdview.hxx>
70 : #include <editeng/eeitem.hxx>
71 : #include <editeng/langitem.hxx>
72 : #include <editeng/kernitem.hxx>
73 : #include <editeng/outliner.hxx>
74 :
75 : #include <i18nlangtag/mslangid.hxx>
76 : #include <i18nlangtag/lang.h>
77 :
78 : #include "annotsh.hxx"
79 : #include "swabstdlg.hxx"
80 : #include "swevent.hxx"
81 : #include "switerator.hxx"
82 : #include <boost/scoped_ptr.hpp>
83 :
84 : // distance between Anchor Y and initial note position
85 : #define POSTIT_INITIAL_ANCHOR_DISTANCE 20
86 : //distance between two postits
87 : #define POSTIT_SPACE_BETWEEN 8
88 : #define POSTIT_MINIMUMSIZE_WITH_META 60
89 : #define POSTIT_SCROLL_SIDEBAR_HEIGHT 20
90 :
91 : // if we layout more often we stop, this should never happen
92 : #define MAX_LOOP_COUNT 50
93 :
94 : using namespace sw::sidebarwindows;
95 :
96 836 : bool comp_pos(const SwSidebarItem* a, const SwSidebarItem* b)
97 : {
98 : // sort by anchor position
99 836 : SwPosition aPosAnchorA = a->GetAnchorPosition();
100 1672 : SwPosition aPosAnchorB = b->GetAnchorPosition();
101 :
102 836 : bool aAnchorAInFooter = false;
103 836 : bool aAnchorBInFooter = false;
104 :
105 : // is the anchor placed in Footnote or the Footer?
106 836 : if( aPosAnchorA.nNode.GetNode().FindFootnoteStartNode() || aPosAnchorA.nNode.GetNode().FindFooterStartNode() )
107 0 : aAnchorAInFooter = true;
108 836 : if( aPosAnchorB.nNode.GetNode().FindFootnoteStartNode() || aPosAnchorB.nNode.GetNode().FindFooterStartNode() )
109 0 : aAnchorBInFooter = true;
110 :
111 : // fdo#34800
112 : // if AnchorA is in footnote, and AnchorB isn't
113 : // we do not want to change over the position
114 836 : if( aAnchorAInFooter && !aAnchorBInFooter )
115 0 : return false;
116 : // if aAnchorA is not placed in a footnote, and aAnchorB is
117 : // force a change over
118 836 : else if( !aAnchorAInFooter && aAnchorBInFooter )
119 0 : return true;
120 : // If neither or both are in the footer, compare the positions.
121 : // Since footnotes are in Inserts section of nodes array and footers
122 : // in Autotext section, all footnotes precede any footers so no need
123 : // to check that.
124 : else
125 1672 : return aPosAnchorA < aPosAnchorB;
126 : }
127 :
128 4708 : SwPostItMgr::SwPostItMgr(SwView* pView)
129 : : mpView(pView)
130 4708 : , mpWrtShell(mpView->GetDocShell()->GetWrtShell())
131 4708 : , mpEditWin(&mpView->GetEditWin())
132 : , mnEventId(0)
133 : , mbWaitingForCalcRects(false)
134 : , mpActivePostIt(0)
135 : , mbLayout(false)
136 : , mbLayoutHeight(0)
137 : , mbLayouting(false)
138 4708 : , mbReadOnly(mpView->GetDocShell()->IsReadOnly())
139 : , mbDeleteNote(true)
140 : , mpAnswer(0)
141 : , mbIsShowAnchor( false )
142 18832 : , mpFrmSidebarWinContainer( 0 )
143 : {
144 4708 : if(!mpView->GetDrawView() )
145 0 : mpView->GetWrtShell().MakeDrawView();
146 :
147 4708 : SwNoteProps aProps;
148 4708 : mbIsShowAnchor = aProps.IsShowAnchor();
149 :
150 : //make sure we get the colour yellow always, even if not the first one of comments or redlining
151 4708 : SW_MOD()->GetRedlineAuthor();
152 :
153 : // collect all PostIts and redline comments that exist after loading the document
154 : // don't check for existence for any of them, don't focus them
155 4708 : AddPostIts(false,false);
156 : /* this code can be used once we want redline comments in the Sidebar
157 : AddRedlineComments(false,false);
158 : */
159 : // we want to receive stuff like SFX_HINT_DOCCHANGED
160 4708 : StartListening(*mpView->GetDocShell());
161 4708 : if (!mvPostItFlds.empty())
162 : {
163 84 : mbWaitingForCalcRects = true;
164 84 : mnEventId = Application::PostUserEvent( LINK( this, SwPostItMgr, CalcHdl), 0 );
165 4708 : }
166 4708 : }
167 :
168 14118 : SwPostItMgr::~SwPostItMgr()
169 : {
170 4706 : if ( mnEventId )
171 44 : Application::RemoveUserEvent( mnEventId );
172 : // forget about all our Sidebar windows
173 4706 : RemoveSidebarWin();
174 4706 : EndListening( *mpView->GetDocShell() );
175 :
176 11308 : for(std::vector<SwPostItPageItem*>::iterator i = mPages.begin(); i != mPages.end() ; ++i)
177 6602 : delete (*i);
178 4706 : mPages.clear();
179 :
180 4706 : delete mpFrmSidebarWinContainer;
181 4706 : mpFrmSidebarWinContainer = 0;
182 9412 : }
183 :
184 0 : void SwPostItMgr::CheckForRemovedPostIts()
185 : {
186 0 : bool bRemoved = false;
187 0 : for(std::list<SwSidebarItem*>::iterator i = mvPostItFlds.begin(); i != mvPostItFlds.end(); )
188 : {
189 0 : std::list<SwSidebarItem*>::iterator it = i++;
190 0 : if ( !(*it)->UseElement() )
191 : {
192 0 : SwSidebarItem* p = (*it);
193 0 : mvPostItFlds.remove(*it);
194 0 : if (GetActiveSidebarWin() == p->pPostIt)
195 0 : SetActiveSidebarWin(0);
196 0 : if (p->pPostIt)
197 0 : delete p->pPostIt;
198 0 : delete p;
199 0 : bRemoved = true;
200 : }
201 : }
202 :
203 0 : if ( bRemoved )
204 : {
205 : // make sure that no deleted items remain in page lists
206 : // todo: only remove deleted ones?!
207 0 : if ( mvPostItFlds.empty() )
208 : {
209 0 : PreparePageContainer();
210 0 : PrepareView();
211 : }
212 : else
213 : // if postits are their make sure that page lists are not empty
214 : // otherwise sudden paints can cause pain (in BorderOverPageBorder)
215 0 : CalcRects();
216 : }
217 0 : }
218 :
219 168 : void SwPostItMgr::InsertItem(SfxBroadcaster* pItem, bool bCheckExistance, bool bFocus)
220 : {
221 168 : if (bCheckExistance)
222 : {
223 14 : for(std::list<SwSidebarItem*>::iterator i = mvPostItFlds.begin(); i != mvPostItFlds.end() ; ++i)
224 : {
225 6 : if ( (*i)->GetBroadCaster() == pItem )
226 170 : return;
227 : }
228 : }
229 166 : mbLayout = bFocus;
230 166 : if (pItem->ISA(SwFmtFld))
231 166 : mvPostItFlds.push_back(new SwAnnotationItem(static_cast<SwFmtFld&>(*pItem), true, bFocus) );
232 : OSL_ENSURE(pItem->ISA(SwFmtFld),"Mgr::InsertItem: seems like new stuff was added");
233 166 : StartListening(*pItem);
234 : }
235 :
236 10 : void SwPostItMgr::RemoveItem( SfxBroadcaster* pBroadcast )
237 : {
238 10 : EndListening(*pBroadcast);
239 22 : for(std::list<SwSidebarItem*>::iterator i = mvPostItFlds.begin(); i != mvPostItFlds.end() ; ++i)
240 : {
241 22 : if ( (*i)->GetBroadCaster() == pBroadcast )
242 : {
243 10 : SwSidebarItem* p = (*i);
244 10 : if (GetActiveSidebarWin() == p->pPostIt)
245 10 : SetActiveSidebarWin(0);
246 10 : mvPostItFlds.erase(i);
247 10 : delete p->pPostIt;
248 10 : delete p;
249 10 : break;
250 : }
251 : }
252 10 : mbLayout = true;
253 10 : PrepareView();
254 10 : }
255 :
256 106435 : void SwPostItMgr::Notify( SfxBroadcaster& rBC, const SfxHint& rHint )
257 : {
258 106435 : if ( dynamic_cast<const SfxEventHint*>(&rHint) )
259 : {
260 29270 : sal_uInt32 nId = ((SfxEventHint&)rHint).GetEventId();
261 29270 : if ( nId == SW_EVENT_LAYOUT_FINISHED )
262 : {
263 194 : if ( !mbWaitingForCalcRects && !mvPostItFlds.empty())
264 : {
265 0 : mbWaitingForCalcRects = true;
266 0 : mnEventId = Application::PostUserEvent( LINK( this, SwPostItMgr, CalcHdl), 0 );
267 : }
268 29270 : }
269 : }
270 77165 : else if ( dynamic_cast<const SfxSimpleHint*>(&rHint) )
271 : {
272 77007 : sal_uInt32 nId = ((SfxSimpleHint&)rHint).GetId();
273 77007 : switch ( nId )
274 : {
275 : case SFX_HINT_MODECHANGED:
276 : {
277 12 : if ( mbReadOnly != !!(mpView->GetDocShell()->IsReadOnly()) )
278 : {
279 0 : mbReadOnly = !mbReadOnly;
280 0 : SetReadOnlyState();
281 0 : mbLayout = true;
282 : }
283 12 : break;
284 : }
285 : case SFX_HINT_DOCCHANGED:
286 : {
287 69926 : if ( mpView->GetDocShell() == &rBC )
288 : {
289 69926 : if ( !mbWaitingForCalcRects && !mvPostItFlds.empty())
290 : {
291 126 : mbWaitingForCalcRects = true;
292 126 : mnEventId = Application::PostUserEvent( LINK( this, SwPostItMgr, CalcHdl), 0 );
293 : }
294 : }
295 69926 : break;
296 : }
297 : case SFX_HINT_USER04:
298 : {
299 : // if we are in a SplitNode/Cut operation, do not delete note and then add again, as this will flicker
300 160 : mbDeleteNote = !mbDeleteNote;
301 160 : break;
302 : }
303 : case SFX_HINT_DYING:
304 : {
305 0 : if ( mpView->GetDocShell() != &rBC )
306 : {
307 : // field to be removed is the broadcaster
308 : OSL_FAIL("Notification for removed SwFmtFld was not sent!");
309 0 : RemoveItem(&rBC);
310 : }
311 0 : break;
312 : }
313 77007 : }
314 : }
315 158 : else if ( dynamic_cast<const SwFmtFldHint*>(&rHint) )
316 : {
317 158 : const SwFmtFldHint& rFmtHint = static_cast<const SwFmtFldHint&>(rHint);
318 158 : SwFmtFld* pFld = const_cast <SwFmtFld*>( rFmtHint.GetField() );
319 158 : switch ( rFmtHint.Which() )
320 : {
321 : case SwFmtFldHintWhich::INSERTED :
322 : {
323 10 : if (!pFld)
324 : {
325 0 : AddPostIts(true);
326 0 : break;
327 : }
328 : // get field to be inserted from hint
329 10 : if ( pFld->IsFldInDoc() )
330 : {
331 10 : bool bEmpty = !HasNotes();
332 10 : InsertItem( pFld, true, false );
333 10 : if (bEmpty && !mvPostItFlds.empty())
334 6 : PrepareView(true);
335 : }
336 : else
337 : {
338 : OSL_FAIL("Inserted field not in document!" );
339 : }
340 10 : break;
341 : }
342 : case SwFmtFldHintWhich::REMOVED:
343 : {
344 12 : if (mbDeleteNote)
345 : {
346 10 : if (!pFld)
347 : {
348 0 : CheckForRemovedPostIts();
349 0 : break;
350 : }
351 10 : RemoveItem(pFld);
352 : }
353 12 : break;
354 : }
355 : case SwFmtFldHintWhich::FOCUS:
356 : {
357 0 : if (rFmtHint.GetView()== mpView)
358 0 : Focus(rBC);
359 0 : break;
360 : }
361 : case SwFmtFldHintWhich::CHANGED:
362 : {
363 0 : SwFmtFld* pFmtFld = dynamic_cast<SwFmtFld*>(&rBC);
364 0 : for(std::list<SwSidebarItem*>::iterator i = mvPostItFlds.begin(); i != mvPostItFlds.end() ; ++i)
365 : {
366 0 : if ( pFmtFld == (*i)->GetBroadCaster() )
367 : {
368 0 : if ((*i)->pPostIt)
369 : {
370 0 : (*i)->pPostIt->SetPostItText();
371 0 : mbLayout = true;
372 : }
373 0 : break;
374 : }
375 : }
376 0 : break;
377 : }
378 :
379 : case SwFmtFldHintWhich::LANGUAGE:
380 : {
381 136 : SwFmtFld* pFmtFld = dynamic_cast<SwFmtFld*>(&rBC);
382 212 : for(std::list<SwSidebarItem*>::iterator i = mvPostItFlds.begin(); i != mvPostItFlds.end() ; ++i)
383 : {
384 212 : if ( pFmtFld == (*i)->GetBroadCaster() )
385 : {
386 136 : if ((*i)->pPostIt)
387 : {
388 0 : const sal_uInt16 nScriptType = SvtLanguageOptions::GetScriptTypeOfLanguage( (*i)->GetFmtFld().GetField()->GetLanguage() );
389 0 : sal_uInt16 nLangWhichId = 0;
390 0 : switch (nScriptType)
391 : {
392 0 : case SCRIPTTYPE_LATIN : nLangWhichId = EE_CHAR_LANGUAGE ; break;
393 0 : case SCRIPTTYPE_ASIAN : nLangWhichId = EE_CHAR_LANGUAGE_CJK; break;
394 0 : case SCRIPTTYPE_COMPLEX : nLangWhichId = EE_CHAR_LANGUAGE_CTL; break;
395 : }
396 0 : (*i)->pPostIt->SetLanguage(
397 : SvxLanguageItem(
398 0 : (*i)->GetFmtFld().GetField()->GetLanguage(),
399 0 : nLangWhichId) );
400 : }
401 136 : break;
402 : }
403 : }
404 136 : break;
405 : }
406 : }
407 : }
408 106435 : }
409 :
410 0 : void SwPostItMgr::Focus(SfxBroadcaster& rBC)
411 : {
412 0 : if (!mpWrtShell->GetViewOptions()->IsPostIts())
413 : {
414 0 : SfxRequest aRequest(mpView->GetViewFrame(),FN_VIEW_NOTES);
415 0 : mpView->ExecViewOptions(aRequest);
416 : }
417 :
418 0 : for(std::list<SwSidebarItem*>::iterator i = mvPostItFlds.begin(); i != mvPostItFlds.end() ; ++i)
419 : {
420 : // field to get the focus is the broadcaster
421 0 : if ( &rBC == (*i)->GetBroadCaster() )
422 : {
423 0 : if ((*i)->pPostIt)
424 : {
425 0 : (*i)->pPostIt->GrabFocus();
426 0 : MakeVisible((*i)->pPostIt);
427 : }
428 : else
429 : {
430 : // when the layout algorithm starts, this postit is created and receives focus
431 0 : (*i)->bFocus = true;
432 : }
433 : }
434 : }
435 0 : }
436 :
437 45156 : bool SwPostItMgr::CalcRects()
438 : {
439 45156 : if ( mnEventId )
440 : {
441 : // if CalcRects() was forced and an event is still pending: remove it
442 : // it is superfluous and also may cause reentrance problems if triggered while layouting
443 164 : Application::RemoveUserEvent( mnEventId );
444 164 : mnEventId = 0;
445 : }
446 :
447 45156 : bool bChange = false;
448 45156 : bool bRepair = false;
449 45156 : PreparePageContainer();
450 45156 : if ( !mvPostItFlds.empty() )
451 : {
452 2240 : for(std::list<SwSidebarItem*>::iterator i = mvPostItFlds.begin(); i != mvPostItFlds.end() ; ++i)
453 : {
454 1408 : SwSidebarItem* pItem = (*i);
455 1408 : if ( !pItem->UseElement() )
456 : {
457 : OSL_FAIL("PostIt is not in doc or other wrong use");
458 0 : bRepair = true;
459 0 : continue;
460 : }
461 :
462 1408 : const SwRect aOldAnchorRect( pItem->maLayoutInfo.mPosition );
463 1408 : const SwPostItHelper::SwLayoutStatus eOldLayoutStatus = pItem->mLayoutStatus;
464 1408 : const sal_uLong nOldStartNodeIdx( pItem->maLayoutInfo.mnStartNodeIdx );
465 1408 : const sal_Int32 nOldStartContent( pItem->maLayoutInfo.mnStartContent );
466 : {
467 : // update layout information
468 : const SwTxtAnnotationFld* pTxtAnnotationFld =
469 1408 : dynamic_cast< const SwTxtAnnotationFld* >( pItem->GetFmtFld().GetTxtFld() );
470 : const ::sw::mark::IMark* pAnnotationMark =
471 1408 : pTxtAnnotationFld != NULL ? pTxtAnnotationFld->GetAnnotationMark() : NULL;
472 1408 : if ( pAnnotationMark != NULL )
473 : {
474 : pItem->mLayoutStatus =
475 : SwPostItHelper::getLayoutInfos(
476 : pItem->maLayoutInfo,
477 974 : pItem->GetAnchorPosition(),
478 1948 : &pAnnotationMark->GetMarkStart() );
479 : }
480 : else
481 : {
482 : pItem->mLayoutStatus =
483 434 : SwPostItHelper::getLayoutInfos( pItem->maLayoutInfo, pItem->GetAnchorPosition() );
484 : }
485 : }
486 : bChange = bChange
487 1342 : || pItem->maLayoutInfo.mPosition != aOldAnchorRect
488 1262 : || pItem->mLayoutStatus != eOldLayoutStatus
489 1258 : || pItem->maLayoutInfo.mnStartNodeIdx != nOldStartNodeIdx
490 2666 : || pItem->maLayoutInfo.mnStartContent != nOldStartContent;
491 : }
492 :
493 : // show notes in right order in navigator
494 : //prevent Anchors during layout to overlap, e.g. when moving a frame
495 832 : Sort();
496 :
497 : // sort the items into the right page vector, so layout can be done by page
498 2240 : for(std::list<SwSidebarItem*>::iterator i = mvPostItFlds.begin(); i != mvPostItFlds.end() ; ++i)
499 : {
500 1408 : SwSidebarItem* pItem = (*i);
501 1408 : if( SwPostItHelper::INVISIBLE == pItem->mLayoutStatus )
502 : {
503 138 : if (pItem->pPostIt)
504 0 : pItem->pPostIt->HideNote();
505 386 : continue;
506 : }
507 :
508 1270 : if( SwPostItHelper::HIDDEN == pItem->mLayoutStatus )
509 : {
510 110 : if (!mpWrtShell->GetViewOptions()->IsShowHiddenChar())
511 : {
512 110 : if (pItem->pPostIt)
513 0 : pItem->pPostIt->HideNote();
514 110 : continue;
515 : }
516 : }
517 :
518 1160 : const unsigned long aPageNum = pItem->maLayoutInfo.mnPageNumber;
519 1160 : if (aPageNum > mPages.size())
520 : {
521 0 : const unsigned long nNumberOfPages = mPages.size();
522 0 : for (unsigned int j=0; j<aPageNum - nNumberOfPages; ++j)
523 0 : mPages.push_back( new SwPostItPageItem());
524 : }
525 1160 : mPages[aPageNum-1]->mList->push_back(pItem);
526 1160 : mPages[aPageNum-1]->mPageRect = pItem->maLayoutInfo.mPageFrame;
527 1160 : mPages[aPageNum-1]->eSidebarPosition = pItem->maLayoutInfo.meSidebarPosition;
528 : }
529 :
530 832 : if (!bChange && mpWrtShell->getIDocumentSettingAccess()->get(IDocumentSettingAccess::BROWSE_MODE))
531 : {
532 0 : long nLayoutHeight = SwPostItHelper::getLayoutHeight( mpWrtShell->GetLayout() );
533 0 : if( nLayoutHeight > mbLayoutHeight )
534 : {
535 0 : if (mPages[0]->bScrollbar || HasScrollbars())
536 0 : bChange = true;
537 : }
538 0 : else if( nLayoutHeight < mbLayoutHeight )
539 : {
540 0 : if (mPages[0]->bScrollbar || !BorderOverPageBorder(1))
541 0 : bChange = true;
542 : }
543 : }
544 : }
545 :
546 45156 : if ( bRepair )
547 0 : CheckForRemovedPostIts();
548 :
549 45156 : mbLayoutHeight = SwPostItHelper::getLayoutHeight( mpWrtShell->GetLayout() );
550 45156 : mbWaitingForCalcRects = false;
551 45156 : return bChange;
552 : }
553 :
554 0 : bool SwPostItMgr::HasScrollbars() const
555 : {
556 0 : for(std::list<SwSidebarItem*>::const_iterator i = mvPostItFlds.begin(); i != mvPostItFlds.end() ; ++i)
557 : {
558 0 : if ((*i)->bShow && (*i)->pPostIt && (*i)->pPostIt->HasScrollbar())
559 0 : return true;
560 : }
561 0 : return false;
562 : }
563 :
564 49862 : void SwPostItMgr::PreparePageContainer()
565 : {
566 : // we do not just delete the SwPostItPageItem, so offset/scrollbar is not lost
567 49862 : long lPageSize = mpWrtShell->GetNumPages();
568 49862 : long lContainerSize = mPages.size();
569 :
570 49862 : if (lContainerSize < lPageSize)
571 : {
572 11776 : for (int i=0; i<lPageSize - lContainerSize;i++)
573 6856 : mPages.push_back( new SwPostItPageItem());
574 : }
575 44942 : else if (lContainerSize > lPageSize)
576 : {
577 342 : for (int i=mPages.size()-1; i >= lPageSize;--i)
578 : {
579 254 : delete mPages[i];
580 254 : mPages.pop_back();
581 : }
582 : }
583 : // only clear the list, DO NOT delete the objects itself
584 123210 : for(std::vector<SwPostItPageItem*>::iterator i = mPages.begin(); i != mPages.end() ; ++i)
585 : {
586 73348 : (*i)->mList->clear();
587 73348 : if (mvPostItFlds.empty())
588 72486 : (*i)->bScrollbar = false;
589 :
590 : }
591 49862 : }
592 :
593 45156 : void SwPostItMgr::LayoutPostIts()
594 : {
595 45156 : if ( !mvPostItFlds.empty() && !mbWaitingForCalcRects )
596 : {
597 832 : mbLayouting = true;
598 :
599 : //loop over all pages and do the layout
600 : // - create SwPostIt if necessary
601 : // - place SwPostIts on their initial position
602 : // - calculate necessary height for all PostIts together
603 832 : bool bUpdate = false;
604 1694 : for (unsigned long n=0;n<mPages.size();n++)
605 : {
606 : // only layout if there are notes on this page
607 862 : if (mPages[n]->mList->size()>0)
608 : {
609 730 : std::list<SwSidebarWin*> aVisiblePostItList;
610 730 : unsigned long lNeededHeight = 0;
611 730 : long mlPageBorder = 0;
612 730 : long mlPageEnd = 0;
613 :
614 1890 : for(SwSidebarItem_iterator i = mPages[n]->mList->begin(); i != mPages[n]->mList->end(); ++i)
615 : {
616 1160 : SwSidebarItem* pItem = (*i);
617 1160 : SwSidebarWin* pPostIt = pItem->pPostIt;
618 :
619 1160 : if (mPages[n]->eSidebarPosition == sw::sidebarwindows::SIDEBAR_LEFT )
620 : {
621 : // x value for notes positioning
622 0 : mlPageBorder = mpEditWin->LogicToPixel( Point( mPages[n]->mPageRect.Left(), 0)).X() - GetSidebarWidth(true);// - GetSidebarBorderWidth(true);
623 : //bending point
624 : mlPageEnd =
625 0 : mpWrtShell->getIDocumentSettingAccess()->get(IDocumentSettingAccess::BROWSE_MODE)
626 0 : ? pItem->maLayoutInfo.mPagePrtArea.Left()
627 0 : : mPages[n]->mPageRect.Left() + 350;
628 : }
629 1160 : else if (mPages[n]->eSidebarPosition == sw::sidebarwindows::SIDEBAR_RIGHT )
630 : {
631 : // x value for notes positioning
632 1160 : mlPageBorder = mpEditWin->LogicToPixel( Point(mPages[n]->mPageRect.Right(), 0)).X() + GetSidebarBorderWidth(true);
633 : //bending point
634 : mlPageEnd =
635 1160 : mpWrtShell->getIDocumentSettingAccess()->get(IDocumentSettingAccess::BROWSE_MODE)
636 0 : ? pItem->maLayoutInfo.mPagePrtArea.Right() :
637 1160 : mPages[n]->mPageRect.Right() - 350;
638 : }
639 :
640 1160 : if (pItem->bShow)
641 : {
642 1160 : long Y = mpEditWin->LogicToPixel( Point(0,pItem->maLayoutInfo.mPosition.Bottom())).Y();
643 1160 : long aPostItHeight = 0;
644 1160 : if (!pPostIt)
645 : {
646 260 : pPostIt = (*i)->GetSidebarWindow( mpView->GetEditWin(),
647 : WB_DIALOGCONTROL,
648 : *this,
649 260 : 0 );
650 130 : pPostIt->InitControls();
651 130 : pPostIt->SetReadonly(mbReadOnly);
652 130 : pItem->pPostIt = pPostIt;
653 130 : if (mpAnswer)
654 : {
655 0 : if (pPostIt->CalcFollow()) //do we really have another note in front of this one
656 0 : static_cast<sw::annotation::SwAnnotationWin*>(pPostIt)->InitAnswer(mpAnswer);
657 0 : delete mpAnswer;
658 0 : mpAnswer = 0;
659 : }
660 : }
661 :
662 : pPostIt->SetChangeTracking(
663 : pItem->mLayoutStatus,
664 1160 : GetColorAnchor(pItem->maLayoutInfo.mRedlineAuthor));
665 1160 : pPostIt->SetSidebarPosition(mPages[n]->eSidebarPosition);
666 1160 : pPostIt->SetFollow(pPostIt->CalcFollow());
667 1160 : aPostItHeight = ( pPostIt->GetPostItTextHeight() < pPostIt->GetMinimumSizeWithoutMeta()
668 1100 : ? pPostIt->GetMinimumSizeWithoutMeta()
669 60 : : pPostIt->GetPostItTextHeight() )
670 2320 : + pPostIt->GetMetaHeight();
671 : pPostIt->SetPosSizePixelRect( mlPageBorder ,
672 1160 : Y - GetInitialAnchorDistance(),
673 1160 : GetNoteWidth() ,
674 : aPostItHeight,
675 : pItem->maLayoutInfo.mPosition,
676 3480 : mlPageEnd );
677 1160 : pPostIt->ChangeSidebarItem( *pItem );
678 :
679 1160 : if (pItem->bFocus)
680 : {
681 0 : mbLayout = true;
682 0 : pPostIt->GrabFocus();
683 0 : pItem->bFocus = false;
684 : }
685 : // only the visible postits are used for the final layout
686 1160 : aVisiblePostItList.push_back(pPostIt);
687 1160 : lNeededHeight += pPostIt->IsFollow() ? aPostItHeight : aPostItHeight+GetSpaceBetween();
688 : }
689 : else // we don't want to see it
690 : {
691 0 : if (pPostIt)
692 0 : pPostIt->HideNote();
693 : }
694 : }
695 :
696 730 : if ((!aVisiblePostItList.empty()) && ShowNotes())
697 : {
698 730 : bool bOldScrollbar = mPages[n]->bScrollbar;
699 730 : if (ShowNotes())
700 730 : mPages[n]->bScrollbar = LayoutByPage(aVisiblePostItList, mPages[n]->mPageRect.SVRect(), lNeededHeight);
701 : else
702 0 : mPages[n]->bScrollbar = false;
703 730 : if (!mPages[n]->bScrollbar)
704 : {
705 730 : mPages[n]->lOffset = 0;
706 : }
707 : else
708 : {
709 : //when we changed our zoom level, the offset value can be to big, so lets check for the largest possible zoom value
710 0 : long aAvailableHeight = mpEditWin->LogicToPixel(Size(0,mPages[n]->mPageRect.Height())).Height() - 2 * GetSidebarScrollerHeight();
711 0 : long lOffset = -1 * GetScrollSize() * (aVisiblePostItList.size() - aAvailableHeight / GetScrollSize());
712 0 : if (mPages[n]->lOffset < lOffset)
713 0 : mPages[n]->lOffset = lOffset;
714 : }
715 730 : bUpdate = (bOldScrollbar != mPages[n]->bScrollbar) || bUpdate;
716 730 : const long aSidebarheight = mPages[n]->bScrollbar ? mpEditWin->PixelToLogic(Size(0,GetSidebarScrollerHeight())).Height() : 0;
717 : /*
718 : TODO
719 : - enlarge all notes till GetNextBorder(), as we resized to average value before
720 : */
721 : //lets hide the ones which overlap the page
722 1890 : for(SwSidebarWin_iterator i = aVisiblePostItList.begin(); i != aVisiblePostItList.end() ; ++i)
723 : {
724 1160 : if (mPages[n]->lOffset != 0)
725 0 : (*i)->TranslateTopPosition(mPages[n]->lOffset);
726 :
727 1160 : bool bBottom = mpEditWin->PixelToLogic(Point(0,(*i)->VirtualPos().Y()+(*i)->VirtualSize().Height())).Y() <= (mPages[n]->mPageRect.Bottom()-aSidebarheight);
728 1160 : bool bTop = mpEditWin->PixelToLogic(Point(0,(*i)->VirtualPos().Y())).Y() >= (mPages[n]->mPageRect.Top()+aSidebarheight);
729 1160 : if ( bBottom && bTop )
730 : {
731 1160 : (*i)->ShowNote();
732 : }
733 : else
734 : {
735 0 : if (mpEditWin->PixelToLogic(Point(0,(*i)->VirtualPos().Y())).Y() < (mPages[n]->mPageRect.Top()+aSidebarheight))
736 : {
737 0 : if ( mPages[n]->eSidebarPosition == sw::sidebarwindows::SIDEBAR_LEFT )
738 0 : (*i)->ShowAnchorOnly(Point( mPages[n]->mPageRect.Left(),
739 0 : mPages[n]->mPageRect.Top()));
740 0 : else if ( mPages[n]->eSidebarPosition == sw::sidebarwindows::SIDEBAR_RIGHT )
741 0 : (*i)->ShowAnchorOnly(Point( mPages[n]->mPageRect.Right(),
742 0 : mPages[n]->mPageRect.Top()));
743 : }
744 : else
745 : {
746 0 : if ( mPages[n]->eSidebarPosition == sw::sidebarwindows::SIDEBAR_LEFT )
747 0 : (*i)->ShowAnchorOnly(Point(mPages[n]->mPageRect.Left(),
748 0 : mPages[n]->mPageRect.Bottom()));
749 0 : else if ( mPages[n]->eSidebarPosition == sw::sidebarwindows::SIDEBAR_RIGHT )
750 0 : (*i)->ShowAnchorOnly(Point(mPages[n]->mPageRect.Right(),
751 0 : mPages[n]->mPageRect.Bottom()));
752 : }
753 : OSL_ENSURE(mPages[n]->bScrollbar,"SwPostItMgr::LayoutByPage(): note overlaps, but bScrollbar is not true");
754 : }
755 : }
756 : }
757 : else
758 : {
759 0 : for(SwSidebarWin_iterator i = aVisiblePostItList.begin(); i != aVisiblePostItList.end() ; ++i)
760 0 : (*i)->SetPosAndSize();
761 :
762 0 : bool bOldScrollbar = mPages[n]->bScrollbar;
763 0 : mPages[n]->bScrollbar = false;
764 0 : bUpdate = (bOldScrollbar != mPages[n]->bScrollbar) || bUpdate;
765 : }
766 730 : aVisiblePostItList.clear();
767 : }
768 : else
769 : {
770 132 : bUpdate = true;
771 132 : mPages[n]->bScrollbar = false;
772 : }
773 : }
774 :
775 832 : if (!ShowNotes())
776 : { // we do not want to see the notes anymore -> Options-Writer-View-Notes
777 0 : bool bRepair = false;
778 0 : for(SwSidebarItem_iterator i = mvPostItFlds.begin(); i != mvPostItFlds.end() ; ++i)
779 : {
780 0 : SwSidebarItem* pItem = (*i);
781 0 : if ( !pItem->UseElement() )
782 : {
783 : OSL_FAIL("PostIt is not in doc!");
784 0 : bRepair = true;
785 0 : continue;
786 : }
787 :
788 0 : if ((*i)->pPostIt)
789 : {
790 0 : (*i)->pPostIt->HideNote();
791 0 : if ((*i)->pPostIt->HasChildPathFocus())
792 : {
793 0 : SetActiveSidebarWin(0);
794 0 : (*i)->pPostIt->GrabFocusToDocument();
795 : }
796 : }
797 : }
798 :
799 0 : if ( bRepair )
800 0 : CheckForRemovedPostIts();
801 : }
802 :
803 : // notes scrollbar is otherwise not drawn correctly for some cases
804 : // scrollbar area is enough
805 832 : if (bUpdate)
806 104 : mpEditWin->Invalidate();
807 832 : mbLayouting = false;
808 : }
809 45156 : }
810 :
811 0 : bool SwPostItMgr::BorderOverPageBorder(unsigned long aPage) const
812 : {
813 0 : if ( mPages[aPage-1]->mList->empty() )
814 : {
815 : OSL_FAIL("Notes SidePane painted but no rects and page lists calculated!");
816 0 : return false;
817 : }
818 :
819 0 : SwSidebarItem_iterator aItem = mPages[aPage-1]->mList->end();
820 0 : --aItem;
821 : OSL_ENSURE ((*aItem)->pPostIt,"BorderOverPageBorder: NULL postIt, should never happen");
822 0 : if ((*aItem)->pPostIt)
823 : {
824 0 : const long aSidebarheight = mPages[aPage-1]->bScrollbar ? mpEditWin->PixelToLogic(Size(0,GetSidebarScrollerHeight())).Height() : 0;
825 0 : const long aEndValue = mpEditWin->PixelToLogic(Point(0,(*aItem)->pPostIt->GetPosPixel().Y()+(*aItem)->pPostIt->GetSizePixel().Height())).Y();
826 0 : return aEndValue <= mPages[aPage-1]->mPageRect.Bottom()-aSidebarheight;
827 : }
828 : else
829 0 : return false;
830 : }
831 :
832 0 : void SwPostItMgr::DrawNotesForPage(OutputDevice *pOutDev, sal_uInt32 nPage)
833 : {
834 : assert(nPage < mPages.size());
835 0 : if (nPage >= mPages.size())
836 0 : return;
837 0 : for(SwSidebarItem_iterator i = mPages[nPage]->mList->begin(); i != mPages[nPage]->mList->end(); ++i)
838 : {
839 0 : SwSidebarWin* pPostIt = (*i)->pPostIt;
840 0 : if (!pPostIt)
841 0 : continue;
842 0 : Point aPoint(mpEditWin->PixelToLogic(pPostIt->GetPosPixel()));
843 0 : Size aSize(pPostIt->PixelToLogic(pPostIt->GetSizePixel()));
844 0 : pPostIt->Draw(pOutDev, aPoint, aSize, 0);
845 : }
846 : }
847 :
848 0 : void SwPostItMgr::Scroll(const long lScroll,const unsigned long aPage)
849 : {
850 : OSL_ENSURE((lScroll % GetScrollSize() )==0,"SwPostItMgr::Scroll: scrolling by wrong value");
851 : // do not scroll more than necessary up or down
852 0 : if ( ((mPages[aPage-1]->lOffset == 0) && (lScroll>0)) || ( BorderOverPageBorder(aPage) && (lScroll<0)) )
853 0 : return;
854 :
855 0 : const bool bOldUp = ArrowEnabled(KEY_PAGEUP,aPage);
856 0 : const bool bOldDown = ArrowEnabled(KEY_PAGEDOWN,aPage);
857 0 : const long aSidebarheight = mpEditWin->PixelToLogic(Size(0,GetSidebarScrollerHeight())).Height();
858 0 : for(SwSidebarItem_iterator i = mPages[aPage-1]->mList->begin(); i != mPages[aPage-1]->mList->end(); ++i)
859 : {
860 0 : SwSidebarWin* pPostIt = (*i)->pPostIt;
861 : // if this is an answer, we should take the normal position and not the real, slightly moved position
862 0 : pPostIt->SetVirtualPosSize(pPostIt->GetPosPixel(),pPostIt->GetSizePixel());
863 0 : pPostIt->TranslateTopPosition(lScroll);
864 :
865 0 : if ((*i)->bShow)
866 : {
867 0 : bool bBottom = mpEditWin->PixelToLogic(Point(0,pPostIt->VirtualPos().Y()+pPostIt->VirtualSize().Height())).Y() <= (mPages[aPage-1]->mPageRect.Bottom()-aSidebarheight);
868 0 : bool bTop = mpEditWin->PixelToLogic(Point(0,pPostIt->VirtualPos().Y())).Y() >= (mPages[aPage-1]->mPageRect.Top()+aSidebarheight);
869 0 : if ( bBottom && bTop)
870 : {
871 0 : pPostIt->ShowNote();
872 : }
873 : else
874 : {
875 0 : if ( mpEditWin->PixelToLogic(Point(0,pPostIt->VirtualPos().Y())).Y() < (mPages[aPage-1]->mPageRect.Top()+aSidebarheight))
876 : {
877 0 : if (mPages[aPage-1]->eSidebarPosition == sw::sidebarwindows::SIDEBAR_LEFT)
878 0 : pPostIt->ShowAnchorOnly(Point(mPages[aPage-1]->mPageRect.Left(),mPages[aPage-1]->mPageRect.Top()));
879 0 : else if (mPages[aPage-1]->eSidebarPosition == sw::sidebarwindows::SIDEBAR_RIGHT)
880 0 : pPostIt->ShowAnchorOnly(Point(mPages[aPage-1]->mPageRect.Right(),mPages[aPage-1]->mPageRect.Top()));
881 : }
882 : else
883 : {
884 0 : if (mPages[aPage-1]->eSidebarPosition == sw::sidebarwindows::SIDEBAR_LEFT)
885 0 : pPostIt->ShowAnchorOnly(Point(mPages[aPage-1]->mPageRect.Left(),mPages[aPage-1]->mPageRect.Bottom()));
886 0 : else if (mPages[aPage-1]->eSidebarPosition == sw::sidebarwindows::SIDEBAR_RIGHT)
887 0 : pPostIt->ShowAnchorOnly(Point(mPages[aPage-1]->mPageRect.Right(),mPages[aPage-1]->mPageRect.Bottom()));
888 : }
889 : }
890 : }
891 : }
892 0 : mPages[aPage-1]->lOffset += lScroll;
893 0 : if ( (bOldUp != ArrowEnabled(KEY_PAGEUP,aPage)) ||(bOldDown != ArrowEnabled(KEY_PAGEDOWN,aPage)) )
894 : {
895 0 : mpEditWin->Invalidate(GetBottomScrollRect(aPage));
896 0 : mpEditWin->Invalidate(GetTopScrollRect(aPage));
897 : }
898 : }
899 :
900 0 : void SwPostItMgr::AutoScroll(const SwSidebarWin* pPostIt,const unsigned long aPage )
901 : {
902 : // otherwise all notes are visible
903 0 : if (mPages[aPage-1]->bScrollbar)
904 : {
905 0 : const long aSidebarheight = mpEditWin->PixelToLogic(Size(0,GetSidebarScrollerHeight())).Height();
906 0 : const bool bBottom = mpEditWin->PixelToLogic(Point(0,pPostIt->GetPosPixel().Y()+pPostIt->GetSizePixel().Height())).Y() <= (mPages[aPage-1]->mPageRect.Bottom()-aSidebarheight);
907 0 : const bool bTop = mpEditWin->PixelToLogic(Point(0,pPostIt->GetPosPixel().Y())).Y() >= (mPages[aPage-1]->mPageRect.Top()+aSidebarheight);
908 0 : if ( !(bBottom && bTop))
909 : {
910 0 : const long aDiff = bBottom ? mpEditWin->LogicToPixel(Point(0,mPages[aPage-1]->mPageRect.Top() + aSidebarheight)).Y() - pPostIt->GetPosPixel().Y() :
911 0 : mpEditWin->LogicToPixel(Point(0,mPages[aPage-1]->mPageRect.Bottom() - aSidebarheight)).Y() - (pPostIt->GetPosPixel().Y()+pPostIt->GetSizePixel().Height());
912 : // this just adds the missing value to get the next a* GetScrollSize() after aDiff
913 : // e.g aDiff= 61 POSTIT_SCOLL=50 --> lScroll = 100
914 0 : const long lScroll = bBottom ? (aDiff + ( GetScrollSize() - (aDiff % GetScrollSize()))) : (aDiff - (GetScrollSize() + (aDiff % GetScrollSize())));
915 0 : Scroll(lScroll, aPage);
916 : }
917 : }
918 0 : }
919 :
920 0 : void SwPostItMgr::MakeVisible(const SwSidebarWin* pPostIt,long aPage )
921 : {
922 0 : if (aPage == -1)
923 : {
924 : // we dont know the page yet, lets find it ourselves
925 0 : for (unsigned long n=0;n<mPages.size();n++)
926 : {
927 0 : if (mPages[n]->mList->size()>0)
928 : {
929 0 : for(SwSidebarItem_iterator i = mPages[n]->mList->begin(); i != mPages[n]->mList->end(); ++i)
930 : {
931 0 : if ((*i)->pPostIt==pPostIt)
932 : {
933 0 : aPage = n+1;
934 0 : break;
935 : }
936 : }
937 : }
938 : }
939 : }
940 0 : if (aPage!=-1)
941 0 : AutoScroll(pPostIt,aPage);
942 0 : Rectangle aNoteRect (Point(pPostIt->GetPosPixel().X(),pPostIt->GetPosPixel().Y()-5),pPostIt->GetSizePixel());
943 0 : if (!aNoteRect.IsEmpty())
944 0 : mpWrtShell->MakeVisible(SwRect(mpEditWin->PixelToLogic(aNoteRect)));
945 0 : }
946 :
947 0 : bool SwPostItMgr::ArrowEnabled(sal_uInt16 aDirection,unsigned long aPage) const
948 : {
949 0 : switch (aDirection)
950 : {
951 : case KEY_PAGEUP:
952 : {
953 0 : return (mPages[aPage-1]->lOffset != 0);
954 : }
955 : case KEY_PAGEDOWN:
956 : {
957 0 : return (!BorderOverPageBorder(aPage));
958 : }
959 0 : default: return false;
960 : }
961 : }
962 :
963 0 : Color SwPostItMgr::GetArrowColor(sal_uInt16 aDirection,unsigned long aPage) const
964 : {
965 0 : if (ArrowEnabled(aDirection,aPage))
966 : {
967 0 : if (Application::GetSettings().GetStyleSettings().GetHighContrastMode())
968 0 : return Color(COL_WHITE);
969 : else
970 0 : return COL_NOTES_SIDEPANE_ARROW_ENABLED;
971 : }
972 : else
973 : {
974 0 : return COL_NOTES_SIDEPANE_ARROW_DISABLED;
975 : }
976 : }
977 :
978 730 : bool SwPostItMgr::LayoutByPage(std::list<SwSidebarWin*> &aVisiblePostItList,const Rectangle aBorder, long lNeededHeight)
979 : {
980 : /*** General layout idea:***/
981 : // - if we have space left, we always move the current one up,
982 : // otherwise the next one down
983 : // - first all notes are resized
984 : // - then the real layout starts
985 :
986 : //rBorder is the page rect
987 730 : const Rectangle rBorder = mpEditWin->LogicToPixel( aBorder);
988 730 : long lTopBorder = rBorder.Top() + 5;
989 730 : long lBottomBorder = rBorder.Bottom() - 5;
990 730 : const long lVisibleHeight = lBottomBorder - lTopBorder; //rBorder.GetHeight() ;
991 730 : long lTranslatePos = 0;
992 730 : bool bScrollbars = false;
993 :
994 : // do all necessary resizings
995 730 : if (!aVisiblePostItList.empty() && lVisibleHeight < lNeededHeight)
996 : {
997 : // ok, now we have to really resize and adding scrollbars
998 0 : const long lAverageHeight = (lVisibleHeight - aVisiblePostItList.size()*GetSpaceBetween()) / aVisiblePostItList.size();
999 0 : if (lAverageHeight<GetMinimumSizeWithMeta())
1000 : {
1001 0 : bScrollbars = true;
1002 0 : lTopBorder += GetSidebarScrollerHeight() + 10;
1003 0 : lBottomBorder -= (GetSidebarScrollerHeight() + 10);
1004 0 : for(SwSidebarWin_iterator i = aVisiblePostItList.begin(); i != aVisiblePostItList.end() ; ++i)
1005 0 : (*i)->SetSize(Size((*i)->VirtualSize().getWidth(),(*i)->GetMinimumSizeWithMeta()));
1006 : }
1007 : else
1008 : {
1009 0 : for(SwSidebarWin_iterator i = aVisiblePostItList.begin(); i != aVisiblePostItList.end() ; ++i)
1010 : {
1011 0 : if ( (*i)->VirtualSize().getHeight() > lAverageHeight)
1012 0 : (*i)->SetSize(Size((*i)->VirtualSize().getWidth(),lAverageHeight));
1013 : }
1014 : }
1015 : }
1016 :
1017 : //start the real layout so nothing overlaps anymore
1018 730 : if (aVisiblePostItList.size()>1)
1019 : {
1020 274 : long lSpaceUsed = 0;
1021 274 : int loop = 0;
1022 274 : bool bDone = false;
1023 : // if no window is moved anymore we are finished
1024 1096 : while (!bDone)
1025 : {
1026 548 : loop++;
1027 548 : bDone = true;
1028 548 : lSpaceUsed = lTopBorder + GetSpaceBetween();
1029 1956 : for(SwSidebarWin_iterator i = aVisiblePostItList.begin(); i != aVisiblePostItList.end() ; ++i)
1030 : {
1031 1408 : SwSidebarWin_iterator aNextPostIt = i;
1032 1408 : ++aNextPostIt;
1033 :
1034 1408 : if (aNextPostIt != aVisiblePostItList.end())
1035 : {
1036 860 : lTranslatePos = ( (*i)->VirtualPos().Y() + (*i)->VirtualSize().Height()) - (*aNextPostIt)->VirtualPos().Y();
1037 860 : if (lTranslatePos > 0) // note windows overlaps the next one
1038 : {
1039 : // we are not done yet, loop at least once more
1040 430 : bDone = false;
1041 : // if there is space left, move the current note up
1042 : // it could also happen that there is no space left for the first note due to a scrollbar
1043 : // then we also jump into, so we move the current one up and the next one down
1044 430 : if ( (lSpaceUsed <= (*i)->VirtualPos().Y()) || (i==aVisiblePostItList.begin()))
1045 : {
1046 : // we have space left, so let's move the current one up
1047 274 : if ( ((*i)->VirtualPos().Y()- lTranslatePos - GetSpaceBetween()) > lTopBorder)
1048 : {
1049 88 : if ((*aNextPostIt)->IsFollow())
1050 2 : (*i)->TranslateTopPosition(-1*(lTranslatePos+ANCHORLINE_WIDTH));
1051 : else
1052 86 : (*i)->TranslateTopPosition(-1*(lTranslatePos+GetSpaceBetween()));
1053 : }
1054 : else
1055 : {
1056 186 : long lMoveUp = (*i)->VirtualPos().Y() - lTopBorder;
1057 186 : (*i)->TranslateTopPosition(-1* lMoveUp);
1058 186 : if ((*aNextPostIt)->IsFollow())
1059 10 : (*aNextPostIt)->TranslateTopPosition( (lTranslatePos+ANCHORLINE_WIDTH) - lMoveUp);
1060 : else
1061 176 : (*aNextPostIt)->TranslateTopPosition( (lTranslatePos+GetSpaceBetween()) - lMoveUp);
1062 : }
1063 : }
1064 : else
1065 : {
1066 : // no space left, left move the next one down
1067 156 : if ((*aNextPostIt)->IsFollow())
1068 2 : (*aNextPostIt)->TranslateTopPosition(lTranslatePos+ANCHORLINE_WIDTH);
1069 : else
1070 154 : (*aNextPostIt)->TranslateTopPosition(lTranslatePos+GetSpaceBetween());
1071 : }
1072 : }
1073 : else
1074 : {
1075 : // the first one could overlap the topborder instead of a second note
1076 430 : if (i==aVisiblePostItList.begin())
1077 : {
1078 274 : long lMoveDown = lTopBorder - (*i)->VirtualPos().Y();
1079 274 : if (lMoveDown>0)
1080 : {
1081 0 : bDone = false;
1082 0 : (*i)->TranslateTopPosition( lMoveDown);
1083 : }
1084 : }
1085 : }
1086 860 : if ( (*aNextPostIt)->IsFollow() )
1087 28 : lSpaceUsed += (*i)->VirtualSize().Height() + ANCHORLINE_WIDTH;
1088 : else
1089 832 : lSpaceUsed += (*i)->VirtualSize().Height() + GetSpaceBetween();
1090 : }
1091 : else
1092 : {
1093 : //(*i) is the last visible item
1094 548 : SwSidebarWin_iterator aPrevPostIt = i;
1095 548 : --aPrevPostIt;
1096 548 : lTranslatePos = ( (*aPrevPostIt)->VirtualPos().Y() + (*aPrevPostIt)->VirtualSize().Height() ) - (*i)->VirtualPos().Y();
1097 548 : if (lTranslatePos > 0)
1098 : {
1099 0 : bDone = false;
1100 0 : if ( ((*i)->VirtualPos().Y()+ (*i)->VirtualSize().Height()+lTranslatePos) < lBottomBorder)
1101 : {
1102 0 : if ( (*i)->IsFollow() )
1103 0 : (*i)->TranslateTopPosition(lTranslatePos+ANCHORLINE_WIDTH);
1104 : else
1105 0 : (*i)->TranslateTopPosition(lTranslatePos+GetSpaceBetween());
1106 : }
1107 : else
1108 : {
1109 0 : (*i)->TranslateTopPosition(lBottomBorder - ((*i)->VirtualPos().Y()+ (*i)->VirtualSize().Height()) );
1110 : }
1111 : }
1112 : else
1113 : {
1114 : // note does not overlap, but we might be over the lower border
1115 : // only do this if there are no scrollbars, otherwise notes are supposed to overlap the border
1116 548 : if (!bScrollbars && ((*i)->VirtualPos().Y()+ (*i)->VirtualSize().Height() > lBottomBorder) )
1117 : {
1118 0 : bDone = false;
1119 0 : (*i)->TranslateTopPosition(lBottomBorder - ((*i)->VirtualPos().Y()+ (*i)->VirtualSize().Height()));
1120 : }
1121 : }
1122 : }
1123 : }
1124 : // security check so we don't loop forever
1125 548 : if (loop>MAX_LOOP_COUNT)
1126 : {
1127 : OSL_FAIL("PostItMgr::Layout(): We are looping forever");
1128 0 : break;
1129 : }
1130 : }
1131 : }
1132 : else
1133 : {
1134 : // only one left, make sure it is not hidden at the top or bottom
1135 456 : SwSidebarWin_iterator i = aVisiblePostItList.begin();
1136 456 : lTranslatePos = lTopBorder - (*i)->VirtualPos().Y();
1137 456 : if (lTranslatePos>0)
1138 : {
1139 0 : (*i)->TranslateTopPosition(lTranslatePos+GetSpaceBetween());
1140 : }
1141 456 : lTranslatePos = lBottomBorder - ((*i)->VirtualPos().Y()+ (*i)->VirtualSize().Height());
1142 456 : if (lTranslatePos<0)
1143 : {
1144 0 : (*i)->TranslateTopPosition(lTranslatePos);
1145 : }
1146 : }
1147 730 : return bScrollbars;
1148 : }
1149 :
1150 4708 : void SwPostItMgr::AddPostIts(bool bCheckExistance, bool bFocus)
1151 : {
1152 4708 : bool bEmpty = mvPostItFlds.empty();
1153 4708 : SwFieldType* pType = mpView->GetDocShell()->GetDoc()->getIDocumentFieldsAccess().GetFldType(RES_POSTITFLD, OUString(),false);
1154 4708 : SwIterator<SwFmtFld,SwFieldType> aIter( *pType );
1155 4708 : SwFmtFld* pSwFmtFld = aIter.First();
1156 9574 : while(pSwFmtFld)
1157 : {
1158 158 : if ( pSwFmtFld->GetTxtFld())
1159 : {
1160 158 : if ( pSwFmtFld->IsFldInDoc() )
1161 158 : InsertItem(pSwFmtFld,bCheckExistance,bFocus);
1162 : }
1163 158 : pSwFmtFld = aIter.Next();
1164 : }
1165 :
1166 : // if we just added the first one we have to update the view for centering
1167 4708 : if (bEmpty && !mvPostItFlds.empty())
1168 84 : PrepareView(true);
1169 4708 : }
1170 :
1171 4706 : void SwPostItMgr::RemoveSidebarWin()
1172 : {
1173 4706 : if (!mvPostItFlds.empty())
1174 : {
1175 244 : for(std::list<SwSidebarItem*>::iterator i = mvPostItFlds.begin(); i != mvPostItFlds.end() ; ++i)
1176 : {
1177 156 : EndListening( *(const_cast<SfxBroadcaster*>((*i)->GetBroadCaster())) );
1178 156 : if ((*i)->pPostIt)
1179 130 : delete (*i)->pPostIt;
1180 156 : delete (*i);
1181 : }
1182 88 : mvPostItFlds.clear();
1183 : }
1184 :
1185 : // all postits removed, no items should be left in pages
1186 4706 : PreparePageContainer();
1187 4706 : }
1188 :
1189 0 : class FilterFunctor : public std::unary_function<const SwFmtFld*, bool>
1190 : {
1191 : public:
1192 : virtual bool operator()(const SwFmtFld* pFld) const = 0;
1193 0 : virtual ~FilterFunctor() {}
1194 : };
1195 :
1196 0 : class IsPostitField : public FilterFunctor
1197 : {
1198 : public:
1199 0 : bool operator()(const SwFmtFld* pFld) const SAL_OVERRIDE
1200 : {
1201 0 : return pFld->GetField()->GetTyp()->Which() == RES_POSTITFLD;
1202 : }
1203 : };
1204 :
1205 0 : class IsPostitFieldWithAuthorOf : public FilterFunctor
1206 : {
1207 : OUString m_sAuthor;
1208 : public:
1209 0 : IsPostitFieldWithAuthorOf(const OUString &rAuthor)
1210 0 : : m_sAuthor(rAuthor)
1211 : {
1212 0 : }
1213 0 : bool operator()(const SwFmtFld* pFld) const SAL_OVERRIDE
1214 : {
1215 0 : if (pFld->GetField()->GetTyp()->Which() != RES_POSTITFLD)
1216 0 : return false;
1217 0 : return static_cast<const SwPostItField*>(pFld->GetField())->GetPar1() == m_sAuthor;
1218 : }
1219 : };
1220 :
1221 :
1222 : //Manages the passed in vector by automatically removing entries if they are deleted
1223 : //and automatically adding entries if they appear in the document and match the
1224 : //functor.
1225 : //
1226 : //This will completely refill in the case of a "anonymous" NULL pFld stating
1227 : //rather unhelpfully that "something changed" so you may process the same
1228 : //Fields more than once.
1229 : class FieldDocWatchingStack : public SfxListener
1230 : {
1231 : std::list<SwSidebarItem*>& l;
1232 : std::vector<const SwFmtFld*> v;
1233 : SwDocShell& m_rDocShell;
1234 : FilterFunctor& m_rFilter;
1235 :
1236 0 : virtual void Notify(SfxBroadcaster&, const SfxHint& rHint) SAL_OVERRIDE
1237 : {
1238 0 : const SwFmtFldHint* pHint = dynamic_cast<const SwFmtFldHint*>(&rHint);
1239 0 : if (pHint)
1240 : {
1241 0 : bool bAllInvalidated = false;
1242 0 : if (pHint->Which() == SwFmtFldHintWhich::REMOVED)
1243 : {
1244 0 : const SwFmtFld* pFld = pHint->GetField();
1245 0 : bAllInvalidated = pFld == NULL;
1246 0 : if (!bAllInvalidated && m_rFilter(pFld))
1247 : {
1248 0 : EndListening(const_cast<SwFmtFld&>(*pFld));
1249 0 : v.erase(std::remove(v.begin(), v.end(), pFld), v.end());
1250 : }
1251 : }
1252 0 : else if (pHint->Which() == SwFmtFldHintWhich::INSERTED)
1253 : {
1254 0 : const SwFmtFld* pFld = pHint->GetField();
1255 0 : bAllInvalidated = pFld == NULL;
1256 0 : if (!bAllInvalidated && m_rFilter(pFld))
1257 : {
1258 0 : StartListening(const_cast<SwFmtFld&>(*pFld));
1259 0 : v.push_back(pFld);
1260 : }
1261 : }
1262 :
1263 0 : if (bAllInvalidated)
1264 0 : FillVector();
1265 :
1266 0 : return;
1267 : }
1268 : }
1269 :
1270 : public:
1271 0 : FieldDocWatchingStack(std::list<SwSidebarItem*>& in, SwDocShell &rDocShell, FilterFunctor& rFilter)
1272 : : l(in)
1273 : , m_rDocShell(rDocShell)
1274 0 : , m_rFilter(rFilter)
1275 : {
1276 0 : FillVector();
1277 0 : StartListening(m_rDocShell);
1278 0 : }
1279 0 : void FillVector()
1280 : {
1281 0 : EndListeningToAllFields();
1282 0 : v.clear();
1283 0 : v.reserve(l.size());
1284 0 : for(std::list<SwSidebarItem*>::iterator aI = l.begin(); aI != l.end(); ++aI)
1285 : {
1286 0 : SwSidebarItem* p = *aI;
1287 0 : const SwFmtFld& rFld = p->GetFmtFld();
1288 0 : if (!m_rFilter(&rFld))
1289 0 : continue;
1290 0 : StartListening(const_cast<SwFmtFld&>(rFld));
1291 0 : v.push_back(&rFld);
1292 : }
1293 0 : }
1294 0 : void EndListeningToAllFields()
1295 : {
1296 0 : for(std::vector<const SwFmtFld*>::iterator aI = v.begin(); aI != v.end(); ++aI)
1297 : {
1298 0 : const SwFmtFld* pFld = *aI;
1299 0 : EndListening(const_cast<SwFmtFld&>(*pFld));
1300 : }
1301 0 : }
1302 0 : virtual ~FieldDocWatchingStack()
1303 0 : {
1304 0 : EndListeningToAllFields();
1305 0 : EndListening(m_rDocShell);
1306 0 : }
1307 0 : const SwFmtFld* pop()
1308 : {
1309 0 : if (v.empty())
1310 0 : return NULL;
1311 0 : const SwFmtFld* p = v.back();
1312 0 : EndListening(const_cast<SwFmtFld&>(*p));
1313 0 : v.pop_back();
1314 0 : return p;
1315 : }
1316 : };
1317 :
1318 : // copy to new vector, otherwise RemoveItem would operate and delete stuff on mvPostItFlds as well
1319 : // RemoveItem will clean up the core field and visible postit if necessary
1320 : // we cannot just delete everything as before, as postits could move into change tracking
1321 0 : void SwPostItMgr::Delete(const OUString& rAuthor)
1322 : {
1323 0 : mpWrtShell->StartAllAction();
1324 0 : if (HasActiveSidebarWin() && (GetActiveSidebarWin()->GetAuthor() == rAuthor))
1325 : {
1326 0 : SetActiveSidebarWin(0);
1327 : }
1328 0 : SwRewriter aRewriter;
1329 0 : aRewriter.AddRule(UndoArg1, SW_RESSTR(STR_DELETE_AUTHOR_NOTES) + rAuthor);
1330 0 : mpWrtShell->StartUndo( UNDO_DELETE, &aRewriter );
1331 :
1332 0 : IsPostitFieldWithAuthorOf aFilter(rAuthor);
1333 0 : FieldDocWatchingStack aStack(mvPostItFlds, *mpView->GetDocShell(), aFilter);
1334 0 : while (const SwFmtFld* pFld = aStack.pop())
1335 : {
1336 0 : if (mpWrtShell->GotoField(*pFld))
1337 0 : mpWrtShell->DelRight();
1338 : }
1339 0 : mpWrtShell->EndUndo();
1340 0 : PrepareView();
1341 0 : mpWrtShell->EndAllAction();
1342 0 : mbLayout = true;
1343 0 : CalcRects();
1344 0 : LayoutPostIts();
1345 0 : }
1346 :
1347 0 : void SwPostItMgr::Delete()
1348 : {
1349 0 : mpWrtShell->StartAllAction();
1350 0 : SetActiveSidebarWin(0);
1351 0 : SwRewriter aRewriter;
1352 0 : aRewriter.AddRule(UndoArg1, SW_RES(STR_DELETE_ALL_NOTES) );
1353 0 : mpWrtShell->StartUndo( UNDO_DELETE, &aRewriter );
1354 :
1355 0 : IsPostitField aFilter;
1356 0 : FieldDocWatchingStack aStack(mvPostItFlds, *mpView->GetDocShell(),
1357 0 : aFilter);
1358 0 : while (const SwFmtFld* pFld = aStack.pop())
1359 : {
1360 0 : if (mpWrtShell->GotoField(*pFld))
1361 0 : mpWrtShell->DelRight();
1362 : }
1363 :
1364 0 : mpWrtShell->EndUndo();
1365 0 : PrepareView();
1366 0 : mpWrtShell->EndAllAction();
1367 0 : mbLayout = true;
1368 0 : CalcRects();
1369 0 : LayoutPostIts();
1370 0 : }
1371 :
1372 0 : void SwPostItMgr::ExecuteFormatAllDialog(SwView& rView)
1373 : {
1374 0 : if (mvPostItFlds.empty())
1375 0 : return;
1376 0 : sw::sidebarwindows::SwSidebarWin *pOrigActiveWin = GetActiveSidebarWin();
1377 0 : sw::sidebarwindows::SwSidebarWin *pWin = pOrigActiveWin;
1378 0 : if (!pWin)
1379 : {
1380 0 : for (SwSidebarItem_iterator i = mvPostItFlds.begin(); i != mvPostItFlds.end(); ++i)
1381 : {
1382 0 : pWin = (*i)->pPostIt;
1383 0 : if (pWin)
1384 0 : break;
1385 : }
1386 : }
1387 0 : if (!pWin)
1388 0 : return;
1389 0 : SetActiveSidebarWin(pWin);
1390 0 : OutlinerView* pOLV = pWin->GetOutlinerView();
1391 0 : SfxItemSet aEditAttr(pOLV->GetAttribs());
1392 0 : SfxItemPool* pPool(SwAnnotationShell::GetAnnotationPool(rView));
1393 0 : SfxItemSet aDlgAttr(*pPool, EE_ITEMS_START, EE_ITEMS_END);
1394 0 : aDlgAttr.Put(aEditAttr);
1395 0 : SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
1396 0 : boost::scoped_ptr<SfxAbstractTabDialog> pDlg(pFact->CreateSwCharDlg(rView.GetWindow(), rView, aDlgAttr, DLG_CHAR_ANN));
1397 0 : sal_uInt16 nRet = pDlg->Execute();
1398 0 : if (RET_OK == nRet)
1399 : {
1400 0 : aDlgAttr.Put(*pDlg->GetOutputItemSet());
1401 0 : FormatAll(aDlgAttr);
1402 : }
1403 0 : pDlg.reset();
1404 0 : SetActiveSidebarWin(pOrigActiveWin);
1405 : }
1406 :
1407 0 : void SwPostItMgr::FormatAll(const SfxItemSet &rNewAttr)
1408 : {
1409 0 : mpWrtShell->StartAllAction();
1410 0 : SwRewriter aRewriter;
1411 0 : aRewriter.AddRule(UndoArg1, SW_RES(STR_FORMAT_ALL_NOTES) );
1412 0 : mpWrtShell->StartUndo( UNDO_INSATTR, &aRewriter );
1413 :
1414 0 : for(SwSidebarItem_iterator i = mvPostItFlds.begin(); i != mvPostItFlds.end() ; ++i)
1415 : {
1416 0 : if (!(*i)->pPostIt)
1417 0 : continue;
1418 0 : OutlinerView* pOLV = (*i)->pPostIt->GetOutlinerView();
1419 : //save old selection
1420 0 : ESelection aOrigSel(pOLV->GetSelection());
1421 : //select all
1422 0 : Outliner *pOutliner = pOLV->GetOutliner();
1423 0 : if (pOutliner)
1424 : {
1425 0 : sal_Int32 nParaCount = pOutliner->GetParagraphCount();
1426 0 : if (nParaCount > 0)
1427 0 : pOLV->SelectRange(0, nParaCount);
1428 : }
1429 : //set new char properties
1430 0 : pOLV->SetAttribs(rNewAttr);
1431 : //restore old selection
1432 0 : pOLV->SetSelection(aOrigSel);
1433 : }
1434 :
1435 0 : mpWrtShell->EndUndo();
1436 0 : PrepareView();
1437 0 : mpWrtShell->EndAllAction();
1438 0 : mbLayout = true;
1439 0 : CalcRects();
1440 0 : LayoutPostIts();
1441 0 : }
1442 :
1443 0 : void SwPostItMgr::Hide( const OUString& rAuthor )
1444 : {
1445 0 : for(SwSidebarItem_iterator i = mvPostItFlds.begin(); i != mvPostItFlds.end() ; ++i)
1446 : {
1447 0 : if ( (*i)->pPostIt && ((*i)->pPostIt->GetAuthor() == rAuthor) )
1448 : {
1449 0 : (*i)->bShow = false;
1450 0 : (*i)->pPostIt->HideNote();
1451 : }
1452 : }
1453 :
1454 0 : LayoutPostIts();
1455 0 : }
1456 :
1457 0 : void SwPostItMgr::Hide()
1458 : {
1459 0 : for(SwSidebarItem_iterator i = mvPostItFlds.begin(); i != mvPostItFlds.end() ; ++i)
1460 : {
1461 0 : (*i)->bShow = false;
1462 0 : (*i)->pPostIt->HideNote();
1463 : }
1464 0 : }
1465 :
1466 0 : void SwPostItMgr::Show()
1467 : {
1468 0 : for(SwSidebarItem_iterator i = mvPostItFlds.begin(); i != mvPostItFlds.end() ; ++i)
1469 : {
1470 0 : (*i)->bShow = true;
1471 : }
1472 0 : LayoutPostIts();
1473 0 : }
1474 :
1475 832 : void SwPostItMgr::Sort()
1476 : {
1477 832 : if (mvPostItFlds.size()>1 )
1478 : {
1479 332 : mvPostItFlds.sort(comp_pos);
1480 : }
1481 832 : }
1482 :
1483 0 : SwSidebarWin* SwPostItMgr::GetSidebarWin( const SfxBroadcaster* pBroadcaster) const
1484 : {
1485 0 : for(const_iterator i = mvPostItFlds.begin(); i != mvPostItFlds.end() ; ++i)
1486 : {
1487 0 : if ( (*i)->GetBroadCaster() == pBroadcaster)
1488 0 : return (*i)->pPostIt;
1489 : }
1490 0 : return NULL;
1491 : }
1492 :
1493 16 : sw::annotation::SwAnnotationWin* SwPostItMgr::GetAnnotationWin(const SwPostItField* pFld) const
1494 : {
1495 16 : for(const_iterator i = mvPostItFlds.begin(); i != mvPostItFlds.end() ; ++i)
1496 : {
1497 16 : if ( (*i)->GetFmtFld().GetField() == pFld )
1498 16 : return dynamic_cast<sw::annotation::SwAnnotationWin*>((*i)->pPostIt);
1499 : }
1500 0 : return NULL;
1501 : }
1502 :
1503 0 : SwSidebarWin* SwPostItMgr::GetNextPostIt( sal_uInt16 aDirection,
1504 : SwSidebarWin* aPostIt )
1505 : {
1506 0 : if (mvPostItFlds.size()>1)
1507 : {
1508 0 : for(SwSidebarItem_iterator i = mvPostItFlds.begin(); i != mvPostItFlds.end() ; ++i)
1509 : {
1510 0 : if ( (*i)->pPostIt == aPostIt)
1511 : {
1512 0 : SwSidebarItem_iterator iNextPostIt = i;
1513 0 : if (aDirection == KEY_PAGEUP)
1514 : {
1515 0 : if ( iNextPostIt == mvPostItFlds.begin() )
1516 : {
1517 0 : return NULL;
1518 : }
1519 0 : --iNextPostIt;
1520 : }
1521 : else
1522 : {
1523 0 : ++iNextPostIt;
1524 0 : if ( iNextPostIt == mvPostItFlds.end() )
1525 : {
1526 0 : return NULL;
1527 : }
1528 : }
1529 : // lets quit, we are back at the beginning
1530 0 : if ( (*iNextPostIt)->pPostIt == aPostIt)
1531 0 : return NULL;
1532 0 : return (*iNextPostIt)->pPostIt;
1533 : }
1534 : }
1535 0 : return NULL;
1536 : }
1537 : else
1538 0 : return NULL;
1539 : }
1540 :
1541 0 : long SwPostItMgr::GetNextBorder()
1542 : {
1543 0 : for (unsigned long n=0;n<mPages.size();n++)
1544 : {
1545 0 : for(SwSidebarItem_iterator b = mPages[n]->mList->begin(); b!= mPages[n]->mList->end(); ++b)
1546 : {
1547 0 : if ((*b)->pPostIt == mpActivePostIt)
1548 : {
1549 0 : SwSidebarItem_iterator aNext = b;
1550 0 : ++aNext;
1551 0 : bool bFollow = (aNext == mPages[n]->mList->end()) ? false : (*aNext)->pPostIt->IsFollow();
1552 0 : if ( mPages[n]->bScrollbar || bFollow )
1553 : {
1554 0 : return -1;
1555 : }
1556 : else
1557 : {
1558 : //if this is the last item, return the bottom border otherwise the next item
1559 0 : if (aNext == mPages[n]->mList->end())
1560 0 : return mpEditWin->LogicToPixel(Point(0,mPages[n]->mPageRect.Bottom())).Y() - GetSpaceBetween();
1561 : else
1562 0 : return (*aNext)->pPostIt->GetPosPixel().Y() - GetSpaceBetween();
1563 : }
1564 : }
1565 : }
1566 : }
1567 :
1568 : OSL_FAIL("SwPostItMgr::GetNextBorder(): We have to find a next border here");
1569 0 : return -1;
1570 : }
1571 :
1572 24734 : void SwPostItMgr::SetShadowState(const SwPostItField* pFld,bool bCursor)
1573 : {
1574 24734 : if (pFld)
1575 : {
1576 18 : if (pFld !=mShadowState.mpShadowFld)
1577 : {
1578 16 : if (mShadowState.mpShadowFld)
1579 : {
1580 : // reset old one if still alive
1581 : // TODO: does not work properly if mouse and cursor was set
1582 : sw::annotation::SwAnnotationWin* pOldPostIt =
1583 0 : GetAnnotationWin(mShadowState.mpShadowFld);
1584 0 : if (pOldPostIt && pOldPostIt->Shadow() && (pOldPostIt->Shadow()->GetShadowState() != SS_EDIT))
1585 0 : pOldPostIt->SetViewState(VS_NORMAL);
1586 : }
1587 : //set new one, if it is not currently edited
1588 16 : sw::annotation::SwAnnotationWin* pNewPostIt = GetAnnotationWin(pFld);
1589 16 : if (pNewPostIt && pNewPostIt->Shadow() && (pNewPostIt->Shadow()->GetShadowState() != SS_EDIT))
1590 : {
1591 6 : pNewPostIt->SetViewState(VS_VIEW);
1592 : //remember our new field
1593 6 : mShadowState.mpShadowFld = pFld;
1594 6 : mShadowState.bCursor = false;
1595 6 : mShadowState.bMouse = false;
1596 : }
1597 : }
1598 18 : if (bCursor)
1599 18 : mShadowState.bCursor = true;
1600 : else
1601 0 : mShadowState.bMouse = true;
1602 : }
1603 : else
1604 : {
1605 24716 : if (mShadowState.mpShadowFld)
1606 : {
1607 0 : if (bCursor)
1608 0 : mShadowState.bCursor = false;
1609 : else
1610 0 : mShadowState.bMouse = false;
1611 0 : if (!mShadowState.bCursor && !mShadowState.bMouse)
1612 : {
1613 : // reset old one if still alive
1614 0 : sw::annotation::SwAnnotationWin* pOldPostIt = GetAnnotationWin(mShadowState.mpShadowFld);
1615 0 : if (pOldPostIt && pOldPostIt->Shadow() && (pOldPostIt->Shadow()->GetShadowState() != SS_EDIT))
1616 : {
1617 0 : pOldPostIt->SetViewState(VS_NORMAL);
1618 0 : mShadowState.mpShadowFld = 0;
1619 : }
1620 : }
1621 : }
1622 : }
1623 24734 : }
1624 :
1625 326 : void SwPostItMgr::PrepareView(bool bIgnoreCount)
1626 : {
1627 326 : if (!HasNotes() || bIgnoreCount)
1628 : {
1629 318 : mpWrtShell->StartAllAction();
1630 318 : SwRootFrm* pLayout = mpWrtShell->GetLayout();
1631 318 : if ( pLayout )
1632 : SwPostItHelper::setSidebarChanged( pLayout,
1633 318 : mpWrtShell->getIDocumentSettingAccess()->get( IDocumentSettingAccess::BROWSE_MODE ) );
1634 318 : mpWrtShell->EndAllAction();
1635 : }
1636 326 : }
1637 :
1638 22 : bool SwPostItMgr::ShowScrollbar(const unsigned long aPage) const
1639 : {
1640 22 : if (mPages.size() > aPage-1)
1641 22 : return (mPages[aPage-1]->bScrollbar && !mbWaitingForCalcRects);
1642 : else
1643 0 : return false;
1644 : }
1645 :
1646 0 : bool SwPostItMgr::IsHit(const Point &aPointPixel)
1647 : {
1648 0 : if (HasNotes() && ShowNotes())
1649 : {
1650 0 : const Point aPoint = mpEditWin->PixelToLogic(aPointPixel);
1651 0 : const SwRootFrm* pLayout = mpWrtShell->GetLayout();
1652 0 : SwRect aPageFrm;
1653 0 : const unsigned long nPageNum = SwPostItHelper::getPageInfo( aPageFrm, pLayout, aPoint );
1654 0 : if( nPageNum )
1655 : {
1656 0 : Rectangle aRect;
1657 : OSL_ENSURE(mPages.size()>nPageNum-1,"SwPostitMgr:: page container size wrong");
1658 0 : aRect = mPages[nPageNum-1]->eSidebarPosition == sw::sidebarwindows::SIDEBAR_LEFT
1659 0 : ? Rectangle(Point(aPageFrm.Left()-GetSidebarWidth()-GetSidebarBorderWidth(),aPageFrm.Top()),Size(GetSidebarWidth(),aPageFrm.Height()))
1660 0 : : Rectangle( Point(aPageFrm.Right()+GetSidebarBorderWidth(),aPageFrm.Top()) , Size(GetSidebarWidth(),aPageFrm.Height()));
1661 0 : if (aRect.IsInside(aPoint))
1662 : {
1663 : // we hit the note's sidebar
1664 : // lets now test for the arrow area
1665 0 : if (mPages[nPageNum-1]->bScrollbar)
1666 0 : return ScrollbarHit(nPageNum,aPoint);
1667 : else
1668 0 : return false;
1669 : }
1670 : }
1671 : }
1672 0 : return false;
1673 : }
1674 0 : Rectangle SwPostItMgr::GetBottomScrollRect(const unsigned long aPage) const
1675 : {
1676 0 : SwRect aPageRect = mPages[aPage-1]->mPageRect;
1677 0 : Point aPointBottom = mPages[aPage-1]->eSidebarPosition == sw::sidebarwindows::SIDEBAR_LEFT
1678 0 : ? Point(aPageRect.Left() - GetSidebarWidth() - GetSidebarBorderWidth() + mpEditWin->PixelToLogic(Size(2,0)).Width(),aPageRect.Bottom()- mpEditWin->PixelToLogic(Size(0,2+GetSidebarScrollerHeight())).Height())
1679 0 : : Point(aPageRect.Right() + GetSidebarBorderWidth() + mpEditWin->PixelToLogic(Size(2,0)).Width(),aPageRect.Bottom()- mpEditWin->PixelToLogic(Size(0,2+GetSidebarScrollerHeight())).Height());
1680 0 : Size aSize(GetSidebarWidth() - mpEditWin->PixelToLogic(Size(4,0)).Width(), mpEditWin->PixelToLogic(Size(0,GetSidebarScrollerHeight())).Height()) ;
1681 0 : return Rectangle(aPointBottom,aSize);
1682 : }
1683 :
1684 0 : Rectangle SwPostItMgr::GetTopScrollRect(const unsigned long aPage) const
1685 : {
1686 0 : SwRect aPageRect = mPages[aPage-1]->mPageRect;
1687 0 : Point aPointTop = mPages[aPage-1]->eSidebarPosition == sw::sidebarwindows::SIDEBAR_LEFT
1688 0 : ? Point(aPageRect.Left() - GetSidebarWidth() -GetSidebarBorderWidth()+ mpEditWin->PixelToLogic(Size(2,0)).Width(),aPageRect.Top() + mpEditWin->PixelToLogic(Size(0,2)).Height())
1689 0 : : Point(aPageRect.Right() + GetSidebarBorderWidth() + mpEditWin->PixelToLogic(Size(2,0)).Width(),aPageRect.Top() + mpEditWin->PixelToLogic(Size(0,2)).Height());
1690 0 : Size aSize(GetSidebarWidth() - mpEditWin->PixelToLogic(Size(4,0)).Width(), mpEditWin->PixelToLogic(Size(0,GetSidebarScrollerHeight())).Height()) ;
1691 0 : return Rectangle(aPointTop,aSize);
1692 : }
1693 :
1694 : //IMPORTANT: if you change the rects here, also change SwPageFrm::PaintNotesSidebar()
1695 0 : bool SwPostItMgr::ScrollbarHit(const unsigned long aPage,const Point &aPoint)
1696 : {
1697 0 : SwRect aPageRect = mPages[aPage-1]->mPageRect;
1698 0 : Point aPointBottom = mPages[aPage-1]->eSidebarPosition == sw::sidebarwindows::SIDEBAR_LEFT
1699 0 : ? Point(aPageRect.Left() - GetSidebarWidth()-GetSidebarBorderWidth() + mpEditWin->PixelToLogic(Size(2,0)).Width(),aPageRect.Bottom()- mpEditWin->PixelToLogic(Size(0,2+GetSidebarScrollerHeight())).Height())
1700 0 : : Point(aPageRect.Right() + GetSidebarBorderWidth()+ mpEditWin->PixelToLogic(Size(2,0)).Width(),aPageRect.Bottom()- mpEditWin->PixelToLogic(Size(0,2+GetSidebarScrollerHeight())).Height());
1701 :
1702 0 : Point aPointTop = mPages[aPage-1]->eSidebarPosition == sw::sidebarwindows::SIDEBAR_LEFT
1703 0 : ? Point(aPageRect.Left() - GetSidebarWidth()-GetSidebarBorderWidth()+ mpEditWin->PixelToLogic(Size(2,0)).Width(),aPageRect.Top() + mpEditWin->PixelToLogic(Size(0,2)).Height())
1704 0 : : Point(aPageRect.Right()+GetSidebarBorderWidth()+ mpEditWin->PixelToLogic(Size(2,0)).Width(),aPageRect.Top() + mpEditWin->PixelToLogic(Size(0,2)).Height());
1705 :
1706 0 : Rectangle aRectBottom(GetBottomScrollRect(aPage));
1707 0 : Rectangle aRectTop(GetTopScrollRect(aPage));
1708 :
1709 0 : if (aRectBottom.IsInside(aPoint))
1710 : {
1711 0 : if (aPoint.X() < long((aPointBottom.X() + GetSidebarWidth()/3)))
1712 0 : Scroll( GetScrollSize(),aPage);
1713 : else
1714 0 : Scroll( -1*GetScrollSize(), aPage);
1715 0 : return true;
1716 : }
1717 0 : else if (aRectTop.IsInside(aPoint))
1718 : {
1719 0 : if (aPoint.X() < long((aPointTop.X() + GetSidebarWidth()/3*2)))
1720 0 : Scroll(GetScrollSize(), aPage);
1721 : else
1722 0 : Scroll(-1*GetScrollSize(), aPage);
1723 0 : return true;
1724 : }
1725 0 : return false;
1726 : }
1727 :
1728 398 : void SwPostItMgr::CorrectPositions()
1729 : {
1730 398 : if ( mbWaitingForCalcRects || mbLayouting || mvPostItFlds.empty() )
1731 0 : return;
1732 :
1733 : // find first valid note
1734 398 : SwSidebarWin *pFirstPostIt = 0;
1735 576 : for(SwSidebarItem_iterator i = mvPostItFlds.begin(); i != mvPostItFlds.end() ; ++i)
1736 : {
1737 488 : pFirstPostIt = (*i)->pPostIt;
1738 488 : if (pFirstPostIt)
1739 310 : break;
1740 : }
1741 :
1742 : //if we have not found a valid note, forget about it and leave
1743 398 : if (!pFirstPostIt)
1744 88 : return;
1745 :
1746 : // yeah, I know, if this is a left page it could be wrong, but finding the page and the note is probably not even faster than just doing it
1747 : // check, if anchor overlay object exists.
1748 310 : const long aAnchorX = pFirstPostIt->Anchor()
1749 1240 : ? mpEditWin->LogicToPixel( Point((long)(pFirstPostIt->Anchor()->GetSixthPosition().getX()),0)).X()
1750 930 : : 0;
1751 310 : const long aAnchorY = pFirstPostIt->Anchor()
1752 1240 : ? mpEditWin->LogicToPixel( Point(0,(long)(pFirstPostIt->Anchor()->GetSixthPosition().getY()))).Y() + 1
1753 930 : : 0;
1754 310 : if (Point(aAnchorX,aAnchorY) != pFirstPostIt->GetPosPixel())
1755 : {
1756 0 : long aAnchorPosX = 0;
1757 0 : long aAnchorPosY = 0;
1758 0 : for (unsigned long n=0;n<mPages.size();n++)
1759 : {
1760 0 : for(SwSidebarItem_iterator i = mPages[n]->mList->begin(); i != mPages[n]->mList->end(); ++i)
1761 : {
1762 : // check, if anchor overlay object exists.
1763 0 : if ( (*i)->bShow && (*i)->pPostIt && (*i)->pPostIt->Anchor() )
1764 : {
1765 0 : aAnchorPosX = mPages[n]->eSidebarPosition == sw::sidebarwindows::SIDEBAR_LEFT
1766 0 : ? mpEditWin->LogicToPixel( Point((long)((*i)->pPostIt->Anchor()->GetSeventhPosition().getX()),0)).X()
1767 0 : : mpEditWin->LogicToPixel( Point((long)((*i)->pPostIt->Anchor()->GetSixthPosition().getX()),0)).X();
1768 0 : aAnchorPosY = mpEditWin->LogicToPixel( Point(0,(long)((*i)->pPostIt->Anchor()->GetSixthPosition().getY()))).Y() + 1;
1769 0 : (*i)->pPostIt->SetPosPixel(Point(aAnchorPosX,aAnchorPosY));
1770 : }
1771 : }
1772 : }
1773 : }
1774 : }
1775 :
1776 111681 : bool SwPostItMgr::ShowNotes() const
1777 : {
1778 : // we only want to see notes if Options - Writer - View - Notes is ticked
1779 111681 : return mpWrtShell->GetViewOptions()->IsPostIts();
1780 : }
1781 :
1782 165649 : bool SwPostItMgr::HasNotes() const
1783 : {
1784 165649 : return !mvPostItFlds.empty();
1785 : }
1786 :
1787 96327 : unsigned long SwPostItMgr::GetSidebarWidth(bool bPx) const
1788 : {
1789 96327 : unsigned long aWidth = (unsigned long)(mpWrtShell->GetViewOptions()->GetZoom() * 1.8);
1790 96327 : if (bPx)
1791 95972 : return aWidth;
1792 : else
1793 355 : return mpEditWin->PixelToLogic(Size( aWidth ,0)).Width();
1794 : }
1795 :
1796 96349 : unsigned long SwPostItMgr::GetSidebarBorderWidth(bool bPx) const
1797 : {
1798 96349 : if (bPx)
1799 95972 : return 2;
1800 : else
1801 377 : return mpEditWin->PixelToLogic(Size(2,0)).Width();
1802 : }
1803 :
1804 1160 : unsigned long SwPostItMgr::GetNoteWidth()
1805 : {
1806 1160 : return GetSidebarWidth(true);
1807 : }
1808 :
1809 130 : Color SwPostItMgr::GetColorDark(sal_uInt16 aAuthorIndex)
1810 : {
1811 130 : if (!Application::GetSettings().GetStyleSettings().GetHighContrastMode())
1812 : {
1813 : static const Color aArrayNormal[] = {
1814 : COL_AUTHOR1_NORMAL, COL_AUTHOR2_NORMAL, COL_AUTHOR3_NORMAL,
1815 : COL_AUTHOR4_NORMAL, COL_AUTHOR5_NORMAL, COL_AUTHOR6_NORMAL,
1816 130 : COL_AUTHOR7_NORMAL, COL_AUTHOR8_NORMAL, COL_AUTHOR9_NORMAL };
1817 :
1818 130 : return Color( aArrayNormal[ aAuthorIndex % (sizeof( aArrayNormal )/ sizeof( aArrayNormal[0] ))]);
1819 : }
1820 : else
1821 0 : return Color(COL_WHITE);
1822 : }
1823 :
1824 130 : Color SwPostItMgr::GetColorLight(sal_uInt16 aAuthorIndex)
1825 : {
1826 130 : if (!Application::GetSettings().GetStyleSettings().GetHighContrastMode())
1827 : {
1828 : static const Color aArrayLight[] = {
1829 : COL_AUTHOR1_LIGHT, COL_AUTHOR2_LIGHT, COL_AUTHOR3_LIGHT,
1830 : COL_AUTHOR4_LIGHT, COL_AUTHOR5_LIGHT, COL_AUTHOR6_LIGHT,
1831 130 : COL_AUTHOR7_LIGHT, COL_AUTHOR8_LIGHT, COL_AUTHOR9_LIGHT };
1832 :
1833 130 : return Color( aArrayLight[ aAuthorIndex % (sizeof( aArrayLight )/ sizeof( aArrayLight[0] ))]);
1834 : }
1835 : else
1836 0 : return Color(COL_WHITE);
1837 : }
1838 :
1839 1290 : Color SwPostItMgr::GetColorAnchor(sal_uInt16 aAuthorIndex)
1840 : {
1841 1290 : if (!Application::GetSettings().GetStyleSettings().GetHighContrastMode())
1842 : {
1843 : static const Color aArrayAnchor[] = {
1844 : COL_AUTHOR1_DARK, COL_AUTHOR2_DARK, COL_AUTHOR3_DARK,
1845 : COL_AUTHOR4_DARK, COL_AUTHOR5_DARK, COL_AUTHOR6_DARK,
1846 1290 : COL_AUTHOR7_DARK, COL_AUTHOR8_DARK, COL_AUTHOR9_DARK };
1847 :
1848 1290 : return Color( aArrayAnchor[ aAuthorIndex % (sizeof( aArrayAnchor ) / sizeof( aArrayAnchor[0] ))]);
1849 : }
1850 : else
1851 0 : return Color(COL_WHITE);
1852 : }
1853 :
1854 10 : void SwPostItMgr::SetActiveSidebarWin( SwSidebarWin* p)
1855 : {
1856 10 : if ( p != mpActivePostIt )
1857 : {
1858 : // we need the temp variable so we can set mpActivePostIt before we call DeactivatePostIt
1859 : // therefore we get a new layout in DOCCHANGED when switching from postit to document,
1860 : // otherwise, GetActivePostIt() would still hold our old postit
1861 0 : SwSidebarWin* pActive = mpActivePostIt;
1862 0 : mpActivePostIt = p;
1863 0 : if (pActive)
1864 : {
1865 0 : pActive->DeactivatePostIt();
1866 0 : mShadowState.mpShadowFld = 0;
1867 : }
1868 0 : if (mpActivePostIt)
1869 : {
1870 0 : mpActivePostIt->GotoPos();
1871 0 : mpView->SetAnnotationMode(true);
1872 0 : mpView->AttrChangedNotify(0);
1873 0 : mpView->SetAnnotationMode(false);
1874 0 : mpActivePostIt->ActivatePostIt();
1875 : }
1876 : }
1877 10 : }
1878 :
1879 4 : IMPL_LINK( SwPostItMgr, CalcHdl, void*, /* pVoid*/ )
1880 : {
1881 2 : mnEventId = 0;
1882 2 : if ( mbLayouting )
1883 : {
1884 : OSL_FAIL("Reentrance problem in Layout Manager!");
1885 0 : mbWaitingForCalcRects = false;
1886 0 : return 0;
1887 : }
1888 :
1889 : // do not change order, even if it would seem so in the first place, we need the calcrects always
1890 2 : if (CalcRects() || mbLayout)
1891 : {
1892 2 : mbLayout = false;
1893 2 : LayoutPostIts();
1894 : }
1895 2 : return 0;
1896 : }
1897 :
1898 22066 : void SwPostItMgr::Rescale()
1899 : {
1900 22746 : for(std::list<SwSidebarItem*>::iterator i = mvPostItFlds.begin(); i != mvPostItFlds.end() ; ++i)
1901 680 : if ( (*i)->pPostIt )
1902 496 : (*i)->pPostIt->Rescale();
1903 22066 : }
1904 :
1905 1160 : sal_Int32 SwPostItMgr::GetInitialAnchorDistance() const
1906 : {
1907 1160 : const Fraction& f( mpEditWin->GetMapMode().GetScaleY() );
1908 1160 : return POSTIT_INITIAL_ANCHOR_DISTANCE * f.GetNumerator() / f.GetDenominator();
1909 : }
1910 :
1911 3216 : sal_Int32 SwPostItMgr::GetSpaceBetween() const
1912 : {
1913 3216 : const Fraction& f( mpEditWin->GetMapMode().GetScaleY() );
1914 3216 : return ( POSTIT_SPACE_BETWEEN ) * f.GetNumerator() / f.GetDenominator();
1915 : }
1916 :
1917 0 : sal_Int32 SwPostItMgr::GetScrollSize() const
1918 : {
1919 0 : const Fraction& f( mpEditWin->GetMapMode().GetScaleY() );
1920 0 : return ( POSTIT_SPACE_BETWEEN + POSTIT_MINIMUMSIZE_WITH_META ) * f.GetNumerator() / f.GetDenominator();
1921 : }
1922 :
1923 0 : sal_Int32 SwPostItMgr::GetMinimumSizeWithMeta() const
1924 : {
1925 0 : const Fraction& f( mpEditWin->GetMapMode().GetScaleY() );
1926 0 : return POSTIT_MINIMUMSIZE_WITH_META * f.GetNumerator() / f.GetDenominator();
1927 : }
1928 :
1929 22 : sal_Int32 SwPostItMgr::GetSidebarScrollerHeight() const
1930 : {
1931 22 : const Fraction& f( mpEditWin->GetMapMode().GetScaleY() );
1932 22 : return POSTIT_SCROLL_SIDEBAR_HEIGHT * f.GetNumerator() / f.GetDenominator();
1933 : }
1934 :
1935 0 : void SwPostItMgr::SetSpellChecking()
1936 : {
1937 0 : for(std::list<SwSidebarItem*>::iterator i = mvPostItFlds.begin(); i != mvPostItFlds.end() ; ++i)
1938 0 : if ( (*i)->pPostIt )
1939 0 : (*i)->pPostIt->SetSpellChecking();
1940 0 : }
1941 :
1942 0 : void SwPostItMgr::SetReadOnlyState()
1943 : {
1944 0 : for(std::list<SwSidebarItem*>::iterator i = mvPostItFlds.begin(); i != mvPostItFlds.end() ; ++i)
1945 0 : if ( (*i)->pPostIt )
1946 0 : (*i)->pPostIt->SetReadonly( mbReadOnly );
1947 0 : }
1948 :
1949 0 : void SwPostItMgr::CheckMetaText()
1950 : {
1951 0 : for(std::list<SwSidebarItem*>::iterator i = mvPostItFlds.begin(); i != mvPostItFlds.end() ; ++i)
1952 0 : if ( (*i)->pPostIt )
1953 0 : (*i)->pPostIt->CheckMetaText();
1954 :
1955 0 : }
1956 :
1957 0 : sal_uInt16 SwPostItMgr::Replace(SvxSearchItem* pItem)
1958 : {
1959 0 : SwSidebarWin* pWin = GetActiveSidebarWin();
1960 0 : sal_uInt16 aResult = pWin->GetOutlinerView()->StartSearchAndReplace( *pItem );
1961 0 : if (!aResult)
1962 0 : SetActiveSidebarWin(0);
1963 0 : return aResult;
1964 : }
1965 :
1966 0 : sal_uInt16 SwPostItMgr::FinishSearchReplace(const ::com::sun::star::util::SearchOptions& rSearchOptions, bool bSrchForward)
1967 : {
1968 0 : SwSidebarWin* pWin = GetActiveSidebarWin();
1969 0 : SvxSearchItem aItem(SID_SEARCH_ITEM );
1970 0 : aItem.SetSearchOptions(rSearchOptions);
1971 0 : aItem.SetBackward(!bSrchForward);
1972 0 : sal_uInt16 aResult = pWin->GetOutlinerView()->StartSearchAndReplace( aItem );
1973 0 : if (!aResult)
1974 0 : SetActiveSidebarWin(0);
1975 0 : return aResult;
1976 : }
1977 :
1978 0 : sal_uInt16 SwPostItMgr::SearchReplace(const SwFmtFld &pFld, const ::com::sun::star::util::SearchOptions& rSearchOptions, bool bSrchForward)
1979 : {
1980 0 : sal_uInt16 aResult = 0;
1981 0 : SwSidebarWin* pWin = GetSidebarWin(&pFld);
1982 0 : if (pWin)
1983 : {
1984 0 : ESelection aOldSelection = pWin->GetOutlinerView()->GetSelection();
1985 0 : if (bSrchForward)
1986 0 : pWin->GetOutlinerView()->SetSelection(ESelection(0,0,0,0));
1987 : else
1988 : pWin->GetOutlinerView()->SetSelection(
1989 0 : ESelection(EE_PARA_MAX_COUNT,EE_TEXTPOS_MAX_COUNT,EE_PARA_MAX_COUNT,EE_TEXTPOS_MAX_COUNT));
1990 0 : SvxSearchItem aItem(SID_SEARCH_ITEM );
1991 0 : aItem.SetSearchOptions(rSearchOptions);
1992 0 : aItem.SetBackward(!bSrchForward);
1993 0 : aResult = pWin->GetOutlinerView()->StartSearchAndReplace( aItem );
1994 0 : if (!aResult)
1995 0 : pWin->GetOutlinerView()->SetSelection(aOldSelection);
1996 : else
1997 : {
1998 0 : SetActiveSidebarWin(pWin);
1999 0 : MakeVisible(pWin);
2000 0 : }
2001 : }
2002 0 : return aResult;
2003 : }
2004 :
2005 0 : void SwPostItMgr::AssureStdModeAtShell()
2006 : {
2007 : // deselect any drawing or frame and leave editing mode
2008 0 : SdrView* pSdrView = mpWrtShell->GetDrawView();
2009 0 : if ( pSdrView && pSdrView->IsTextEdit() )
2010 : {
2011 0 : bool bLockView = mpWrtShell->IsViewLocked();
2012 0 : mpWrtShell->LockView( true );
2013 0 : mpWrtShell->EndTextEdit();
2014 0 : mpWrtShell->LockView( bLockView );
2015 : }
2016 :
2017 0 : if( mpWrtShell->IsSelFrmMode() || mpWrtShell->IsObjSelected())
2018 : {
2019 0 : mpWrtShell->UnSelectFrm();
2020 0 : mpWrtShell->LeaveSelFrmMode();
2021 0 : mpWrtShell->GetView().LeaveDrawCreate();
2022 0 : mpWrtShell->EnterStdMode();
2023 :
2024 0 : mpWrtShell->DrawSelChanged();
2025 0 : mpView->StopShellTimer();
2026 : }
2027 0 : }
2028 :
2029 38660 : bool SwPostItMgr::HasActiveSidebarWin() const
2030 : {
2031 38660 : return mpActivePostIt != 0;
2032 : }
2033 :
2034 0 : bool SwPostItMgr::HasActiveAnnotationWin() const
2035 : {
2036 0 : return HasActiveSidebarWin() &&
2037 0 : dynamic_cast<sw::annotation::SwAnnotationWin*>(mpActivePostIt) != 0;
2038 : }
2039 :
2040 0 : void SwPostItMgr::GrabFocusOnActiveSidebarWin()
2041 : {
2042 0 : if ( HasActiveSidebarWin() )
2043 : {
2044 0 : mpActivePostIt->GrabFocus();
2045 : }
2046 0 : }
2047 :
2048 0 : void SwPostItMgr::UpdateDataOnActiveSidebarWin()
2049 : {
2050 0 : if ( HasActiveSidebarWin() )
2051 : {
2052 0 : mpActivePostIt->UpdateData();
2053 : }
2054 0 : }
2055 :
2056 0 : void SwPostItMgr::DeleteActiveSidebarWin()
2057 : {
2058 0 : if ( HasActiveSidebarWin() )
2059 : {
2060 0 : mpActivePostIt->Delete();
2061 : }
2062 0 : }
2063 :
2064 0 : void SwPostItMgr::HideActiveSidebarWin()
2065 : {
2066 0 : if ( HasActiveSidebarWin() )
2067 : {
2068 0 : mpActivePostIt->Hide();
2069 : }
2070 0 : }
2071 :
2072 0 : void SwPostItMgr::ToggleInsModeOnActiveSidebarWin()
2073 : {
2074 0 : if ( HasActiveSidebarWin() )
2075 : {
2076 0 : mpActivePostIt->ToggleInsMode();
2077 : }
2078 0 : }
2079 :
2080 130 : void SwPostItMgr::ConnectSidebarWinToFrm( const SwFrm& rFrm,
2081 : const SwFmtFld& rFmtFld,
2082 : SwSidebarWin& rSidebarWin )
2083 : {
2084 130 : if ( mpFrmSidebarWinContainer == 0 )
2085 : {
2086 80 : mpFrmSidebarWinContainer = new SwFrmSidebarWinContainer();
2087 : }
2088 :
2089 130 : const bool bInserted = mpFrmSidebarWinContainer->insert( rFrm, rFmtFld, rSidebarWin );
2090 260 : if ( bInserted &&
2091 130 : mpWrtShell->GetAccessibleMap() )
2092 : {
2093 0 : mpWrtShell->GetAccessibleMap()->InvalidatePosOrSize( 0, 0, &rSidebarWin, SwRect() );
2094 : }
2095 130 : }
2096 :
2097 130 : void SwPostItMgr::DisconnectSidebarWinFromFrm( const SwFrm& rFrm,
2098 : SwSidebarWin& rSidebarWin )
2099 : {
2100 130 : if ( mpFrmSidebarWinContainer != 0 )
2101 : {
2102 130 : const bool bRemoved = mpFrmSidebarWinContainer->remove( rFrm, rSidebarWin );
2103 260 : if ( bRemoved &&
2104 130 : mpWrtShell->GetAccessibleMap() )
2105 : {
2106 0 : mpWrtShell->GetAccessibleMap()->Dispose( 0, 0, &rSidebarWin );
2107 : }
2108 : }
2109 130 : }
2110 :
2111 0 : bool SwPostItMgr::HasFrmConnectedSidebarWins( const SwFrm& rFrm )
2112 : {
2113 0 : bool bRet( false );
2114 :
2115 0 : if ( mpFrmSidebarWinContainer != 0 )
2116 : {
2117 0 : bRet = !mpFrmSidebarWinContainer->empty( rFrm );
2118 : }
2119 :
2120 0 : return bRet;
2121 : }
2122 :
2123 0 : vcl::Window* SwPostItMgr::GetSidebarWinForFrmByIndex( const SwFrm& rFrm,
2124 : const sal_Int32 nIndex )
2125 : {
2126 0 : vcl::Window* pSidebarWin( 0 );
2127 :
2128 0 : if ( mpFrmSidebarWinContainer != 0 )
2129 : {
2130 0 : pSidebarWin = mpFrmSidebarWinContainer->get( rFrm, nIndex );
2131 : }
2132 :
2133 0 : return pSidebarWin;
2134 : }
2135 :
2136 0 : void SwPostItMgr::GetAllSidebarWinForFrm( const SwFrm& rFrm,
2137 : std::vector< vcl::Window* >* pChildren )
2138 : {
2139 0 : if ( mpFrmSidebarWinContainer != 0 )
2140 : {
2141 0 : mpFrmSidebarWinContainer->getAll( rFrm, pChildren );
2142 : }
2143 0 : }
2144 :
2145 0 : void SwNoteProps::Commit() {}
2146 270 : void SwNoteProps::Notify( const ::com::sun::star::uno::Sequence< OUString >& ) {}
2147 :
2148 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
