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 <redline.hxx>
21 : #include <tools/datetime.hxx>
22 : #include <vcl/msgbox.hxx>
23 : #include <svl/eitem.hxx>
24 : #include <sfx2/viewfrm.hxx>
25 : #include <sfx2/dispatch.hxx>
26 : #include <svx/ctredlin.hxx>
27 : #include <svx/postattr.hxx>
28 : #include <swtypes.hxx>
29 : #include <wrtsh.hxx>
30 : #include <view.hxx>
31 : #include <swmodule.hxx>
32 : #include <redlndlg.hxx>
33 : #include <swwait.hxx>
34 : #include <uitool.hxx>
35 :
36 : #include <helpid.h>
37 : #include <cmdid.h>
38 : #include <misc.hrc>
39 : #include <redlndlg.hrc>
40 : #include <shells.hrc>
41 :
42 : // -> #111827#
43 : #include <comcore.hrc>
44 : #include <swundo.hxx>
45 : #include <SwRewriter.hxx>
46 : // <- #111827#
47 :
48 : #include <vector>
49 : #include <svx/svxdlg.hxx>
50 : #include <svx/dialogs.hrc>
51 :
52 : #include <unomid.h>
53 :
54 : #include <docsh.hxx>
55 :
56 : #include <IDocumentRedlineAccess.hxx>
57 : #include <boost/scoped_ptr.hpp>
58 :
59 37231 : SFX_IMPL_MODELESSDIALOG_WITHID( SwRedlineAcceptChild, FN_REDLINE_ACCEPT )
60 :
61 : static sal_uInt16 nSortMode = 0xffff;
62 : static bool bSortDir = true;
63 :
64 0 : SwRedlineAcceptChild::SwRedlineAcceptChild( vcl::Window* _pParent,
65 : sal_uInt16 nId,
66 : SfxBindings* pBindings,
67 : SfxChildWinInfo* pInfo ) :
68 0 : SwChildWinWrapper( _pParent, nId )
69 : {
70 0 : pWindow = VclPtr<SwModelessRedlineAcceptDlg>::Create( pBindings, this, _pParent);
71 :
72 0 : static_cast<SwModelessRedlineAcceptDlg *>(pWindow.get())->Initialize(pInfo);
73 0 : }
74 :
75 : // newly initialise dialog after document switch
76 0 : bool SwRedlineAcceptChild::ReInitDlg(SwDocShell *pDocSh)
77 : {
78 : bool bRet;
79 :
80 0 : if ((bRet = SwChildWinWrapper::ReInitDlg(pDocSh))) // update immediately, doc switch!
81 0 : static_cast<SwModelessRedlineAcceptDlg*>(GetWindow())->Activate();
82 :
83 0 : return bRet;
84 : }
85 :
86 0 : SwModelessRedlineAcceptDlg::SwModelessRedlineAcceptDlg(
87 : SfxBindings* _pBindings, SwChildWinWrapper* pChild, vcl::Window *_pParent)
88 : : SfxModelessDialog(_pBindings, pChild, _pParent,
89 : "AcceptRejectChangesDialog", "svx/ui/acceptrejectchangesdialog.ui")
90 0 : , pChildWin (pChild)
91 : {
92 0 : pImplDlg = new SwRedlineAcceptDlg(this, this, get_content_area());
93 0 : }
94 :
95 0 : void SwModelessRedlineAcceptDlg::Activate()
96 : {
97 0 : SwView *pView = ::GetActiveView();
98 0 : if (!pView) // can happen when switching to another app, when a Listbox in dialog
99 0 : return; // had the focus previously (actually THs Bug)
100 :
101 0 : SwDocShell *pDocSh = pView->GetDocShell();
102 :
103 0 : if (pChildWin->GetOldDocShell() != pDocSh)
104 : { // doc-switch
105 0 : SwWait aWait( *pDocSh, false );
106 0 : SwWrtShell* pSh = pView->GetWrtShellPtr();
107 :
108 0 : pChildWin->SetOldDocShell(pDocSh); // avoid recursion (using modified-Hdl)
109 :
110 0 : bool bMod = pSh->IsModified();
111 0 : SfxBoolItem aShow(FN_REDLINE_SHOW, true);
112 0 : pSh->GetView().GetViewFrame()->GetDispatcher()->Execute(
113 0 : FN_REDLINE_SHOW, SfxCallMode::SYNCHRON|SfxCallMode::RECORD, &aShow, 0L);
114 0 : if (!bMod)
115 0 : pSh->ResetModified();
116 0 : pImplDlg->Init();
117 :
118 0 : return;
119 : }
120 :
121 0 : pImplDlg->Activate();
122 : }
123 :
124 0 : void SwModelessRedlineAcceptDlg::Initialize(SfxChildWinInfo *pInfo)
125 : {
126 0 : if (pInfo != NULL)
127 0 : pImplDlg->Initialize(pInfo->aExtraString);
128 :
129 0 : SfxModelessDialog::Initialize(pInfo);
130 0 : }
131 :
132 0 : void SwModelessRedlineAcceptDlg::FillInfo(SfxChildWinInfo& rInfo) const
133 : {
134 0 : SfxModelessDialog::FillInfo(rInfo);
135 0 : pImplDlg->FillInfo(rInfo.aExtraString);
136 0 : }
137 :
138 0 : SwModelessRedlineAcceptDlg::~SwModelessRedlineAcceptDlg()
139 : {
140 0 : disposeOnce();
141 0 : }
142 :
143 0 : void SwModelessRedlineAcceptDlg::dispose()
144 : {
145 0 : delete pImplDlg;
146 0 : SfxModelessDialog::dispose();
147 0 : }
148 :
149 0 : SwRedlineAcceptDlg::SwRedlineAcceptDlg(vcl::Window *pParent, VclBuilderContainer *pBuilder,
150 : vcl::Window *pContentArea, bool bAutoFormat) :
151 : pParentDlg (pParent),
152 : aTabPagesCTRL (VclPtr<SvxAcceptChgCtr>::Create(pContentArea, pBuilder)),
153 : aPopup (SW_RES(MN_REDLINE_POPUP)),
154 : sInserted (SW_RES(STR_REDLINE_INSERTED)),
155 : sDeleted (SW_RES(STR_REDLINE_DELETED)),
156 : sFormated (SW_RES(STR_REDLINE_FORMATED)),
157 : sTableChgd (SW_RES(STR_REDLINE_TABLECHG)),
158 : sFormatCollSet (SW_RES(STR_REDLINE_FMTCOLLSET)),
159 : sAutoFormat (SW_RES(STR_REDLINE_AUTOFMT)),
160 : bOnlyFormatedRedlines( false ),
161 : bHasReadonlySel ( false ),
162 : bRedlnAutoFormat (bAutoFormat),
163 0 : bInhibitActivate( false )
164 : {
165 0 : aTabPagesCTRL->SetHelpId(HID_REDLINE_CTRL);
166 0 : pTPView = aTabPagesCTRL->GetViewPage();
167 :
168 0 : pTable = pTPView->GetTableControl();
169 :
170 0 : pTPView->InsertWriterHeader();
171 0 : pTPView->SetAcceptClickHdl(LINK(this, SwRedlineAcceptDlg, AcceptHdl));
172 0 : pTPView->SetAcceptAllClickHdl(LINK(this, SwRedlineAcceptDlg, AcceptAllHdl));
173 0 : pTPView->SetRejectClickHdl(LINK(this, SwRedlineAcceptDlg, RejectHdl));
174 0 : pTPView->SetRejectAllClickHdl(LINK(this, SwRedlineAcceptDlg, RejectAllHdl));
175 0 : pTPView->SetUndoClickHdl(LINK(this, SwRedlineAcceptDlg, UndoHdl));
176 : //tdf#89227 default to disabled, and only enable if possible to accept/reject
177 0 : pTPView->EnableAccept(false);
178 0 : pTPView->EnableReject(false);
179 0 : pTPView->EnableAcceptAll(false);
180 0 : pTPView->EnableRejectAll(false);
181 :
182 0 : aTabPagesCTRL->GetFilterPage()->SetReadyHdl(LINK(this, SwRedlineAcceptDlg, FilterChangedHdl));
183 :
184 0 : ListBox *pActLB = aTabPagesCTRL->GetFilterPage()->GetLbAction();
185 0 : pActLB->InsertEntry(sInserted);
186 0 : pActLB->InsertEntry(sDeleted);
187 0 : pActLB->InsertEntry(sFormated);
188 0 : pActLB->InsertEntry(sTableChgd);
189 :
190 0 : if (HasRedlineAutoFormat())
191 : {
192 0 : pActLB->InsertEntry(sFormatCollSet);
193 0 : pActLB->InsertEntry(sAutoFormat);
194 0 : pTPView->ShowUndo(true);
195 0 : pTPView->DisableUndo(); // no UNDO events yet
196 : }
197 :
198 0 : pActLB->SelectEntryPos(0);
199 :
200 0 : pTable->SetStyle(pTable->GetStyle()|WB_HASLINES|WB_CLIPCHILDREN|WB_HASBUTTONS|WB_HASBUTTONSATROOT|WB_HSCROLL);
201 0 : pTable->SetNodeDefaultImages();
202 0 : pTable->SetSelectionMode(MULTIPLE_SELECTION);
203 0 : pTable->SetHighlightRange(1);
204 :
205 0 : pTable->SortByCol(nSortMode, bSortDir);
206 :
207 0 : aOldSelectHdl = pTable->GetSelectHdl();
208 0 : aOldDeselectHdl = pTable->GetDeselectHdl();
209 0 : pTable->SetSelectHdl(LINK(this, SwRedlineAcceptDlg, SelectHdl));
210 0 : pTable->SetDeselectHdl(LINK(this, SwRedlineAcceptDlg, DeselectHdl));
211 0 : pTable->SetCommandHdl(LINK(this, SwRedlineAcceptDlg, CommandHdl));
212 :
213 : // avoid flickering of buttons:
214 0 : aDeselectTimer.SetTimeout(100);
215 0 : aDeselectTimer.SetTimeoutHdl(LINK(this, SwRedlineAcceptDlg, SelectTimerHdl));
216 :
217 : // avoid multiple selection of the same texts:
218 0 : aSelectTimer.SetTimeout(100);
219 0 : aSelectTimer.SetTimeoutHdl(LINK(this, SwRedlineAcceptDlg, GotoHdl));
220 0 : }
221 :
222 0 : SwRedlineAcceptDlg::~SwRedlineAcceptDlg()
223 : {
224 0 : aTabPagesCTRL.disposeAndClear();
225 0 : }
226 :
227 0 : void SwRedlineAcceptDlg::Init(sal_uInt16 nStart)
228 : {
229 0 : SwWait aWait( *::GetActiveView()->GetDocShell(), false );
230 0 : pTable->SetUpdateMode(false);
231 0 : aUsedSeqNo.clear();
232 :
233 0 : if (nStart)
234 0 : RemoveParents(nStart, aRedlineParents.size() - 1);
235 : else
236 : {
237 0 : pTable->Clear();
238 0 : aRedlineChildren.clear();
239 0 : aRedlineParents.erase(aRedlineParents.begin() + nStart, aRedlineParents.end());
240 : }
241 :
242 : // insert parents
243 0 : InsertParents(nStart);
244 0 : InitAuthors();
245 :
246 0 : pTable->SetUpdateMode(true);
247 : // #i69618# this moves the list box to the right position, visually
248 0 : SvTreeListEntry* pSelEntry = pTable->FirstSelected();
249 0 : if( pSelEntry )
250 0 : pTable->MakeVisible( pSelEntry, true ); //#i70937#, force the scroll
251 0 : }
252 :
253 0 : void SwRedlineAcceptDlg::InitAuthors()
254 : {
255 0 : SwWrtShell* pSh = ::GetActiveView()->GetWrtShellPtr();
256 :
257 0 : if (!aTabPagesCTRL)
258 0 : return;
259 :
260 0 : SvxTPFilter *pFilterPage = aTabPagesCTRL->GetFilterPage();
261 :
262 0 : std::vector<OUString> aStrings;
263 0 : OUString sOldAuthor(pFilterPage->GetSelectedAuthor());
264 0 : pFilterPage->ClearAuthors();
265 :
266 0 : sal_uInt16 nCount = pSh->GetRedlineCount();
267 :
268 0 : bOnlyFormatedRedlines = true;
269 0 : bHasReadonlySel = false;
270 0 : bool bIsNotFormated = false;
271 : sal_uInt16 i;
272 :
273 : // determine authors
274 0 : for ( i = 0; i < nCount; i++)
275 : {
276 0 : const SwRangeRedline& rRedln = pSh->GetRedline(i);
277 :
278 0 : if( bOnlyFormatedRedlines && nsRedlineType_t::REDLINE_FORMAT != rRedln.GetType() )
279 0 : bOnlyFormatedRedlines = false;
280 :
281 0 : aStrings.push_back(rRedln.GetAuthorString());
282 :
283 0 : for (sal_uInt16 nStack = 1; nStack < rRedln.GetStackCount(); nStack++)
284 : {
285 0 : aStrings.push_back(rRedln.GetAuthorString(nStack));
286 : }
287 : }
288 :
289 0 : std::sort(aStrings.begin(), aStrings.end());
290 0 : aStrings.erase(std::unique(aStrings.begin(), aStrings.end()), aStrings.end());
291 :
292 0 : for (i = 0; i < aStrings.size(); i++)
293 0 : pFilterPage->InsertAuthor(aStrings[i]);
294 :
295 0 : if (pFilterPage->SelectAuthor(sOldAuthor) == LISTBOX_ENTRY_NOTFOUND && !aStrings.empty())
296 0 : pFilterPage->SelectAuthor(aStrings[0]);
297 :
298 0 : bool bEnable = pTable->GetEntryCount() != 0 && !pSh->getIDocumentRedlineAccess()->GetRedlinePassword().getLength();
299 0 : bool bSel = pTable->FirstSelected() != 0;
300 :
301 0 : SvTreeListEntry* pSelEntry = pTable->FirstSelected();
302 0 : while (pSelEntry)
303 : {
304 : // find the selected redline
305 : // (fdo#57874: ignore, if the redline is already gone)
306 0 : sal_uInt16 nPos = GetRedlinePos(*pSelEntry);
307 0 : if( nPos != USHRT_MAX )
308 : {
309 0 : const SwRangeRedline& rRedln = pSh->GetRedline( nPos );
310 :
311 0 : bIsNotFormated |= nsRedlineType_t::REDLINE_FORMAT != rRedln.GetType();
312 : }
313 0 : pSelEntry = pTable->NextSelected(pSelEntry);
314 : }
315 :
316 0 : pTPView->EnableAccept( bEnable && bSel );
317 0 : pTPView->EnableReject( bEnable && bIsNotFormated && bSel );
318 0 : pTPView->EnableAcceptAll( bEnable && !bHasReadonlySel );
319 0 : pTPView->EnableRejectAll( bEnable && !bHasReadonlySel &&
320 0 : !bOnlyFormatedRedlines );
321 : }
322 :
323 0 : OUString SwRedlineAcceptDlg::GetRedlineText(const SwRangeRedline& rRedln, DateTime &rDateTime, sal_uInt16 nStack)
324 : {
325 0 : OUString sEntry(rRedln.GetAuthorString(nStack));
326 0 : sEntry += "\t";
327 :
328 0 : const DateTime &rDT = rRedln.GetTimeStamp(nStack);
329 0 : rDateTime = rDT;
330 :
331 0 : sEntry += GetAppLangDateTimeString( rDT );
332 0 : sEntry += "\t";
333 :
334 0 : sEntry += rRedln.GetComment(nStack);
335 :
336 0 : return sEntry;
337 : }
338 :
339 0 : Image SwRedlineAcceptDlg::GetActionImage(const SwRangeRedline& rRedln, sal_uInt16 nStack)
340 : {
341 0 : const static Image aInserted(SW_RES(IMG_REDLINE_INSERTED));
342 0 : const static Image aDeleted(SW_RES(IMG_REDLINE_DELETED));
343 0 : const static Image aFormated(SW_RES(IMG_REDLINE_FORMATED));
344 0 : const static Image aTableChgd(SW_RES(IMG_REDLINE_TABLECHG));
345 0 : const static Image aFormatCollSet(SW_RES(IMG_REDLINE_FMTCOLLSET));
346 0 : const static Image aAutoFormat(SW_RES(IMG_REDLINE_AUTOFMT));
347 :
348 0 : switch (rRedln.GetType(nStack))
349 : {
350 0 : case nsRedlineType_t::REDLINE_INSERT: return aInserted;
351 0 : case nsRedlineType_t::REDLINE_DELETE: return aDeleted;
352 0 : case nsRedlineType_t::REDLINE_FORMAT: return aFormated;
353 0 : case nsRedlineType_t::REDLINE_PARAGRAPH_FORMAT: return aFormated;
354 0 : case nsRedlineType_t::REDLINE_TABLE: return aTableChgd;
355 0 : case nsRedlineType_t::REDLINE_FMTCOLL: return aFormatCollSet;
356 : }
357 :
358 0 : return Image();
359 : }
360 :
361 0 : OUString SwRedlineAcceptDlg::GetActionText(const SwRangeRedline& rRedln, sal_uInt16 nStack)
362 : {
363 0 : switch( rRedln.GetType(nStack) )
364 : {
365 0 : case nsRedlineType_t::REDLINE_INSERT: return sInserted;
366 0 : case nsRedlineType_t::REDLINE_DELETE: return sDeleted;
367 0 : case nsRedlineType_t::REDLINE_FORMAT: return sFormated;
368 0 : case nsRedlineType_t::REDLINE_PARAGRAPH_FORMAT: return sFormated;
369 0 : case nsRedlineType_t::REDLINE_TABLE: return sTableChgd;
370 0 : case nsRedlineType_t::REDLINE_FMTCOLL: return sFormatCollSet;
371 : default:;//prevent warning
372 : }
373 :
374 0 : return OUString();
375 : }
376 :
377 : // newly initialise after activation
378 0 : void SwRedlineAcceptDlg::Activate()
379 : {
380 : // prevent update if flag is set (#102547#)
381 0 : if( bInhibitActivate )
382 0 : return;
383 :
384 0 : SwView *pView = ::GetActiveView();
385 0 : if (!pView) // can happen when switching to another app
386 : {
387 0 : pTPView->EnableAccept(false);
388 0 : pTPView->EnableReject(false);
389 0 : pTPView->EnableAcceptAll(false);
390 0 : pTPView->EnableRejectAll(false);
391 0 : return; // had the focus previously
392 : }
393 :
394 0 : SwWait aWait( *pView->GetDocShell(), false );
395 :
396 0 : aUsedSeqNo.clear();
397 :
398 : // did something change?
399 0 : SwWrtShell* pSh = pView->GetWrtShellPtr();
400 0 : sal_uInt16 nCount = pSh->GetRedlineCount();
401 :
402 : // check the number of pointers
403 0 : SwRedlineDataParent *pParent = 0;
404 : sal_uInt16 i;
405 :
406 0 : for ( i = 0; i < nCount; i++)
407 : {
408 0 : const SwRangeRedline& rRedln = pSh->GetRedline(i);
409 :
410 0 : if (i >= aRedlineParents.size())
411 : {
412 : // new entries have been appended
413 0 : Init(i);
414 0 : return;
415 : }
416 :
417 0 : pParent = &aRedlineParents[i];
418 0 : if (&rRedln.GetRedlineData() != pParent->pData)
419 : {
420 : // Redline-Parents were inserted, changed or deleted
421 0 : if ((i = CalcDiff(i, false)) == USHRT_MAX)
422 0 : return;
423 0 : continue;
424 : }
425 :
426 0 : const SwRedlineData *pRedlineData = rRedln.GetRedlineData().Next();
427 0 : const SwRedlineDataChild *pBackupData = pParent->pNext;
428 :
429 0 : if (!pRedlineData && pBackupData)
430 : {
431 : // Redline-Children were deleted
432 0 : if ((i = CalcDiff(i, true)) == USHRT_MAX)
433 0 : return;
434 0 : continue;
435 : }
436 : else
437 : {
438 0 : while (pRedlineData)
439 : {
440 0 : if (pRedlineData != pBackupData->pChild)
441 : {
442 : // Redline-Children were inserted, changed or deleted
443 0 : if ((i = CalcDiff(i, true)) == USHRT_MAX)
444 0 : return;
445 0 : continue;
446 : }
447 0 : pBackupData = pBackupData->pNext;
448 0 : pRedlineData = pRedlineData->Next();
449 : }
450 : }
451 : }
452 :
453 0 : if (nCount != aRedlineParents.size())
454 : {
455 : // Redlines were deleted at the end
456 0 : Init(nCount);
457 0 : return;
458 : }
459 :
460 : // check comment
461 0 : for (i = 0; i < nCount; i++)
462 : {
463 0 : const SwRangeRedline& rRedln = pSh->GetRedline(i);
464 0 : pParent = &aRedlineParents[i];
465 :
466 0 : if(rRedln.GetComment() != pParent->sComment)
467 : {
468 0 : if (pParent->pTLBParent)
469 : {
470 : // update only comment
471 0 : OUString sComment(rRedln.GetComment());
472 0 : pTable->SetEntryText(sComment.replace('\n', ' '), pParent->pTLBParent, 3);
473 : }
474 0 : pParent->sComment = rRedln.GetComment();
475 : }
476 : }
477 :
478 0 : InitAuthors();
479 : }
480 :
481 0 : sal_uInt16 SwRedlineAcceptDlg::CalcDiff(sal_uInt16 nStart, bool bChild)
482 : {
483 0 : if (!nStart)
484 : {
485 0 : Init();
486 0 : return USHRT_MAX;
487 : }
488 :
489 0 : pTable->SetUpdateMode(false);
490 0 : SwView *pView = ::GetActiveView();
491 0 : SwWrtShell* pSh = pView->GetWrtShellPtr();
492 0 : sal_uInt16 nAutoFormat = HasRedlineAutoFormat() ? nsRedlineType_t::REDLINE_FORM_AUTOFMT : 0;
493 0 : SwRedlineDataParent *pParent = &aRedlineParents[nStart];
494 0 : const SwRangeRedline& rRedln = pSh->GetRedline(nStart);
495 :
496 0 : if (bChild) // should actually never happen, but just in case...
497 : {
498 : // throw away all entry's children and initialise newly
499 0 : SwRedlineDataChild* pBackupData = const_cast<SwRedlineDataChild*>(pParent->pNext);
500 : SwRedlineDataChild* pNext;
501 :
502 0 : while (pBackupData)
503 : {
504 0 : pNext = const_cast<SwRedlineDataChild*>(pBackupData->pNext);
505 0 : if (pBackupData->pTLBChild)
506 0 : pTable->RemoveEntry(pBackupData->pTLBChild);
507 :
508 0 : for( SwRedlineDataChildArr::iterator it = aRedlineChildren.begin();
509 0 : it != aRedlineChildren.end(); ++it)
510 0 : if (&*it == pBackupData)
511 : {
512 0 : aRedlineChildren.erase(it);
513 0 : break;
514 : }
515 0 : pBackupData = pNext;
516 : }
517 0 : pParent->pNext = 0;
518 :
519 : // insert new children
520 0 : InsertChildren(pParent, rRedln, nAutoFormat);
521 :
522 0 : pTable->SetUpdateMode(true);
523 0 : return nStart;
524 : }
525 :
526 : // have entries been deleted?
527 0 : const SwRedlineData *pRedlineData = &rRedln.GetRedlineData();
528 : sal_uInt16 i;
529 0 : for ( i = nStart + 1; i < aRedlineParents.size(); i++)
530 : {
531 0 : if (aRedlineParents[i].pData == pRedlineData)
532 : {
533 : // remove entries from nStart to i-1
534 0 : RemoveParents(nStart, i - 1);
535 0 : pTable->SetUpdateMode(true);
536 0 : return nStart - 1;
537 : }
538 : }
539 :
540 : // entries been inserted?
541 0 : sal_uInt16 nCount = pSh->GetRedlineCount();
542 0 : pRedlineData = aRedlineParents[nStart].pData;
543 :
544 0 : for (i = nStart + 1; i < nCount; i++)
545 : {
546 0 : if (&pSh->GetRedline(i).GetRedlineData() == pRedlineData)
547 : {
548 : // insert entries from nStart to i-1
549 0 : InsertParents(nStart, i - 1);
550 0 : pTable->SetUpdateMode(true);
551 0 : return nStart - 1;
552 : }
553 : }
554 :
555 0 : pTable->SetUpdateMode(true);
556 0 : Init(nStart); // adjust all entries until the end
557 0 : return USHRT_MAX;
558 : }
559 :
560 0 : void SwRedlineAcceptDlg::InsertChildren(SwRedlineDataParent *pParent, const SwRangeRedline& rRedln, const sal_uInt16 nAutoFormat)
561 : {
562 0 : OUString sChild;
563 0 : SwRedlineDataChild *pLastRedlineChild = 0;
564 0 : const SwRedlineData *pRedlineData = &rRedln.GetRedlineData();
565 0 : bool bAutoFormat = (rRedln.GetRealType() & nAutoFormat) != 0;
566 :
567 0 : OUString sAction = GetActionText(rRedln);
568 0 : bool bValidParent = sFilterAction.isEmpty() || sFilterAction == sAction;
569 0 : bValidParent = bValidParent && pTable->IsValidEntry(rRedln.GetAuthorString(), rRedln.GetTimeStamp(), rRedln.GetComment());
570 0 : if (nAutoFormat)
571 : {
572 :
573 0 : if (pParent->pData->GetSeqNo())
574 : {
575 : std::pair<SwRedlineDataParentSortArr::const_iterator,bool> const ret
576 0 : = aUsedSeqNo.insert(pParent);
577 0 : if (ret.second) // already there
578 : {
579 0 : if (pParent->pTLBParent)
580 : {
581 0 : pTable->SetEntryText(
582 0 : sAutoFormat, (*ret.first)->pTLBParent, 0);
583 0 : pTable->RemoveEntry(pParent->pTLBParent);
584 0 : pParent->pTLBParent = 0;
585 : }
586 0 : return;
587 : }
588 : }
589 0 : bValidParent = bValidParent && bAutoFormat;
590 : }
591 0 : bool bValidTree = bValidParent;
592 :
593 0 : for (sal_uInt16 nStack = 1; nStack < rRedln.GetStackCount(); nStack++)
594 : {
595 0 : pRedlineData = pRedlineData->Next();
596 :
597 0 : SwRedlineDataChildPtr pRedlineChild = new SwRedlineDataChild;
598 0 : pRedlineChild->pChild = pRedlineData;
599 0 : aRedlineChildren.push_back(pRedlineChild);
600 :
601 0 : if ( pLastRedlineChild )
602 0 : pLastRedlineChild->pNext = pRedlineChild;
603 : else
604 0 : pParent->pNext = pRedlineChild;
605 :
606 0 : sAction = GetActionText(rRedln, nStack);
607 0 : bool bValidChild = sFilterAction.isEmpty() || sFilterAction == sAction;
608 0 : bValidChild = bValidChild && pTable->IsValidEntry(rRedln.GetAuthorString(nStack), rRedln.GetTimeStamp(nStack), rRedln.GetComment());
609 0 : if (nAutoFormat)
610 0 : bValidChild = bValidChild && bAutoFormat;
611 0 : bValidTree |= bValidChild;
612 :
613 0 : if (bValidChild)
614 : {
615 0 : RedlinData *pData = new RedlinData;
616 0 : pData->pData = pRedlineChild;
617 0 : pData->bDisabled = true;
618 0 : sChild = GetRedlineText(rRedln, pData->aDateTime, nStack);
619 :
620 : SvTreeListEntry* pChild = pTable->InsertEntry(GetActionImage(rRedln, nStack),
621 0 : sChild, pData, pParent->pTLBParent);
622 :
623 0 : pRedlineChild->pTLBChild = pChild;
624 0 : if (!bValidParent)
625 0 : pTable->Expand(pParent->pTLBParent);
626 : }
627 : else
628 0 : pRedlineChild->pTLBChild = 0;
629 :
630 0 : pLastRedlineChild = pRedlineChild;
631 : }
632 :
633 0 : if (pLastRedlineChild)
634 0 : pLastRedlineChild->pNext = 0;
635 :
636 0 : if (!bValidTree && pParent->pTLBParent)
637 : {
638 0 : pTable->RemoveEntry(pParent->pTLBParent);
639 0 : pParent->pTLBParent = 0;
640 0 : if (nAutoFormat)
641 0 : aUsedSeqNo.erase(pParent);
642 0 : }
643 : }
644 :
645 0 : void SwRedlineAcceptDlg::RemoveParents(sal_uInt16 nStart, sal_uInt16 nEnd)
646 : {
647 0 : SwWrtShell* pSh = ::GetActiveView()->GetWrtShellPtr();
648 0 : sal_uInt16 nCount = pSh->GetRedlineCount();
649 :
650 0 : SvLBoxEntryArr aLBoxArr;
651 :
652 : // because of Bug of TLB that ALWAYS calls the SelectHandler at Remove:
653 0 : pTable->SetSelectHdl(aOldSelectHdl);
654 0 : pTable->SetDeselectHdl(aOldDeselectHdl);
655 0 : bool bChildrenRemoved = false;
656 0 : pTable->SelectAll(false);
657 :
658 : // set the cursor after the last entry because otherwise performance problem in TLB.
659 : // TLB would otherwise reset the cursor at every Remove (expensive)
660 0 : sal_uInt16 nPos = std::min((sal_uInt16)nCount, (sal_uInt16)aRedlineParents.size());
661 0 : SvTreeListEntry *pCurEntry = NULL;
662 0 : while( ( pCurEntry == NULL ) && ( nPos > 0 ) )
663 : {
664 0 : --nPos;
665 0 : pCurEntry = aRedlineParents[nPos].pTLBParent;
666 : }
667 :
668 0 : if (pCurEntry)
669 0 : pTable->SetCurEntry(pCurEntry);
670 :
671 0 : SvTreeList* pModel = pTable->GetModel();
672 :
673 0 : for (sal_uInt16 i = nStart; i <= nEnd; i++)
674 : {
675 0 : if (!bChildrenRemoved && aRedlineParents[i].pNext)
676 : {
677 0 : SwRedlineDataChildPtr pChildPtr = const_cast<SwRedlineDataChildPtr>(aRedlineParents[i].pNext);
678 0 : for( SwRedlineDataChildArr::iterator it = aRedlineChildren.begin();
679 0 : it != aRedlineChildren.end(); ++it)
680 0 : if (&*it == pChildPtr)
681 : {
682 0 : sal_uInt16 nChildren = 0;
683 0 : while (pChildPtr)
684 : {
685 0 : pChildPtr = const_cast<SwRedlineDataChildPtr>(pChildPtr->pNext);
686 0 : nChildren++;
687 : }
688 :
689 0 : aRedlineChildren.erase(it, it + nChildren);
690 0 : bChildrenRemoved = true;
691 0 : break;
692 : }
693 : }
694 0 : SvTreeListEntry *pEntry = aRedlineParents[i].pTLBParent;
695 0 : if (pEntry)
696 : {
697 0 : long nIdx = aLBoxArr.size() - 1L;
698 0 : sal_uLong nAbsPos = pModel->GetAbsPos(pEntry);
699 0 : while (nIdx >= 0 &&
700 0 : pModel->GetAbsPos(aLBoxArr[ static_cast< sal_uInt16 >(nIdx) ]) > nAbsPos)
701 0 : nIdx--;
702 0 : aLBoxArr.insert( aLBoxArr.begin() + static_cast< sal_uInt16 >(++nIdx) , pEntry);
703 : }
704 : }
705 :
706 : // clear TLB from behind
707 0 : long nIdx = (long)aLBoxArr.size() - 1L;
708 0 : while (nIdx >= 0)
709 0 : pTable->RemoveEntry(aLBoxArr[ static_cast< sal_uInt16 >(nIdx--) ]);
710 :
711 0 : pTable->SetSelectHdl(LINK(this, SwRedlineAcceptDlg, SelectHdl));
712 0 : pTable->SetDeselectHdl(LINK(this, SwRedlineAcceptDlg, DeselectHdl));
713 : // unfortunately by Remove it was selected from the TLB always again ...
714 0 : pTable->SelectAll(false);
715 :
716 0 : aRedlineParents.erase( aRedlineParents.begin() + nStart, aRedlineParents.begin() + nEnd + 1);
717 0 : }
718 :
719 0 : void SwRedlineAcceptDlg::InsertParents(sal_uInt16 nStart, sal_uInt16 nEnd)
720 : {
721 0 : SwView *pView = ::GetActiveView();
722 0 : SwWrtShell* pSh = pView->GetWrtShellPtr();
723 0 : sal_uInt16 nAutoFormat = HasRedlineAutoFormat() ? nsRedlineType_t::REDLINE_FORM_AUTOFMT : 0;
724 :
725 0 : OUString sParent;
726 0 : sal_uInt16 nCount = pSh->GetRedlineCount();
727 0 : nEnd = std::min((sal_uInt16)nEnd, (sal_uInt16)(nCount - 1)); // also treats nEnd=USHRT_MAX (until the end)
728 :
729 0 : if (nEnd == USHRT_MAX)
730 0 : return; // no redlines in the document
731 :
732 : SvTreeListEntry *pParent;
733 : SwRedlineDataParent* pRedlineParent;
734 : const SwRangeRedline* pCurrRedline;
735 0 : if( !nStart && !pTable->FirstSelected() )
736 : {
737 0 : pCurrRedline = pSh->GetCurrRedline();
738 0 : if( !pCurrRedline )
739 : {
740 0 : pSh->SwCrsrShell::Push();
741 0 : if( 0 == (pCurrRedline = pSh->SelNextRedline()))
742 0 : pCurrRedline = pSh->SelPrevRedline();
743 0 : pSh->SwCrsrShell::Pop( false );
744 : }
745 : }
746 : else
747 0 : pCurrRedline = 0;
748 :
749 0 : for (sal_uInt16 i = nStart; i <= nEnd; i++)
750 : {
751 0 : const SwRangeRedline& rRedln = pSh->GetRedline(i);
752 0 : const SwRedlineData *pRedlineData = &rRedln.GetRedlineData();
753 :
754 0 : pRedlineParent = new SwRedlineDataParent;
755 0 : pRedlineParent->pData = pRedlineData;
756 0 : pRedlineParent->pNext = 0;
757 0 : OUString sComment(rRedln.GetComment());
758 0 : pRedlineParent->sComment = sComment.replace('\n', ' ');
759 0 : aRedlineParents.insert(aRedlineParents.begin() + i, pRedlineParent);
760 :
761 0 : RedlinData *pData = new RedlinData;
762 0 : pData->pData = pRedlineParent;
763 0 : pData->bDisabled = false;
764 :
765 0 : sParent = GetRedlineText(rRedln, pData->aDateTime);
766 0 : pParent = pTable->InsertEntry(GetActionImage(rRedln), sParent, pData, 0, i);
767 0 : if( pCurrRedline == &rRedln )
768 : {
769 0 : pTable->SetCurEntry( pParent );
770 0 : pTable->Select( pParent );
771 0 : pTable->MakeVisible( pParent );
772 : }
773 :
774 0 : pRedlineParent->pTLBParent = pParent;
775 :
776 0 : InsertChildren(pRedlineParent, rRedln, nAutoFormat);
777 0 : }
778 : }
779 :
780 0 : void SwRedlineAcceptDlg::CallAcceptReject( bool bSelect, bool bAccept )
781 : {
782 0 : SwWrtShell* pSh = ::GetActiveView()->GetWrtShellPtr();
783 0 : SvTreeListEntry* pEntry = bSelect ? pTable->FirstSelected() : pTable->First();
784 0 : sal_uLong nPos = LONG_MAX;
785 :
786 : typedef std::vector<SvTreeListEntry*> ListBoxEntries_t;
787 0 : ListBoxEntries_t aRedlines;
788 :
789 : // don't activate
790 : OSL_ENSURE( !bInhibitActivate,
791 : "recursive call of CallAcceptReject?");
792 0 : bInhibitActivate = true;
793 :
794 : // collect redlines-to-be-accepted/rejected in aRedlines vector
795 0 : while( pEntry )
796 : {
797 0 : if( !pTable->GetParent( pEntry ) )
798 : {
799 0 : if( bSelect && LONG_MAX == nPos )
800 0 : nPos = pTable->GetModel()->GetAbsPos( pEntry );
801 :
802 0 : RedlinData *pData = static_cast<RedlinData *>(pEntry->GetUserData());
803 :
804 0 : if( !pData->bDisabled )
805 0 : aRedlines.push_back( pEntry );
806 : }
807 :
808 0 : pEntry = bSelect ? pTable->NextSelected(pEntry) : pTable->Next(pEntry);
809 : }
810 :
811 0 : bool (SwEditShell:: *FnAccRej)( sal_uInt16 ) = &SwEditShell::AcceptRedline;
812 0 : if( !bAccept )
813 0 : FnAccRej = &SwEditShell::RejectRedline;
814 :
815 0 : SwWait aWait( *pSh->GetView().GetDocShell(), true );
816 0 : pSh->StartAction();
817 :
818 : // #111827#
819 0 : if (aRedlines.size() > 1)
820 : {
821 0 : OUString aTmpStr;
822 : {
823 0 : SwRewriter aRewriter;
824 : aRewriter.AddRule(UndoArg1,
825 0 : OUString::number(aRedlines.size()));
826 0 : aTmpStr = aRewriter.Apply(OUString(SW_RES(STR_N_REDLINES)));
827 : }
828 :
829 0 : SwRewriter aRewriter;
830 0 : aRewriter.AddRule(UndoArg1, aTmpStr);
831 :
832 : pSh->StartUndo(bAccept? UNDO_ACCEPT_REDLINE : UNDO_REJECT_REDLINE,
833 0 : &aRewriter);
834 : }
835 :
836 : // accept/reject the redlines in aRedlines. The absolute
837 : // position may change during the process (e.g. when two redlines
838 : // are merged in result of another one being deleted), so the
839 : // position must be resolved late and checked before using it.
840 : // (cf #102547#)
841 0 : ListBoxEntries_t::iterator aEnd = aRedlines.end();
842 0 : for( ListBoxEntries_t::iterator aIter = aRedlines.begin();
843 : aIter != aEnd;
844 : ++aIter )
845 : {
846 0 : sal_uInt16 nPosition = GetRedlinePos( **aIter );
847 0 : if( nPosition != USHRT_MAX )
848 0 : (pSh->*FnAccRej)( nPosition );
849 : }
850 :
851 : // #111827#
852 0 : if (aRedlines.size() > 1)
853 : {
854 0 : pSh->EndUndo();
855 : }
856 :
857 0 : pSh->EndAction();
858 :
859 0 : bInhibitActivate = false;
860 0 : Activate();
861 :
862 0 : if( ULONG_MAX != nPos && pTable->GetEntryCount() )
863 : {
864 0 : if( nPos >= pTable->GetEntryCount() )
865 0 : nPos = pTable->GetEntryCount() - 1;
866 0 : pEntry = pTable->GetEntryAtAbsPos( nPos );
867 0 : if( !pEntry && nPos-- )
868 0 : pEntry = pTable->GetEntryAtAbsPos( nPos );
869 0 : if( pEntry )
870 : {
871 0 : pTable->Select( pEntry );
872 0 : pTable->MakeVisible( pEntry );
873 0 : pTable->SetCurEntry(pEntry);
874 : }
875 : }
876 0 : pTPView->EnableUndo();
877 0 : }
878 :
879 0 : sal_uInt16 SwRedlineAcceptDlg::GetRedlinePos( const SvTreeListEntry& rEntry ) const
880 : {
881 0 : SwWrtShell* pSh = ::GetActiveView()->GetWrtShellPtr();
882 : return pSh->FindRedlineOfData( *static_cast<SwRedlineDataParent*>(static_cast<RedlinData *>(
883 0 : rEntry.GetUserData())->pData)->pData );
884 : }
885 :
886 0 : IMPL_LINK_NOARG(SwRedlineAcceptDlg, AcceptHdl)
887 : {
888 0 : CallAcceptReject( true, true );
889 0 : return 0;
890 : }
891 :
892 0 : IMPL_LINK_NOARG(SwRedlineAcceptDlg, AcceptAllHdl)
893 : {
894 0 : CallAcceptReject( false, true );
895 0 : return 0;
896 : }
897 :
898 0 : IMPL_LINK_NOARG(SwRedlineAcceptDlg, RejectHdl)
899 : {
900 0 : CallAcceptReject( true, false );
901 0 : return 0;
902 : }
903 :
904 0 : IMPL_LINK_NOARG(SwRedlineAcceptDlg, RejectAllHdl)
905 : {
906 0 : CallAcceptReject( false, false );
907 0 : return 0;
908 : }
909 :
910 0 : IMPL_LINK_NOARG(SwRedlineAcceptDlg, UndoHdl)
911 : {
912 0 : SwView * pView = ::GetActiveView();
913 : pView->GetViewFrame()->GetDispatcher()->
914 0 : Execute(SID_UNDO, SfxCallMode::SYNCHRON);
915 0 : pTPView->EnableUndo(pView->GetSlotState(SID_UNDO) != 0);
916 :
917 0 : Activate();
918 :
919 0 : return 0;
920 : }
921 :
922 0 : IMPL_LINK_NOARG(SwRedlineAcceptDlg, FilterChangedHdl)
923 : {
924 0 : SvxTPFilter *pFilterTP = aTabPagesCTRL->GetFilterPage();
925 :
926 0 : if (pFilterTP->IsAction())
927 0 : sFilterAction = pFilterTP->GetLbAction()->GetSelectEntry();
928 : else
929 0 : sFilterAction = aEmptyOUStr;
930 :
931 0 : Init();
932 :
933 0 : return 0;
934 : }
935 :
936 0 : IMPL_LINK_NOARG(SwRedlineAcceptDlg, DeselectHdl)
937 : {
938 : // avoid flickering of buttons:
939 0 : aDeselectTimer.Start();
940 :
941 0 : return 0;
942 : }
943 :
944 0 : IMPL_LINK_NOARG(SwRedlineAcceptDlg, SelectHdl)
945 : {
946 0 : SelectTimerHdl(nullptr);
947 0 : return 0;
948 : }
949 :
950 0 : IMPL_LINK_NOARG_TYPED(SwRedlineAcceptDlg, SelectTimerHdl, Timer *, void)
951 : {
952 0 : aDeselectTimer.Stop();
953 0 : aSelectTimer.Start();
954 0 : }
955 :
956 0 : IMPL_LINK_NOARG_TYPED(SwRedlineAcceptDlg, GotoHdl, Timer *, void)
957 : {
958 0 : SwWrtShell* pSh = ::GetActiveView()->GetWrtShellPtr();
959 0 : aSelectTimer.Stop();
960 :
961 0 : bool bIsNotFormated = false;
962 0 : bool bSel = false;
963 :
964 : //#98883# don't select redlines while the dialog is not focussed
965 : //#107938# But not only ask pTable if it has the focus. To move
966 : // the selection to the selected redline any child of pParentDlg
967 : // may the focus.
968 0 : SvTreeListEntry* pSelEntry = 0;
969 :
970 0 : if (pParentDlg->HasChildPathFocus())
971 0 : pSelEntry = pTable->FirstSelected();
972 :
973 0 : if( pSelEntry )
974 : {
975 0 : SvTreeListEntry* pActEntry = pSelEntry;
976 0 : pSh->StartAction();
977 0 : pSh->EnterStdMode();
978 0 : SwViewShell::SetCareWin(pParentDlg);
979 :
980 0 : while (pSelEntry)
981 : {
982 0 : if (pTable->GetParent(pSelEntry))
983 : {
984 0 : pActEntry = pTable->GetParent(pSelEntry);
985 :
986 0 : if (pTable->IsSelected(pActEntry))
987 : {
988 0 : pSelEntry = pActEntry = pTable->NextSelected(pSelEntry);
989 0 : continue; // don't select twice
990 : }
991 : }
992 : else
993 0 : bSel = true;
994 :
995 : // #98864# find the selected redline (ignore, if the redline is already gone)
996 0 : sal_uInt16 nPos = GetRedlinePos(*pActEntry);
997 0 : if( nPos != USHRT_MAX )
998 : {
999 :
1000 0 : const SwRangeRedline& rRedln = pSh->GetRedline( nPos );
1001 0 : bIsNotFormated |= nsRedlineType_t::REDLINE_FORMAT != rRedln.GetType();
1002 :
1003 0 : if (pSh->GotoRedline(nPos, true))
1004 : {
1005 0 : pSh->SetInSelect();
1006 0 : pSh->EnterAddMode();
1007 : }
1008 : }
1009 :
1010 0 : pSelEntry = pActEntry = pTable->NextSelected(pSelEntry);
1011 : }
1012 :
1013 0 : pSh->LeaveAddMode();
1014 0 : pSh->EndAction();
1015 0 : SwViewShell::SetCareWin(NULL);
1016 : }
1017 0 : bool bEnable = !pSh->getIDocumentRedlineAccess()->GetRedlinePassword().getLength();
1018 0 : pTPView->EnableAccept( bEnable && bSel /*&& !bReadonlySel*/ );
1019 0 : pTPView->EnableReject( bEnable && bSel && bIsNotFormated /*&& !bReadonlySel*/ );
1020 0 : pTPView->EnableRejectAll( bEnable && !bOnlyFormatedRedlines && !bHasReadonlySel );
1021 0 : }
1022 :
1023 0 : IMPL_LINK_NOARG(SwRedlineAcceptDlg, CommandHdl)
1024 : {
1025 0 : const CommandEvent aCEvt(pTable->GetCommandEvent());
1026 :
1027 0 : switch ( aCEvt.GetCommand() )
1028 : {
1029 : case CommandEventId::ContextMenu:
1030 : {
1031 0 : SwWrtShell* pSh = ::GetActiveView()->GetWrtShellPtr();
1032 0 : SvTreeListEntry* pEntry = pTable->FirstSelected();
1033 0 : const SwRangeRedline *pRed = 0;
1034 :
1035 0 : if (pEntry)
1036 : {
1037 0 : SvTreeListEntry* pTopEntry = pEntry;
1038 :
1039 0 : if (pTable->GetParent(pEntry))
1040 0 : pTopEntry = pTable->GetParent(pEntry);
1041 :
1042 0 : sal_uInt16 nPos = GetRedlinePos(*pTopEntry);
1043 :
1044 : // disable commenting for protected areas
1045 0 : if (nPos != USHRT_MAX && (pRed = pSh->GotoRedline(nPos, true)) != 0)
1046 : {
1047 0 : if( pSh->IsCrsrPtAtEnd() )
1048 0 : pSh->SwapPam();
1049 0 : pSh->SetInSelect();
1050 : }
1051 : }
1052 :
1053 0 : aPopup.EnableItem( MN_EDIT_COMMENT, pEntry && pRed &&
1054 0 : !pTable->GetParent(pEntry) &&
1055 0 : !pTable->NextSelected(pEntry)
1056 : //JP 27.9.2001: make no sense if we handle readonly sections
1057 : // && pRed->HasReadonlySel()
1058 0 : );
1059 :
1060 0 : aPopup.EnableItem( MN_SUB_SORT, pTable->First() != 0 );
1061 0 : sal_uInt16 nColumn = pTable->GetSortedCol();
1062 0 : if (nColumn == 0xffff)
1063 0 : nColumn = 4;
1064 :
1065 0 : PopupMenu *pSubMenu = aPopup.GetPopupMenu(MN_SUB_SORT);
1066 0 : if (pSubMenu)
1067 : {
1068 0 : for (sal_uInt16 i = MN_SORT_ACTION; i < MN_SORT_ACTION + 5; i++)
1069 0 : pSubMenu->CheckItem(i, false);
1070 :
1071 0 : pSubMenu->CheckItem(nColumn + MN_SORT_ACTION);
1072 : }
1073 :
1074 0 : sal_uInt16 nRet = aPopup.Execute(pTable, aCEvt.GetMousePosPixel());
1075 :
1076 0 : switch( nRet )
1077 : {
1078 : case MN_EDIT_COMMENT:
1079 : {
1080 0 : if (pEntry)
1081 : {
1082 0 : if (pTable->GetParent(pEntry))
1083 0 : pEntry = pTable->GetParent(pEntry);
1084 :
1085 0 : sal_uInt16 nPos = GetRedlinePos(*pEntry);
1086 :
1087 0 : if (nPos == USHRT_MAX)
1088 0 : break;
1089 :
1090 0 : const SwRangeRedline &rRedline = pSh->GetRedline(nPos);
1091 :
1092 : /* enable again once we have redline comments in the margin
1093 : sComment = rRedline.GetComment();
1094 : if ( !sComment.Len() )
1095 : GetActiveView()->GetDocShell()->Broadcast(SwRedlineHint(&rRedline,SWREDLINE_INSERTED));
1096 : const_cast<SwRangeRedline&>(rRedline).Broadcast(SwRedlineHint(&rRedline,SWREDLINE_FOCUS));
1097 : */
1098 :
1099 0 : OUString sComment = convertLineEnd(rRedline.GetComment(), GetSystemLineEnd());
1100 0 : SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
1101 : OSL_ENSURE(pFact, "Dialog creation failed!");
1102 0 : ::DialogGetRanges fnGetRange = pFact->GetDialogGetRangesFunc();
1103 : OSL_ENSURE(fnGetRange, "Dialog creation failed! GetRanges()");
1104 0 : SfxItemSet aSet( pSh->GetAttrPool(), fnGetRange() );
1105 :
1106 0 : aSet.Put(SvxPostItTextItem(sComment, SID_ATTR_POSTIT_TEXT));
1107 0 : aSet.Put(SvxPostItAuthorItem(rRedline.GetAuthorString(), SID_ATTR_POSTIT_AUTHOR));
1108 :
1109 : aSet.Put(SvxPostItDateItem( GetAppLangDateTimeString(
1110 0 : rRedline.GetRedlineData().GetTimeStamp() ),
1111 0 : SID_ATTR_POSTIT_DATE ));
1112 :
1113 0 : boost::scoped_ptr<AbstractSvxPostItDialog> pDlg(pFact->CreateSvxPostItDialog( pParentDlg, aSet, false ));
1114 : OSL_ENSURE(pDlg, "Dialog creation failed!");
1115 :
1116 0 : pDlg->HideAuthor();
1117 :
1118 0 : sal_uInt16 nResId = 0;
1119 0 : switch( rRedline.GetType() )
1120 : {
1121 : case nsRedlineType_t::REDLINE_INSERT:
1122 0 : nResId = STR_REDLINE_INSERTED;
1123 0 : break;
1124 : case nsRedlineType_t::REDLINE_DELETE:
1125 0 : nResId = STR_REDLINE_DELETED;
1126 0 : break;
1127 : case nsRedlineType_t::REDLINE_FORMAT:
1128 : case nsRedlineType_t::REDLINE_PARAGRAPH_FORMAT:
1129 0 : nResId = STR_REDLINE_FORMATED;
1130 0 : break;
1131 : case nsRedlineType_t::REDLINE_TABLE:
1132 0 : nResId = STR_REDLINE_TABLECHG;
1133 0 : break;
1134 : default:;//prevent warning
1135 : }
1136 0 : OUString sTitle(SW_RES(STR_REDLINE_COMMENT));
1137 0 : if( nResId )
1138 0 : sTitle += SW_RESSTR( nResId );
1139 0 : pDlg->SetText(sTitle);
1140 :
1141 0 : SwViewShell::SetCareWin(pDlg->GetWindow());
1142 :
1143 0 : if ( pDlg->Execute() == RET_OK )
1144 : {
1145 0 : const SfxItemSet* pOutSet = pDlg->GetOutputItemSet();
1146 0 : OUString sMsg(static_cast<const SvxPostItTextItem&>(pOutSet->Get(SID_ATTR_POSTIT_TEXT)).GetValue());
1147 :
1148 : // insert / change comment
1149 0 : pSh->SetRedlineComment(sMsg);
1150 0 : pTable->SetEntryText(sMsg.replace('\n', ' '), pEntry, 3);
1151 : }
1152 :
1153 0 : pDlg.reset();
1154 0 : SwViewShell::SetCareWin(NULL);
1155 : }
1156 :
1157 : }
1158 0 : break;
1159 :
1160 : case MN_SORT_ACTION:
1161 : case MN_SORT_AUTHOR:
1162 : case MN_SORT_DATE:
1163 : case MN_SORT_COMMENT:
1164 : case MN_SORT_POSITION:
1165 : {
1166 0 : bSortDir = true;
1167 0 : if (nRet - MN_SORT_ACTION == 4 && pTable->GetSortedCol() == 0xffff)
1168 0 : break; // we already have it
1169 :
1170 0 : nSortMode = nRet - MN_SORT_ACTION;
1171 0 : if (nSortMode == 4)
1172 0 : nSortMode = 0xffff; // unsorted / sorted by position
1173 :
1174 0 : if (pTable->GetSortedCol() == nSortMode)
1175 0 : bSortDir = !pTable->GetSortDirection();
1176 :
1177 0 : SwWait aWait( *::GetActiveView()->GetDocShell(), false );
1178 0 : pTable->SortByCol(nSortMode, bSortDir);
1179 0 : if (nSortMode == 0xffff)
1180 0 : Init(); // newly fill everything
1181 : }
1182 0 : break;
1183 : }
1184 : }
1185 0 : break;
1186 0 : default: break;
1187 : }
1188 :
1189 0 : return 0;
1190 : }
1191 :
1192 0 : void SwRedlineAcceptDlg::Initialize(const OUString& rExtraData)
1193 : {
1194 0 : if (!rExtraData.isEmpty())
1195 : {
1196 0 : sal_Int32 nPos = rExtraData.indexOf("AcceptChgDat:");
1197 :
1198 : // try to read the alignment string "ALIGN:(...)"; if none existing,
1199 : // it's an old version
1200 0 : if (nPos != -1)
1201 : {
1202 0 : sal_Int32 n1 = rExtraData.indexOf('(', nPos);
1203 0 : if (n1 != -1)
1204 : {
1205 0 : sal_Int32 n2 = rExtraData.indexOf(')', n1);
1206 0 : if (n2 != -1)
1207 : {
1208 : // cut out the alignment string
1209 0 : OUString aStr = rExtraData.copy(nPos, n2 - nPos + 1);
1210 0 : aStr = aStr.copy(n1 - nPos + 1);
1211 :
1212 0 : if (!aStr.isEmpty())
1213 : {
1214 0 : sal_uInt16 nCount = static_cast< sal_uInt16 >(aStr.toInt32());
1215 :
1216 0 : for (sal_uInt16 i = 0; i < nCount; i++)
1217 : {
1218 0 : sal_Int32 n3 = aStr.indexOf(';');
1219 0 : aStr = aStr.copy(n3 + 1);
1220 0 : pTable->SetTab(i, aStr.toInt32(), MAP_PIXEL);
1221 : }
1222 0 : }
1223 : }
1224 : }
1225 : }
1226 : }
1227 0 : }
1228 :
1229 0 : void SwRedlineAcceptDlg::FillInfo(OUString &rExtraData) const
1230 : {
1231 0 : rExtraData += "AcceptChgDat:(";
1232 :
1233 0 : sal_uInt16 nCount = pTable->TabCount();
1234 :
1235 0 : rExtraData += OUString::number(nCount);
1236 0 : rExtraData += ";";
1237 0 : for(sal_uInt16 i = 0; i < nCount; i++)
1238 : {
1239 0 : rExtraData += OUString::number( pTable->GetTab(i) );
1240 0 : rExtraData += ";";
1241 : }
1242 0 : rExtraData += ")";
1243 0 : }
1244 :
1245 0 : SwRedlineAcceptPanel::SwRedlineAcceptPanel(vcl::Window* pParent, const css::uno::Reference<css::frame::XFrame>& rFrame)
1246 0 : : PanelLayout(pParent, "ManageChangesPanel", "modules/swriter/ui/managechangessidebar.ui", rFrame)
1247 : {
1248 0 : mpImplDlg = new SwRedlineAcceptDlg(this, this, get<VclGrid>("content_area"));
1249 :
1250 0 : mpImplDlg->Init();
1251 :
1252 : // we want to receive SFX_HINT_DOCCHANGED
1253 0 : StartListening(*(SW_MOD()->GetView()->GetDocShell()));
1254 0 : }
1255 :
1256 0 : SwRedlineAcceptPanel::~SwRedlineAcceptPanel()
1257 : {
1258 0 : disposeOnce();
1259 0 : }
1260 :
1261 0 : void SwRedlineAcceptPanel::dispose()
1262 : {
1263 0 : delete mpImplDlg;
1264 0 : mpImplDlg = NULL;
1265 0 : PanelLayout::dispose();
1266 0 : }
1267 :
1268 0 : void SwRedlineAcceptPanel::Notify(SfxBroadcaster& /*rBC*/, const SfxHint& rHint)
1269 : {
1270 0 : const SfxSimpleHint *pHint = dynamic_cast<const SfxSimpleHint*>(&rHint);
1271 0 : if (mpImplDlg && pHint && pHint->GetId() == SFX_HINT_DOCCHANGED)
1272 0 : mpImplDlg->Activate();
1273 177 : }
1274 :
1275 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
