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