xref: /aoo42x/main/sw/source/ui/misc/redlndlg.cxx (revision efeef26f) 
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_sw.hxx"
26 
27 
28 #define _SVSTDARR_STRINGSSORTDTOR
29 #define _SVSTDARR_USHORTSSORT
30 #define _SVSTDARR_USHORTS
31 
32 
33 #include <redline.hxx>
34 #include <tools/datetime.hxx>
35 #include <vcl/msgbox.hxx>
36 #include <svl/svstdarr.hxx>
37 #include <svl/eitem.hxx>
38 #include <sfx2/viewfrm.hxx>
39 #include <sfx2/dispatch.hxx>
40 #include <svx/ctredlin.hxx>
41 #include <svx/postattr.hxx>
42 #include <swtypes.hxx>
43 #include <wrtsh.hxx>
44 #include <view.hxx>
45 #include <swmodule.hxx>
46 #ifndef _REDLNDLG_HXX
47 #define _REDLNACCEPTDLG
48 #include <redlndlg.hxx>
49 #endif
50 #include <swwait.hxx>
51 #include <uitool.hxx>
52 
53 #include <helpid.h>
54 #include <cmdid.h>
55 #include <misc.hrc>
56 #include <redlndlg.hrc>
57 #include <shells.hrc>
58 
59 // -> #111827#
60 #include <comcore.hrc>
61 #include <swundo.hxx>
62 #include <SwRewriter.hxx>
63 // <- #111827#
64 
65 #include <vector>
66 #include <svx/svxdlg.hxx>
67 #include <svx/dialogs.hrc>
68 
69 #include <unomid.h>
70 
71 #include <docsh.hxx>
72 
73 #include <IDocumentRedlineAccess.hxx>
74 
75 /*------------------------------------------------------------------------
76 	Beschreibung:
77 ------------------------------------------------------------------------*/
78 
79 SFX_IMPL_MODELESSDIALOG( SwRedlineAcceptChild, FN_REDLINE_ACCEPT )
80 
81 SV_IMPL_PTRARR(SwRedlineDataParentArr, SwRedlineDataParentPtr)
82 SV_IMPL_OP_PTRARR_SORT(SwRedlineDataParentSortArr, SwRedlineDataParentPtr)
83 SV_IMPL_PTRARR(SwRedlineDataChildArr, SwRedlineDataChildPtr)
84 SV_IMPL_PTRARR(SvLBoxEntryArr, SvLBoxEntryPtr)
85 
86 static sal_uInt16 nSortMode = 0xffff;
87 static sal_Bool   bSortDir = sal_True;
88 
89 /*------------------------------------------------------------------------
90 	Beschreibung:
91 ------------------------------------------------------------------------*/
92 
93 SwRedlineAcceptChild::SwRedlineAcceptChild( Window* _pParent,
94 											sal_uInt16 nId,
95 											SfxBindings* pBindings,
96 											SfxChildWinInfo* pInfo ) :
97     SwChildWinWrapper( _pParent, nId )
98 {
99     pWindow = new SwModelessRedlineAcceptDlg( pBindings, this, _pParent);
100 
101 	((SwModelessRedlineAcceptDlg *)pWindow)->Initialize(pInfo);
102 }
103 
104 /*--------------------------------------------------------------------
105 	Beschreibung: Nach Dok-Wechsel Dialog neu initialisieren
106  --------------------------------------------------------------------*/
107 
108 sal_Bool SwRedlineAcceptChild::ReInitDlg(SwDocShell *pDocSh)
109 {
110 	sal_Bool bRet;
111 
112 	if ((bRet = SwChildWinWrapper::ReInitDlg(pDocSh)) == sal_True)	// Sofort aktualisieren, Dok-Wechsel
113 		((SwModelessRedlineAcceptDlg*)GetWindow())->Activate();
114 
115 	return bRet;
116 }
117 
118 /*------------------------------------------------------------------------
119 	Beschreibung:
120 ------------------------------------------------------------------------*/
121 
122 SwModelessRedlineAcceptDlg::SwModelessRedlineAcceptDlg( SfxBindings* _pBindings,
123 														SwChildWinWrapper* pChild,
124                                                         Window *_pParent) :
125     SfxModelessDialog(_pBindings, pChild, _pParent, SW_RES(DLG_REDLINE_ACCEPT)),
126 	pChildWin		(pChild)
127 {
128 	pImplDlg = new SwRedlineAcceptDlg(this);
129 
130 	FreeResource();
131 }
132 
133 /*--------------------------------------------------------------------
134 	Beschreibung:
135  --------------------------------------------------------------------*/
136 
137 void SwModelessRedlineAcceptDlg::Activate()
138 {
139 	SwView *pView = ::GetActiveView();
140 
141 	if (!pView)	// Kann passieren, wenn man auf eine andere App umschaltet, wenn
142 		return;	// vorher eine Listbox im Dialog den Focus hatte (eigentlich THs Bug)
143 
144 	SwDocShell *pDocSh = pView->GetDocShell();
145 
146 	if (pChildWin->GetOldDocShell() != pDocSh)
147 	{	// Dok-Wechsel
148 		SwWait aWait( *pDocSh, sal_False );
149 		SwWrtShell* pSh = pView->GetWrtShellPtr();
150 
151 		pChildWin->SetOldDocShell(pDocSh);	// Rekursion vermeiden (durch Modified-Hdl)
152 
153 		sal_Bool bMod = pSh->IsModified();
154 		SfxBoolItem aShow(FN_REDLINE_SHOW, sal_True);
155 		pSh->GetView().GetViewFrame()->GetDispatcher()->Execute(
156 			FN_REDLINE_SHOW, SFX_CALLMODE_SYNCHRON|SFX_CALLMODE_RECORD, &aShow, 0L);
157 		if (!bMod)
158 			pSh->ResetModified();
159 		pImplDlg->Init();
160 
161 		return;
162 	}
163 
164 	pImplDlg->Activate();
165 }
166 
167 /*--------------------------------------------------------------------
168 	Beschreibung:
169  --------------------------------------------------------------------*/
170 
171 void SwModelessRedlineAcceptDlg::Initialize(SfxChildWinInfo *pInfo)
172 {
173 	String aStr;
174 	if (pInfo != NULL)
175 		pImplDlg->Initialize(pInfo->aExtraString);
176 
177 	SfxModelessDialog::Initialize(pInfo);
178 }
179 
180 /*--------------------------------------------------------------------
181 	Beschreibung:
182  --------------------------------------------------------------------*/
183 
184 void SwModelessRedlineAcceptDlg::FillInfo(SfxChildWinInfo& rInfo) const
185 {
186 	SfxModelessDialog::FillInfo(rInfo);
187 	pImplDlg->FillInfo(rInfo.aExtraString);
188 }
189 
190 /*------------------------------------------------------------------------
191 	Beschreibung:
192 ------------------------------------------------------------------------*/
193 
194 void SwModelessRedlineAcceptDlg::Resize()
195 {
196 	pImplDlg->Resize();
197 	SfxModelessDialog::Resize();
198 }
199 
200 /*------------------------------------------------------------------------
201 	Beschreibung:
202 ------------------------------------------------------------------------*/
203 
204 SwModelessRedlineAcceptDlg::~SwModelessRedlineAcceptDlg()
205 {
206 	delete pImplDlg;
207 }
208 
209 /*------------------------------------------------------------------------
210 	Beschreibung:
211 ------------------------------------------------------------------------*/
212 
213 SwRedlineAcceptDlg::SwRedlineAcceptDlg(Dialog *pParent, sal_Bool bAutoFmt) :
214 	pParentDlg		(pParent),
215     aTabPagesCTRL   (pParent, SW_RES(CTRL_TABPAGES)),
216     aPopup          (SW_RES(MN_REDLINE_POPUP)),
217     sInserted       (SW_RES(STR_REDLINE_INSERTED)),
218     sDeleted        (SW_RES(STR_REDLINE_DELETED)),
219     sFormated       (SW_RES(STR_REDLINE_FORMATED)),
220     sTableChgd      (SW_RES(STR_REDLINE_TABLECHG)),
221     sFmtCollSet     (SW_RES(STR_REDLINE_FMTCOLLSET)),
222     sAutoFormat     (SW_RES(STR_REDLINE_AUTOFMT)),
223 	bOnlyFormatedRedlines( sal_False ),
224 	bHasReadonlySel	( sal_False ),
225 	bRedlnAutoFmt	(bAutoFmt),
226     bInhibitActivate( false )
227 {
228 	aTabPagesCTRL.SetHelpId(HID_REDLINE_CTRL);
229 	pTPView = aTabPagesCTRL.GetViewPage();
230 	pTable = pTPView->GetTableControl();
231 
232 	pTPView->InsertWriterHeader();
233 	pTPView->SetAcceptClickHdl(LINK(this, SwRedlineAcceptDlg, AcceptHdl));
234 	pTPView->SetAcceptAllClickHdl(LINK(this, SwRedlineAcceptDlg, AcceptAllHdl));
235 	pTPView->SetRejectClickHdl(LINK(this, SwRedlineAcceptDlg, RejectHdl));
236 	pTPView->SetRejectAllClickHdl(LINK(this, SwRedlineAcceptDlg, RejectAllHdl));
237 	pTPView->SetUndoClickHdl(LINK(this, SwRedlineAcceptDlg, UndoHdl));
238 
239 	aTabPagesCTRL.GetFilterPage()->SetReadyHdl(LINK(this, SwRedlineAcceptDlg, FilterChangedHdl));
240 
241 	ListBox *pActLB = aTabPagesCTRL.GetFilterPage()->GetLbAction();
242 	pActLB->InsertEntry(sInserted);
243 	pActLB->InsertEntry(sDeleted);
244 	pActLB->InsertEntry(sFormated);
245 	pActLB->InsertEntry(sTableChgd);
246 
247 	if (HasRedlineAutoFmt())
248 	{
249 		pActLB->InsertEntry(sFmtCollSet);
250 		pActLB->InsertEntry(sAutoFormat);
251 		pTPView->ShowUndo(sal_True);
252 		pTPView->DisableUndo();		// Noch gibts keine UNDO-Events
253 	}
254 
255 	pActLB->SelectEntryPos(0);
256 
257 	pTable->SetStyle(pTable->GetStyle()|WB_HASLINES|WB_CLIPCHILDREN|WB_HASBUTTONS|WB_HASBUTTONSATROOT|WB_HSCROLL);
258 	pTable->SetNodeDefaultImages();
259 	pTable->SetSelectionMode(MULTIPLE_SELECTION);
260 	pTable->SetHighlightRange(1);
261 
262 	static long aStaticTabs[]=
263 	{
264 		4,10,70,120,170
265 	};
266 
267 	pTable->SetTabs(aStaticTabs);
268 
269 	// Minimalgroesse setzen
270 	Size aMinSz(aTabPagesCTRL.GetMinSizePixel());
271 	Point aPos(aTabPagesCTRL.GetPosPixel());
272 
273 	aMinSz.Width() += (aPos.X() * 2 - 1);
274 	aMinSz.Height() += (aPos.Y() * 2 - 1);
275 	pParentDlg->SetMinOutputSizePixel(aMinSz);
276 
277 	if (pParentDlg->GetOutputSizePixel().Width() < aMinSz.Width())
278 		pParentDlg->SetOutputSizePixel(Size(aMinSz.Width(), pParentDlg->GetOutputSizePixel().Height()));
279 	if (pParentDlg->GetOutputSizePixel().Height() < aMinSz.Height())
280 		pParentDlg->SetOutputSizePixel(Size(pParentDlg->GetOutputSizePixel().Width(), aMinSz.Height()));
281 
282 	pTable->SortByCol(nSortMode, bSortDir);
283 
284 	aOldSelectHdl = pTable->GetSelectHdl();
285 	aOldDeselectHdl = pTable->GetDeselectHdl();
286 	pTable->SetSelectHdl(LINK(this, SwRedlineAcceptDlg, SelectHdl));
287 	pTable->SetDeselectHdl(LINK(this, SwRedlineAcceptDlg, DeselectHdl));
288 	pTable->SetCommandHdl(LINK(this, SwRedlineAcceptDlg, CommandHdl));
289 
290 	// Flackern der Buttons vermeiden:
291 	aDeselectTimer.SetTimeout(100);
292 	aDeselectTimer.SetTimeoutHdl(LINK(this, SwRedlineAcceptDlg, SelectHdl));
293 
294 	// Mehrfachselektion der selben Texte vermeiden:
295 	aSelectTimer.SetTimeout(100);
296 	aSelectTimer.SetTimeoutHdl(LINK(this, SwRedlineAcceptDlg, GotoHdl));
297 }
298 
299 /*------------------------------------------------------------------------
300 	Beschreibung:
301 ------------------------------------------------------------------------*/
302 
303 SwRedlineAcceptDlg::~SwRedlineAcceptDlg()
304 {
305 }
306 
307 /*------------------------------------------------------------------------
308 	Beschreibung:
309 ------------------------------------------------------------------------*/
310 
311 void SwRedlineAcceptDlg::Init(sal_uInt16 nStart)
312 {
313 	SwWait aWait( *::GetActiveView()->GetDocShell(), sal_False );
314 	pTable->SetUpdateMode(sal_False);
315 	aUsedSeqNo.Remove((sal_uInt16)0, aUsedSeqNo.Count());
316 
317 	if (nStart)
318 		RemoveParents(nStart, aRedlineParents.Count() - 1);
319 	else
320 	{
321 		pTable->Clear();
322 		aRedlineChilds.DeleteAndDestroy(0, aRedlineChilds.Count());
323 		aRedlineParents.DeleteAndDestroy(nStart, aRedlineParents.Count() - nStart);
324 	}
325 
326 	// Parents einfuegen
327 	InsertParents(nStart);
328 	InitAuthors();
329 
330 	pTable->SetUpdateMode(sal_True);
331     // #i69618# this moves the list box to the right position, visually
332     SvLBoxEntry* pSelEntry = pTable->FirstSelected();
333     if( pSelEntry )
334         pTable->MakeVisible( pSelEntry, sal_True ); //#i70937#, force the scroll
335 }
336 
337 /*------------------------------------------------------------------------
338 	Beschreibung:
339 ------------------------------------------------------------------------*/
340 
341 void SwRedlineAcceptDlg::InitAuthors()
342 {
343 	SwWrtShell* pSh = ::GetActiveView()->GetWrtShellPtr();
344 
345 	SvxTPFilter *pFilterPage = aTabPagesCTRL.GetFilterPage();
346 
347 	String sAuthor;
348 	SvStringsSortDtor aStrings;
349 	String sOldAuthor(pFilterPage->GetSelectedAuthor());
350 	pFilterPage->ClearAuthors();
351 
352 	String sParent;
353 	sal_uInt16 nCount = pSh->GetRedlineCount();
354 
355 	bOnlyFormatedRedlines = sal_True;
356 	bHasReadonlySel = sal_False;
357 	sal_Bool bIsNotFormated = sal_False;
358 	sal_uInt16 i;
359 
360 	// Autoren ermitteln
361 	for ( i = 0; i < nCount; i++)
362 	{
363 		const SwRedline& rRedln = pSh->GetRedline(i);
364 
365 		if( bOnlyFormatedRedlines && nsRedlineType_t::REDLINE_FORMAT != rRedln.GetType() )
366 			bOnlyFormatedRedlines = sal_False;
367 
368 //JP 27.9.2001: make no sense if we handle readonly sections
369 //		if( !bHasReadonlySel && rRedln.HasReadonlySel() )
370 //			bHasReadonlySel = sal_True;
371 
372 		String *pAuthor = new String(rRedln.GetAuthorString());
373 		if (!aStrings.Insert(pAuthor))
374 			delete pAuthor;
375 
376 		for (sal_uInt16 nStack = 1; nStack < rRedln.GetStackCount(); nStack++)
377 		{
378 			pAuthor = new String(rRedln.GetAuthorString(nStack));
379 			if (!aStrings.Insert(pAuthor))
380 				delete pAuthor;
381 		}
382 	}
383 
384 	for (i = 0; i < aStrings.Count(); i++)
385 		pFilterPage->InsertAuthor(*aStrings[i]);
386 
387 	if (pFilterPage->SelectAuthor(sOldAuthor) == LISTBOX_ENTRY_NOTFOUND && aStrings.Count())
388 		pFilterPage->SelectAuthor(*aStrings[0]);
389 
390     sal_Bool bEnable = pTable->GetEntryCount() != 0 && !pSh->getIDocumentRedlineAccess()->GetRedlinePassword().getLength();
391 	sal_Bool bSel = pTable->FirstSelected() != 0;
392 
393 	SvLBoxEntry* pSelEntry = pTable->FirstSelected();
394 	while (pSelEntry)
395 	{
396 		sal_uInt16 nPos = GetRedlinePos(*pSelEntry);
397 		const SwRedline& rRedln = pSh->GetRedline( nPos );
398 
399 		bIsNotFormated |= nsRedlineType_t::REDLINE_FORMAT != rRedln.GetType();
400 		pSelEntry = pTable->NextSelected(pSelEntry);
401 	}
402 
403 	pTPView->EnableAccept( bEnable && bSel );
404 	pTPView->EnableReject( bEnable && bIsNotFormated && bSel );
405 	pTPView->EnableAcceptAll( bEnable && !bHasReadonlySel );
406 	pTPView->EnableRejectAll( bEnable && !bHasReadonlySel &&
407 								!bOnlyFormatedRedlines );
408 }
409 
410 /*------------------------------------------------------------------------
411 	Beschreibung:
412 ------------------------------------------------------------------------*/
413 
414 String SwRedlineAcceptDlg::GetRedlineText( const SwRedline& rRedln,
415 										DateTime &rDateTime, sal_uInt16 nStack)
416 {
417 	String sEntry(GetActionText(rRedln, nStack));
418 	sEntry += '\t';
419 	sEntry += rRedln.GetAuthorString(nStack);
420 	sEntry += '\t';
421 
422 	const DateTime &rDT = rRedln.GetTimeStamp(nStack);
423 	rDateTime = rDT;
424 
425 	sEntry += GetAppLangDateTimeString( rDT );
426 	sEntry += '\t';
427 
428 	sEntry += rRedln.GetComment(nStack);
429 
430 	return sEntry;
431 }
432 
433 /*------------------------------------------------------------------------
434 	Beschreibung:
435 ------------------------------------------------------------------------*/
436 
437 const String &SwRedlineAcceptDlg::GetActionText(const SwRedline& rRedln, sal_uInt16 nStack)
438 {
439 	switch( rRedln.GetType(nStack) )
440 	{
441 		case nsRedlineType_t::REDLINE_INSERT:	return sInserted;
442 		case nsRedlineType_t::REDLINE_DELETE:	return sDeleted;
443 		case nsRedlineType_t::REDLINE_FORMAT:	return sFormated;
444 		case nsRedlineType_t::REDLINE_TABLE: 	return sTableChgd;
445 		case nsRedlineType_t::REDLINE_FMTCOLL: 	return sFmtCollSet;
446         default:;//prevent warning
447 	}
448 
449 	return aEmptyStr;
450 }
451 
452 /*------------------------------------------------------------------------
453 	Beschreibung:
454 ------------------------------------------------------------------------*/
455 
456 void SwRedlineAcceptDlg::Resize()
457 {
458 	Size aSz(pParentDlg->GetOutputSizePixel());
459 
460 	Point aPos(aTabPagesCTRL.GetPosPixel());
461 
462 	aSz.Width() -= (aPos.X() * 2 - 1);
463 	aSz.Height() -= (aPos.Y() * 2 - 1);
464 
465 	aTabPagesCTRL.SetOutputSizePixel(aSz);
466 }
467 
468 /*--------------------------------------------------------------------
469 	Beschreibung: Nach Aktivierung neu initialisieren
470  --------------------------------------------------------------------*/
471 
472 void SwRedlineAcceptDlg::Activate()
473 {
474     // prevent update if flag is set (#102547#)
475     if( bInhibitActivate )
476         return;
477 
478 	SwView *pView = ::GetActiveView();
479 	SwWait aWait( *pView->GetDocShell(), sal_False );
480 
481 	aUsedSeqNo.Remove((sal_uInt16)0, aUsedSeqNo.Count());
482 
483 	if (!pView)	// Kann passieren, wenn man auf eine andere App umschaltet, wenn
484 		return;	// vorher eine Listbox im Dialog den Focus hatte (eigentlich THs Bug)
485 
486 /*	if (HasRedlineAutoFmt())
487 	{
488 		Init();
489 		return;
490 	}*/
491 
492 	// Hat sich was geaendert?
493 	SwWrtShell* pSh = pView->GetWrtShellPtr();
494 	sal_uInt16 nCount = pSh->GetRedlineCount();
495 
496 	// Anzahl und Pointer ueberpruefen
497 	SwRedlineDataParent *pParent = 0;
498 	sal_uInt16 i;
499 
500 	for ( i = 0; i < nCount; i++)
501 	{
502 		const SwRedline& rRedln = pSh->GetRedline(i);
503 
504 		if (i >= aRedlineParents.Count())
505 		{
506 			// Neue Eintraege wurden angehaengt
507 			Init(i);
508 			return;
509 		}
510 
511 		pParent = aRedlineParents[i];
512 		if (&rRedln.GetRedlineData() != pParent->pData)
513 		{
514 			// Redline-Parents wurden eingefuegt, geaendert oder geloescht
515 			if ((i = CalcDiff(i, sal_False)) == USHRT_MAX)
516 				return;
517 			continue;
518 		}
519 
520 		const SwRedlineData *pRedlineData = rRedln.GetRedlineData().Next();
521 		const SwRedlineDataChild *pBackupData = pParent->pNext;
522 
523 		if (!pRedlineData && pBackupData)
524 		{
525 			// Redline-Childs wurden geloescht
526 			if ((i = CalcDiff(i, sal_True)) == USHRT_MAX)
527 				return;
528 			continue;
529 		}
530 		else
531 		{
532 			while (pRedlineData)
533 			{
534 				if (pRedlineData != pBackupData->pChild)
535 				{
536 					// Redline-Childs wurden eingefuegt, geaendert oder geloescht
537 					if ((i = CalcDiff(i, sal_True)) == USHRT_MAX)
538 						return;
539 					continue;
540 				}
541 				if (pBackupData)
542 					pBackupData = pBackupData->pNext;
543 				pRedlineData = pRedlineData->Next();
544 			}
545 		}
546 	}
547 
548 	if (nCount != aRedlineParents.Count())
549 	{
550 		// Redlines wurden am Ende geloescht
551 		Init(nCount);
552 		return;
553 	}
554 
555 	// Kommentar ueberpruefen
556 	for (i = 0; i < nCount; i++)
557 	{
558 		const SwRedline& rRedln = pSh->GetRedline(i);
559 		pParent = aRedlineParents[i];
560 
561 		if(!rRedln.GetComment().Equals(pParent->sComment))
562 		{
563 			if (pParent->pTLBParent)
564 			{
565 				// Nur Kommentar aktualisieren
566 				String sComment(rRedln.GetComment());
567 				sComment.SearchAndReplaceAll((sal_Unicode)_LF,(sal_Unicode)' ');
568 				pTable->SetEntryText(sComment, pParent->pTLBParent, 3);
569 			}
570 			pParent->sComment = rRedln.GetComment();
571 		}
572 	}
573 
574 	InitAuthors();
575 }
576 
577 /* -----------------05.06.98 13:06-------------------
578  *
579  * --------------------------------------------------*/
580 
581 sal_uInt16 SwRedlineAcceptDlg::CalcDiff(sal_uInt16 nStart, sal_Bool bChild)
582 {
583 	if (!nStart)
584 	{
585 		Init();
586 		return USHRT_MAX;
587 	}
588 
589 	pTable->SetUpdateMode(sal_False);
590 	SwView *pView	= ::GetActiveView();
591 	SwWrtShell* pSh	= pView->GetWrtShellPtr();
592     sal_uInt16 nAutoFmt = HasRedlineAutoFmt() ? nsRedlineType_t::REDLINE_FORM_AUTOFMT : 0;
593     SwRedlineDataParent *pParent = aRedlineParents[nStart];
594 	const SwRedline& rRedln = pSh->GetRedline(nStart);
595 
596 	if (bChild)		// Sollte eigentlich nie vorkommen, aber sicher ist sicher...
597 	{
598 		// Alle Childs des Eintrags wegwerfen und neu initialisieren
599 		SwRedlineDataChildPtr pBackupData = (SwRedlineDataChildPtr)pParent->pNext;
600 		SwRedlineDataChildPtr pNext;
601 
602 		while (pBackupData)
603 		{
604 			pNext = (SwRedlineDataChildPtr)pBackupData->pNext;
605 			if (pBackupData->pTLBChild)
606                 pTable->RemoveEntry(pBackupData->pTLBChild);
607 
608 			aRedlineChilds.DeleteAndDestroy(aRedlineChilds.GetPos(pBackupData), 1);
609 			pBackupData = pNext;
610 		}
611 		pParent->pNext = 0;
612 
613 		// Neue Childs einfuegen
614 		InsertChilds(pParent, rRedln, nAutoFmt);
615 
616 		pTable->SetUpdateMode(sal_True);
617 		return nStart;
618 	}
619 
620 	// Wurden Eintraege geloescht?
621 	const SwRedlineData *pRedlineData = &rRedln.GetRedlineData();
622 	sal_uInt16 i;
623 	for ( i = nStart + 1; i < aRedlineParents.Count(); i++)
624 	{
625 		if (aRedlineParents[i]->pData == pRedlineData)
626 		{
627 			// Eintraege von nStart bis i-1 entfernen
628 			RemoveParents(nStart, i - 1);
629 			pTable->SetUpdateMode(sal_True);
630 			return nStart - 1;
631 		}
632 	}
633 
634 	// Wurden Eintraege eingefuegt?
635 	sal_uInt16 nCount = pSh->GetRedlineCount();
636 	pRedlineData = aRedlineParents[nStart]->pData;
637 
638 	for (i = nStart + 1; i < nCount; i++)
639 	{
640 		if (&pSh->GetRedline(i).GetRedlineData() == pRedlineData)
641 		{
642 			// Eintraege von nStart bis i-1 einfuegen
643 			InsertParents(nStart, i - 1);
644 			pTable->SetUpdateMode(sal_True);
645 			return nStart - 1;
646 		}
647 	}
648 
649 	pTable->SetUpdateMode(sal_True);
650 	Init(nStart);	// Alle Eintraege bis zum Ende abgleichen
651 	return USHRT_MAX;
652 }
653 
654 /* -----------------05.06.98 13:57-------------------
655  *
656  * --------------------------------------------------*/
657 
658 void SwRedlineAcceptDlg::InsertChilds(SwRedlineDataParent *pParent, const SwRedline& rRedln, const sal_uInt16 nAutoFmt)
659 {
660 	String sChild;
661 	SwRedlineDataChild *pLastRedlineChild = 0;
662 	const SwRedlineData *pRedlineData = &rRedln.GetRedlineData();
663 	sal_Bool bAutoFmt = (rRedln.GetRealType() & nAutoFmt) != 0;
664 
665 	const String *pAction = &GetActionText(rRedln);
666 	sal_Bool bValidParent = !sFilterAction.Len() || sFilterAction == *pAction;
667 	bValidParent = bValidParent && pTable->IsValidEntry(&rRedln.GetAuthorString(), &rRedln.GetTimeStamp(), &rRedln.GetComment());
668 	if (nAutoFmt)
669 	{
670 		sal_uInt16 nPos;
671 
672 		if (pParent->pData->GetSeqNo() && !aUsedSeqNo.Insert(pParent, nPos))	// Gibts schon
673 		{
674 			if (pParent->pTLBParent)
675 			{
676 				pTable->SetEntryText(sAutoFormat, aUsedSeqNo[nPos]->pTLBParent, 0);
677                 pTable->RemoveEntry(pParent->pTLBParent);
678 				pParent->pTLBParent = 0;
679 			}
680 			return;
681 		}
682 		bValidParent = bValidParent && bAutoFmt;
683 	}
684 	sal_Bool bValidTree = bValidParent;
685 
686 	for (sal_uInt16 nStack = 1; nStack < rRedln.GetStackCount(); nStack++)
687 	{
688 		pRedlineData = pRedlineData->Next();
689 
690 		SwRedlineDataChildPtr pRedlineChild = new SwRedlineDataChild;
691 		pRedlineChild->pChild = pRedlineData;
692 		aRedlineChilds.Insert(pRedlineChild, aRedlineChilds.Count());
693 
694 		if ( pLastRedlineChild )
695 			pLastRedlineChild->pNext = pRedlineChild;
696 		else
697 			pParent->pNext = pRedlineChild;
698 
699 		pAction = &GetActionText(rRedln, nStack);
700 		sal_Bool bValidChild = !sFilterAction.Len() || sFilterAction == *pAction;
701 		bValidChild = bValidChild && pTable->IsValidEntry(&rRedln.GetAuthorString(nStack), &rRedln.GetTimeStamp(nStack), &rRedln.GetComment());
702 		if (nAutoFmt)
703 			bValidChild = bValidChild && bAutoFmt;
704 		bValidTree |= bValidChild;
705 
706 		if (bValidChild)
707 		{
708 			RedlinData *pData = new RedlinData;
709 			pData->pData = pRedlineChild;
710 			pData->bDisabled = sal_True;
711 			sChild = GetRedlineText(rRedln, pData->aDateTime, nStack);
712 
713 			SvLBoxEntry* pChild = pTable->InsertEntry(sChild, pData, pParent->pTLBParent);
714 
715 			pRedlineChild->pTLBChild = pChild;
716 			if (!bValidParent)
717 				pTable->Expand(pParent->pTLBParent);
718 		}
719 		else
720 			pRedlineChild->pTLBChild = 0;
721 
722 		pLastRedlineChild = pRedlineChild;
723 	}
724 
725 	if (pLastRedlineChild)
726 		pLastRedlineChild->pNext = 0;
727 
728 	if (!bValidTree && pParent->pTLBParent)
729 	{
730         pTable->RemoveEntry(pParent->pTLBParent);
731 		pParent->pTLBParent = 0;
732 		if (nAutoFmt)
733 			aUsedSeqNo.Remove(pParent);
734 	}
735 }
736 
737 /* -----------------05.06.98 15:20-------------------
738  *
739  * --------------------------------------------------*/
740 
741 void SwRedlineAcceptDlg::RemoveParents(sal_uInt16 nStart, sal_uInt16 nEnd)
742 {
743 	SwWrtShell* pSh = ::GetActiveView()->GetWrtShellPtr();
744 	sal_uInt16 nCount = pSh->GetRedlineCount();
745 
746 	SvLBoxEntryArr aLBoxArr;
747 
748 	// Wegen Bug der TLB, die bei Remove den SelectHandler IMMER ruft:
749 	pTable->SetSelectHdl(aOldSelectHdl);
750 	pTable->SetDeselectHdl(aOldDeselectHdl);
751 	sal_Bool bChildsRemoved = sal_False;
752 	pTable->SelectAll(sal_False);
753 
754 	// Hinter dem letzten Eintrag Cursor setzen, da sonst Performance-Problem in TLB.
755 	// TLB wuerde sonst bei jedem Remove den Cursor erneut umsetzen (teuer)
756 	sal_uInt16 nPos = Min((sal_uInt16)nCount, (sal_uInt16)aRedlineParents.Count());
757 	SvLBoxEntry *pCurEntry = NULL;
758 	while( ( pCurEntry == NULL ) && ( nPos > 0 ) )
759 	{
760 		--nPos;
761 		pCurEntry = aRedlineParents[nPos]->pTLBParent;
762 	}
763 
764 	if (pCurEntry)
765 		pTable->SetCurEntry(pCurEntry);
766 
767 	SvLBoxTreeList*	pModel = pTable->GetModel();
768 
769 	for (sal_uInt16 i = nStart; i <= nEnd; i++)
770 	{
771 		if (!bChildsRemoved && aRedlineParents[i]->pNext)
772 		{
773 			SwRedlineDataChildPtr pChildPtr = (SwRedlineDataChildPtr)aRedlineParents[i]->pNext;
774             sal_uInt16 nChildPos = aRedlineChilds.GetPos(pChildPtr);
775 
776             if (nChildPos != USHRT_MAX)
777 			{
778 				sal_uInt16 nChilds = 0;
779 
780 				while (pChildPtr)
781 				{
782 					pChildPtr = (SwRedlineDataChildPtr)pChildPtr->pNext;
783 					nChilds++;
784 				}
785 
786                 aRedlineChilds.DeleteAndDestroy(nChildPos, nChilds);
787 				bChildsRemoved = sal_True;
788 			}
789 		}
790 		SvLBoxEntry *pEntry = aRedlineParents[i]->pTLBParent;
791 		if (pEntry)
792 		{
793             long nIdx = aLBoxArr.Count() - 1L;
794 			sal_uLong nAbsPos = pModel->GetAbsPos(pEntry);
795 			while (nIdx >= 0 &&
796                     pModel->GetAbsPos(aLBoxArr[ static_cast< sal_uInt16 >(nIdx) ]) > nAbsPos)
797 				nIdx--;
798             aLBoxArr.Insert( pEntry, static_cast< sal_uInt16 >(++nIdx) );
799 		}
800 	}
801 
802 	// TLB von hinten abraeumen
803 	long nIdx = (long)aLBoxArr.Count() - 1L;
804 	while (nIdx >= 0)
805         pTable->RemoveEntry(aLBoxArr[ static_cast< sal_uInt16 >(nIdx--) ]);
806 
807 	pTable->SetSelectHdl(LINK(this, SwRedlineAcceptDlg, SelectHdl));
808 	pTable->SetDeselectHdl(LINK(this, SwRedlineAcceptDlg, DeselectHdl));
809 	// Durch Remove wurde leider wieder dauernd von der TLB selektiert...
810 	pTable->SelectAll(sal_False);
811 
812 	aRedlineParents.DeleteAndDestroy( nStart, nEnd - nStart + 1);
813 }
814 
815 /* -----------------05.06.98 15:20-------------------
816  *
817  * --------------------------------------------------*/
818 
819 void SwRedlineAcceptDlg::InsertParents(sal_uInt16 nStart, sal_uInt16 nEnd)
820 {
821 	SwView *pView	= ::GetActiveView();
822 	SwWrtShell* pSh	= pView->GetWrtShellPtr();
823 	sal_uInt16 nAutoFmt	= HasRedlineAutoFmt() ? nsRedlineType_t::REDLINE_FORM_AUTOFMT : 0;
824 
825 	String sParent;
826 	sal_uInt16 nCount = pSh->GetRedlineCount();
827 	nEnd = Min((sal_uInt16)nEnd, (sal_uInt16)(nCount - 1));	// Handelt auch nEnd=USHRT_MAX (bis zum Ende) ab
828 
829 	if (nEnd == USHRT_MAX)
830 		return;		// Keine Redlines im Dokument
831 
832 	RedlinData *pData;
833     SvLBoxEntry *pParent;
834 	SwRedlineDataParentPtr pRedlineParent;
835 	const SwRedline* pCurrRedline;
836 	if( !nStart && !pTable->FirstSelected() )
837 	{
838 		pCurrRedline = pSh->GetCurrRedline();
839 		if( !pCurrRedline )
840 		{
841 			pSh->SwCrsrShell::Push();
842 			if( 0 == (pCurrRedline = pSh->SelNextRedline()))
843 				pCurrRedline = pSh->SelPrevRedline();
844 			pSh->SwCrsrShell::Pop( sal_False );
845 		}
846 	}
847 	else
848 		pCurrRedline = 0;
849 
850 	for (sal_uInt16 i = nStart; i <= nEnd; i++)
851 	{
852 		const SwRedline& rRedln = pSh->GetRedline(i);
853 		const SwRedlineData *pRedlineData = &rRedln.GetRedlineData();
854 
855 		pRedlineParent = new SwRedlineDataParent;
856 		pRedlineParent->pData	 = pRedlineData;
857 		pRedlineParent->pNext	 = 0;
858 		String sComment(rRedln.GetComment());
859 		sComment.SearchAndReplaceAll((sal_Unicode)_LF,(sal_Unicode)' ');
860 		pRedlineParent->sComment = sComment;
861 		aRedlineParents.Insert(pRedlineParent, i);
862 
863 		pData = new RedlinData;
864 		pData->pData = pRedlineParent;
865 		pData->bDisabled = sal_False;
866 
867 		sParent = GetRedlineText(rRedln, pData->aDateTime);
868 		pParent = pTable->InsertEntry(sParent, pData, 0, i);
869 		if( pCurrRedline == &rRedln )
870 		{
871 			pTable->SetCurEntry( pParent );
872 			pTable->Select( pParent );
873 			pTable->MakeVisible( pParent );
874 		}
875 
876 		pRedlineParent->pTLBParent = pParent;
877 
878 		InsertChilds(pRedlineParent, rRedln, nAutoFmt);
879 	}
880 }
881 
882 /* -----------------05.06.98 13:06-------------------
883  *
884  * --------------------------------------------------*/
885 
886 void SwRedlineAcceptDlg::CallAcceptReject( sal_Bool bSelect, sal_Bool bAccept )
887 {
888 	SwWrtShell* pSh = ::GetActiveView()->GetWrtShellPtr();
889 	SvLBoxEntry* pEntry = bSelect ? pTable->FirstSelected() : pTable->First();
890 	sal_uLong nPos = LONG_MAX;
891 
892     typedef std::vector<SvLBoxEntry*> ListBoxEntries_t;
893     ListBoxEntries_t aRedlines;
894 
895     // don't activate
896     DBG_ASSERT( bInhibitActivate == false,
897                 "recursive call of CallAcceptReject?");
898     bInhibitActivate = true;
899 
900     // collect redlines-to-be-accepted/rejected in aRedlines vector
901 	while( pEntry )
902 	{
903 		if( !pTable->GetParent( pEntry ) )
904 		{
905 			if( bSelect && LONG_MAX == nPos )
906 				nPos = pTable->GetModel()->GetAbsPos( pEntry );
907 
908 			RedlinData *pData = (RedlinData *)pEntry->GetUserData();
909 
910 			if( !pData->bDisabled )
911 				aRedlines.push_back( pEntry );
912 		}
913 
914 		pEntry = bSelect ? pTable->NextSelected(pEntry) : pTable->Next(pEntry);
915 	}
916 
917 	sal_Bool (SwEditShell:: *FnAccRej)( sal_uInt16 ) = &SwEditShell::AcceptRedline;
918 	if( !bAccept )
919 		FnAccRej = &SwEditShell::RejectRedline;
920 
921 	SwWait aWait( *pSh->GetView().GetDocShell(), sal_True );
922 	pSh->StartAction();
923 
924     // #111827#
925     if (aRedlines.size() > 1)
926     {
927         String aTmpStr;
928         {
929             SwRewriter aRewriter;
930             aRewriter.AddRule(UNDO_ARG1,
931                               String::CreateFromInt32(aRedlines.size()));
932             aTmpStr = aRewriter.Apply(String(SW_RES(STR_N_REDLINES)));
933         }
934 
935         SwRewriter aRewriter;
936         aRewriter.AddRule(UNDO_ARG1, aTmpStr);
937 
938         pSh->StartUndo(bAccept? UNDO_ACCEPT_REDLINE : UNDO_REJECT_REDLINE,
939                        &aRewriter);
940     }
941 
942     // accept/reject the the redlines in aRedlines. The absolute
943     // position may change during the process (e.g. when two redlines
944     // are merged in result of another one being deleted), so the
945     // position must be resolved late and checked before using it.
946     // (cf #102547#)
947     ListBoxEntries_t::iterator aEnd = aRedlines.end();
948 	for( ListBoxEntries_t::iterator aIter = aRedlines.begin();
949          aIter != aEnd;
950          aIter++ )
951     {
952         sal_uInt16 nPosition = GetRedlinePos( **aIter );
953         if( nPosition != USHRT_MAX )
954             (pSh->*FnAccRej)( nPosition );
955     }
956 
957     // #111827#
958     if (aRedlines.size() > 1)
959     {
960         pSh->EndUndo();
961     }
962 
963 	pSh->EndAction();
964 
965     bInhibitActivate = false;
966 	Activate();
967 
968 	if( ULONG_MAX != nPos && pTable->GetEntryCount() )
969 	{
970 		if( nPos >= pTable->GetEntryCount() )
971 			nPos = pTable->GetEntryCount() - 1;
972 		pEntry = pTable->GetEntry( nPos );
973 		if( !pEntry && nPos-- )
974 			pEntry = pTable->GetEntry( nPos );
975 		if( pEntry )
976 		{
977 			pTable->Select( pEntry );
978 			pTable->MakeVisible( pEntry );
979 			pTable->SetCurEntry(pEntry);
980 		}
981 	}
982 	pTPView->EnableUndo();
983 }
984 
985 /*--------------------------------------------------------------------
986 	Beschreibung:
987  --------------------------------------------------------------------*/
988 
989 sal_uInt16 SwRedlineAcceptDlg::GetRedlinePos( const SvLBoxEntry& rEntry ) const
990 {
991 	SwWrtShell* pSh = ::GetActiveView()->GetWrtShellPtr();
992 	return pSh->FindRedlineOfData( *((SwRedlineDataParent*)((RedlinData *)
993 									rEntry.GetUserData())->pData)->pData );
994 }
995 
996 /*--------------------------------------------------------------------
997 	Beschreibung:
998  --------------------------------------------------------------------*/
999 
1000 IMPL_LINK( SwRedlineAcceptDlg, AcceptHdl, void*, EMPTYARG)
1001 {
1002 	CallAcceptReject( sal_True, sal_True );
1003 	return 0;
1004 }
1005 
1006 /*--------------------------------------------------------------------
1007 	Beschreibung:
1008  --------------------------------------------------------------------*/
1009 
1010 IMPL_LINK( SwRedlineAcceptDlg, AcceptAllHdl, void*, EMPTYARG )
1011 {
1012 	CallAcceptReject( sal_False, sal_True );
1013 	return 0;
1014 }
1015 
1016 /*--------------------------------------------------------------------
1017 	Beschreibung:
1018  --------------------------------------------------------------------*/
1019 
1020 IMPL_LINK( SwRedlineAcceptDlg, RejectHdl, void*, EMPTYARG )
1021 {
1022 	CallAcceptReject( sal_True, sal_False );
1023 	return 0;
1024 }
1025 
1026 /*--------------------------------------------------------------------
1027 	Beschreibung:
1028  --------------------------------------------------------------------*/
1029 
1030 IMPL_LINK( SwRedlineAcceptDlg, RejectAllHdl, void*, EMPTYARG )
1031 {
1032 	CallAcceptReject( sal_False, sal_False );
1033 	return 0;
1034 }
1035 
1036 /*--------------------------------------------------------------------
1037 	Beschreibung:
1038  --------------------------------------------------------------------*/
1039 
1040 IMPL_LINK( SwRedlineAcceptDlg, UndoHdl, void*, EMPTYARG )
1041 {
1042 	SwView * pView = ::GetActiveView();
1043 	pView->GetViewFrame()->GetDispatcher()->
1044 				Execute(SID_UNDO, SFX_CALLMODE_SYNCHRON);
1045 	pTPView->EnableUndo(pView->GetSlotState(SID_UNDO) != 0);
1046 
1047 	Activate();
1048 
1049 	return 0;
1050 }
1051 
1052 /*--------------------------------------------------------------------
1053 	Beschreibung:
1054  --------------------------------------------------------------------*/
1055 
1056 IMPL_LINK( SwRedlineAcceptDlg, FilterChangedHdl, void*, EMPTYARG )
1057 {
1058 	SvxTPFilter *pFilterTP = aTabPagesCTRL.GetFilterPage();
1059 
1060 	if (pFilterTP->IsAction())
1061 		sFilterAction = pFilterTP->GetLbAction()->GetSelectEntry();
1062 	else
1063 		sFilterAction = aEmptyStr;
1064 
1065 	Init();
1066 
1067 	return 0;
1068 }
1069 
1070 /*--------------------------------------------------------------------
1071 	Beschreibung:
1072  --------------------------------------------------------------------*/
1073 
1074 IMPL_LINK( SwRedlineAcceptDlg, DeselectHdl, void*, EMPTYARG )
1075 {
1076 	// Flackern der Buttons vermeiden:
1077 	aDeselectTimer.Start();
1078 
1079 	return 0;
1080 }
1081 
1082 /*--------------------------------------------------------------------
1083 	Beschreibung:
1084  --------------------------------------------------------------------*/
1085 
1086 IMPL_LINK( SwRedlineAcceptDlg, SelectHdl, void*, EMPTYARG )
1087 {
1088 	aDeselectTimer.Stop();
1089 	aSelectTimer.Start();
1090 
1091 	return 0;
1092 }
1093 
1094 /*--------------------------------------------------------------------
1095 	Beschreibung:
1096  --------------------------------------------------------------------*/
1097 
1098 IMPL_LINK( SwRedlineAcceptDlg, GotoHdl, void*, EMPTYARG )
1099 {
1100 	SwWrtShell* pSh = ::GetActiveView()->GetWrtShellPtr();
1101 	aSelectTimer.Stop();
1102 
1103 	sal_Bool bIsNotFormated = sal_False;
1104 	sal_Bool bSel = sal_False;
1105 //  sal_Bool bReadonlySel = sal_False;
1106 
1107     //#98883# don't select redlines while the dialog is not focussed
1108     //#107938# But not only ask pTable if it has the focus. To move
1109     //         the selection to the selected redline any child of pParentDlg
1110     //         may the focus.
1111     SvLBoxEntry* pSelEntry = 0;
1112 
1113     if (pParentDlg->HasChildPathFocus())
1114         pSelEntry = pTable->FirstSelected();
1115 
1116     if( pSelEntry )
1117 	{
1118 		SvLBoxEntry* pActEntry = pSelEntry;
1119 		pSh->StartAction();
1120 		pSh->EnterStdMode();
1121 		pSh->SetCareWin(pParentDlg);
1122 
1123 		while (pSelEntry)
1124 		{
1125 			if (pTable->GetParent(pSelEntry))
1126 			{
1127 				pActEntry = pTable->GetParent(pSelEntry);
1128 
1129 				if (pTable->IsSelected(pActEntry))
1130 				{
1131 					pSelEntry = pActEntry = pTable->NextSelected(pSelEntry);
1132 					continue;	// Nicht zweimal selektieren
1133 				}
1134 			}
1135 			else
1136 				bSel = sal_True;
1137 
1138 			// #98864# find the selected redline (ignore, if the redline is already gone)
1139 			sal_uInt16 nPos = GetRedlinePos(*pActEntry);
1140 			if( nPos != USHRT_MAX )
1141 			{
1142 
1143 				const SwRedline& rRedln = pSh->GetRedline( nPos );
1144 				bIsNotFormated |= nsRedlineType_t::REDLINE_FORMAT != rRedln.GetType();
1145 
1146 //JP 27.9.2001: make no sense if we handle readonly sections
1147 //			if( !bReadonlySel && rRedln.HasReadonlySel() )
1148 //				bReadonlySel = sal_True;
1149 
1150 				if (pSh->GotoRedline(nPos, sal_True))
1151 				{
1152 					pSh->SetInSelect();
1153 					pSh->EnterAddMode();
1154 				}
1155 			}
1156 
1157             pSelEntry = pActEntry = pTable->NextSelected(pSelEntry);
1158 		}
1159 
1160 		pSh->LeaveAddMode();
1161 		pSh->EndAction();
1162 		pSh->SetCareWin(NULL);
1163 	}
1164     sal_Bool bEnable = !pSh->getIDocumentRedlineAccess()->GetRedlinePassword().getLength();
1165     pTPView->EnableAccept( bEnable && bSel /*&& !bReadonlySel*/ );
1166     pTPView->EnableReject( bEnable && bSel && bIsNotFormated /*&& !bReadonlySel*/ );
1167     pTPView->EnableRejectAll( bEnable && !bOnlyFormatedRedlines && !bHasReadonlySel );
1168 
1169 	return 0;
1170 }
1171 
1172 /*--------------------------------------------------------------------
1173 	Beschreibung:
1174  --------------------------------------------------------------------*/
1175 
1176 IMPL_LINK( SwRedlineAcceptDlg, CommandHdl, void*, EMPTYARG )
1177 {
1178 	const CommandEvent aCEvt(pTable->GetCommandEvent());
1179 
1180 	switch ( aCEvt.GetCommand() )
1181 	{
1182 		case COMMAND_CONTEXTMENU:
1183 		{
1184 			SwWrtShell* pSh = ::GetActiveView()->GetWrtShellPtr();
1185 			SvLBoxEntry* pEntry = pTable->FirstSelected();
1186 			const SwRedline *pRed = 0;
1187 
1188 			if (pEntry)
1189 			{
1190 				SvLBoxEntry* pTopEntry = pEntry;
1191 
1192 				if (pTable->GetParent(pEntry))
1193 					pTopEntry = pTable->GetParent(pEntry);
1194 
1195 				sal_uInt16 nPos = GetRedlinePos(*pTopEntry);
1196 
1197 				// Bei geschuetzten Bereichen kommentieren disablen
1198 				if ((pRed = pSh->GotoRedline(nPos, sal_True)) != 0)
1199 				{
1200 					if( pSh->IsCrsrPtAtEnd() )
1201 						pSh->SwapPam();
1202 					pSh->SetInSelect();
1203 				}
1204 			}
1205 
1206 			aPopup.EnableItem( MN_EDIT_COMMENT, pEntry && pRed &&
1207 											!pTable->GetParent(pEntry) &&
1208 											!pTable->NextSelected(pEntry)
1209 //JP 27.9.2001: make no sense if we handle readonly sections
1210 //											&& pRed->HasReadonlySel()
1211 											);
1212 
1213 			aPopup.EnableItem( MN_SUB_SORT, pTable->First() != 0 );
1214 			sal_uInt16 nColumn = pTable->GetSortedCol();
1215 			if (nColumn == 0xffff)
1216 				nColumn = 4;
1217 
1218 			PopupMenu *pSubMenu = aPopup.GetPopupMenu(MN_SUB_SORT);
1219 			if (pSubMenu)
1220 			{
1221 				for (sal_uInt16 i = MN_SORT_ACTION; i < MN_SORT_ACTION + 5; i++)
1222 					pSubMenu->CheckItem(i, sal_False);
1223 
1224 				pSubMenu->CheckItem(nColumn + MN_SORT_ACTION);
1225 			}
1226 
1227 			sal_uInt16 nRet = aPopup.Execute(pTable, aCEvt.GetMousePosPixel());
1228 
1229 			switch( nRet )
1230 			{
1231 				case MN_EDIT_COMMENT:
1232 				{
1233 					String sComment;
1234 					if (pEntry)
1235 					{
1236 						if (pTable->GetParent(pEntry))
1237 							pEntry = pTable->GetParent(pEntry);
1238 
1239 						sal_uInt16 nPos = GetRedlinePos(*pEntry);
1240 						const SwRedline &rRedline = pSh->GetRedline(nPos);
1241 
1242 
1243 						/* enable again once we have redline comments in the margin
1244 						sComment = rRedline.GetComment();
1245 						if ( sComment == String(::rtl::OUString::createFromAscii("")) )
1246 							GetActiveView()->GetDocShell()->Broadcast(SwRedlineHint(&rRedline,SWREDLINE_INSERTED));
1247 						const_cast<SwRedline&>(rRedline).Broadcast(SwRedlineHint(&rRedline,SWREDLINE_FOCUS));
1248 						*/
1249 
1250 						sComment = rRedline.GetComment();
1251 						SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
1252                         DBG_ASSERT(pFact, "Dialogdiet fail!");
1253 						::DialogGetRanges fnGetRange = pFact->GetDialogGetRangesFunc( RID_SVXDLG_POSTIT );
1254                         DBG_ASSERT(fnGetRange, "Dialogdiet fail! GetRanges()");
1255 						SfxItemSet aSet( pSh->GetAttrPool(), fnGetRange() );
1256 
1257 						aSet.Put(SvxPostItTextItem(sComment.ConvertLineEnd(), SID_ATTR_POSTIT_TEXT));
1258 						aSet.Put(SvxPostItAuthorItem(rRedline.GetAuthorString(), SID_ATTR_POSTIT_AUTHOR));
1259 
1260 						aSet.Put(SvxPostItDateItem( GetAppLangDateTimeString(
1261 									rRedline.GetRedlineData().GetTimeStamp() ),
1262 									SID_ATTR_POSTIT_DATE ));
1263 
1264                         AbstractSvxPostItDialog* pDlg = pFact->CreateSvxPostItDialog( pParentDlg, aSet, sal_False );
1265                         DBG_ASSERT(pDlg, "Dialogdiet fail!");
1266 
1267 						pDlg->HideAuthor();
1268 
1269 						sal_uInt16 nResId = 0;
1270 						switch( rRedline.GetType() )
1271 						{
1272 						case nsRedlineType_t::REDLINE_INSERT:
1273 							nResId = STR_REDLINE_INSERTED;
1274 							break;
1275 						case nsRedlineType_t::REDLINE_DELETE:
1276 							nResId = STR_REDLINE_DELETED;
1277 							break;
1278 						case nsRedlineType_t::REDLINE_FORMAT:
1279 							nResId = STR_REDLINE_FORMATED;
1280 							break;
1281 						case nsRedlineType_t::REDLINE_TABLE:
1282 							nResId = STR_REDLINE_TABLECHG;
1283 							break;
1284                         default:;//prevent warning
1285 						}
1286 						String sTitle(SW_RES(STR_REDLINE_COMMENT));
1287 						if( nResId )
1288 							sTitle += SW_RESSTR( nResId );
1289 						pDlg->SetText(sTitle);
1290 
1291 						pSh->SetCareWin(pDlg->GetWindow());
1292 
1293 						if ( pDlg->Execute() == RET_OK )
1294 						{
1295 							const SfxItemSet* pOutSet = pDlg->GetOutputItemSet();
1296 							String sMsg(((const SvxPostItTextItem&)pOutSet->Get(SID_ATTR_POSTIT_TEXT)).GetValue());
1297 
1298 							// Kommentar einfuegen bzw aendern
1299 							pSh->SetRedlineComment(sMsg);
1300 							sMsg.SearchAndReplaceAll((sal_Unicode)_LF,(sal_Unicode)' ');
1301 							pTable->SetEntryText(sMsg, pEntry, 3);
1302 						}
1303 
1304 						delete pDlg;
1305 						pSh->SetCareWin(NULL);
1306 					}
1307 
1308 				}
1309 				break;
1310 
1311 			case MN_SORT_ACTION:
1312 			case MN_SORT_AUTHOR:
1313 			case MN_SORT_DATE:
1314 			case MN_SORT_COMMENT:
1315 			case MN_SORT_POSITION:
1316 				{
1317 					bSortDir = sal_True;
1318 					if (nRet - MN_SORT_ACTION == 4 && pTable->GetSortedCol() == 0xffff)
1319 						break;	// Haben wir schon
1320 
1321 					nSortMode = nRet - MN_SORT_ACTION;
1322 					if (nSortMode == 4)
1323 						nSortMode = 0xffff;	// unsortiert bzw sortiert nach Position
1324 
1325 					if (pTable->GetSortedCol() == nSortMode)
1326 						bSortDir = !pTable->GetSortDirection();
1327 
1328 					SwWait aWait( *::GetActiveView()->GetDocShell(), sal_False );
1329 					pTable->SortByCol(nSortMode, bSortDir);
1330 					if (nSortMode == 0xffff)
1331 						Init();				// Alles neu fuellen
1332 				}
1333 				break;
1334 			}
1335 		}
1336 		break;
1337 	}
1338 
1339 	return 0;
1340 }
1341 
1342 /*--------------------------------------------------------------------
1343 	Beschreibung:
1344  --------------------------------------------------------------------*/
1345 
1346 void SwRedlineAcceptDlg::Initialize(const String& rExtraData)
1347 {
1348 	if (rExtraData.Len())
1349 	{
1350 		sal_uInt16 nPos = rExtraData.Search(C2S("AcceptChgDat:"));
1351 
1352 		// Versuche, den Alignment-String "ALIGN:(...)" einzulesen; wenn
1353 		// er nicht vorhanden ist, liegt eine "altere Version vor
1354 		if (nPos != STRING_NOTFOUND)
1355 		{
1356 			sal_uInt16 n1 = rExtraData.Search('(', nPos);
1357 			if (n1 != STRING_NOTFOUND)
1358 			{
1359 				sal_uInt16 n2 = rExtraData.Search(')', n1);
1360 				if (n2 != STRING_NOTFOUND)
1361 				{
1362 					// Alignment-String herausschneiden
1363 					String aStr = rExtraData.Copy(nPos, n2 - nPos + 1);
1364 					aStr.Erase(0, n1 - nPos + 1);
1365 
1366 					if (aStr.Len())
1367 					{
1368                         sal_uInt16 nCount = static_cast< sal_uInt16 >(aStr.ToInt32());
1369 
1370 						for (sal_uInt16 i = 0; i < nCount; i++)
1371 						{
1372                             sal_uInt16 n3 = aStr.Search(';');
1373                             aStr.Erase(0, n3 + 1);
1374 							pTable->SetTab(i, aStr.ToInt32(), MAP_PIXEL);
1375 						}
1376 					}
1377 				}
1378 			}
1379 		}
1380 	}
1381 }
1382 
1383 /*--------------------------------------------------------------------
1384 	Beschreibung:
1385  --------------------------------------------------------------------*/
1386 
1387 void SwRedlineAcceptDlg::FillInfo(String &rExtraData) const
1388 {
1389 	rExtraData.AppendAscii("AcceptChgDat:(");
1390 
1391 	sal_uInt16	nCount = pTable->TabCount();
1392 
1393 	rExtraData += String::CreateFromInt32(nCount);
1394 	rExtraData += ';';
1395 	for(sal_uInt16 i = 0; i < nCount; i++)
1396 	{
1397 		rExtraData += String::CreateFromInt32( pTable->GetTab(i) );
1398 		rExtraData += ';';
1399 	}
1400 	rExtraData += ')';
1401 }
1402