?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update ooo320-m1
[ooovba.git] / sc / source / ui / docshell / docsh3.cxx
blobefc44842374fd1791b6c8375e5db0cae1be2ae00
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: docsh3.cxx,v $
10 * $Revision: 1.38.52.2 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 // MARKER(update_precomp.py): autogen include statement, do not remove
32 #include "precompiled_sc.hxx"
33
34
35
36 // INCLUDE ---------------------------------------------------------------
37
38 #include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>
39 #include <com/sun/star/document/XDocumentProperties.hpp>
40
41 #include "scitems.hxx"
42 #include "rangelst.hxx"
43 #include <svx/flstitem.hxx>
44 #include <svx/pageitem.hxx>
45 #include <svx/paperinf.hxx>
46 #include <svx/postattr.hxx>
47 //#include <svx/postdlg.hxx>
48 #include <svx/sizeitem.hxx>
49
50 #include <sfx2/viewfrm.hxx>
51 #include <sfx2/app.hxx>
52 #include <sfx2/docfile.hxx>
53 #include <svtools/misccfg.hxx>
54 #include <sfx2/printer.hxx>
55 #include <svtools/ctrltool.hxx>
56 #include <vcl/virdev.hxx>
57 #include <vcl/svapp.hxx>
58 #include <vcl/msgbox.hxx>
59 #include <unotools/localedatawrapper.hxx>
60
61 #include "docsh.hxx"
62 #include "docshimp.hxx"
63 #include "scmod.hxx"
64 #include "tabvwsh.hxx"
65 #include "viewdata.hxx"
66 #include "docpool.hxx"
67 #include "stlpool.hxx"
68 #include "patattr.hxx"
69 #include "uiitems.hxx"
70 #include "hints.hxx"
71 #include "docoptio.hxx"
72 #include "viewopti.hxx"
73 #include "pntlock.hxx"
74 #include "chgtrack.hxx"
75 #include "docfunc.hxx"
76 #include "cell.hxx"
77 #include "chgviset.hxx"
78 #include "progress.hxx"
79 #include "redcom.hxx"
80 #include "sc.hrc"
81 #include "inputopt.hxx"
82 #include "drwlayer.hxx"
83 #include "inputhdl.hxx"
84 #include "conflictsdlg.hxx"
85 #include "globstr.hrc"
86
87 #if DEBUG_CHANGETRACK
88 #include <stdio.h>
89 #endif // DEBUG_CHANGETRACK
90
91
92 //------------------------------------------------------------------
93
94 //
95 // Redraw - Benachrichtigungen
96 //
97
98
99 void ScDocShell::PostEditView( ScEditEngineDefaulter* pEditEngine, const ScAddress& rCursorPos )
100 {
101 // Broadcast( ScEditViewHint( pEditEngine, rCursorPos ) );
102
103 // Test: nur aktive ViewShell
104
105 ScTabViewShell* pViewSh = ScTabViewShell::GetActiveViewShell();
106 if (pViewSh && pViewSh->GetViewData()->GetDocShell() == this)
107 {
108 ScEditViewHint aHint( pEditEngine, rCursorPos );
109 pViewSh->Notify( *this, aHint );
110 }
111 }
112
113 void ScDocShell::PostDataChanged()
114 {
115 Broadcast( SfxSimpleHint( FID_DATACHANGED ) );
116 aDocument.ResetChanged( ScRange(0,0,0,MAXCOL,MAXROW,MAXTAB) );
117
118 SFX_APP()->Broadcast(SfxSimpleHint( FID_ANYDATACHANGED )); // Navigator
119 //! Navigator direkt benachrichtigen!
120 }
121
122 void ScDocShell::PostPaint( SCCOL nStartCol, SCROW nStartRow, SCTAB nStartTab,
123 SCCOL nEndCol, SCROW nEndRow, SCTAB nEndTab, USHORT nPart,
124 USHORT nExtFlags )
125 {
126 if (!ValidCol(nStartCol)) nStartCol = MAXCOL;
127 if (!ValidRow(nStartRow)) nStartRow = MAXROW;
128 if (!ValidCol(nEndCol)) nEndCol = MAXCOL;
129 if (!ValidRow(nEndRow)) nEndRow = MAXROW;
130
131 if ( pPaintLockData )
132 {
133 // #i54081# PAINT_EXTRAS still has to be brodcast because it changes the
134 // current sheet if it's invalid. All other flags added to pPaintLockData.
135 USHORT nLockPart = nPart & ~PAINT_EXTRAS;
136 if ( nLockPart )
137 {
138 //! nExtFlags ???
139 pPaintLockData->AddRange( ScRange( nStartCol, nStartRow, nStartTab,
140 nEndCol, nEndRow, nEndTab ), nLockPart );
141 }
142
143 nPart &= PAINT_EXTRAS; // for broadcasting
144 if ( !nPart )
145 return;
146 }
147
148
149 if (nExtFlags & SC_PF_LINES) // Platz fuer Linien beruecksichtigen
150 {
151 //! Abfrage auf versteckte Spalten/Zeilen!
152 if (nStartCol>0) --nStartCol;
153 if (nEndCol<MAXCOL) ++nEndCol;
154 if (nStartRow>0) --nStartRow;
155 if (nEndRow<MAXROW) ++nEndRow;
156 }
157
158 // um zusammengefasste erweitern
159 if (nExtFlags & SC_PF_TESTMERGE)
160 aDocument.ExtendMerge( nStartCol, nStartRow, nEndCol, nEndRow, nStartTab );
161
162 if ( nStartCol != 0 || nEndCol != MAXCOL )
163 {
164 // Extend to whole rows if SC_PF_WHOLEROWS is set, or rotated or non-left
165 // aligned cells are contained (see UpdatePaintExt).
166 // Special handling for RTL text (#i9731#) is unnecessary now with full
167 // support of right-aligned text.
168
169 if ( ( nExtFlags & SC_PF_WHOLEROWS ) ||
170 aDocument.HasAttrib( nStartCol,nStartRow,nStartTab,
171 MAXCOL,nEndRow,nEndTab, HASATTR_ROTATE | HASATTR_RIGHTORCENTER ) )
172 {
173 nStartCol = 0;
174 nEndCol = MAXCOL;
175 }
176 }
177
178 Broadcast( ScPaintHint( ScRange( nStartCol, nStartRow, nStartTab,
179 nEndCol, nEndRow, nEndTab ), nPart ) );
180
181 if ( nPart & PAINT_GRID )
182 aDocument.ResetChanged( ScRange(nStartCol,nStartRow,nStartTab,nEndCol,nEndRow,nEndTab) );
183 }
184
185 void ScDocShell::PostPaint( const ScRange& rRange, USHORT nPart, USHORT nExtFlags )
186 {
187 PostPaint( rRange.aStart.Col(), rRange.aStart.Row(), rRange.aStart.Tab(),
188 rRange.aEnd.Col(), rRange.aEnd.Row(), rRange.aEnd.Tab(),
189 nPart, nExtFlags );
190 }
191
192 void ScDocShell::PostPaintGridAll()
193 {
194 PostPaint( 0,0,0, MAXCOL,MAXROW,MAXTAB, PAINT_GRID );
195 }
196
197 void ScDocShell::PostPaintCell( SCCOL nCol, SCROW nRow, SCTAB nTab )
198 {
199 PostPaint( nCol,nRow,nTab, nCol,nRow,nTab, PAINT_GRID, SC_PF_TESTMERGE );
200 }
201
202 void ScDocShell::PostPaintCell( const ScAddress& rPos )
203 {
204 PostPaintCell( rPos.Col(), rPos.Row(), rPos.Tab() );
205 }
206
207 void ScDocShell::PostPaintExtras()
208 {
209 PostPaint( 0,0,0, MAXCOL,MAXROW,MAXTAB, PAINT_EXTRAS );
210 }
211
212 void ScDocShell::UpdatePaintExt( USHORT& rExtFlags, const ScRange& rRange )
213 {
214 if ( ( rExtFlags & SC_PF_LINES ) == 0 && aDocument.HasAttrib( rRange, HASATTR_PAINTEXT ) )
215 {
216 // If the range contains lines, shadow or conditional formats,
217 // set SC_PF_LINES to include one extra cell in all directions.
218
219 rExtFlags |= SC_PF_LINES;
220 }
221
222 if ( ( rExtFlags & SC_PF_WHOLEROWS ) == 0 &&
223 ( rRange.aStart.Col() != 0 || rRange.aEnd.Col() != MAXCOL ) &&
224 aDocument.HasAttrib( rRange, HASATTR_ROTATE | HASATTR_RIGHTORCENTER ) )
225 {
226 // If the range contains (logically) right- or center-aligned cells,
227 // or rotated cells, set SC_PF_WHOLEROWS to paint the whole rows.
228 // This test isn't needed after the cell changes, because it's also
229 // tested in PostPaint. UpdatePaintExt may later be changed to do this
230 // only if called before the changes.
231
232 rExtFlags |= SC_PF_WHOLEROWS;
233 }
234 }
235
236 void ScDocShell::UpdatePaintExt( USHORT& rExtFlags, SCCOL nStartCol, SCROW nStartRow, SCTAB nStartTab,
237 SCCOL nEndCol, SCROW nEndRow, SCTAB nEndTab )
238 {
239 UpdatePaintExt( rExtFlags, ScRange( nStartCol, nStartRow, nStartTab, nEndCol, nEndRow, nEndTab ) );
240 }
241
242 //------------------------------------------------------------------
243
244 void ScDocShell::LockPaint_Impl(BOOL bDoc)
245 {
246 if ( !pPaintLockData )
247 pPaintLockData = new ScPaintLockData(0); //! Modus...
248 pPaintLockData->IncLevel(bDoc);
249 }
250
251 void ScDocShell::UnlockPaint_Impl(BOOL bDoc)
252 {
253 if ( pPaintLockData )
254 {
255 if ( pPaintLockData->GetLevel(bDoc) )
256 pPaintLockData->DecLevel(bDoc);
257 if (!pPaintLockData->GetLevel(!bDoc) && !pPaintLockData->GetLevel(bDoc))
258 {
259 // Paint jetzt ausfuehren
260
261 ScPaintLockData* pPaint = pPaintLockData;
262 pPaintLockData = NULL; // nicht weitersammeln
263
264 ScRangeListRef xRangeList = pPaint->GetRangeList();
265 if (xRangeList)
266 {
267 USHORT nParts = pPaint->GetParts();
268 ULONG nCount = xRangeList->Count();
269 for ( ULONG i=0; i<nCount; i++ )
270 {
271 //! nExtFlags ???
272 ScRange aRange = *xRangeList->GetObject(i);
273 PostPaint( aRange.aStart.Col(), aRange.aStart.Row(), aRange.aStart.Tab(),
274 aRange.aEnd.Col(), aRange.aEnd.Row(), aRange.aEnd.Tab(),
275 nParts );
276 }
277 }
278
279 if ( pPaint->GetModified() )
280 SetDocumentModified();
281
282 delete pPaint;
283 }
284 }
285 else
286 {
287 DBG_ERROR("UnlockPaint ohne LockPaint");
288 }
289 }
290
291 void ScDocShell::LockDocument_Impl(USHORT nNew)
292 {
293 if (!nDocumentLock)
294 {
295 ScDrawLayer* pDrawLayer = aDocument.GetDrawLayer();
296 if (pDrawLayer)
297 pDrawLayer->setLock(TRUE);
298 }
299 nDocumentLock = nNew;
300 }
301
302 void ScDocShell::UnlockDocument_Impl(USHORT nNew)
303 {
304 nDocumentLock = nNew;
305 if (!nDocumentLock)
306 {
307 ScDrawLayer* pDrawLayer = aDocument.GetDrawLayer();
308 if (pDrawLayer)
309 pDrawLayer->setLock(FALSE);
310 }
311 }
312
313 USHORT ScDocShell::GetLockCount() const
314 {
315 return nDocumentLock;
316 }
317
318 void ScDocShell::SetLockCount(USHORT nNew)
319 {
320 if (nNew) // setzen
321 {
322 if ( !pPaintLockData )
323 pPaintLockData = new ScPaintLockData(0); //! Modus...
324 pPaintLockData->SetLevel(nNew-1, TRUE);
325 LockDocument_Impl(nNew);
326 }
327 else if (pPaintLockData) // loeschen
328 {
329 pPaintLockData->SetLevel(0, TRUE); // bei Unlock sofort ausfuehren
330 UnlockPaint_Impl(TRUE); // jetzt
331 UnlockDocument_Impl(0);
332 }
333 }
334
335 void ScDocShell::LockPaint()
336 {
337 LockPaint_Impl(FALSE);
338 }
339
340 void ScDocShell::UnlockPaint()
341 {
342 UnlockPaint_Impl(FALSE);
343 }
344
345 void ScDocShell::LockDocument()
346 {
347 LockPaint_Impl(TRUE);
348 LockDocument_Impl(nDocumentLock + 1);
349 }
350
351 void ScDocShell::UnlockDocument()
352 {
353 if (nDocumentLock)
354 {
355 UnlockPaint_Impl(TRUE);
356 UnlockDocument_Impl(nDocumentLock - 1);
357 }
358 else
359 {
360 DBG_ERROR("UnlockDocument without LockDocument");
361 }
362 }
363
364 //------------------------------------------------------------------
365
366 void ScDocShell::SetInplace( BOOL bInplace )
367 {
368 if (bIsInplace != bInplace)
369 {
370 bIsInplace = bInplace;
371 CalcOutputFactor();
372 }
373 }
374
375 void ScDocShell::CalcOutputFactor()
376 {
377 if (bIsInplace)
378 {
379 nPrtToScreenFactor = 1.0; // passt sonst nicht zur inaktiven Darstellung
380 return;
381 }
382
383 BOOL bTextWysiwyg = SC_MOD()->GetInputOptions().GetTextWysiwyg();
384 if (bTextWysiwyg)
385 {
386 nPrtToScreenFactor = 1.0;
387 return;
388 }
389
390 String aTestString = String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM(
391 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01234567890123456789" ));
392 long nPrinterWidth = 0;
393 long nWindowWidth = 0;
394 const ScPatternAttr* pPattern = (const ScPatternAttr*)&aDocument.GetPool()->
395 GetDefaultItem(ATTR_PATTERN);
396
397 Font aDefFont;
398 OutputDevice* pRefDev = GetRefDevice();
399 MapMode aOldMode = pRefDev->GetMapMode();
400 Font aOldFont = pRefDev->GetFont();
401
402 pRefDev->SetMapMode(MAP_PIXEL);
403 pPattern->GetFont(aDefFont, SC_AUTOCOL_BLACK, pRefDev); // font color doesn't matter here
404 pRefDev->SetFont(aDefFont);
405 nPrinterWidth = pRefDev->PixelToLogic( Size( pRefDev->GetTextWidth(aTestString), 0 ), MAP_100TH_MM ).Width();
406 pRefDev->SetFont(aOldFont);
407 pRefDev->SetMapMode(aOldMode);
408
409 VirtualDevice aVirtWindow( *Application::GetDefaultDevice() );
410 aVirtWindow.SetMapMode(MAP_PIXEL);
411 pPattern->GetFont(aDefFont, SC_AUTOCOL_BLACK, &aVirtWindow); // font color doesn't matter here
412 aVirtWindow.SetFont(aDefFont);
413 nWindowWidth = aVirtWindow.GetTextWidth(aTestString);
414 nWindowWidth = (long) ( nWindowWidth / ScGlobal::nScreenPPTX * HMM_PER_TWIPS );
415
416 if (nPrinterWidth && nWindowWidth)
417 nPrtToScreenFactor = nPrinterWidth / (double) nWindowWidth;
418 else
419 {
420 DBG_ERROR("GetTextSize gibt 0 ??");
421 nPrtToScreenFactor = 1.0;
422 }
423 }
424
425 double ScDocShell::GetOutputFactor() const
426 {
427 return nPrtToScreenFactor;
428 }
429
430 //---------------------------------------------------------------------
431
432 void ScDocShell::InitOptions() // Fortsetzung von InitNew (CLOOKs)
433 {
434 // Einstellungen aus dem SpellCheckCfg kommen in Doc- und ViewOptions
435
436 USHORT nDefLang, nCjkLang, nCtlLang;
437 BOOL bAutoSpell;
438 ScModule::GetSpellSettings( nDefLang, nCjkLang, nCtlLang, bAutoSpell );
439 ScModule* pScMod = SC_MOD();
440
441 ScDocOptions aDocOpt = pScMod->GetDocOptions();
442 ScViewOptions aViewOpt = pScMod->GetViewOptions();
443 aDocOpt.SetAutoSpell( bAutoSpell );
444
445 // zweistellige Jahreszahleneingabe aus Extras->Optionen->Allgemein->Sonstiges
446 aDocOpt.SetYear2000( sal::static_int_cast<USHORT>( SFX_APP()->GetMiscConfig()->GetYear2000() ) );
447
448 aDocument.SetDocOptions( aDocOpt );
449 aDocument.SetViewOptions( aViewOpt );
450
451 // Druck-Optionen werden jetzt direkt vor dem Drucken gesetzt
452
453 aDocument.SetLanguage( (LanguageType) nDefLang, (LanguageType) nCjkLang, (LanguageType) nCtlLang );
454 }
455
456 //---------------------------------------------------------------------
457
458 Printer* ScDocShell::GetDocumentPrinter() // fuer OLE
459 {
460 return aDocument.GetPrinter();
461 }
462
463 SfxPrinter* ScDocShell::GetPrinter(BOOL bCreateIfNotExist)
464 {
465 return aDocument.GetPrinter(bCreateIfNotExist);
466 }
467
468 void ScDocShell::UpdateFontList()
469 {
470 delete pImpl->pFontList;
471 // pImpl->pFontList = new FontList( GetPrinter(), Application::GetDefaultDevice() );
472 pImpl->pFontList = new FontList( GetRefDevice(), NULL, FALSE ); // FALSE or TRUE???
473 SvxFontListItem aFontListItem( pImpl->pFontList, SID_ATTR_CHAR_FONTLIST );
474 PutItem( aFontListItem );
475
476 CalcOutputFactor();
477 }
478
479 OutputDevice* ScDocShell::GetRefDevice()
480 {
481 return aDocument.GetRefDevice();
482 }
483
484 USHORT ScDocShell::SetPrinter( SfxPrinter* pNewPrinter, USHORT nDiffFlags )
485 {
486 SfxPrinter *pOld = aDocument.GetPrinter( FALSE );
487 if ( pOld && pOld->IsPrinting() )
488 return SFX_PRINTERROR_BUSY;
489
490 if (nDiffFlags & SFX_PRINTER_PRINTER)
491 {
492 if ( aDocument.GetPrinter() != pNewPrinter )
493 {
494 aDocument.SetPrinter( pNewPrinter );
495 aDocument.SetPrintOptions();
496
497 // MT: Use UpdateFontList: Will use Printer fonts only if needed!
498 /*
499 delete pImpl->pFontList;
500 pImpl->pFontList = new FontList( pNewPrinter, Application::GetDefaultDevice() );
501 SvxFontListItem aFontListItem( pImpl->pFontList, SID_ATTR_CHAR_FONTLIST );
502 PutItem( aFontListItem );
503
504 CalcOutputFactor();
505 */
506 if ( SC_MOD()->GetInputOptions().GetTextWysiwyg() )
507 UpdateFontList();
508
509 ScModule* pScMod = SC_MOD();
510 SfxViewFrame *pFrame = SfxViewFrame::GetFirst( this );
511 while (pFrame)
512 {
513 SfxViewShell* pSh = pFrame->GetViewShell();
514 if (pSh && pSh->ISA(ScTabViewShell))
515 {
516 ScTabViewShell* pViewSh = (ScTabViewShell*)pSh;
517 ScInputHandler* pInputHdl = pScMod->GetInputHdl(pViewSh);
518 if (pInputHdl)
519 pInputHdl->UpdateRefDevice();
520 }
521 pFrame = SfxViewFrame::GetNext( *pFrame, this );
522 }
523 }
524 }
525 else if (nDiffFlags & SFX_PRINTER_JOBSETUP)
526 {
527 SfxPrinter* pOldPrinter = aDocument.GetPrinter();
528 if (pOldPrinter)
529 {
530 pOldPrinter->SetJobSetup( pNewPrinter->GetJobSetup() );
531
532 // #i6706# Call SetPrinter with the old printer again, so the drawing layer
533 // RefDevice is set (calling ReformatAllTextObjects and rebuilding charts),
534 // because the JobSetup (printer device settings) may affect text layout.
535 aDocument.SetPrinter( pOldPrinter );
536 CalcOutputFactor(); // also with the new settings
537 }
538 }
539
540 if (nDiffFlags & SFX_PRINTER_OPTIONS)
541 {
542 aDocument.SetPrintOptions(); //! aus neuem Printer ???
543 }
544
545 if (nDiffFlags & (SFX_PRINTER_CHG_ORIENTATION | SFX_PRINTER_CHG_SIZE))
546 {
547 String aStyle = aDocument.GetPageStyle( GetCurTab() );
548 ScStyleSheetPool* pStPl = aDocument.GetStyleSheetPool();
549 SfxStyleSheet* pStyleSheet = (SfxStyleSheet*)pStPl->Find(aStyle, SFX_STYLE_FAMILY_PAGE);
550 if (pStyleSheet)
551 {
552 SfxItemSet& rSet = pStyleSheet->GetItemSet();
553
554 if (nDiffFlags & SFX_PRINTER_CHG_ORIENTATION)
555 {
556 const SvxPageItem& rOldItem = (const SvxPageItem&)rSet.Get(ATTR_PAGE);
557 BOOL bWasLand = rOldItem.IsLandscape();
558 BOOL bNewLand = ( pNewPrinter->GetOrientation() == ORIENTATION_LANDSCAPE );
559 if (bNewLand != bWasLand)
560 {
561 SvxPageItem aNewItem( rOldItem );
562 aNewItem.SetLandscape( bNewLand );
563 rSet.Put( aNewItem );
564
565 // Groesse umdrehen
566 Size aOldSize = ((const SvxSizeItem&)rSet.Get(ATTR_PAGE_SIZE)).GetSize();
567 Size aNewSize(aOldSize.Height(),aOldSize.Width());
568 SvxSizeItem aNewSItem(ATTR_PAGE_SIZE,aNewSize);
569 rSet.Put( aNewSItem );
570 }
571 }
572 if (nDiffFlags & SFX_PRINTER_CHG_SIZE)
573 {
574 SvxSizeItem aPaperSizeItem( ATTR_PAGE_SIZE, SvxPaperInfo::GetPaperSize(pNewPrinter) );
575 rSet.Put( aPaperSizeItem );
576 }
577 }
578 }
579
580 PostPaint(0,0,0,MAXCOL,MAXROW,MAXTAB,PAINT_ALL);
581
582 return 0;
583 }
584
585 //---------------------------------------------------------------------
586
587 ScChangeAction* ScDocShell::GetChangeAction( const ScAddress& rPos )
588 {
589 ScChangeTrack* pTrack = GetDocument()->GetChangeTrack();
590 if (!pTrack)
591 return NULL;
592
593 SCTAB nTab = rPos.Tab();
594
595 const ScChangeAction* pFound = NULL;
596 const ScChangeAction* pFoundContent = NULL;
597 const ScChangeAction* pFoundMove = NULL;
598 long nModified = 0;
599 const ScChangeAction* pAction = pTrack->GetFirst();
600 while (pAction)
601 {
602 ScChangeActionType eType = pAction->GetType();
603 //! ScViewUtil::IsActionShown( *pAction, *pSettings, *pDoc )...
604 if ( pAction->IsVisible() && eType != SC_CAT_DELETE_TABS )
605 {
606 const ScBigRange& rBig = pAction->GetBigRange();
607 if ( rBig.aStart.Tab() == nTab )
608 {
609 ScRange aRange = rBig.MakeRange();
610
611 if ( eType == SC_CAT_DELETE_ROWS )
612 aRange.aEnd.SetRow( aRange.aStart.Row() );
613 else if ( eType == SC_CAT_DELETE_COLS )
614 aRange.aEnd.SetCol( aRange.aStart.Col() );
615
616 if ( aRange.In( rPos ) )
617 {
618 pFound = pAction; // der letzte gewinnt
619 switch ( pAction->GetType() )
620 {
621 case SC_CAT_CONTENT :
622 pFoundContent = pAction;
623 break;
624 case SC_CAT_MOVE :
625 pFoundMove = pAction;
626 break;
627 default:
628 {
629 // added to avoid warnings
630 }
631 }
632 ++nModified;
633 }
634 }
635 if ( pAction->GetType() == SC_CAT_MOVE )
636 {
637 ScRange aRange =
638 ((const ScChangeActionMove*)pAction)->
639 GetFromRange().MakeRange();
640 if ( aRange.In( rPos ) )
641 {
642 pFound = pAction;
643 ++nModified;
644 }
645 }
646 }
647 pAction = pAction->GetNext();
648 }
649
650 return (ScChangeAction*)pFound;
651 }
652
653 void ScDocShell::SetChangeComment( ScChangeAction* pAction, const String& rComment )
654 {
655 if (pAction)
656 {
657 pAction->SetComment( rComment );
658 //! Undo ???
659 SetDocumentModified();
660
661 // Dialog-Notify
662 ScChangeTrack* pTrack = GetDocument()->GetChangeTrack();
663 if (pTrack)
664 {
665 ULONG nNumber = pAction->GetActionNumber();
666 pTrack->NotifyModified( SC_CTM_CHANGE, nNumber, nNumber );
667 }
668 }
669 }
670
671 void ScDocShell::ExecuteChangeCommentDialog( ScChangeAction* pAction, Window* pParent,BOOL bPrevNext)
672 {
673 if (!pAction) return; // ohne Aktion ist nichts..
674
675 String aComment = pAction->GetComment();
676 String aAuthor = pAction->GetUser();
677
678 DateTime aDT = pAction->GetDateTime();
679 String aDate = ScGlobal::pLocaleData->getDate( aDT );
680 aDate += ' ';
681 aDate += ScGlobal::pLocaleData->getTime( aDT, FALSE, FALSE );
682
683 SfxItemSet aSet( GetPool(),
684 SID_ATTR_POSTIT_AUTHOR, SID_ATTR_POSTIT_AUTHOR,
685 SID_ATTR_POSTIT_DATE, SID_ATTR_POSTIT_DATE,
686 SID_ATTR_POSTIT_TEXT, SID_ATTR_POSTIT_TEXT,
687 0 );
688
689 aSet.Put( SvxPostItTextItem ( aComment, SID_ATTR_POSTIT_TEXT ) );
690 aSet.Put( SvxPostItAuthorItem( aAuthor, SID_ATTR_POSTIT_AUTHOR ) );
691 aSet.Put( SvxPostItDateItem ( aDate, SID_ATTR_POSTIT_DATE ) );
692
693 ScRedComDialog* pDlg = new ScRedComDialog( pParent, aSet,this,pAction,bPrevNext);
694
695 pDlg->Execute();
696
697 delete pDlg;
698 }
699
700 //---------------------------------------------------------------------
701
702 void ScDocShell::CompareDocument( ScDocument& rOtherDoc )
703 {
704 ScChangeTrack* pTrack = aDocument.GetChangeTrack();
705 if ( pTrack && pTrack->GetFirst() )
706 {
707 //! Changes vorhanden -> Nachfrage ob geloescht werden soll
708 }
709
710 aDocument.EndChangeTracking();
711 aDocument.StartChangeTracking();
712
713 String aOldUser;
714 pTrack = aDocument.GetChangeTrack();
715 if ( pTrack )
716 {
717 aOldUser = pTrack->GetUser();
718
719 // check if comparing to same document
720
721 String aThisFile;
722 const SfxMedium* pThisMed = GetMedium();
723 if (pThisMed)
724 aThisFile = pThisMed->GetName();
725 String aOtherFile;
726 SfxObjectShell* pOtherSh = rOtherDoc.GetDocumentShell();
727 if (pOtherSh)
728 {
729 const SfxMedium* pOtherMed = pOtherSh->GetMedium();
730 if (pOtherMed)
731 aOtherFile = pOtherMed->GetName();
732 }
733 BOOL bSameDoc = ( aThisFile == aOtherFile && aThisFile.Len() );
734 if ( !bSameDoc )
735 {
736 // create change actions from comparing with the name of the user
737 // who last saved the document
738 // (only if comparing different documents)
739
740 using namespace ::com::sun::star;
741 uno::Reference<document::XDocumentPropertiesSupplier> xDPS(
742 GetModel(), uno::UNO_QUERY_THROW);
743 uno::Reference<document::XDocumentProperties> xDocProps(
744 xDPS->getDocumentProperties());
745 DBG_ASSERT(xDocProps.is(), "no DocumentProperties");
746 String aDocUser = xDocProps->getModifiedBy();
747
748 if ( aDocUser.Len() )
749 pTrack->SetUser( aDocUser );
750 }
751 }
752
753 aDocument.CompareDocument( rOtherDoc );
754
755 pTrack = aDocument.GetChangeTrack();
756 if ( pTrack )
757 pTrack->SetUser( aOldUser );
758
759 PostPaintGridAll();
760 SetDocumentModified();
761 }
762
763 //---------------------------------------------------------------------
764 //
765 // Merge (Aenderungen zusammenfuehren)
766 //
767 //---------------------------------------------------------------------
768
769 inline BOOL lcl_Equal( const ScChangeAction* pA, const ScChangeAction* pB, BOOL bIgnore100Sec )
770 {
771 return pA && pB &&
772 pA->GetActionNumber() == pB->GetActionNumber() &&
773 pA->GetType() == pB->GetType() &&
774 pA->GetUser() == pB->GetUser() &&
775 (bIgnore100Sec ?
776 pA->GetDateTimeUTC().IsEqualIgnore100Sec( pB->GetDateTimeUTC() ) :
777 pA->GetDateTimeUTC() == pB->GetDateTimeUTC());
778 // State nicht vergleichen, falls eine alte Aenderung akzeptiert wurde
779 }
780
781 bool lcl_FindAction( ScDocument* pDoc, const ScChangeAction* pAction, ScDocument* pSearchDoc, const ScChangeAction* pFirstSearchAction, const ScChangeAction* pLastSearchAction, BOOL bIgnore100Sec )
782 {
783 if ( !pDoc || !pAction || !pSearchDoc || !pFirstSearchAction || !pLastSearchAction )
784 {
785 return false;
786 }
787
788 ULONG nLastSearchAction = pLastSearchAction->GetActionNumber();
789 const ScChangeAction* pA = pFirstSearchAction;
790 while ( pA && pA->GetActionNumber() <= nLastSearchAction )
791 {
792 if ( pAction->GetType() == pA->GetType() &&
793 pAction->GetUser() == pA->GetUser() &&
794 (bIgnore100Sec ?
795 pAction->GetDateTimeUTC().IsEqualIgnore100Sec( pA->GetDateTimeUTC() ) :
796 pAction->GetDateTimeUTC() == pA->GetDateTimeUTC() ) &&
797 pAction->GetBigRange() == pA->GetBigRange() )
798 {
799 String aActionDesc;
800 pAction->GetDescription( aActionDesc, pDoc, TRUE );
801 String aADesc;
802 pA->GetDescription( aADesc, pSearchDoc, TRUE );
803 if ( aActionDesc.Equals( aADesc ) )
804 {
805 DBG_ERROR( "lcl_FindAction(): found equal action!" );
806 return true;
807 }
808 }
809 pA = pA->GetNext();
810 }
811
812 return false;
813 }
814
815 void ScDocShell::MergeDocument( ScDocument& rOtherDoc, bool bShared, bool bCheckDuplicates, ULONG nOffset, ScChangeActionMergeMap* pMergeMap, bool bInverseMap )
816 {
817 ScTabViewShell* pViewSh = GetBestViewShell( FALSE ); //! Funktionen an die DocShell
818 if (!pViewSh)
819 return;
820
821 ScChangeTrack* pSourceTrack = rOtherDoc.GetChangeTrack();
822 if (!pSourceTrack)
823 return; //! nichts zu tun - Fehlermeldung?
824
825 ScChangeTrack* pThisTrack = aDocument.GetChangeTrack();
826 if ( !pThisTrack )
827 { // anschalten
828 aDocument.StartChangeTracking();
829 pThisTrack = aDocument.GetChangeTrack();
830 DBG_ASSERT(pThisTrack,"ChangeTracking nicht angeschaltet?");
831 if ( !bShared )
832 {
833 // #51138# visuelles RedLining einschalten
834 ScChangeViewSettings aChangeViewSet;
835 aChangeViewSet.SetShowChanges(TRUE);
836 aDocument.SetChangeViewSettings(aChangeViewSet);
837 }
838 }
839
840 // #97286# include 100th seconds in compare?
841 BOOL bIgnore100Sec = !pSourceTrack->IsTime100thSeconds() ||
842 !pThisTrack->IsTime100thSeconds();
843
844 // gemeinsame Ausgangsposition suchen
845 ULONG nFirstNewNumber = 0;
846 const ScChangeAction* pSourceAction = pSourceTrack->GetFirst();
847 const ScChangeAction* pThisAction = pThisTrack->GetFirst();
848 // skip identical actions
849 while ( lcl_Equal( pSourceAction, pThisAction, bIgnore100Sec ) )
850 {
851 nFirstNewNumber = pSourceAction->GetActionNumber() + 1;
852 pSourceAction = pSourceAction->GetNext();
853 pThisAction = pThisAction->GetNext();
854 }
855 // pSourceAction und pThisAction zeigen jetzt auf die ersten "eigenen" Aktionen
856 // Die gemeinsamen Aktionen davor interessieren ueberhaupt nicht
857
858 //! Abfrage, ob die Dokumente vor dem Change-Tracking gleich waren !!!
859
860
861 const ScChangeAction* pFirstMergeAction = pSourceAction;
862 const ScChangeAction* pFirstSearchAction = pThisAction;
863
864 // #i94841# [Collaboration] When deleting rows is rejected, the content is sometimes wrong
865 const ScChangeAction* pLastSearchAction = pThisTrack->GetLast();
866
867 // MergeChangeData aus den folgenden Aktionen erzeugen
868 ULONG nNewActionCount = 0;
869 const ScChangeAction* pCount = pSourceAction;
870 while ( pCount )
871 {
872 if ( bShared || !ScChangeTrack::MergeIgnore( *pCount, nFirstNewNumber ) )
873 ++nNewActionCount;
874 pCount = pCount->GetNext();
875 }
876 if (!nNewActionCount)
877 return; //! nichts zu tun - Fehlermeldung?
878 // ab hier kein return mehr
879
880 ScProgress aProgress( this,
881 String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("...")),
882 nNewActionCount );
883
884 ULONG nLastMergeAction = pSourceTrack->GetLast()->GetActionNumber();
885 // UpdateReference-Undo, gueltige Referenzen fuer den letzten gemeinsamen Zustand
886 pSourceTrack->MergePrepare( (ScChangeAction*) pFirstMergeAction, bShared );
887
888 // MergeChangeData an alle noch folgenden Aktionen in diesem Dokument anpassen
889 // -> Referenzen gueltig fuer dieses Dokument
890 while ( pThisAction )
891 {
892 // #i87049# [Collaboration] Conflict between delete row and insert content is not merged correctly
893 if ( !bShared || !ScChangeTrack::MergeIgnore( *pThisAction, nFirstNewNumber ) )
894 {
895 ScChangeActionType eType = pThisAction->GetType();
896 switch ( eType )
897 {
898 case SC_CAT_INSERT_COLS :
899 case SC_CAT_INSERT_ROWS :
900 case SC_CAT_INSERT_TABS :
901 pSourceTrack->AppendInsert( pThisAction->GetBigRange().MakeRange() );
902 break;
903 case SC_CAT_DELETE_COLS :
904 case SC_CAT_DELETE_ROWS :
905 case SC_CAT_DELETE_TABS :
906 {
907 const ScChangeActionDel* pDel = (const ScChangeActionDel*) pThisAction;
908 if ( pDel->IsTopDelete() && !pDel->IsTabDeleteCol() )
909 { // deleted Table enthaelt deleted Cols, die nicht
910 ULONG nStart, nEnd;
911 pSourceTrack->AppendDeleteRange(
912 pDel->GetOverAllRange().MakeRange(), NULL, nStart, nEnd );
913 }
914 }
915 break;
916 case SC_CAT_MOVE :
917 {
918 const ScChangeActionMove* pMove = (const ScChangeActionMove*) pThisAction;
919 pSourceTrack->AppendMove( pMove->GetFromRange().MakeRange(),
920 pMove->GetBigRange().MakeRange(), NULL );
921 }
922 break;
923 default:
924 {
925 // added to avoid warnings
926 }
927 }
928 }
929 pThisAction = pThisAction->GetNext();
930 }
931
932 LockPaint(); // #i73877# no repainting after each action
933
934 // MergeChangeData in das aktuelle Dokument uebernehmen
935 BOOL bHasRejected = FALSE;
936 String aOldUser = pThisTrack->GetUser();
937 pThisTrack->SetUseFixDateTime( TRUE );
938 ScMarkData& rMarkData = pViewSh->GetViewData()->GetMarkData();
939 ScMarkData aOldMarkData( rMarkData );
940 pSourceAction = pFirstMergeAction;
941 while ( pSourceAction && pSourceAction->GetActionNumber() <= nLastMergeAction )
942 {
943 bool bMergeAction = false;
944 if ( bShared )
945 {
946 if ( !bCheckDuplicates || !lcl_FindAction( &rOtherDoc, pSourceAction, &aDocument, pFirstSearchAction, pLastSearchAction, bIgnore100Sec ) )
947 {
948 bMergeAction = true;
949 }
950 }
951 else
952 {
953 if ( !ScChangeTrack::MergeIgnore( *pSourceAction, nFirstNewNumber ) )
954 {
955 bMergeAction = true;
956 }
957 }
958
959 if ( bMergeAction )
960 {
961 ScChangeActionType eSourceType = pSourceAction->GetType();
962 if ( !bShared && pSourceAction->IsDeletedIn() )
963 {
964 //! muss hier noch festgestellt werden, ob wirklich in
965 //! _diesem_ Dokument geloescht?
966
967 // liegt in einem Bereich, der in diesem Dokument geloescht wurde
968 // -> wird weggelassen
969 //! ??? Loesch-Aktion rueckgaengig machen ???
970 //! ??? Aktion irgendwo anders speichern ???
971 #ifndef PRODUCT
972 String aValue;
973 if ( eSourceType == SC_CAT_CONTENT )
974 ((const ScChangeActionContent*)pSourceAction)->GetNewString( aValue );
975 ByteString aError( aValue, gsl_getSystemTextEncoding() );
976 aError += " weggelassen";
977 DBG_ERROR( aError.GetBuffer() );
978 #endif
979 }
980 else
981 {
982 //! Datum/Autor/Kommentar der Source-Aktion uebernehmen!
983
984 pThisTrack->SetUser( pSourceAction->GetUser() );
985 pThisTrack->SetFixDateTimeUTC( pSourceAction->GetDateTimeUTC() );
986 ULONG nOldActionMax = pThisTrack->GetActionMax();
987
988 bool bExecute = true;
989 ULONG nReject = pSourceAction->GetRejectAction();
990 if ( nReject )
991 {
992 if ( bShared )
993 {
994 if ( nReject >= nFirstNewNumber )
995 {
996 nReject += nOffset;
997 }
998 ScChangeAction* pOldAction = pThisTrack->GetAction( nReject );
999 if ( pOldAction && pOldAction->IsVirgin() )
1000 {
1001 pThisTrack->Reject( pOldAction );
1002 bHasRejected = TRUE;
1003 bExecute = false;
1004 }
1005 }
1006 else
1007 {
1008 // alte Aktion (aus den gemeinsamen) ablehnen
1009 ScChangeAction* pOldAction = pThisTrack->GetAction( nReject );
1010 if (pOldAction && pOldAction->GetState() == SC_CAS_VIRGIN)
1011 {
1012 //! was passiert bei Aktionen, die in diesem Dokument accepted worden sind???
1013 //! Fehlermeldung oder was???
1014 //! oder Reject-Aenderung normal ausfuehren
1015
1016 pThisTrack->Reject(pOldAction);
1017 bHasRejected = TRUE; // fuer Paint
1018 }
1019 bExecute = false;
1020 }
1021 }
1022
1023 if ( bExecute )
1024 {
1025 // normal ausfuehren
1026 ScRange aSourceRange = pSourceAction->GetBigRange().MakeRange();
1027 rMarkData.SelectOneTable( aSourceRange.aStart.Tab() );
1028 switch ( eSourceType )
1029 {
1030 case SC_CAT_CONTENT:
1031 {
1032 //! Test, ob es ganz unten im Dokument war, dann automatisches
1033 //! Zeilen-Einfuegen ???
1034
1035 DBG_ASSERT( aSourceRange.aStart == aSourceRange.aEnd, "huch?" );
1036 ScAddress aPos = aSourceRange.aStart;
1037 String aValue;
1038 ((const ScChangeActionContent*)pSourceAction)->GetNewString( aValue );
1039 BYTE eMatrix = MM_NONE;
1040 const ScBaseCell* pCell = ((const ScChangeActionContent*)pSourceAction)->GetNewCell();
1041 if ( pCell && pCell->GetCellType() == CELLTYPE_FORMULA )
1042 eMatrix = ((const ScFormulaCell*)pCell)->GetMatrixFlag();
1043 switch ( eMatrix )
1044 {
1045 case MM_NONE :
1046 pViewSh->EnterData( aPos.Col(), aPos.Row(), aPos.Tab(), aValue );
1047 break;
1048 case MM_FORMULA :
1049 {
1050 SCCOL nCols;
1051 SCROW nRows;
1052 ((const ScFormulaCell*)pCell)->GetMatColsRows( nCols, nRows );
1053 aSourceRange.aEnd.SetCol( aPos.Col() + nCols - 1 );
1054 aSourceRange.aEnd.SetRow( aPos.Row() + nRows - 1 );
1055 aValue.Erase( 0, 1 );
1056 aValue.Erase( aValue.Len()-1, 1 );
1057 GetDocFunc().EnterMatrix( aSourceRange,
1058 NULL, NULL, aValue, FALSE, FALSE,
1059 EMPTY_STRING, formula::FormulaGrammar::GRAM_DEFAULT );
1060 }
1061 break;
1062 case MM_REFERENCE : // do nothing
1063 break;
1064 case MM_FAKE :
1065 DBG_WARNING( "MergeDocument: MatrixFlag MM_FAKE" );
1066 pViewSh->EnterData( aPos.Col(), aPos.Row(), aPos.Tab(), aValue );
1067 break;
1068 default:
1069 DBG_ERROR( "MergeDocument: unknown MatrixFlag" );
1070 }
1071 }
1072 break;
1073 case SC_CAT_INSERT_TABS :
1074 {
1075 String aName;
1076 aDocument.CreateValidTabName( aName );
1077 GetDocFunc().InsertTable( aSourceRange.aStart.Tab(), aName, TRUE, FALSE );
1078 }
1079 break;
1080 case SC_CAT_INSERT_ROWS:
1081 GetDocFunc().InsertCells( aSourceRange, NULL, INS_INSROWS, TRUE, FALSE );
1082 break;
1083 case SC_CAT_INSERT_COLS:
1084 GetDocFunc().InsertCells( aSourceRange, NULL, INS_INSCOLS, TRUE, FALSE );
1085 break;
1086 case SC_CAT_DELETE_TABS :
1087 GetDocFunc().DeleteTable( aSourceRange.aStart.Tab(), TRUE, FALSE );
1088 break;
1089 case SC_CAT_DELETE_ROWS:
1090 {
1091 const ScChangeActionDel* pDel = (const ScChangeActionDel*) pSourceAction;
1092 if ( pDel->IsTopDelete() )
1093 {
1094 aSourceRange = pDel->GetOverAllRange().MakeRange();
1095 GetDocFunc().DeleteCells( aSourceRange, NULL, DEL_DELROWS, TRUE, FALSE );
1096 }
1097 }
1098 break;
1099 case SC_CAT_DELETE_COLS:
1100 {
1101 const ScChangeActionDel* pDel = (const ScChangeActionDel*) pSourceAction;
1102 if ( pDel->IsTopDelete() && !pDel->IsTabDeleteCol() )
1103 { // deleted Table enthaelt deleted Cols, die nicht
1104 aSourceRange = pDel->GetOverAllRange().MakeRange();
1105 GetDocFunc().DeleteCells( aSourceRange, NULL, DEL_DELCOLS, TRUE, FALSE );
1106 }
1107 }
1108 break;
1109 case SC_CAT_MOVE :
1110 {
1111 const ScChangeActionMove* pMove = (const ScChangeActionMove*) pSourceAction;
1112 ScRange aFromRange( pMove->GetFromRange().MakeRange() );
1113 GetDocFunc().MoveBlock( aFromRange,
1114 aSourceRange.aStart, TRUE, TRUE, FALSE, FALSE );
1115 }
1116 break;
1117 default:
1118 {
1119 // added to avoid warnings
1120 }
1121 }
1122 }
1123 const String& rComment = pSourceAction->GetComment();
1124 if ( rComment.Len() )
1125 {
1126 ScChangeAction* pAct = pThisTrack->GetLast();
1127 if ( pAct && pAct->GetActionNumber() > nOldActionMax )
1128 pAct->SetComment( rComment );
1129 #ifndef PRODUCT
1130 else
1131 DBG_ERROR( "MergeDocument: wohin mit dem Kommentar?!?" );
1132 #endif
1133 }
1134
1135 // Referenzen anpassen
1136 pSourceTrack->MergeOwn( (ScChangeAction*) pSourceAction, nFirstNewNumber, bShared );
1137
1138 // merge action state
1139 if ( bShared && !pSourceAction->IsRejected() )
1140 {
1141 ScChangeAction* pAct = pThisTrack->GetLast();
1142 if ( pAct && pAct->GetActionNumber() > nOldActionMax )
1143 {
1144 pThisTrack->MergeActionState( pAct, pSourceAction );
1145 }
1146 }
1147
1148 // fill merge map
1149 if ( bShared && pMergeMap )
1150 {
1151 ScChangeAction* pAct = pThisTrack->GetLast();
1152 if ( pAct && pAct->GetActionNumber() > nOldActionMax )
1153 {
1154 ULONG nActionMax = pAct->GetActionNumber();
1155 ULONG nActionCount = nActionMax - nOldActionMax;
1156 ULONG nAction = nActionMax - nActionCount + 1;
1157 ULONG nSourceAction = pSourceAction->GetActionNumber() - nActionCount + 1;
1158 while ( nAction <= nActionMax )
1159 {
1160 if ( bInverseMap )
1161 {
1162 (*pMergeMap)[ nAction++ ] = nSourceAction++;
1163 }
1164 else
1165 {
1166 (*pMergeMap)[ nSourceAction++ ] = nAction++;
1167 }
1168 }
1169 }
1170 }
1171 }
1172 aProgress.SetStateCountDown( --nNewActionCount );
1173 }
1174 pSourceAction = pSourceAction->GetNext();
1175 }
1176
1177 rMarkData = aOldMarkData;
1178 pThisTrack->SetUser(aOldUser);
1179 pThisTrack->SetUseFixDateTime( FALSE );
1180
1181 pSourceTrack->Clear(); //! der ist jetzt verhunzt
1182
1183 if (bHasRejected)
1184 PostPaintGridAll(); // Reject() paintet nicht selber
1185
1186 UnlockPaint();
1187 }
1188
1189 bool ScDocShell::MergeSharedDocument( ScDocShell* pSharedDocShell )
1190 {
1191 if ( !pSharedDocShell )
1192 {
1193 return false;
1194 }
1195
1196 ScChangeTrack* pThisTrack = aDocument.GetChangeTrack();
1197 if ( !pThisTrack )
1198 {
1199 return false;
1200 }
1201
1202 ScDocument& rSharedDoc = *( pSharedDocShell->GetDocument() );
1203 ScChangeTrack* pSharedTrack = rSharedDoc.GetChangeTrack();
1204 if ( !pSharedTrack )
1205 {
1206 return false;
1207 }
1208
1209 #if DEBUG_CHANGETRACK
1210 ::rtl::OUString aMessage = ::rtl::OUString::createFromAscii( "\nbefore merge:\n" );
1211 aMessage += pThisTrack->ToString();
1212 ::rtl::OString aMsg = ::rtl::OUStringToOString( aMessage, RTL_TEXTENCODING_UTF8 );
1213 OSL_ENSURE( false, aMsg.getStr() );
1214 //fprintf( stdout, "%s ", aMsg.getStr() );
1215 //fflush( stdout );
1216 #endif // DEBUG_CHANGETRACK
1217
1218 // reset show changes
1219 ScChangeViewSettings aChangeViewSet;
1220 aChangeViewSet.SetShowChanges( FALSE );
1221 aDocument.SetChangeViewSettings( aChangeViewSet );
1222
1223 // find first merge action in this document
1224 BOOL bIgnore100Sec = !pThisTrack->IsTime100thSeconds() || !pSharedTrack->IsTime100thSeconds();
1225 ScChangeAction* pThisAction = pThisTrack->GetFirst();
1226 ScChangeAction* pSharedAction = pSharedTrack->GetFirst();
1227 while ( lcl_Equal( pThisAction, pSharedAction, bIgnore100Sec ) )
1228 {
1229 pThisAction = pThisAction->GetNext();
1230 pSharedAction = pSharedAction->GetNext();
1231 }
1232
1233 if ( pSharedAction )
1234 {
1235 if ( pThisAction )
1236 {
1237 // merge own changes into shared document
1238 ULONG nActStartShared = pSharedAction->GetActionNumber();
1239 ULONG nActEndShared = pSharedTrack->GetActionMax();
1240 ScDocument* pTmpDoc = new ScDocument;
1241 for ( sal_Int32 nIndex = 0; nIndex < aDocument.GetTableCount(); ++nIndex )
1242 {
1243 String sTabName;
1244 pTmpDoc->CreateValidTabName( sTabName );
1245 pTmpDoc->InsertTab( SC_TAB_APPEND, sTabName );
1246 }
1247 aDocument.GetChangeTrack()->Clone( pTmpDoc );
1248 ScChangeActionMergeMap aOwnInverseMergeMap;
1249 pSharedDocShell->MergeDocument( *pTmpDoc, true, true, 0, &aOwnInverseMergeMap, true );
1250 delete pTmpDoc;
1251 ULONG nActStartOwn = nActEndShared + 1;
1252 ULONG nActEndOwn = pSharedTrack->GetActionMax();
1253
1254 // find conflicts
1255 ScConflictsList aConflictsList;
1256 ScConflictsFinder aFinder( pSharedTrack, nActStartShared, nActEndShared, nActStartOwn, nActEndOwn, aConflictsList );
1257 if ( aFinder.Find() )
1258 {
1259 ScConflictsListHelper::TransformConflictsList( aConflictsList, NULL, &aOwnInverseMergeMap );
1260 bool bLoop = true;
1261 while ( bLoop )
1262 {
1263 bLoop = false;
1264 ScConflictsDlg aDlg( GetActiveDialogParent(), GetViewData(), &rSharedDoc, aConflictsList );
1265 if ( aDlg.Execute() == RET_CANCEL )
1266 {
1267 QueryBox aBox( GetActiveDialogParent(), WinBits( WB_YES_NO | WB_DEF_YES ),
1268 ScGlobal::GetRscString( STR_DOC_WILLNOTBESAVED ) );
1269 if ( aBox.Execute() == RET_YES )
1270 {
1271 return false;
1272 }
1273 else
1274 {
1275 bLoop = true;
1276 }
1277 }
1278 }
1279 }
1280
1281 // undo own changes in shared document
1282 pSharedTrack->Undo( nActStartOwn, nActEndOwn );
1283
1284 // clone change track for merging into own document
1285 pTmpDoc = new ScDocument;
1286 for ( sal_Int32 nIndex = 0; nIndex < aDocument.GetTableCount(); ++nIndex )
1287 {
1288 String sTabName;
1289 pTmpDoc->CreateValidTabName( sTabName );
1290 pTmpDoc->InsertTab( SC_TAB_APPEND, sTabName );
1291 }
1292 pThisTrack->Clone( pTmpDoc );
1293
1294 // undo own changes since last save in own document
1295 ULONG nStartShared = pThisAction->GetActionNumber();
1296 ScChangeAction* pAction = pThisTrack->GetLast();
1297 while ( pAction && pAction->GetActionNumber() >= nStartShared )
1298 {
1299 pThisTrack->Reject( pAction, true );
1300 pAction = pAction->GetPrev();
1301 }
1302
1303 // #i94841# [Collaboration] When deleting rows is rejected, the content is sometimes wrong
1304 pThisTrack->Undo( nStartShared, pThisTrack->GetActionMax(), true );
1305
1306 // merge shared changes into own document
1307 ScChangeActionMergeMap aSharedMergeMap;
1308 MergeDocument( rSharedDoc, true, true, 0, &aSharedMergeMap );
1309 ULONG nEndShared = pThisTrack->GetActionMax();
1310
1311 // resolve conflicts for shared non-content actions
1312 if ( !aConflictsList.empty() )
1313 {
1314 ScConflictsListHelper::TransformConflictsList( aConflictsList, &aSharedMergeMap, NULL );
1315 ScConflictsResolver aResolver( pThisTrack, aConflictsList );
1316 pAction = pThisTrack->GetAction( nEndShared );
1317 while ( pAction && pAction->GetActionNumber() >= nStartShared )
1318 {
1319 aResolver.HandleAction( pAction, true /*bIsSharedAction*/,
1320 false /*bHandleContentAction*/, true /*bHandleNonContentAction*/ );
1321 pAction = pAction->GetPrev();
1322 }
1323 }
1324 nEndShared = pThisTrack->GetActionMax();
1325
1326 // only show changes from shared document
1327 aChangeViewSet.SetShowChanges( TRUE );
1328 aChangeViewSet.SetShowAccepted( TRUE );
1329 aChangeViewSet.SetHasActionRange( true );
1330 aChangeViewSet.SetTheActionRange( nStartShared, nEndShared );
1331 aDocument.SetChangeViewSettings( aChangeViewSet );
1332
1333 // merge own changes back into own document
1334 ULONG nStartOwn = nEndShared + 1;
1335 ScChangeActionMergeMap aOwnMergeMap;
1336 MergeDocument( *pTmpDoc, true, true, nEndShared - nStartShared + 1, &aOwnMergeMap );
1337 delete pTmpDoc;
1338 ULONG nEndOwn = pThisTrack->GetActionMax();
1339
1340 // resolve conflicts for shared content actions and own actions
1341 if ( !aConflictsList.empty() )
1342 {
1343 ScConflictsListHelper::TransformConflictsList( aConflictsList, NULL, &aOwnMergeMap );
1344 ScConflictsResolver aResolver( pThisTrack, aConflictsList );
1345 pAction = pThisTrack->GetAction( nEndShared );
1346 while ( pAction && pAction->GetActionNumber() >= nStartShared )
1347 {
1348 aResolver.HandleAction( pAction, true /*bIsSharedAction*/,
1349 true /*bHandleContentAction*/, false /*bHandleNonContentAction*/ );
1350 pAction = pAction->GetPrev();
1351 }
1352
1353 pAction = pThisTrack->GetAction( nEndOwn );
1354 while ( pAction && pAction->GetActionNumber() >= nStartOwn )
1355 {
1356 aResolver.HandleAction( pAction, false /*bIsSharedAction*/,
1357 true /*bHandleContentAction*/, true /*bHandleNonContentAction*/ );
1358 pAction = pAction->GetPrev();
1359 }
1360 }
1361 nEndOwn = pThisTrack->GetActionMax();
1362 }
1363 else
1364 {
1365 // merge shared changes into own document
1366 ULONG nStartShared = pThisTrack->GetActionMax() + 1;
1367 MergeDocument( rSharedDoc, true, true );
1368 ULONG nEndShared = pThisTrack->GetActionMax();
1369
1370 // only show changes from shared document
1371 aChangeViewSet.SetShowChanges( TRUE );
1372 aChangeViewSet.SetShowAccepted( TRUE );
1373 aChangeViewSet.SetHasActionRange( true );
1374 aChangeViewSet.SetTheActionRange( nStartShared, nEndShared );
1375 aDocument.SetChangeViewSettings( aChangeViewSet );
1376 }
1377
1378 // update view
1379 PostPaintExtras();
1380 PostPaintGridAll();
1381
1382 InfoBox aInfoBox( GetActiveDialogParent(), ScGlobal::GetRscString( STR_DOC_UPDATED ) );
1383 aInfoBox.Execute();
1384 }
1385
1386 #if DEBUG_CHANGETRACK
1387 aMessage = ::rtl::OUString::createFromAscii( "\nafter merge:\n" );
1388 aMessage += pThisTrack->ToString();
1389 aMsg = ::rtl::OUStringToOString( aMessage, RTL_TEXTENCODING_UTF8 );
1390 OSL_ENSURE( false, aMsg.getStr() );
1391 //fprintf( stdout, "%s ", aMsg.getStr() );
1392 //fflush( stdout );
1393 #endif // DEBUG_CHANGETRACK
1394
1395 return ( pThisAction != NULL );
1396 }
vba interoperability for OOo