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