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