1*b1cdbd2cSJim Jagielski /**************************************************************
2*b1cdbd2cSJim Jagielski *
3*b1cdbd2cSJim Jagielski * Licensed to the Apache Software Foundation (ASF) under one
4*b1cdbd2cSJim Jagielski * or more contributor license agreements. See the NOTICE file
5*b1cdbd2cSJim Jagielski * distributed with this work for additional information
6*b1cdbd2cSJim Jagielski * regarding copyright ownership. The ASF licenses this file
7*b1cdbd2cSJim Jagielski * to you under the Apache License, Version 2.0 (the
8*b1cdbd2cSJim Jagielski * "License"); you may not use this file except in compliance
9*b1cdbd2cSJim Jagielski * with the License. You may obtain a copy of the License at
10*b1cdbd2cSJim Jagielski *
11*b1cdbd2cSJim Jagielski * http://www.apache.org/licenses/LICENSE-2.0
12*b1cdbd2cSJim Jagielski *
13*b1cdbd2cSJim Jagielski * Unless required by applicable law or agreed to in writing,
14*b1cdbd2cSJim Jagielski * software distributed under the License is distributed on an
15*b1cdbd2cSJim Jagielski * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16*b1cdbd2cSJim Jagielski * KIND, either express or implied. See the License for the
17*b1cdbd2cSJim Jagielski * specific language governing permissions and limitations
18*b1cdbd2cSJim Jagielski * under the License.
19*b1cdbd2cSJim Jagielski *
20*b1cdbd2cSJim Jagielski *************************************************************/
21*b1cdbd2cSJim Jagielski
22*b1cdbd2cSJim Jagielski
23*b1cdbd2cSJim Jagielski
24*b1cdbd2cSJim Jagielski // MARKER(update_precomp.py): autogen include statement, do not remove
25*b1cdbd2cSJim Jagielski #include "precompiled_sw.hxx"
26*b1cdbd2cSJim Jagielski
27*b1cdbd2cSJim Jagielski #include <UndoTable.hxx>
28*b1cdbd2cSJim Jagielski
29*b1cdbd2cSJim Jagielski #include <UndoRedline.hxx>
30*b1cdbd2cSJim Jagielski #include <UndoDelete.hxx>
31*b1cdbd2cSJim Jagielski #include <UndoSplitMove.hxx>
32*b1cdbd2cSJim Jagielski #include <UndoCore.hxx>
33*b1cdbd2cSJim Jagielski #include <hintids.hxx>
34*b1cdbd2cSJim Jagielski #include <hints.hxx>
35*b1cdbd2cSJim Jagielski #include <editeng/brkitem.hxx>
36*b1cdbd2cSJim Jagielski #include <fmtornt.hxx>
37*b1cdbd2cSJim Jagielski #include <fmtpdsc.hxx>
38*b1cdbd2cSJim Jagielski #include <doc.hxx>
39*b1cdbd2cSJim Jagielski #include <IDocumentUndoRedo.hxx>
40*b1cdbd2cSJim Jagielski #include <editsh.hxx>
41*b1cdbd2cSJim Jagielski #include <docary.hxx>
42*b1cdbd2cSJim Jagielski #include <ndtxt.hxx>
43*b1cdbd2cSJim Jagielski #include <swtable.hxx>
44*b1cdbd2cSJim Jagielski #include <pam.hxx>
45*b1cdbd2cSJim Jagielski #include <cntfrm.hxx>
46*b1cdbd2cSJim Jagielski #include <tblsel.hxx>
47*b1cdbd2cSJim Jagielski #include <swundo.hxx> // fuer die UndoIds
48*b1cdbd2cSJim Jagielski #include <rolbck.hxx>
49*b1cdbd2cSJim Jagielski #include <ddefld.hxx>
50*b1cdbd2cSJim Jagielski #include <tabcol.hxx>
51*b1cdbd2cSJim Jagielski #include <tabfrm.hxx>
52*b1cdbd2cSJim Jagielski #include <rowfrm.hxx>
53*b1cdbd2cSJim Jagielski #include <cellfrm.hxx>
54*b1cdbd2cSJim Jagielski #include <swcache.hxx>
55*b1cdbd2cSJim Jagielski #include <tblafmt.hxx>
56*b1cdbd2cSJim Jagielski #include <poolfmt.hxx>
57*b1cdbd2cSJim Jagielski #include <mvsave.hxx>
58*b1cdbd2cSJim Jagielski #include <cellatr.hxx>
59*b1cdbd2cSJim Jagielski #include <swtblfmt.hxx>
60*b1cdbd2cSJim Jagielski #include <swddetbl.hxx>
61*b1cdbd2cSJim Jagielski #include <redline.hxx>
62*b1cdbd2cSJim Jagielski #include <node2lay.hxx>
63*b1cdbd2cSJim Jagielski #include <tblrwcl.hxx>
64*b1cdbd2cSJim Jagielski #include <fmtanchr.hxx>
65*b1cdbd2cSJim Jagielski #include <comcore.hrc>
66*b1cdbd2cSJim Jagielski #include <unochart.hxx>
67*b1cdbd2cSJim Jagielski #include <switerator.hxx>
68*b1cdbd2cSJim Jagielski
69*b1cdbd2cSJim Jagielski #ifndef DBG_UTIL
70*b1cdbd2cSJim Jagielski #define CHECK_TABLE(t)
71*b1cdbd2cSJim Jagielski #else
72*b1cdbd2cSJim Jagielski #ifdef DEBUG
73*b1cdbd2cSJim Jagielski #define CHECK_TABLE(t) (t).CheckConsistency();
74*b1cdbd2cSJim Jagielski #else
75*b1cdbd2cSJim Jagielski #define CHECK_TABLE(t)
76*b1cdbd2cSJim Jagielski #endif
77*b1cdbd2cSJim Jagielski #endif
78*b1cdbd2cSJim Jagielski
79*b1cdbd2cSJim Jagielski #ifndef DBG_UTIL
80*b1cdbd2cSJim Jagielski #define _DEBUG_REDLINE( pDoc )
81*b1cdbd2cSJim Jagielski #else
82*b1cdbd2cSJim Jagielski void lcl_DebugRedline( const SwDoc* pDoc );
83*b1cdbd2cSJim Jagielski #define _DEBUG_REDLINE( pDoc ) lcl_DebugRedline( pDoc );
84*b1cdbd2cSJim Jagielski #endif
85*b1cdbd2cSJim Jagielski
86*b1cdbd2cSJim Jagielski extern void ClearFEShellTabCols();
87*b1cdbd2cSJim Jagielski
88*b1cdbd2cSJim Jagielski typedef SfxItemSet* SfxItemSetPtr;
89*b1cdbd2cSJim Jagielski SV_DECL_PTRARR_DEL( SfxItemSets, SfxItemSetPtr, 10, 5 )
90*b1cdbd2cSJim Jagielski
91*b1cdbd2cSJim Jagielski typedef SwUndoSaveSection* SwUndoSaveSectionPtr;
92*b1cdbd2cSJim Jagielski SV_DECL_PTRARR_DEL( SwUndoSaveSections, SwUndoSaveSectionPtr, 0, 10 )
93*b1cdbd2cSJim Jagielski
94*b1cdbd2cSJim Jagielski typedef SwUndoMove* SwUndoMovePtr;
95*b1cdbd2cSJim Jagielski SV_DECL_PTRARR_DEL( SwUndoMoves, SwUndoMovePtr, 0, 10 )
96*b1cdbd2cSJim Jagielski
97*b1cdbd2cSJim Jagielski struct SwTblToTxtSave;
98*b1cdbd2cSJim Jagielski typedef SwTblToTxtSave* SwTblToTxtSavePtr;
99*b1cdbd2cSJim Jagielski SV_DECL_PTRARR_DEL( SwTblToTxtSaves, SwTblToTxtSavePtr, 0, 10 )
100*b1cdbd2cSJim Jagielski
101*b1cdbd2cSJim Jagielski struct _UndoTblCpyTbl_Entry
102*b1cdbd2cSJim Jagielski {
103*b1cdbd2cSJim Jagielski sal_uLong nBoxIdx, nOffset;
104*b1cdbd2cSJim Jagielski SfxItemSet* pBoxNumAttr;
105*b1cdbd2cSJim Jagielski SwUndo* pUndo;
106*b1cdbd2cSJim Jagielski
107*b1cdbd2cSJim Jagielski // Was the last paragraph of the new and the first paragraph of the old content joined?
108*b1cdbd2cSJim Jagielski bool bJoin; // For redlining only
109*b1cdbd2cSJim Jagielski
110*b1cdbd2cSJim Jagielski _UndoTblCpyTbl_Entry( const SwTableBox& rBox );
111*b1cdbd2cSJim Jagielski ~_UndoTblCpyTbl_Entry();
112*b1cdbd2cSJim Jagielski };
113*b1cdbd2cSJim Jagielski typedef _UndoTblCpyTbl_Entry* _UndoTblCpyTbl_EntryPtr;
114*b1cdbd2cSJim Jagielski SV_DECL_PTRARR_DEL( _UndoTblCpyTbl_Entries, _UndoTblCpyTbl_EntryPtr, 0, 10 )
115*b1cdbd2cSJim Jagielski
116*b1cdbd2cSJim Jagielski class _SaveBox;
117*b1cdbd2cSJim Jagielski class _SaveLine;
118*b1cdbd2cSJim Jagielski
119*b1cdbd2cSJim Jagielski class _SaveTable
120*b1cdbd2cSJim Jagielski {
121*b1cdbd2cSJim Jagielski friend class _SaveBox;
122*b1cdbd2cSJim Jagielski friend class _SaveLine;
123*b1cdbd2cSJim Jagielski SfxItemSet aTblSet;
124*b1cdbd2cSJim Jagielski _SaveLine* pLine;
125*b1cdbd2cSJim Jagielski const SwTable* pSwTable;
126*b1cdbd2cSJim Jagielski SfxItemSets aSets;
127*b1cdbd2cSJim Jagielski SwFrmFmts aFrmFmts;
128*b1cdbd2cSJim Jagielski sal_uInt16 nLineCount;
129*b1cdbd2cSJim Jagielski sal_Bool bModifyBox : 1;
130*b1cdbd2cSJim Jagielski sal_Bool bSaveFormula : 1;
131*b1cdbd2cSJim Jagielski sal_Bool bNewModel : 1;
132*b1cdbd2cSJim Jagielski
133*b1cdbd2cSJim Jagielski public:
134*b1cdbd2cSJim Jagielski _SaveTable( const SwTable& rTbl, sal_uInt16 nLnCnt = USHRT_MAX,
135*b1cdbd2cSJim Jagielski sal_Bool bSaveFml = sal_True );
136*b1cdbd2cSJim Jagielski ~_SaveTable();
137*b1cdbd2cSJim Jagielski
138*b1cdbd2cSJim Jagielski sal_uInt16 AddFmt( SwFrmFmt* pFmt, bool bIsLine );
139*b1cdbd2cSJim Jagielski void NewFrmFmt( const SwTableLine* , const SwTableBox*, sal_uInt16 nFmtPos,
140*b1cdbd2cSJim Jagielski SwFrmFmt* pOldFmt );
141*b1cdbd2cSJim Jagielski
142*b1cdbd2cSJim Jagielski void RestoreAttr( SwTable& rTbl, sal_Bool bModifyBox = sal_False );
143*b1cdbd2cSJim Jagielski void SaveCntntAttrs( SwDoc* pDoc );
144*b1cdbd2cSJim Jagielski void CreateNew( SwTable& rTbl, sal_Bool bCreateFrms = sal_True,
145*b1cdbd2cSJim Jagielski sal_Bool bRestoreChart = sal_True );
IsNewModel() const146*b1cdbd2cSJim Jagielski sal_Bool IsNewModel() const { return bNewModel; }
147*b1cdbd2cSJim Jagielski };
148*b1cdbd2cSJim Jagielski
149*b1cdbd2cSJim Jagielski class _SaveLine
150*b1cdbd2cSJim Jagielski {
151*b1cdbd2cSJim Jagielski friend class _SaveTable;
152*b1cdbd2cSJim Jagielski friend class _SaveBox;
153*b1cdbd2cSJim Jagielski
154*b1cdbd2cSJim Jagielski _SaveLine* pNext;
155*b1cdbd2cSJim Jagielski _SaveBox* pBox;
156*b1cdbd2cSJim Jagielski sal_uInt16 nItemSet;
157*b1cdbd2cSJim Jagielski
158*b1cdbd2cSJim Jagielski public:
159*b1cdbd2cSJim Jagielski
160*b1cdbd2cSJim Jagielski _SaveLine( _SaveLine* pPrev, const SwTableLine& rLine, _SaveTable& rSTbl );
161*b1cdbd2cSJim Jagielski ~_SaveLine();
162*b1cdbd2cSJim Jagielski
163*b1cdbd2cSJim Jagielski void RestoreAttr( SwTableLine& rLine, _SaveTable& rSTbl );
164*b1cdbd2cSJim Jagielski void SaveCntntAttrs( SwDoc* pDoc );
165*b1cdbd2cSJim Jagielski
166*b1cdbd2cSJim Jagielski void CreateNew( SwTable& rTbl, SwTableBox& rParent, _SaveTable& rSTbl );
167*b1cdbd2cSJim Jagielski };
168*b1cdbd2cSJim Jagielski
169*b1cdbd2cSJim Jagielski class _SaveBox
170*b1cdbd2cSJim Jagielski {
171*b1cdbd2cSJim Jagielski friend class _SaveLine;
172*b1cdbd2cSJim Jagielski
173*b1cdbd2cSJim Jagielski _SaveBox* pNext;
174*b1cdbd2cSJim Jagielski sal_uLong nSttNode;
175*b1cdbd2cSJim Jagielski long nRowSpan;
176*b1cdbd2cSJim Jagielski sal_uInt16 nItemSet;
177*b1cdbd2cSJim Jagielski union
178*b1cdbd2cSJim Jagielski {
179*b1cdbd2cSJim Jagielski SfxItemSets* pCntntAttrs;
180*b1cdbd2cSJim Jagielski _SaveLine* pLine;
181*b1cdbd2cSJim Jagielski } Ptrs;
182*b1cdbd2cSJim Jagielski
183*b1cdbd2cSJim Jagielski public:
184*b1cdbd2cSJim Jagielski _SaveBox( _SaveBox* pPrev, const SwTableBox& rBox, _SaveTable& rSTbl );
185*b1cdbd2cSJim Jagielski ~_SaveBox();
186*b1cdbd2cSJim Jagielski
187*b1cdbd2cSJim Jagielski void RestoreAttr( SwTableBox& rBox, _SaveTable& rSTbl );
188*b1cdbd2cSJim Jagielski void SaveCntntAttrs( SwDoc* pDoc );
189*b1cdbd2cSJim Jagielski
190*b1cdbd2cSJim Jagielski void CreateNew( SwTable& rTbl, SwTableLine& rParent, _SaveTable& rSTbl );
191*b1cdbd2cSJim Jagielski };
192*b1cdbd2cSJim Jagielski
193*b1cdbd2cSJim Jagielski void InsertSort( SvUShorts& rArr, sal_uInt16 nIdx, sal_uInt16* pInsPos = 0 );
194*b1cdbd2cSJim Jagielski void InsertSort( SvULongs& rArr, sal_uLong nIdx, sal_uInt16* pInsPos = 0 );
195*b1cdbd2cSJim Jagielski
196*b1cdbd2cSJim Jagielski #if defined( JP_DEBUG ) && defined(DBG_UTIL)
197*b1cdbd2cSJim Jagielski #include "shellio.hxx"
198*b1cdbd2cSJim Jagielski void DumpDoc( SwDoc* pDoc, const String& rFileNm );
199*b1cdbd2cSJim Jagielski void CheckTable( const SwTable& );
200*b1cdbd2cSJim Jagielski #define DUMPDOC(p,s) DumpDoc( p, s);
201*b1cdbd2cSJim Jagielski #define CHECKTABLE(t) CheckTable( t );
202*b1cdbd2cSJim Jagielski #else
203*b1cdbd2cSJim Jagielski #define DUMPDOC(p,s)
204*b1cdbd2cSJim Jagielski #define CHECKTABLE(t)
205*b1cdbd2cSJim Jagielski #endif
206*b1cdbd2cSJim Jagielski
207*b1cdbd2cSJim Jagielski /* #130880: Crash in undo of table to text when the table has (freshly) merged cells
208*b1cdbd2cSJim Jagielski The order of cell content nodes in the nodes array is not given by the recursive table structure.
209*b1cdbd2cSJim Jagielski The algorithmn must not rely on this even it holds for a fresh loaded table in odt file format.
210*b1cdbd2cSJim Jagielski So we need to remember not only the start node position but the end node position as well.
211*b1cdbd2cSJim Jagielski */
212*b1cdbd2cSJim Jagielski
213*b1cdbd2cSJim Jagielski struct SwTblToTxtSave
214*b1cdbd2cSJim Jagielski {
215*b1cdbd2cSJim Jagielski sal_uLong m_nSttNd;
216*b1cdbd2cSJim Jagielski sal_uLong m_nEndNd;
217*b1cdbd2cSJim Jagielski xub_StrLen m_nCntnt;
218*b1cdbd2cSJim Jagielski SwHistory* m_pHstry;
219*b1cdbd2cSJim Jagielski // metadata references for first and last paragraph in cell
220*b1cdbd2cSJim Jagielski ::boost::shared_ptr< ::sfx2::MetadatableUndo > m_pMetadataUndoStart;
221*b1cdbd2cSJim Jagielski ::boost::shared_ptr< ::sfx2::MetadatableUndo > m_pMetadataUndoEnd;
222*b1cdbd2cSJim Jagielski
223*b1cdbd2cSJim Jagielski SwTblToTxtSave( SwDoc& rDoc, sal_uLong nNd, sal_uLong nEndIdx, xub_StrLen nCntnt );
~SwTblToTxtSaveSwTblToTxtSave224*b1cdbd2cSJim Jagielski ~SwTblToTxtSave() { delete m_pHstry; }
225*b1cdbd2cSJim Jagielski };
226*b1cdbd2cSJim Jagielski
227*b1cdbd2cSJim Jagielski SV_IMPL_PTRARR( SfxItemSets, SfxItemSetPtr )
228*b1cdbd2cSJim Jagielski SV_IMPL_PTRARR( SwUndoSaveSections, SwUndoSaveSectionPtr )
229*b1cdbd2cSJim Jagielski SV_IMPL_PTRARR( SwUndoMoves, SwUndoMovePtr )
230*b1cdbd2cSJim Jagielski SV_IMPL_PTRARR( SwTblToTxtSaves, SwTblToTxtSavePtr )
231*b1cdbd2cSJim Jagielski SV_IMPL_PTRARR( _UndoTblCpyTbl_Entries, _UndoTblCpyTbl_EntryPtr )
232*b1cdbd2cSJim Jagielski
233*b1cdbd2cSJim Jagielski sal_uInt16 __FAR_DATA aSave_BoxCntntSet[] = {
234*b1cdbd2cSJim Jagielski RES_CHRATR_COLOR, RES_CHRATR_CROSSEDOUT,
235*b1cdbd2cSJim Jagielski RES_CHRATR_FONT, RES_CHRATR_FONTSIZE,
236*b1cdbd2cSJim Jagielski RES_CHRATR_POSTURE, RES_CHRATR_POSTURE,
237*b1cdbd2cSJim Jagielski RES_CHRATR_SHADOWED, RES_CHRATR_WEIGHT,
238*b1cdbd2cSJim Jagielski RES_PARATR_ADJUST, RES_PARATR_ADJUST,
239*b1cdbd2cSJim Jagielski 0 };
240*b1cdbd2cSJim Jagielski
241*b1cdbd2cSJim Jagielski
242*b1cdbd2cSJim Jagielski
SwUndoInsTbl(const SwPosition & rPos,sal_uInt16 nCl,sal_uInt16 nRw,sal_uInt16 nAdj,const SwInsertTableOptions & rInsTblOpts,const SwTableAutoFmt * pTAFmt,const SvUShorts * pColArr,const String & rName)243*b1cdbd2cSJim Jagielski SwUndoInsTbl::SwUndoInsTbl( const SwPosition& rPos, sal_uInt16 nCl, sal_uInt16 nRw,
244*b1cdbd2cSJim Jagielski sal_uInt16 nAdj, const SwInsertTableOptions& rInsTblOpts,
245*b1cdbd2cSJim Jagielski const SwTableAutoFmt* pTAFmt,
246*b1cdbd2cSJim Jagielski const SvUShorts* pColArr,
247*b1cdbd2cSJim Jagielski const String & rName)
248*b1cdbd2cSJim Jagielski : SwUndo( UNDO_INSTABLE ),
249*b1cdbd2cSJim Jagielski aInsTblOpts( rInsTblOpts ), pDDEFldType( 0 ), pColWidth( 0 ), pRedlData( 0 ), pAutoFmt( 0 ),
250*b1cdbd2cSJim Jagielski nSttNode( rPos.nNode.GetIndex() ), nRows( nRw ), nCols( nCl ), nAdjust( nAdj )
251*b1cdbd2cSJim Jagielski {
252*b1cdbd2cSJim Jagielski if( pColArr )
253*b1cdbd2cSJim Jagielski {
254*b1cdbd2cSJim Jagielski pColWidth = new SvUShorts( 0, 1 );
255*b1cdbd2cSJim Jagielski pColWidth->Insert( pColArr, 0 );
256*b1cdbd2cSJim Jagielski }
257*b1cdbd2cSJim Jagielski if( pTAFmt )
258*b1cdbd2cSJim Jagielski pAutoFmt = new SwTableAutoFmt( *pTAFmt );
259*b1cdbd2cSJim Jagielski
260*b1cdbd2cSJim Jagielski // Redline beachten
261*b1cdbd2cSJim Jagielski SwDoc& rDoc = *rPos.nNode.GetNode().GetDoc();
262*b1cdbd2cSJim Jagielski if( rDoc.IsRedlineOn() )
263*b1cdbd2cSJim Jagielski {
264*b1cdbd2cSJim Jagielski pRedlData = new SwRedlineData( nsRedlineType_t::REDLINE_INSERT, rDoc.GetRedlineAuthor() );
265*b1cdbd2cSJim Jagielski SetRedlineMode( rDoc.GetRedlineMode() );
266*b1cdbd2cSJim Jagielski }
267*b1cdbd2cSJim Jagielski
268*b1cdbd2cSJim Jagielski sTblNm = rName;
269*b1cdbd2cSJim Jagielski }
270*b1cdbd2cSJim Jagielski
271*b1cdbd2cSJim Jagielski
~SwUndoInsTbl()272*b1cdbd2cSJim Jagielski SwUndoInsTbl::~SwUndoInsTbl()
273*b1cdbd2cSJim Jagielski {
274*b1cdbd2cSJim Jagielski delete pDDEFldType;
275*b1cdbd2cSJim Jagielski delete pColWidth;
276*b1cdbd2cSJim Jagielski delete pRedlData;
277*b1cdbd2cSJim Jagielski delete pAutoFmt;
278*b1cdbd2cSJim Jagielski }
279*b1cdbd2cSJim Jagielski
UndoImpl(::sw::UndoRedoContext & rContext)280*b1cdbd2cSJim Jagielski void SwUndoInsTbl::UndoImpl(::sw::UndoRedoContext & rContext)
281*b1cdbd2cSJim Jagielski {
282*b1cdbd2cSJim Jagielski SwDoc & rDoc = rContext.GetDoc();
283*b1cdbd2cSJim Jagielski SwNodeIndex aIdx( rDoc.GetNodes(), nSttNode );
284*b1cdbd2cSJim Jagielski
285*b1cdbd2cSJim Jagielski SwTableNode* pTblNd = aIdx.GetNode().GetTableNode();
286*b1cdbd2cSJim Jagielski ASSERT( pTblNd, "kein TabellenNode" );
287*b1cdbd2cSJim Jagielski pTblNd->DelFrms();
288*b1cdbd2cSJim Jagielski
289*b1cdbd2cSJim Jagielski if( IDocumentRedlineAccess::IsRedlineOn( GetRedlineMode() ))
290*b1cdbd2cSJim Jagielski rDoc.DeleteRedline( *pTblNd, true, USHRT_MAX );
291*b1cdbd2cSJim Jagielski RemoveIdxFromSection( rDoc, nSttNode );
292*b1cdbd2cSJim Jagielski
293*b1cdbd2cSJim Jagielski // harte SeitenUmbrueche am nachfolgenden Node verschieben
294*b1cdbd2cSJim Jagielski SwCntntNode* pNextNd = rDoc.GetNodes()[ pTblNd->EndOfSectionIndex()+1 ]->GetCntntNode();
295*b1cdbd2cSJim Jagielski if( pNextNd )
296*b1cdbd2cSJim Jagielski {
297*b1cdbd2cSJim Jagielski SwFrmFmt* pTableFmt = pTblNd->GetTable().GetFrmFmt();
298*b1cdbd2cSJim Jagielski const SfxPoolItem *pItem;
299*b1cdbd2cSJim Jagielski
300*b1cdbd2cSJim Jagielski if( SFX_ITEM_SET == pTableFmt->GetItemState( RES_PAGEDESC,
301*b1cdbd2cSJim Jagielski sal_False, &pItem ) )
302*b1cdbd2cSJim Jagielski pNextNd->SetAttr( *pItem );
303*b1cdbd2cSJim Jagielski
304*b1cdbd2cSJim Jagielski if( SFX_ITEM_SET == pTableFmt->GetItemState( RES_BREAK,
305*b1cdbd2cSJim Jagielski sal_False, &pItem ) )
306*b1cdbd2cSJim Jagielski pNextNd->SetAttr( *pItem );
307*b1cdbd2cSJim Jagielski }
308*b1cdbd2cSJim Jagielski
309*b1cdbd2cSJim Jagielski
310*b1cdbd2cSJim Jagielski sTblNm = pTblNd->GetTable().GetFrmFmt()->GetName();
311*b1cdbd2cSJim Jagielski if( pTblNd->GetTable().IsA( TYPE( SwDDETable )) )
312*b1cdbd2cSJim Jagielski pDDEFldType = (SwDDEFieldType*)((SwDDETable&)pTblNd->GetTable()).
313*b1cdbd2cSJim Jagielski GetDDEFldType()->Copy();
314*b1cdbd2cSJim Jagielski
315*b1cdbd2cSJim Jagielski rDoc.GetNodes().Delete( aIdx, pTblNd->EndOfSectionIndex() -
316*b1cdbd2cSJim Jagielski aIdx.GetIndex() + 1 );
317*b1cdbd2cSJim Jagielski
318*b1cdbd2cSJim Jagielski SwPaM & rPam( rContext.GetCursorSupplier().CreateNewShellCursor() );
319*b1cdbd2cSJim Jagielski rPam.DeleteMark();
320*b1cdbd2cSJim Jagielski rPam.GetPoint()->nNode = aIdx;
321*b1cdbd2cSJim Jagielski rPam.GetPoint()->nContent.Assign( rPam.GetCntntNode(), 0 );
322*b1cdbd2cSJim Jagielski }
323*b1cdbd2cSJim Jagielski
324*b1cdbd2cSJim Jagielski
RedoImpl(::sw::UndoRedoContext & rContext)325*b1cdbd2cSJim Jagielski void SwUndoInsTbl::RedoImpl(::sw::UndoRedoContext & rContext)
326*b1cdbd2cSJim Jagielski {
327*b1cdbd2cSJim Jagielski SwDoc & rDoc = rContext.GetDoc();
328*b1cdbd2cSJim Jagielski
329*b1cdbd2cSJim Jagielski SwPosition const aPos(SwNodeIndex(rDoc.GetNodes(), nSttNode));
330*b1cdbd2cSJim Jagielski const SwTable* pTbl = rDoc.InsertTable( aInsTblOpts, aPos, nRows, nCols,
331*b1cdbd2cSJim Jagielski nAdjust,
332*b1cdbd2cSJim Jagielski pAutoFmt, pColWidth );
333*b1cdbd2cSJim Jagielski ((SwFrmFmt*)pTbl->GetFrmFmt())->SetName( sTblNm );
334*b1cdbd2cSJim Jagielski SwTableNode* pTblNode = (SwTableNode*)rDoc.GetNodes()[nSttNode]->GetTableNode();
335*b1cdbd2cSJim Jagielski
336*b1cdbd2cSJim Jagielski if( pDDEFldType )
337*b1cdbd2cSJim Jagielski {
338*b1cdbd2cSJim Jagielski SwDDEFieldType* pNewType = (SwDDEFieldType*)rDoc.InsertFldType(
339*b1cdbd2cSJim Jagielski *pDDEFldType);
340*b1cdbd2cSJim Jagielski SwDDETable* pDDETbl = new SwDDETable( pTblNode->GetTable(), pNewType );
341*b1cdbd2cSJim Jagielski pTblNode->SetNewTable( pDDETbl ); // setze die DDE-Tabelle
342*b1cdbd2cSJim Jagielski delete pDDEFldType, pDDEFldType = 0;
343*b1cdbd2cSJim Jagielski }
344*b1cdbd2cSJim Jagielski
345*b1cdbd2cSJim Jagielski if( (pRedlData && IDocumentRedlineAccess::IsRedlineOn( GetRedlineMode() )) ||
346*b1cdbd2cSJim Jagielski ( !( nsRedlineMode_t::REDLINE_IGNORE & GetRedlineMode() ) &&
347*b1cdbd2cSJim Jagielski rDoc.GetRedlineTbl().Count() ))
348*b1cdbd2cSJim Jagielski {
349*b1cdbd2cSJim Jagielski SwPaM aPam( *pTblNode->EndOfSectionNode(), *pTblNode, 1 );
350*b1cdbd2cSJim Jagielski SwCntntNode* pCNd = aPam.GetCntntNode( sal_False );
351*b1cdbd2cSJim Jagielski if( pCNd )
352*b1cdbd2cSJim Jagielski aPam.GetMark()->nContent.Assign( pCNd, 0 );
353*b1cdbd2cSJim Jagielski
354*b1cdbd2cSJim Jagielski if( pRedlData && IDocumentRedlineAccess::IsRedlineOn( GetRedlineMode() ) )
355*b1cdbd2cSJim Jagielski {
356*b1cdbd2cSJim Jagielski RedlineMode_t eOld = rDoc.GetRedlineMode();
357*b1cdbd2cSJim Jagielski rDoc.SetRedlineMode_intern((RedlineMode_t)(eOld & ~nsRedlineMode_t::REDLINE_IGNORE));
358*b1cdbd2cSJim Jagielski
359*b1cdbd2cSJim Jagielski rDoc.AppendRedline( new SwRedline( *pRedlData, aPam ), true);
360*b1cdbd2cSJim Jagielski rDoc.SetRedlineMode_intern( eOld );
361*b1cdbd2cSJim Jagielski }
362*b1cdbd2cSJim Jagielski else
363*b1cdbd2cSJim Jagielski rDoc.SplitRedline( aPam );
364*b1cdbd2cSJim Jagielski }
365*b1cdbd2cSJim Jagielski }
366*b1cdbd2cSJim Jagielski
367*b1cdbd2cSJim Jagielski
RepeatImpl(::sw::RepeatContext & rContext)368*b1cdbd2cSJim Jagielski void SwUndoInsTbl::RepeatImpl(::sw::RepeatContext & rContext)
369*b1cdbd2cSJim Jagielski {
370*b1cdbd2cSJim Jagielski rContext.GetDoc().InsertTable(
371*b1cdbd2cSJim Jagielski aInsTblOpts, *rContext.GetRepeatPaM().GetPoint(),
372*b1cdbd2cSJim Jagielski nRows, nCols, nAdjust, pAutoFmt, pColWidth );
373*b1cdbd2cSJim Jagielski }
374*b1cdbd2cSJim Jagielski
GetRewriter() const375*b1cdbd2cSJim Jagielski SwRewriter SwUndoInsTbl::GetRewriter() const
376*b1cdbd2cSJim Jagielski {
377*b1cdbd2cSJim Jagielski SwRewriter aRewriter;
378*b1cdbd2cSJim Jagielski
379*b1cdbd2cSJim Jagielski aRewriter.AddRule(UNDO_ARG1, SW_RES(STR_START_QUOTE));
380*b1cdbd2cSJim Jagielski aRewriter.AddRule(UNDO_ARG2, sTblNm);
381*b1cdbd2cSJim Jagielski aRewriter.AddRule(UNDO_ARG3, SW_RES(STR_END_QUOTE));
382*b1cdbd2cSJim Jagielski
383*b1cdbd2cSJim Jagielski return aRewriter;
384*b1cdbd2cSJim Jagielski }
385*b1cdbd2cSJim Jagielski
386*b1cdbd2cSJim Jagielski // -----------------------------------------------------
387*b1cdbd2cSJim Jagielski
SwTblToTxtSave(SwDoc & rDoc,sal_uLong nNd,sal_uLong nEndIdx,xub_StrLen nCnt)388*b1cdbd2cSJim Jagielski SwTblToTxtSave::SwTblToTxtSave( SwDoc& rDoc, sal_uLong nNd, sal_uLong nEndIdx, xub_StrLen nCnt )
389*b1cdbd2cSJim Jagielski : m_nSttNd( nNd ), m_nEndNd( nEndIdx), m_nCntnt( nCnt ), m_pHstry( 0 )
390*b1cdbd2cSJim Jagielski {
391*b1cdbd2cSJim Jagielski // Attributierung des gejointen Node merken.
392*b1cdbd2cSJim Jagielski SwTxtNode* pNd = rDoc.GetNodes()[ nNd ]->GetTxtNode();
393*b1cdbd2cSJim Jagielski if( pNd )
394*b1cdbd2cSJim Jagielski {
395*b1cdbd2cSJim Jagielski m_pHstry = new SwHistory;
396*b1cdbd2cSJim Jagielski
397*b1cdbd2cSJim Jagielski m_pHstry->Add( pNd->GetTxtColl(), nNd, ND_TEXTNODE );
398*b1cdbd2cSJim Jagielski if ( pNd->GetpSwpHints() )
399*b1cdbd2cSJim Jagielski {
400*b1cdbd2cSJim Jagielski m_pHstry->CopyAttr( pNd->GetpSwpHints(), nNd, 0,
401*b1cdbd2cSJim Jagielski pNd->GetTxt().Len(), false );
402*b1cdbd2cSJim Jagielski }
403*b1cdbd2cSJim Jagielski if( pNd->HasSwAttrSet() )
404*b1cdbd2cSJim Jagielski m_pHstry->CopyFmtAttr( *pNd->GetpSwAttrSet(), nNd );
405*b1cdbd2cSJim Jagielski
406*b1cdbd2cSJim Jagielski if( !m_pHstry->Count() )
407*b1cdbd2cSJim Jagielski delete m_pHstry, m_pHstry = 0;
408*b1cdbd2cSJim Jagielski
409*b1cdbd2cSJim Jagielski // METADATA: store
410*b1cdbd2cSJim Jagielski m_pMetadataUndoStart = pNd->CreateUndo();
411*b1cdbd2cSJim Jagielski }
412*b1cdbd2cSJim Jagielski
413*b1cdbd2cSJim Jagielski // we also need to store the metadata reference of the _last_ paragraph
414*b1cdbd2cSJim Jagielski // we subtract 1 to account for the removed cell start/end node pair
415*b1cdbd2cSJim Jagielski // (after SectionUp, the end of the range points to the node after the cell)
416*b1cdbd2cSJim Jagielski if ( nEndIdx - 1 > nNd )
417*b1cdbd2cSJim Jagielski {
418*b1cdbd2cSJim Jagielski SwTxtNode* pLastNode( rDoc.GetNodes()[ nEndIdx - 1 ]->GetTxtNode() );
419*b1cdbd2cSJim Jagielski if( pLastNode )
420*b1cdbd2cSJim Jagielski {
421*b1cdbd2cSJim Jagielski // METADATA: store
422*b1cdbd2cSJim Jagielski m_pMetadataUndoEnd = pLastNode->CreateUndo();
423*b1cdbd2cSJim Jagielski }
424*b1cdbd2cSJim Jagielski }
425*b1cdbd2cSJim Jagielski }
426*b1cdbd2cSJim Jagielski
SwUndoTblToTxt(const SwTable & rTbl,sal_Unicode cCh)427*b1cdbd2cSJim Jagielski SwUndoTblToTxt::SwUndoTblToTxt( const SwTable& rTbl, sal_Unicode cCh )
428*b1cdbd2cSJim Jagielski : SwUndo( UNDO_TABLETOTEXT ),
429*b1cdbd2cSJim Jagielski sTblNm( rTbl.GetFrmFmt()->GetName() ), pDDEFldType( 0 ), pHistory( 0 ),
430*b1cdbd2cSJim Jagielski nSttNd( 0 ), nEndNd( 0 ),
431*b1cdbd2cSJim Jagielski nAdjust( static_cast<sal_uInt16>(rTbl.GetFrmFmt()->GetHoriOrient().GetHoriOrient()) ),
432*b1cdbd2cSJim Jagielski cTrenner( cCh ), nHdlnRpt( rTbl.GetRowsToRepeat() )
433*b1cdbd2cSJim Jagielski {
434*b1cdbd2cSJim Jagielski pTblSave = new _SaveTable( rTbl );
435*b1cdbd2cSJim Jagielski pBoxSaves = new SwTblToTxtSaves( (sal_uInt8)rTbl.GetTabSortBoxes().Count() );
436*b1cdbd2cSJim Jagielski
437*b1cdbd2cSJim Jagielski if( rTbl.IsA( TYPE( SwDDETable ) ) )
438*b1cdbd2cSJim Jagielski pDDEFldType = (SwDDEFieldType*)((SwDDETable&)rTbl).GetDDEFldType()->Copy();
439*b1cdbd2cSJim Jagielski
440*b1cdbd2cSJim Jagielski bCheckNumFmt = rTbl.GetFrmFmt()->GetDoc()->IsInsTblFormatNum();
441*b1cdbd2cSJim Jagielski
442*b1cdbd2cSJim Jagielski pHistory = new SwHistory;
443*b1cdbd2cSJim Jagielski const SwTableNode* pTblNd = rTbl.GetTableNode();
444*b1cdbd2cSJim Jagielski sal_uLong nTblStt = pTblNd->GetIndex(), nTblEnd = pTblNd->EndOfSectionIndex();
445*b1cdbd2cSJim Jagielski
446*b1cdbd2cSJim Jagielski const SwSpzFrmFmts& rFrmFmtTbl = *pTblNd->GetDoc()->GetSpzFrmFmts();
447*b1cdbd2cSJim Jagielski for( sal_uInt16 n = 0; n < rFrmFmtTbl.Count(); ++n )
448*b1cdbd2cSJim Jagielski {
449*b1cdbd2cSJim Jagielski SwFrmFmt* pFmt = rFrmFmtTbl[ n ];
450*b1cdbd2cSJim Jagielski SwFmtAnchor const*const pAnchor = &pFmt->GetAnchor();
451*b1cdbd2cSJim Jagielski SwPosition const*const pAPos = pAnchor->GetCntntAnchor();
452*b1cdbd2cSJim Jagielski if (pAPos &&
453*b1cdbd2cSJim Jagielski ((FLY_AT_CHAR == pAnchor->GetAnchorId()) ||
454*b1cdbd2cSJim Jagielski (FLY_AT_PARA == pAnchor->GetAnchorId())) &&
455*b1cdbd2cSJim Jagielski nTblStt <= pAPos->nNode.GetIndex() &&
456*b1cdbd2cSJim Jagielski pAPos->nNode.GetIndex() < nTblEnd )
457*b1cdbd2cSJim Jagielski {
458*b1cdbd2cSJim Jagielski pHistory->Add( *pFmt );
459*b1cdbd2cSJim Jagielski }
460*b1cdbd2cSJim Jagielski }
461*b1cdbd2cSJim Jagielski
462*b1cdbd2cSJim Jagielski if( !pHistory->Count() )
463*b1cdbd2cSJim Jagielski delete pHistory, pHistory = 0;
464*b1cdbd2cSJim Jagielski }
465*b1cdbd2cSJim Jagielski
466*b1cdbd2cSJim Jagielski
~SwUndoTblToTxt()467*b1cdbd2cSJim Jagielski SwUndoTblToTxt::~SwUndoTblToTxt()
468*b1cdbd2cSJim Jagielski {
469*b1cdbd2cSJim Jagielski delete pDDEFldType;
470*b1cdbd2cSJim Jagielski delete pTblSave;
471*b1cdbd2cSJim Jagielski delete pBoxSaves;
472*b1cdbd2cSJim Jagielski delete pHistory;
473*b1cdbd2cSJim Jagielski }
474*b1cdbd2cSJim Jagielski
475*b1cdbd2cSJim Jagielski
476*b1cdbd2cSJim Jagielski
UndoImpl(::sw::UndoRedoContext & rContext)477*b1cdbd2cSJim Jagielski void SwUndoTblToTxt::UndoImpl(::sw::UndoRedoContext & rContext)
478*b1cdbd2cSJim Jagielski {
479*b1cdbd2cSJim Jagielski SwDoc & rDoc = rContext.GetDoc();
480*b1cdbd2cSJim Jagielski SwPaM *const pPam(& rContext.GetCursorSupplier().CreateNewShellCursor());
481*b1cdbd2cSJim Jagielski
482*b1cdbd2cSJim Jagielski SwNodeIndex aFrmIdx( rDoc.GetNodes(), nSttNd );
483*b1cdbd2cSJim Jagielski SwNodeIndex aEndIdx( rDoc.GetNodes(), nEndNd );
484*b1cdbd2cSJim Jagielski
485*b1cdbd2cSJim Jagielski pPam->GetPoint()->nNode = aFrmIdx;
486*b1cdbd2cSJim Jagielski pPam->SetMark();
487*b1cdbd2cSJim Jagielski pPam->GetPoint()->nNode = aEndIdx;
488*b1cdbd2cSJim Jagielski rDoc.DelNumRules( *pPam );
489*b1cdbd2cSJim Jagielski pPam->DeleteMark();
490*b1cdbd2cSJim Jagielski
491*b1cdbd2cSJim Jagielski // dann sammel mal alle Uppers ein
492*b1cdbd2cSJim Jagielski SwNode2Layout aNode2Layout( aFrmIdx.GetNode() );
493*b1cdbd2cSJim Jagielski
494*b1cdbd2cSJim Jagielski // erzeuge die TabelleNode Structur
495*b1cdbd2cSJim Jagielski SwTableNode* pTblNd = rDoc.GetNodes().UndoTableToText( nSttNd, nEndNd, *pBoxSaves );
496*b1cdbd2cSJim Jagielski pTblNd->GetTable().SetTableModel( pTblSave->IsNewModel() );
497*b1cdbd2cSJim Jagielski SwTableFmt* pTableFmt = rDoc.MakeTblFrmFmt( sTblNm, rDoc.GetDfltFrmFmt() );
498*b1cdbd2cSJim Jagielski pTblNd->GetTable().RegisterToFormat( *pTableFmt );
499*b1cdbd2cSJim Jagielski pTblNd->GetTable().SetRowsToRepeat( nHdlnRpt );
500*b1cdbd2cSJim Jagielski
501*b1cdbd2cSJim Jagielski // erzeuge die alte Tabellen Struktur
502*b1cdbd2cSJim Jagielski pTblSave->CreateNew( pTblNd->GetTable() );
503*b1cdbd2cSJim Jagielski
504*b1cdbd2cSJim Jagielski if( pDDEFldType )
505*b1cdbd2cSJim Jagielski {
506*b1cdbd2cSJim Jagielski SwDDEFieldType* pNewType = (SwDDEFieldType*)rDoc.InsertFldType(
507*b1cdbd2cSJim Jagielski *pDDEFldType);
508*b1cdbd2cSJim Jagielski SwDDETable* pDDETbl = new SwDDETable( pTblNd->GetTable(), pNewType );
509*b1cdbd2cSJim Jagielski pTblNd->SetNewTable( pDDETbl, sal_False ); // setze die DDE-Tabelle
510*b1cdbd2cSJim Jagielski delete pDDEFldType, pDDEFldType = 0;
511*b1cdbd2cSJim Jagielski }
512*b1cdbd2cSJim Jagielski
513*b1cdbd2cSJim Jagielski if( bCheckNumFmt )
514*b1cdbd2cSJim Jagielski {
515*b1cdbd2cSJim Jagielski SwTableSortBoxes& rBxs = pTblNd->GetTable().GetTabSortBoxes();
516*b1cdbd2cSJim Jagielski for( sal_uInt16 nBoxes = rBxs.Count(); nBoxes; )
517*b1cdbd2cSJim Jagielski rDoc.ChkBoxNumFmt( *rBxs[ --nBoxes ], sal_False );
518*b1cdbd2cSJim Jagielski }
519*b1cdbd2cSJim Jagielski
520*b1cdbd2cSJim Jagielski if( pHistory )
521*b1cdbd2cSJim Jagielski {
522*b1cdbd2cSJim Jagielski sal_uInt16 nTmpEnd = pHistory->GetTmpEnd();
523*b1cdbd2cSJim Jagielski pHistory->TmpRollback( &rDoc, 0 );
524*b1cdbd2cSJim Jagielski pHistory->SetTmpEnd( nTmpEnd );
525*b1cdbd2cSJim Jagielski }
526*b1cdbd2cSJim Jagielski
527*b1cdbd2cSJim Jagielski aNode2Layout.RestoreUpperFrms( rDoc.GetNodes(),
528*b1cdbd2cSJim Jagielski pTblNd->GetIndex(), pTblNd->GetIndex()+1 );
529*b1cdbd2cSJim Jagielski
530*b1cdbd2cSJim Jagielski // will man eine TabellenSelektion ??
531*b1cdbd2cSJim Jagielski pPam->DeleteMark();
532*b1cdbd2cSJim Jagielski pPam->GetPoint()->nNode = *pTblNd->EndOfSectionNode();
533*b1cdbd2cSJim Jagielski pPam->SetMark();
534*b1cdbd2cSJim Jagielski pPam->GetPoint()->nNode = *pPam->GetNode()->StartOfSectionNode();
535*b1cdbd2cSJim Jagielski pPam->Move( fnMoveForward, fnGoCntnt );
536*b1cdbd2cSJim Jagielski pPam->Exchange();
537*b1cdbd2cSJim Jagielski pPam->Move( fnMoveBackward, fnGoCntnt );
538*b1cdbd2cSJim Jagielski
539*b1cdbd2cSJim Jagielski ClearFEShellTabCols();
540*b1cdbd2cSJim Jagielski }
541*b1cdbd2cSJim Jagielski
542*b1cdbd2cSJim Jagielski // steht im untbl.cxx und darf nur vom Undoobject gerufen werden
UndoTableToText(sal_uLong nSttNd,sal_uLong nEndNd,const SwTblToTxtSaves & rSavedData)543*b1cdbd2cSJim Jagielski SwTableNode* SwNodes::UndoTableToText( sal_uLong nSttNd, sal_uLong nEndNd,
544*b1cdbd2cSJim Jagielski const SwTblToTxtSaves& rSavedData )
545*b1cdbd2cSJim Jagielski {
546*b1cdbd2cSJim Jagielski SwNodeIndex aSttIdx( *this, nSttNd );
547*b1cdbd2cSJim Jagielski SwNodeIndex aEndIdx( *this, nEndNd+1 );
548*b1cdbd2cSJim Jagielski
549*b1cdbd2cSJim Jagielski SwTableNode * pTblNd = new SwTableNode( aSttIdx );
550*b1cdbd2cSJim Jagielski SwEndNode* pEndNd = new SwEndNode( aEndIdx, *pTblNd );
551*b1cdbd2cSJim Jagielski
552*b1cdbd2cSJim Jagielski aEndIdx = *pEndNd;
553*b1cdbd2cSJim Jagielski
554*b1cdbd2cSJim Jagielski /* Set pTblNd as start of section for all nodes in [nSttNd, nEndNd].
555*b1cdbd2cSJim Jagielski Delete all Frames attached to the nodes in that range. */
556*b1cdbd2cSJim Jagielski SwNode* pNd;
557*b1cdbd2cSJim Jagielski {
558*b1cdbd2cSJim Jagielski sal_uLong n, nTmpEnd = aEndIdx.GetIndex();
559*b1cdbd2cSJim Jagielski for( n = pTblNd->GetIndex() + 1; n < nTmpEnd; ++n )
560*b1cdbd2cSJim Jagielski {
561*b1cdbd2cSJim Jagielski if( ( pNd = (*this)[ n ] )->IsCntntNode() )
562*b1cdbd2cSJim Jagielski ((SwCntntNode*)pNd)->DelFrms();
563*b1cdbd2cSJim Jagielski pNd->pStartOfSection = pTblNd;
564*b1cdbd2cSJim Jagielski }
565*b1cdbd2cSJim Jagielski }
566*b1cdbd2cSJim Jagielski
567*b1cdbd2cSJim Jagielski // dann die Tabellen Struktur teilweise aufbauen. Erstmal eine Line
568*b1cdbd2cSJim Jagielski // in der alle Boxen stehen! Die korrekte Struktur kommt dann aus der
569*b1cdbd2cSJim Jagielski // SaveStruct
570*b1cdbd2cSJim Jagielski SwTableBoxFmt* pBoxFmt = GetDoc()->MakeTableBoxFmt();
571*b1cdbd2cSJim Jagielski SwTableLineFmt* pLineFmt = GetDoc()->MakeTableLineFmt();
572*b1cdbd2cSJim Jagielski SwTableLine* pLine = new SwTableLine( pLineFmt, rSavedData.Count(), 0 );
573*b1cdbd2cSJim Jagielski pTblNd->GetTable().GetTabLines().C40_INSERT( SwTableLine, pLine, 0 );
574*b1cdbd2cSJim Jagielski
575*b1cdbd2cSJim Jagielski SvULongs aBkmkArr( 0, 4 );
576*b1cdbd2cSJim Jagielski for( sal_uInt16 n = rSavedData.Count(); n; )
577*b1cdbd2cSJim Jagielski {
578*b1cdbd2cSJim Jagielski SwTblToTxtSave* pSave = rSavedData[ --n ];
579*b1cdbd2cSJim Jagielski // if the start node was merged with last from prev. cell,
580*b1cdbd2cSJim Jagielski // subtract 1 from index to get the merged paragraph, and split that
581*b1cdbd2cSJim Jagielski aSttIdx = pSave->m_nSttNd - ( ( USHRT_MAX != pSave->m_nCntnt ) ? 1 : 0);
582*b1cdbd2cSJim Jagielski SwTxtNode* pTxtNd = aSttIdx.GetNode().GetTxtNode();
583*b1cdbd2cSJim Jagielski
584*b1cdbd2cSJim Jagielski if( USHRT_MAX != pSave->m_nCntnt )
585*b1cdbd2cSJim Jagielski {
586*b1cdbd2cSJim Jagielski // an der ContentPosition splitten, das vorherige Zeichen
587*b1cdbd2cSJim Jagielski // loeschen (ist der Trenner!)
588*b1cdbd2cSJim Jagielski ASSERT( pTxtNd, "Wo ist der TextNode geblieben?" );
589*b1cdbd2cSJim Jagielski SwIndex aCntPos( pTxtNd, pSave->m_nCntnt - 1 );
590*b1cdbd2cSJim Jagielski
591*b1cdbd2cSJim Jagielski pTxtNd->EraseText( aCntPos, 1 );
592*b1cdbd2cSJim Jagielski SwCntntNode* pNewNd = pTxtNd->SplitCntntNode(
593*b1cdbd2cSJim Jagielski SwPosition( aSttIdx, aCntPos ));
594*b1cdbd2cSJim Jagielski if( aBkmkArr.Count() )
595*b1cdbd2cSJim Jagielski _RestoreCntntIdx( aBkmkArr, *pNewNd, pSave->m_nCntnt,
596*b1cdbd2cSJim Jagielski pSave->m_nCntnt + 1 );
597*b1cdbd2cSJim Jagielski }
598*b1cdbd2cSJim Jagielski else
599*b1cdbd2cSJim Jagielski {
600*b1cdbd2cSJim Jagielski if( aBkmkArr.Count() )
601*b1cdbd2cSJim Jagielski aBkmkArr.Remove( 0, aBkmkArr.Count() );
602*b1cdbd2cSJim Jagielski if( pTxtNd )
603*b1cdbd2cSJim Jagielski _SaveCntntIdx( GetDoc(), aSttIdx.GetIndex(),
604*b1cdbd2cSJim Jagielski pTxtNd->GetTxt().Len(), aBkmkArr );
605*b1cdbd2cSJim Jagielski }
606*b1cdbd2cSJim Jagielski
607*b1cdbd2cSJim Jagielski if( pTxtNd )
608*b1cdbd2cSJim Jagielski {
609*b1cdbd2cSJim Jagielski // METADATA: restore
610*b1cdbd2cSJim Jagielski pTxtNd->GetTxtNode()->RestoreMetadata(pSave->m_pMetadataUndoStart);
611*b1cdbd2cSJim Jagielski if( pTxtNd->HasSwAttrSet() )
612*b1cdbd2cSJim Jagielski pTxtNd->ResetAllAttr();
613*b1cdbd2cSJim Jagielski
614*b1cdbd2cSJim Jagielski if( pTxtNd->GetpSwpHints() )
615*b1cdbd2cSJim Jagielski pTxtNd->ClearSwpHintsArr( false );
616*b1cdbd2cSJim Jagielski }
617*b1cdbd2cSJim Jagielski
618*b1cdbd2cSJim Jagielski if( pSave->m_pHstry )
619*b1cdbd2cSJim Jagielski {
620*b1cdbd2cSJim Jagielski sal_uInt16 nTmpEnd = pSave->m_pHstry->GetTmpEnd();
621*b1cdbd2cSJim Jagielski pSave->m_pHstry->TmpRollback( GetDoc(), 0 );
622*b1cdbd2cSJim Jagielski pSave->m_pHstry->SetTmpEnd( nTmpEnd );
623*b1cdbd2cSJim Jagielski }
624*b1cdbd2cSJim Jagielski
625*b1cdbd2cSJim Jagielski // METADATA: restore
626*b1cdbd2cSJim Jagielski // end points to node after cell
627*b1cdbd2cSJim Jagielski if ( pSave->m_nEndNd - 1 > pSave->m_nSttNd )
628*b1cdbd2cSJim Jagielski {
629*b1cdbd2cSJim Jagielski SwTxtNode* pLastNode = (*this)[ pSave->m_nEndNd - 1 ]->GetTxtNode();
630*b1cdbd2cSJim Jagielski if (pLastNode)
631*b1cdbd2cSJim Jagielski {
632*b1cdbd2cSJim Jagielski pLastNode->RestoreMetadata(pSave->m_pMetadataUndoEnd);
633*b1cdbd2cSJim Jagielski }
634*b1cdbd2cSJim Jagielski }
635*b1cdbd2cSJim Jagielski
636*b1cdbd2cSJim Jagielski aEndIdx = pSave->m_nEndNd;
637*b1cdbd2cSJim Jagielski SwStartNode* pSttNd = new SwStartNode( aSttIdx, ND_STARTNODE,
638*b1cdbd2cSJim Jagielski SwTableBoxStartNode );
639*b1cdbd2cSJim Jagielski pSttNd->pStartOfSection = pTblNd;
640*b1cdbd2cSJim Jagielski new SwEndNode( aEndIdx, *pSttNd );
641*b1cdbd2cSJim Jagielski
642*b1cdbd2cSJim Jagielski for( sal_uLong i = aSttIdx.GetIndex(); i < aEndIdx.GetIndex()-1; ++i )
643*b1cdbd2cSJim Jagielski {
644*b1cdbd2cSJim Jagielski pNd = (*this)[ i ];
645*b1cdbd2cSJim Jagielski pNd->pStartOfSection = pSttNd;
646*b1cdbd2cSJim Jagielski if( pNd->IsStartNode() )
647*b1cdbd2cSJim Jagielski i = pNd->EndOfSectionIndex();
648*b1cdbd2cSJim Jagielski }
649*b1cdbd2cSJim Jagielski
650*b1cdbd2cSJim Jagielski SwTableBox* pBox = new SwTableBox( pBoxFmt, *pSttNd, pLine );
651*b1cdbd2cSJim Jagielski pLine->GetTabBoxes().C40_INSERT( SwTableBox, pBox, 0 );
652*b1cdbd2cSJim Jagielski }
653*b1cdbd2cSJim Jagielski return pTblNd;
654*b1cdbd2cSJim Jagielski }
655*b1cdbd2cSJim Jagielski
656*b1cdbd2cSJim Jagielski
RedoImpl(::sw::UndoRedoContext & rContext)657*b1cdbd2cSJim Jagielski void SwUndoTblToTxt::RedoImpl(::sw::UndoRedoContext & rContext)
658*b1cdbd2cSJim Jagielski {
659*b1cdbd2cSJim Jagielski SwDoc & rDoc = rContext.GetDoc();
660*b1cdbd2cSJim Jagielski SwPaM *const pPam(& rContext.GetCursorSupplier().CreateNewShellCursor());
661*b1cdbd2cSJim Jagielski
662*b1cdbd2cSJim Jagielski pPam->GetPoint()->nNode = nSttNd;
663*b1cdbd2cSJim Jagielski pPam->GetPoint()->nContent.Assign( 0, 0 );
664*b1cdbd2cSJim Jagielski SwNodeIndex aSaveIdx( pPam->GetPoint()->nNode, -1 );
665*b1cdbd2cSJim Jagielski
666*b1cdbd2cSJim Jagielski pPam->SetMark(); // alle Indizies abmelden
667*b1cdbd2cSJim Jagielski pPam->DeleteMark();
668*b1cdbd2cSJim Jagielski
669*b1cdbd2cSJim Jagielski SwTableNode* pTblNd = pPam->GetNode()->GetTableNode();
670*b1cdbd2cSJim Jagielski ASSERT( pTblNd, "keinen TableNode gefunden" );
671*b1cdbd2cSJim Jagielski
672*b1cdbd2cSJim Jagielski if( pTblNd->GetTable().IsA( TYPE( SwDDETable )) )
673*b1cdbd2cSJim Jagielski pDDEFldType = (SwDDEFieldType*)((SwDDETable&)pTblNd->GetTable()).
674*b1cdbd2cSJim Jagielski GetDDEFldType()->Copy();
675*b1cdbd2cSJim Jagielski
676*b1cdbd2cSJim Jagielski rDoc.TableToText( pTblNd, cTrenner );
677*b1cdbd2cSJim Jagielski
678*b1cdbd2cSJim Jagielski aSaveIdx++;
679*b1cdbd2cSJim Jagielski SwCntntNode* pCNd = aSaveIdx.GetNode().GetCntntNode();
680*b1cdbd2cSJim Jagielski if( !pCNd && 0 == ( pCNd = rDoc.GetNodes().GoNext( &aSaveIdx ) ) &&
681*b1cdbd2cSJim Jagielski 0 == ( pCNd = rDoc.GetNodes().GoPrevious( &aSaveIdx )) )
682*b1cdbd2cSJim Jagielski {
683*b1cdbd2cSJim Jagielski ASSERT( sal_False, "wo steht denn nun der TextNode" );
684*b1cdbd2cSJim Jagielski }
685*b1cdbd2cSJim Jagielski
686*b1cdbd2cSJim Jagielski pPam->GetPoint()->nNode = aSaveIdx;
687*b1cdbd2cSJim Jagielski pPam->GetPoint()->nContent.Assign( pCNd, 0 );
688*b1cdbd2cSJim Jagielski
689*b1cdbd2cSJim Jagielski pPam->SetMark(); // alle Indizies abmelden
690*b1cdbd2cSJim Jagielski pPam->DeleteMark();
691*b1cdbd2cSJim Jagielski }
692*b1cdbd2cSJim Jagielski
693*b1cdbd2cSJim Jagielski
RepeatImpl(::sw::RepeatContext & rContext)694*b1cdbd2cSJim Jagielski void SwUndoTblToTxt::RepeatImpl(::sw::RepeatContext & rContext)
695*b1cdbd2cSJim Jagielski {
696*b1cdbd2cSJim Jagielski SwPaM *const pPam = & rContext.GetRepeatPaM();
697*b1cdbd2cSJim Jagielski SwTableNode *const pTblNd = pPam->GetNode()->FindTableNode();
698*b1cdbd2cSJim Jagielski if( pTblNd )
699*b1cdbd2cSJim Jagielski {
700*b1cdbd2cSJim Jagielski // move cursor out of table
701*b1cdbd2cSJim Jagielski pPam->GetPoint()->nNode = *pTblNd->EndOfSectionNode();
702*b1cdbd2cSJim Jagielski pPam->Move( fnMoveForward, fnGoCntnt );
703*b1cdbd2cSJim Jagielski pPam->SetMark();
704*b1cdbd2cSJim Jagielski pPam->DeleteMark();
705*b1cdbd2cSJim Jagielski
706*b1cdbd2cSJim Jagielski rContext.GetDoc().TableToText( pTblNd, cTrenner );
707*b1cdbd2cSJim Jagielski }
708*b1cdbd2cSJim Jagielski }
709*b1cdbd2cSJim Jagielski
SetRange(const SwNodeRange & rRg)710*b1cdbd2cSJim Jagielski void SwUndoTblToTxt::SetRange( const SwNodeRange& rRg )
711*b1cdbd2cSJim Jagielski {
712*b1cdbd2cSJim Jagielski nSttNd = rRg.aStart.GetIndex();
713*b1cdbd2cSJim Jagielski nEndNd = rRg.aEnd.GetIndex();
714*b1cdbd2cSJim Jagielski }
715*b1cdbd2cSJim Jagielski
AddBoxPos(SwDoc & rDoc,sal_uLong nNdIdx,sal_uLong nEndIdx,xub_StrLen nCntntIdx)716*b1cdbd2cSJim Jagielski void SwUndoTblToTxt::AddBoxPos( SwDoc& rDoc, sal_uLong nNdIdx, sal_uLong nEndIdx, xub_StrLen nCntntIdx )
717*b1cdbd2cSJim Jagielski {
718*b1cdbd2cSJim Jagielski SwTblToTxtSave* pNew = new SwTblToTxtSave( rDoc, nNdIdx, nEndIdx, nCntntIdx );
719*b1cdbd2cSJim Jagielski pBoxSaves->Insert( pNew, pBoxSaves->Count() );
720*b1cdbd2cSJim Jagielski }
721*b1cdbd2cSJim Jagielski
722*b1cdbd2cSJim Jagielski // -----------------------------------------------------
723*b1cdbd2cSJim Jagielski
SwUndoTxtToTbl(const SwPaM & rRg,const SwInsertTableOptions & rInsTblOpts,sal_Unicode cCh,sal_uInt16 nAdj,const SwTableAutoFmt * pAFmt)724*b1cdbd2cSJim Jagielski SwUndoTxtToTbl::SwUndoTxtToTbl( const SwPaM& rRg,
725*b1cdbd2cSJim Jagielski const SwInsertTableOptions& rInsTblOpts,
726*b1cdbd2cSJim Jagielski sal_Unicode cCh, sal_uInt16 nAdj,
727*b1cdbd2cSJim Jagielski const SwTableAutoFmt* pAFmt )
728*b1cdbd2cSJim Jagielski : SwUndo( UNDO_TEXTTOTABLE ), SwUndRng( rRg ), aInsTblOpts( rInsTblOpts ),
729*b1cdbd2cSJim Jagielski pDelBoxes( 0 ), pAutoFmt( 0 ),
730*b1cdbd2cSJim Jagielski pHistory( 0 ), cTrenner( cCh ), nAdjust( nAdj )
731*b1cdbd2cSJim Jagielski {
732*b1cdbd2cSJim Jagielski if( pAFmt )
733*b1cdbd2cSJim Jagielski pAutoFmt = new SwTableAutoFmt( *pAFmt );
734*b1cdbd2cSJim Jagielski
735*b1cdbd2cSJim Jagielski const SwPosition* pEnd = rRg.End();
736*b1cdbd2cSJim Jagielski SwNodes& rNds = rRg.GetDoc()->GetNodes();
737*b1cdbd2cSJim Jagielski bSplitEnd = pEnd->nContent.GetIndex() && ( pEnd->nContent.GetIndex()
738*b1cdbd2cSJim Jagielski != pEnd->nNode.GetNode().GetCntntNode()->Len() ||
739*b1cdbd2cSJim Jagielski pEnd->nNode.GetIndex() >= rNds.GetEndOfContent().GetIndex()-1 );
740*b1cdbd2cSJim Jagielski }
741*b1cdbd2cSJim Jagielski
~SwUndoTxtToTbl()742*b1cdbd2cSJim Jagielski SwUndoTxtToTbl::~SwUndoTxtToTbl()
743*b1cdbd2cSJim Jagielski {
744*b1cdbd2cSJim Jagielski delete pDelBoxes;
745*b1cdbd2cSJim Jagielski delete pAutoFmt;
746*b1cdbd2cSJim Jagielski }
747*b1cdbd2cSJim Jagielski
UndoImpl(::sw::UndoRedoContext & rContext)748*b1cdbd2cSJim Jagielski void SwUndoTxtToTbl::UndoImpl(::sw::UndoRedoContext & rContext)
749*b1cdbd2cSJim Jagielski {
750*b1cdbd2cSJim Jagielski SwDoc & rDoc = rContext.GetDoc();
751*b1cdbd2cSJim Jagielski
752*b1cdbd2cSJim Jagielski sal_uLong nTblNd = nSttNode;
753*b1cdbd2cSJim Jagielski if( nSttCntnt )
754*b1cdbd2cSJim Jagielski ++nTblNd; // Node wurde vorher gesplittet
755*b1cdbd2cSJim Jagielski SwNodeIndex aIdx( rDoc.GetNodes(), nTblNd );
756*b1cdbd2cSJim Jagielski SwTableNode *const pTNd = aIdx.GetNode().GetTableNode();
757*b1cdbd2cSJim Jagielski OSL_ENSURE( pTNd, "SwUndoTxtToTbl: no TableNode" );
758*b1cdbd2cSJim Jagielski
759*b1cdbd2cSJim Jagielski RemoveIdxFromSection( rDoc, nTblNd );
760*b1cdbd2cSJim Jagielski
761*b1cdbd2cSJim Jagielski sTblNm = pTNd->GetTable().GetFrmFmt()->GetName();
762*b1cdbd2cSJim Jagielski
763*b1cdbd2cSJim Jagielski if( pHistory )
764*b1cdbd2cSJim Jagielski {
765*b1cdbd2cSJim Jagielski pHistory->TmpRollback( &rDoc, 0 );
766*b1cdbd2cSJim Jagielski pHistory->SetTmpEnd( pHistory->Count() );
767*b1cdbd2cSJim Jagielski }
768*b1cdbd2cSJim Jagielski
769*b1cdbd2cSJim Jagielski if( pDelBoxes )
770*b1cdbd2cSJim Jagielski {
771*b1cdbd2cSJim Jagielski SwTable& rTbl = pTNd->GetTable();
772*b1cdbd2cSJim Jagielski for( sal_uInt16 n = pDelBoxes->Count(); n; )
773*b1cdbd2cSJim Jagielski {
774*b1cdbd2cSJim Jagielski SwTableBox* pBox = rTbl.GetTblBox( (*pDelBoxes)[ --n ] );
775*b1cdbd2cSJim Jagielski if( pBox )
776*b1cdbd2cSJim Jagielski ::_DeleteBox( rTbl, pBox, 0, sal_False, sal_False );
777*b1cdbd2cSJim Jagielski else {
778*b1cdbd2cSJim Jagielski ASSERT( !this, "Wo ist die Box geblieben?" );
779*b1cdbd2cSJim Jagielski }
780*b1cdbd2cSJim Jagielski }
781*b1cdbd2cSJim Jagielski }
782*b1cdbd2cSJim Jagielski
783*b1cdbd2cSJim Jagielski SwNodeIndex aEndIdx( *pTNd->EndOfSectionNode() );
784*b1cdbd2cSJim Jagielski rDoc.TableToText( pTNd, 0x0b == cTrenner ? 0x09 : cTrenner );
785*b1cdbd2cSJim Jagielski
786*b1cdbd2cSJim Jagielski // join again at start?
787*b1cdbd2cSJim Jagielski SwPaM aPam(rDoc.GetNodes().GetEndOfContent());
788*b1cdbd2cSJim Jagielski SwPosition *const pPos = aPam.GetPoint();
789*b1cdbd2cSJim Jagielski if( nSttCntnt )
790*b1cdbd2cSJim Jagielski {
791*b1cdbd2cSJim Jagielski pPos->nNode = nTblNd;
792*b1cdbd2cSJim Jagielski pPos->nContent.Assign(pPos->nNode.GetNode().GetCntntNode(), 0);
793*b1cdbd2cSJim Jagielski if (aPam.Move(fnMoveBackward, fnGoCntnt))
794*b1cdbd2cSJim Jagielski {
795*b1cdbd2cSJim Jagielski SwNodeIndex & rIdx = aPam.GetPoint()->nNode;
796*b1cdbd2cSJim Jagielski
797*b1cdbd2cSJim Jagielski // dann die Crsr/etc. nochmal relativ verschieben
798*b1cdbd2cSJim Jagielski RemoveIdxRel( rIdx.GetIndex()+1, *pPos );
799*b1cdbd2cSJim Jagielski
800*b1cdbd2cSJim Jagielski rIdx.GetNode().GetCntntNode()->JoinNext();
801*b1cdbd2cSJim Jagielski }
802*b1cdbd2cSJim Jagielski }
803*b1cdbd2cSJim Jagielski
804*b1cdbd2cSJim Jagielski // join again at end?
805*b1cdbd2cSJim Jagielski if( bSplitEnd )
806*b1cdbd2cSJim Jagielski {
807*b1cdbd2cSJim Jagielski SwNodeIndex& rIdx = pPos->nNode;
808*b1cdbd2cSJim Jagielski rIdx = nEndNode;
809*b1cdbd2cSJim Jagielski SwTxtNode* pTxtNd = rIdx.GetNode().GetTxtNode();
810*b1cdbd2cSJim Jagielski if( pTxtNd && pTxtNd->CanJoinNext() )
811*b1cdbd2cSJim Jagielski {
812*b1cdbd2cSJim Jagielski aPam.GetMark()->nContent.Assign( 0, 0 );
813*b1cdbd2cSJim Jagielski aPam.GetPoint()->nContent.Assign( 0, 0 );
814*b1cdbd2cSJim Jagielski
815*b1cdbd2cSJim Jagielski // dann die Crsr/etc. nochmal relativ verschieben
816*b1cdbd2cSJim Jagielski pPos->nContent.Assign( pTxtNd, pTxtNd->GetTxt().Len() );
817*b1cdbd2cSJim Jagielski RemoveIdxRel( nEndNode + 1, *pPos );
818*b1cdbd2cSJim Jagielski
819*b1cdbd2cSJim Jagielski pTxtNd->JoinNext();
820*b1cdbd2cSJim Jagielski }
821*b1cdbd2cSJim Jagielski }
822*b1cdbd2cSJim Jagielski
823*b1cdbd2cSJim Jagielski AddUndoRedoPaM(rContext);
824*b1cdbd2cSJim Jagielski }
825*b1cdbd2cSJim Jagielski
826*b1cdbd2cSJim Jagielski
RedoImpl(::sw::UndoRedoContext & rContext)827*b1cdbd2cSJim Jagielski void SwUndoTxtToTbl::RedoImpl(::sw::UndoRedoContext & rContext)
828*b1cdbd2cSJim Jagielski {
829*b1cdbd2cSJim Jagielski SwPaM & rPam( AddUndoRedoPaM(rContext) );
830*b1cdbd2cSJim Jagielski RemoveIdxFromRange(rPam, false);
831*b1cdbd2cSJim Jagielski SetPaM(rPam);
832*b1cdbd2cSJim Jagielski
833*b1cdbd2cSJim Jagielski SwTable const*const pTable = rContext.GetDoc().TextToTable(
834*b1cdbd2cSJim Jagielski aInsTblOpts, rPam, cTrenner, nAdjust, pAutoFmt );
835*b1cdbd2cSJim Jagielski ((SwFrmFmt*)pTable->GetFrmFmt())->SetName( sTblNm );
836*b1cdbd2cSJim Jagielski }
837*b1cdbd2cSJim Jagielski
838*b1cdbd2cSJim Jagielski
RepeatImpl(::sw::RepeatContext & rContext)839*b1cdbd2cSJim Jagielski void SwUndoTxtToTbl::RepeatImpl(::sw::RepeatContext & rContext)
840*b1cdbd2cSJim Jagielski {
841*b1cdbd2cSJim Jagielski // no Table In Table
842*b1cdbd2cSJim Jagielski if (!rContext.GetRepeatPaM().GetNode()->FindTableNode())
843*b1cdbd2cSJim Jagielski {
844*b1cdbd2cSJim Jagielski rContext.GetDoc().TextToTable( aInsTblOpts, rContext.GetRepeatPaM(),
845*b1cdbd2cSJim Jagielski cTrenner, nAdjust,
846*b1cdbd2cSJim Jagielski pAutoFmt );
847*b1cdbd2cSJim Jagielski }
848*b1cdbd2cSJim Jagielski }
849*b1cdbd2cSJim Jagielski
AddFillBox(const SwTableBox & rBox)850*b1cdbd2cSJim Jagielski void SwUndoTxtToTbl::AddFillBox( const SwTableBox& rBox )
851*b1cdbd2cSJim Jagielski {
852*b1cdbd2cSJim Jagielski if( !pDelBoxes )
853*b1cdbd2cSJim Jagielski pDelBoxes = new SvULongs;
854*b1cdbd2cSJim Jagielski pDelBoxes->Insert( rBox.GetSttIdx(), pDelBoxes->Count() );
855*b1cdbd2cSJim Jagielski }
856*b1cdbd2cSJim Jagielski
GetHistory()857*b1cdbd2cSJim Jagielski SwHistory& SwUndoTxtToTbl::GetHistory()
858*b1cdbd2cSJim Jagielski {
859*b1cdbd2cSJim Jagielski if( !pHistory )
860*b1cdbd2cSJim Jagielski pHistory = new SwHistory;
861*b1cdbd2cSJim Jagielski return *pHistory;
862*b1cdbd2cSJim Jagielski }
863*b1cdbd2cSJim Jagielski
864*b1cdbd2cSJim Jagielski // -----------------------------------------------------
865*b1cdbd2cSJim Jagielski
SwUndoTblHeadline(const SwTable & rTbl,sal_uInt16 nOldHdl,sal_uInt16 nNewHdl)866*b1cdbd2cSJim Jagielski SwUndoTblHeadline::SwUndoTblHeadline( const SwTable& rTbl, sal_uInt16 nOldHdl,
867*b1cdbd2cSJim Jagielski sal_uInt16 nNewHdl )
868*b1cdbd2cSJim Jagielski : SwUndo( UNDO_TABLEHEADLINE ),
869*b1cdbd2cSJim Jagielski nOldHeadline( nOldHdl ),
870*b1cdbd2cSJim Jagielski nNewHeadline( nNewHdl )
871*b1cdbd2cSJim Jagielski {
872*b1cdbd2cSJim Jagielski ASSERT( rTbl.GetTabSortBoxes().Count(), "Tabelle ohne Inhalt" );
873*b1cdbd2cSJim Jagielski const SwStartNode *pSttNd = rTbl.GetTabSortBoxes()[ 0 ]->GetSttNd();
874*b1cdbd2cSJim Jagielski ASSERT( pSttNd, "Box ohne Inhalt" );
875*b1cdbd2cSJim Jagielski
876*b1cdbd2cSJim Jagielski nTblNd = pSttNd->StartOfSectionIndex();
877*b1cdbd2cSJim Jagielski }
878*b1cdbd2cSJim Jagielski
UndoImpl(::sw::UndoRedoContext & rContext)879*b1cdbd2cSJim Jagielski void SwUndoTblHeadline::UndoImpl(::sw::UndoRedoContext & rContext)
880*b1cdbd2cSJim Jagielski {
881*b1cdbd2cSJim Jagielski SwDoc & rDoc = rContext.GetDoc();
882*b1cdbd2cSJim Jagielski SwTableNode* pTNd = rDoc.GetNodes()[ nTblNd ]->GetTableNode();
883*b1cdbd2cSJim Jagielski ASSERT( pTNd, "keinen Tabellen-Node gefunden" );
884*b1cdbd2cSJim Jagielski
885*b1cdbd2cSJim Jagielski rDoc.SetRowsToRepeat( pTNd->GetTable(), nOldHeadline );
886*b1cdbd2cSJim Jagielski }
887*b1cdbd2cSJim Jagielski
RedoImpl(::sw::UndoRedoContext & rContext)888*b1cdbd2cSJim Jagielski void SwUndoTblHeadline::RedoImpl(::sw::UndoRedoContext & rContext)
889*b1cdbd2cSJim Jagielski {
890*b1cdbd2cSJim Jagielski SwDoc & rDoc = rContext.GetDoc();
891*b1cdbd2cSJim Jagielski
892*b1cdbd2cSJim Jagielski SwTableNode* pTNd = rDoc.GetNodes()[ nTblNd ]->GetTableNode();
893*b1cdbd2cSJim Jagielski ASSERT( pTNd, "keinen Tabellen-Node gefunden" );
894*b1cdbd2cSJim Jagielski
895*b1cdbd2cSJim Jagielski rDoc.SetRowsToRepeat( pTNd->GetTable(), nNewHeadline );
896*b1cdbd2cSJim Jagielski }
897*b1cdbd2cSJim Jagielski
RepeatImpl(::sw::RepeatContext & rContext)898*b1cdbd2cSJim Jagielski void SwUndoTblHeadline::RepeatImpl(::sw::RepeatContext & rContext)
899*b1cdbd2cSJim Jagielski {
900*b1cdbd2cSJim Jagielski SwTableNode *const pTblNd =
901*b1cdbd2cSJim Jagielski rContext.GetRepeatPaM().GetNode()->FindTableNode();
902*b1cdbd2cSJim Jagielski if( pTblNd )
903*b1cdbd2cSJim Jagielski {
904*b1cdbd2cSJim Jagielski rContext.GetDoc().SetRowsToRepeat( pTblNd->GetTable(), nNewHeadline );
905*b1cdbd2cSJim Jagielski }
906*b1cdbd2cSJim Jagielski }
907*b1cdbd2cSJim Jagielski
908*b1cdbd2cSJim Jagielski
909*b1cdbd2cSJim Jagielski //////////////////////////////////////////////////////////////////////////
910*b1cdbd2cSJim Jagielski
911*b1cdbd2cSJim Jagielski
_SaveTable(const SwTable & rTbl,sal_uInt16 nLnCnt,sal_Bool bSaveFml)912*b1cdbd2cSJim Jagielski _SaveTable::_SaveTable( const SwTable& rTbl, sal_uInt16 nLnCnt, sal_Bool bSaveFml )
913*b1cdbd2cSJim Jagielski : aTblSet( *rTbl.GetFrmFmt()->GetAttrSet().GetPool(), aTableSetRange ),
914*b1cdbd2cSJim Jagielski pSwTable( &rTbl ), nLineCount( nLnCnt ), bSaveFormula( bSaveFml )
915*b1cdbd2cSJim Jagielski {
916*b1cdbd2cSJim Jagielski bModifyBox = sal_False;
917*b1cdbd2cSJim Jagielski bNewModel = rTbl.IsNewModel();
918*b1cdbd2cSJim Jagielski aTblSet.Put( rTbl.GetFrmFmt()->GetAttrSet() );
919*b1cdbd2cSJim Jagielski pLine = new _SaveLine( 0, *rTbl.GetTabLines()[ 0 ], *this );
920*b1cdbd2cSJim Jagielski
921*b1cdbd2cSJim Jagielski _SaveLine* pLn = pLine;
922*b1cdbd2cSJim Jagielski if( USHRT_MAX == nLnCnt )
923*b1cdbd2cSJim Jagielski nLnCnt = rTbl.GetTabLines().Count();
924*b1cdbd2cSJim Jagielski for( sal_uInt16 n = 1; n < nLnCnt; ++n )
925*b1cdbd2cSJim Jagielski pLn = new _SaveLine( pLn, *rTbl.GetTabLines()[ n ], *this );
926*b1cdbd2cSJim Jagielski
927*b1cdbd2cSJim Jagielski aFrmFmts.Remove( 0, aFrmFmts.Count() );
928*b1cdbd2cSJim Jagielski pSwTable = 0;
929*b1cdbd2cSJim Jagielski }
930*b1cdbd2cSJim Jagielski
931*b1cdbd2cSJim Jagielski
~_SaveTable()932*b1cdbd2cSJim Jagielski _SaveTable::~_SaveTable()
933*b1cdbd2cSJim Jagielski {
934*b1cdbd2cSJim Jagielski delete pLine;
935*b1cdbd2cSJim Jagielski }
936*b1cdbd2cSJim Jagielski
937*b1cdbd2cSJim Jagielski
AddFmt(SwFrmFmt * pFmt,bool bIsLine)938*b1cdbd2cSJim Jagielski sal_uInt16 _SaveTable::AddFmt( SwFrmFmt* pFmt, bool bIsLine )
939*b1cdbd2cSJim Jagielski {
940*b1cdbd2cSJim Jagielski sal_uInt16 nRet = aFrmFmts.GetPos( pFmt );
941*b1cdbd2cSJim Jagielski if( USHRT_MAX == nRet )
942*b1cdbd2cSJim Jagielski {
943*b1cdbd2cSJim Jagielski // Kopie vom ItemSet anlegen
944*b1cdbd2cSJim Jagielski SfxItemSet* pSet = new SfxItemSet( *pFmt->GetAttrSet().GetPool(),
945*b1cdbd2cSJim Jagielski bIsLine ? aTableLineSetRange : aTableBoxSetRange );
946*b1cdbd2cSJim Jagielski pSet->Put( pFmt->GetAttrSet() );
947*b1cdbd2cSJim Jagielski //JP 20.04.98: Bug 49502 - wenn eine Formel gesetzt ist, nie den
948*b1cdbd2cSJim Jagielski // Value mit sichern. Der muss gegebenfalls neu
949*b1cdbd2cSJim Jagielski // errechnet werden!
950*b1cdbd2cSJim Jagielski //JP 30.07.98: Bug 54295 - Formeln immer im Klartext speichern
951*b1cdbd2cSJim Jagielski const SfxPoolItem* pItem;
952*b1cdbd2cSJim Jagielski if( SFX_ITEM_SET == pSet->GetItemState( RES_BOXATR_FORMULA, sal_True, &pItem ))
953*b1cdbd2cSJim Jagielski {
954*b1cdbd2cSJim Jagielski pSet->ClearItem( RES_BOXATR_VALUE );
955*b1cdbd2cSJim Jagielski if( pSwTable && bSaveFormula )
956*b1cdbd2cSJim Jagielski {
957*b1cdbd2cSJim Jagielski SwTableFmlUpdate aMsgHnt( pSwTable );
958*b1cdbd2cSJim Jagielski aMsgHnt.eFlags = TBL_BOXNAME;
959*b1cdbd2cSJim Jagielski ((SwTblBoxFormula*)pItem)->ChgDefinedIn( pFmt );
960*b1cdbd2cSJim Jagielski ((SwTblBoxFormula*)pItem)->ChangeState( &aMsgHnt );
961*b1cdbd2cSJim Jagielski ((SwTblBoxFormula*)pItem)->ChgDefinedIn( 0 );
962*b1cdbd2cSJim Jagielski }
963*b1cdbd2cSJim Jagielski }
964*b1cdbd2cSJim Jagielski aSets.Insert( pSet, (nRet = aSets.Count() ) );
965*b1cdbd2cSJim Jagielski aFrmFmts.Insert( pFmt, nRet );
966*b1cdbd2cSJim Jagielski }
967*b1cdbd2cSJim Jagielski return nRet;
968*b1cdbd2cSJim Jagielski }
969*b1cdbd2cSJim Jagielski
970*b1cdbd2cSJim Jagielski
RestoreAttr(SwTable & rTbl,sal_Bool bMdfyBox)971*b1cdbd2cSJim Jagielski void _SaveTable::RestoreAttr( SwTable& rTbl, sal_Bool bMdfyBox )
972*b1cdbd2cSJim Jagielski {
973*b1cdbd2cSJim Jagielski sal_uInt16 n;
974*b1cdbd2cSJim Jagielski
975*b1cdbd2cSJim Jagielski bModifyBox = bMdfyBox;
976*b1cdbd2cSJim Jagielski
977*b1cdbd2cSJim Jagielski // zuerst die Attribute des TabellenFrmFormates zurueck holen
978*b1cdbd2cSJim Jagielski SwFrmFmt* pFmt = rTbl.GetFrmFmt();
979*b1cdbd2cSJim Jagielski SfxItemSet& rFmtSet = (SfxItemSet&)pFmt->GetAttrSet();
980*b1cdbd2cSJim Jagielski rFmtSet.ClearItem();
981*b1cdbd2cSJim Jagielski rFmtSet.Put( aTblSet );
982*b1cdbd2cSJim Jagielski
983*b1cdbd2cSJim Jagielski if( pFmt->IsInCache() )
984*b1cdbd2cSJim Jagielski {
985*b1cdbd2cSJim Jagielski SwFrm::GetCache().Delete( pFmt );
986*b1cdbd2cSJim Jagielski pFmt->SetInCache( sal_False );
987*b1cdbd2cSJim Jagielski }
988*b1cdbd2cSJim Jagielski
989*b1cdbd2cSJim Jagielski // zur Sicherheit alle Tableframes invalidieren
990*b1cdbd2cSJim Jagielski SwIterator<SwTabFrm,SwFmt> aIter( *pFmt );
991*b1cdbd2cSJim Jagielski for( SwTabFrm* pLast = aIter.First(); pLast; pLast = aIter.Next() )
992*b1cdbd2cSJim Jagielski if( pLast->GetTable() == &rTbl )
993*b1cdbd2cSJim Jagielski {
994*b1cdbd2cSJim Jagielski pLast->InvalidateAll();
995*b1cdbd2cSJim Jagielski pLast->SetCompletePaint();
996*b1cdbd2cSJim Jagielski }
997*b1cdbd2cSJim Jagielski
998*b1cdbd2cSJim Jagielski // FrmFmts mit Defaults (0) fuellen
999*b1cdbd2cSJim Jagielski pFmt = 0;
1000*b1cdbd2cSJim Jagielski for( n = aSets.Count(); n; --n )
1001*b1cdbd2cSJim Jagielski aFrmFmts.Insert( pFmt, aFrmFmts.Count() );
1002*b1cdbd2cSJim Jagielski
1003*b1cdbd2cSJim Jagielski sal_uInt16 nLnCnt = nLineCount;
1004*b1cdbd2cSJim Jagielski if( USHRT_MAX == nLnCnt )
1005*b1cdbd2cSJim Jagielski nLnCnt = rTbl.GetTabLines().Count();
1006*b1cdbd2cSJim Jagielski
1007*b1cdbd2cSJim Jagielski _SaveLine* pLn = pLine;
1008*b1cdbd2cSJim Jagielski for( n = 0; n < nLnCnt; ++n, pLn = pLn->pNext )
1009*b1cdbd2cSJim Jagielski {
1010*b1cdbd2cSJim Jagielski if( !pLn )
1011*b1cdbd2cSJim Jagielski {
1012*b1cdbd2cSJim Jagielski ASSERT( !this, "Anzahl der Lines hat sich veraendert" );
1013*b1cdbd2cSJim Jagielski break;
1014*b1cdbd2cSJim Jagielski }
1015*b1cdbd2cSJim Jagielski
1016*b1cdbd2cSJim Jagielski pLn->RestoreAttr( *rTbl.GetTabLines()[ n ], *this );
1017*b1cdbd2cSJim Jagielski }
1018*b1cdbd2cSJim Jagielski
1019*b1cdbd2cSJim Jagielski aFrmFmts.Remove( 0, aFrmFmts.Count() );
1020*b1cdbd2cSJim Jagielski bModifyBox = sal_False;
1021*b1cdbd2cSJim Jagielski }
1022*b1cdbd2cSJim Jagielski
1023*b1cdbd2cSJim Jagielski
SaveCntntAttrs(SwDoc * pDoc)1024*b1cdbd2cSJim Jagielski void _SaveTable::SaveCntntAttrs( SwDoc* pDoc )
1025*b1cdbd2cSJim Jagielski {
1026*b1cdbd2cSJim Jagielski pLine->SaveCntntAttrs( pDoc );
1027*b1cdbd2cSJim Jagielski }
1028*b1cdbd2cSJim Jagielski
1029*b1cdbd2cSJim Jagielski
CreateNew(SwTable & rTbl,sal_Bool bCreateFrms,sal_Bool bRestoreChart)1030*b1cdbd2cSJim Jagielski void _SaveTable::CreateNew( SwTable& rTbl, sal_Bool bCreateFrms,
1031*b1cdbd2cSJim Jagielski sal_Bool bRestoreChart )
1032*b1cdbd2cSJim Jagielski {
1033*b1cdbd2cSJim Jagielski sal_uInt16 n;
1034*b1cdbd2cSJim Jagielski
1035*b1cdbd2cSJim Jagielski _FndBox aTmpBox( 0, 0 );
1036*b1cdbd2cSJim Jagielski //if( bRestoreChart )
1037*b1cdbd2cSJim Jagielski // // ? TL_CHART2: notification or locking of controller required ?
1038*b1cdbd2cSJim Jagielski aTmpBox.DelFrms( rTbl );
1039*b1cdbd2cSJim Jagielski
1040*b1cdbd2cSJim Jagielski // zuerst die Attribute des TabellenFrmFormates zurueck holen
1041*b1cdbd2cSJim Jagielski SwFrmFmt* pFmt = rTbl.GetFrmFmt();
1042*b1cdbd2cSJim Jagielski SfxItemSet& rFmtSet = (SfxItemSet&)pFmt->GetAttrSet();
1043*b1cdbd2cSJim Jagielski rFmtSet.ClearItem();
1044*b1cdbd2cSJim Jagielski rFmtSet.Put( aTblSet );
1045*b1cdbd2cSJim Jagielski
1046*b1cdbd2cSJim Jagielski if( pFmt->IsInCache() )
1047*b1cdbd2cSJim Jagielski {
1048*b1cdbd2cSJim Jagielski SwFrm::GetCache().Delete( pFmt );
1049*b1cdbd2cSJim Jagielski pFmt->SetInCache( sal_False );
1050*b1cdbd2cSJim Jagielski }
1051*b1cdbd2cSJim Jagielski
1052*b1cdbd2cSJim Jagielski // SwTableBox muss ein Format haben!!
1053*b1cdbd2cSJim Jagielski SwTableBox aParent( (SwTableBoxFmt*)pFmt, rTbl.GetTabLines().Count(), 0 );
1054*b1cdbd2cSJim Jagielski
1055*b1cdbd2cSJim Jagielski // FrmFmts mit Defaults (0) fuellen
1056*b1cdbd2cSJim Jagielski pFmt = 0;
1057*b1cdbd2cSJim Jagielski for( n = aSets.Count(); n; --n )
1058*b1cdbd2cSJim Jagielski aFrmFmts.Insert( pFmt, aFrmFmts.Count() );
1059*b1cdbd2cSJim Jagielski
1060*b1cdbd2cSJim Jagielski pLine->CreateNew( rTbl, aParent, *this );
1061*b1cdbd2cSJim Jagielski aFrmFmts.Remove( 0, aFrmFmts.Count() );
1062*b1cdbd2cSJim Jagielski
1063*b1cdbd2cSJim Jagielski // die neuen Lines eintragen, die alten loeschen
1064*b1cdbd2cSJim Jagielski sal_uInt16 nOldLines = nLineCount;
1065*b1cdbd2cSJim Jagielski if( USHRT_MAX == nLineCount )
1066*b1cdbd2cSJim Jagielski nOldLines = rTbl.GetTabLines().Count();
1067*b1cdbd2cSJim Jagielski
1068*b1cdbd2cSJim Jagielski SwDoc *pDoc = rTbl.GetFrmFmt()->GetDoc();
1069*b1cdbd2cSJim Jagielski SwChartDataProvider *pPCD = pDoc->GetChartDataProvider();
1070*b1cdbd2cSJim Jagielski for( n = 0; n < aParent.GetTabLines().Count(); ++n )
1071*b1cdbd2cSJim Jagielski {
1072*b1cdbd2cSJim Jagielski SwTableLine* pLn = aParent.GetTabLines()[ n ];
1073*b1cdbd2cSJim Jagielski pLn->SetUpper( 0 );
1074*b1cdbd2cSJim Jagielski if( n < nOldLines )
1075*b1cdbd2cSJim Jagielski {
1076*b1cdbd2cSJim Jagielski SwTableLine* pOld = rTbl.GetTabLines()[ n ];
1077*b1cdbd2cSJim Jagielski
1078*b1cdbd2cSJim Jagielski // TL_CHART2: notify chart about boxes to be removed
1079*b1cdbd2cSJim Jagielski const SwTableBoxes &rBoxes = pOld->GetTabBoxes();
1080*b1cdbd2cSJim Jagielski sal_uInt16 nBoxes = rBoxes.Count();
1081*b1cdbd2cSJim Jagielski for (sal_uInt16 k = 0; k < nBoxes; ++k)
1082*b1cdbd2cSJim Jagielski {
1083*b1cdbd2cSJim Jagielski SwTableBox *pBox = rBoxes[k];
1084*b1cdbd2cSJim Jagielski if (pPCD)
1085*b1cdbd2cSJim Jagielski pPCD->DeleteBox( &rTbl, *pBox );
1086*b1cdbd2cSJim Jagielski }
1087*b1cdbd2cSJim Jagielski
1088*b1cdbd2cSJim Jagielski rTbl.GetTabLines().C40_REPLACE( SwTableLine, pLn, n );
1089*b1cdbd2cSJim Jagielski delete pOld;
1090*b1cdbd2cSJim Jagielski }
1091*b1cdbd2cSJim Jagielski else
1092*b1cdbd2cSJim Jagielski rTbl.GetTabLines().C40_INSERT( SwTableLine, pLn, n );
1093*b1cdbd2cSJim Jagielski }
1094*b1cdbd2cSJim Jagielski
1095*b1cdbd2cSJim Jagielski if( n < nOldLines )
1096*b1cdbd2cSJim Jagielski {
1097*b1cdbd2cSJim Jagielski // remove remaining lines...
1098*b1cdbd2cSJim Jagielski
1099*b1cdbd2cSJim Jagielski for (sal_uInt16 k1 = 0; k1 < nOldLines - n; ++k1)
1100*b1cdbd2cSJim Jagielski {
1101*b1cdbd2cSJim Jagielski const SwTableBoxes &rBoxes = rTbl.GetTabLines()[n + k1]->GetTabBoxes();
1102*b1cdbd2cSJim Jagielski sal_uInt16 nBoxes = rBoxes.Count();
1103*b1cdbd2cSJim Jagielski for (sal_uInt16 k2 = 0; k2 < nBoxes; ++k2)
1104*b1cdbd2cSJim Jagielski {
1105*b1cdbd2cSJim Jagielski SwTableBox *pBox = rBoxes[k2];
1106*b1cdbd2cSJim Jagielski // TL_CHART2: notify chart about boxes to be removed
1107*b1cdbd2cSJim Jagielski if (pPCD)
1108*b1cdbd2cSJim Jagielski pPCD->DeleteBox( &rTbl, *pBox );
1109*b1cdbd2cSJim Jagielski }
1110*b1cdbd2cSJim Jagielski }
1111*b1cdbd2cSJim Jagielski
1112*b1cdbd2cSJim Jagielski rTbl.GetTabLines().DeleteAndDestroy( n, nOldLines - n );
1113*b1cdbd2cSJim Jagielski }
1114*b1cdbd2cSJim Jagielski
1115*b1cdbd2cSJim Jagielski aParent.GetTabLines().Remove( 0, n );
1116*b1cdbd2cSJim Jagielski
1117*b1cdbd2cSJim Jagielski if( bCreateFrms )
1118*b1cdbd2cSJim Jagielski aTmpBox.MakeFrms( rTbl );
1119*b1cdbd2cSJim Jagielski if( bRestoreChart )
1120*b1cdbd2cSJim Jagielski {
1121*b1cdbd2cSJim Jagielski // TL_CHART2: need to inform chart of probably changed cell names
1122*b1cdbd2cSJim Jagielski pDoc->UpdateCharts( rTbl.GetFrmFmt()->GetName() );
1123*b1cdbd2cSJim Jagielski }
1124*b1cdbd2cSJim Jagielski }
1125*b1cdbd2cSJim Jagielski
1126*b1cdbd2cSJim Jagielski
NewFrmFmt(const SwTableLine * pTblLn,const SwTableBox * pTblBx,sal_uInt16 nFmtPos,SwFrmFmt * pOldFmt)1127*b1cdbd2cSJim Jagielski void _SaveTable::NewFrmFmt( const SwTableLine* pTblLn, const SwTableBox* pTblBx,
1128*b1cdbd2cSJim Jagielski sal_uInt16 nFmtPos, SwFrmFmt* pOldFmt )
1129*b1cdbd2cSJim Jagielski {
1130*b1cdbd2cSJim Jagielski SwDoc* pDoc = pOldFmt->GetDoc();
1131*b1cdbd2cSJim Jagielski
1132*b1cdbd2cSJim Jagielski SwFrmFmt* pFmt = aFrmFmts[ nFmtPos ];
1133*b1cdbd2cSJim Jagielski if( !pFmt )
1134*b1cdbd2cSJim Jagielski {
1135*b1cdbd2cSJim Jagielski if( pTblLn )
1136*b1cdbd2cSJim Jagielski pFmt = pDoc->MakeTableLineFmt();
1137*b1cdbd2cSJim Jagielski else
1138*b1cdbd2cSJim Jagielski pFmt = pDoc->MakeTableBoxFmt();
1139*b1cdbd2cSJim Jagielski pFmt->SetFmtAttr( *aSets[ nFmtPos ] );
1140*b1cdbd2cSJim Jagielski aFrmFmts.Replace( pFmt, nFmtPos );
1141*b1cdbd2cSJim Jagielski }
1142*b1cdbd2cSJim Jagielski
1143*b1cdbd2cSJim Jagielski //Erstmal die Frms ummelden.
1144*b1cdbd2cSJim Jagielski SwIterator<SwTabFrm,SwFmt> aIter( *pOldFmt );
1145*b1cdbd2cSJim Jagielski for( SwFrm* pLast = aIter.First(); pLast; pLast = aIter.Next() )
1146*b1cdbd2cSJim Jagielski {
1147*b1cdbd2cSJim Jagielski if( pTblLn ? ((SwRowFrm*)pLast)->GetTabLine() == pTblLn
1148*b1cdbd2cSJim Jagielski : ((SwCellFrm*)pLast)->GetTabBox() == pTblBx )
1149*b1cdbd2cSJim Jagielski {
1150*b1cdbd2cSJim Jagielski pLast->RegisterToFormat(*pFmt);
1151*b1cdbd2cSJim Jagielski pLast->InvalidateAll();
1152*b1cdbd2cSJim Jagielski pLast->ReinitializeFrmSizeAttrFlags();
1153*b1cdbd2cSJim Jagielski if ( !pTblLn )
1154*b1cdbd2cSJim Jagielski {
1155*b1cdbd2cSJim Jagielski ((SwCellFrm*)pLast)->SetDerivedVert( sal_False );
1156*b1cdbd2cSJim Jagielski ((SwCellFrm*)pLast)->CheckDirChange();
1157*b1cdbd2cSJim Jagielski }
1158*b1cdbd2cSJim Jagielski }
1159*b1cdbd2cSJim Jagielski }
1160*b1cdbd2cSJim Jagielski
1161*b1cdbd2cSJim Jagielski //Jetzt noch mich selbst ummelden.
1162*b1cdbd2cSJim Jagielski if ( pTblLn )
1163*b1cdbd2cSJim Jagielski const_cast<SwTableLine*>(pTblLn)->RegisterToFormat( *pFmt );
1164*b1cdbd2cSJim Jagielski else if ( pTblBx )
1165*b1cdbd2cSJim Jagielski const_cast<SwTableBox*>(pTblBx)->RegisterToFormat( *pFmt );
1166*b1cdbd2cSJim Jagielski
1167*b1cdbd2cSJim Jagielski if( bModifyBox && !pTblLn )
1168*b1cdbd2cSJim Jagielski {
1169*b1cdbd2cSJim Jagielski const SfxPoolItem& rOld = pOldFmt->GetFmtAttr( RES_BOXATR_FORMAT ),
1170*b1cdbd2cSJim Jagielski & rNew = pFmt->GetFmtAttr( RES_BOXATR_FORMAT );
1171*b1cdbd2cSJim Jagielski if( rOld != rNew )
1172*b1cdbd2cSJim Jagielski pFmt->ModifyNotification( (SfxPoolItem*)&rOld, (SfxPoolItem*)&rNew );
1173*b1cdbd2cSJim Jagielski }
1174*b1cdbd2cSJim Jagielski
1175*b1cdbd2cSJim Jagielski if( !pOldFmt->GetDepends() )
1176*b1cdbd2cSJim Jagielski delete pOldFmt;
1177*b1cdbd2cSJim Jagielski
1178*b1cdbd2cSJim Jagielski }
1179*b1cdbd2cSJim Jagielski
1180*b1cdbd2cSJim Jagielski
_SaveLine(_SaveLine * pPrev,const SwTableLine & rLine,_SaveTable & rSTbl)1181*b1cdbd2cSJim Jagielski _SaveLine::_SaveLine( _SaveLine* pPrev, const SwTableLine& rLine, _SaveTable& rSTbl )
1182*b1cdbd2cSJim Jagielski : pNext( 0 )
1183*b1cdbd2cSJim Jagielski {
1184*b1cdbd2cSJim Jagielski if( pPrev )
1185*b1cdbd2cSJim Jagielski pPrev->pNext = this;
1186*b1cdbd2cSJim Jagielski
1187*b1cdbd2cSJim Jagielski nItemSet = rSTbl.AddFmt( rLine.GetFrmFmt(), true );
1188*b1cdbd2cSJim Jagielski
1189*b1cdbd2cSJim Jagielski pBox = new _SaveBox( 0, *rLine.GetTabBoxes()[ 0 ], rSTbl );
1190*b1cdbd2cSJim Jagielski _SaveBox* pBx = pBox;
1191*b1cdbd2cSJim Jagielski for( sal_uInt16 n = 1; n < rLine.GetTabBoxes().Count(); ++n )
1192*b1cdbd2cSJim Jagielski pBx = new _SaveBox( pBx, *rLine.GetTabBoxes()[ n ], rSTbl );
1193*b1cdbd2cSJim Jagielski }
1194*b1cdbd2cSJim Jagielski
1195*b1cdbd2cSJim Jagielski
~_SaveLine()1196*b1cdbd2cSJim Jagielski _SaveLine::~_SaveLine()
1197*b1cdbd2cSJim Jagielski {
1198*b1cdbd2cSJim Jagielski delete pBox;
1199*b1cdbd2cSJim Jagielski delete pNext;
1200*b1cdbd2cSJim Jagielski }
1201*b1cdbd2cSJim Jagielski
1202*b1cdbd2cSJim Jagielski
RestoreAttr(SwTableLine & rLine,_SaveTable & rSTbl)1203*b1cdbd2cSJim Jagielski void _SaveLine::RestoreAttr( SwTableLine& rLine, _SaveTable& rSTbl )
1204*b1cdbd2cSJim Jagielski {
1205*b1cdbd2cSJim Jagielski rSTbl.NewFrmFmt( &rLine, 0, nItemSet, rLine.GetFrmFmt() );
1206*b1cdbd2cSJim Jagielski
1207*b1cdbd2cSJim Jagielski _SaveBox* pBx = pBox;
1208*b1cdbd2cSJim Jagielski for( sal_uInt16 n = 0; n < rLine.GetTabBoxes().Count(); ++n, pBx = pBx->pNext )
1209*b1cdbd2cSJim Jagielski {
1210*b1cdbd2cSJim Jagielski if( !pBx )
1211*b1cdbd2cSJim Jagielski {
1212*b1cdbd2cSJim Jagielski ASSERT( !this, "Anzahl der Boxen hat sich veraendert" );
1213*b1cdbd2cSJim Jagielski break;
1214*b1cdbd2cSJim Jagielski }
1215*b1cdbd2cSJim Jagielski pBx->RestoreAttr( *rLine.GetTabBoxes()[ n ], rSTbl );
1216*b1cdbd2cSJim Jagielski }
1217*b1cdbd2cSJim Jagielski }
1218*b1cdbd2cSJim Jagielski
1219*b1cdbd2cSJim Jagielski
SaveCntntAttrs(SwDoc * pDoc)1220*b1cdbd2cSJim Jagielski void _SaveLine::SaveCntntAttrs( SwDoc* pDoc )
1221*b1cdbd2cSJim Jagielski {
1222*b1cdbd2cSJim Jagielski pBox->SaveCntntAttrs( pDoc );
1223*b1cdbd2cSJim Jagielski if( pNext )
1224*b1cdbd2cSJim Jagielski pNext->SaveCntntAttrs( pDoc );
1225*b1cdbd2cSJim Jagielski }
1226*b1cdbd2cSJim Jagielski
1227*b1cdbd2cSJim Jagielski
CreateNew(SwTable & rTbl,SwTableBox & rParent,_SaveTable & rSTbl)1228*b1cdbd2cSJim Jagielski void _SaveLine::CreateNew( SwTable& rTbl, SwTableBox& rParent, _SaveTable& rSTbl )
1229*b1cdbd2cSJim Jagielski {
1230*b1cdbd2cSJim Jagielski SwTableLineFmt* pFmt = (SwTableLineFmt*)rSTbl.aFrmFmts[ nItemSet ];
1231*b1cdbd2cSJim Jagielski if( !pFmt )
1232*b1cdbd2cSJim Jagielski {
1233*b1cdbd2cSJim Jagielski SwDoc* pDoc = rTbl.GetFrmFmt()->GetDoc();
1234*b1cdbd2cSJim Jagielski pFmt = pDoc->MakeTableLineFmt();
1235*b1cdbd2cSJim Jagielski pFmt->SetFmtAttr( *rSTbl.aSets[ nItemSet ] );
1236*b1cdbd2cSJim Jagielski rSTbl.aFrmFmts.Replace( pFmt, nItemSet );
1237*b1cdbd2cSJim Jagielski }
1238*b1cdbd2cSJim Jagielski SwTableLine* pNew = new SwTableLine( pFmt, 1, &rParent );
1239*b1cdbd2cSJim Jagielski
1240*b1cdbd2cSJim Jagielski rParent.GetTabLines().C40_INSERT( SwTableLine, pNew, rParent.GetTabLines().Count() );
1241*b1cdbd2cSJim Jagielski
1242*b1cdbd2cSJim Jagielski // HB, #127868# robustness: in some cases - which I
1243*b1cdbd2cSJim Jagielski // cannot reproduce nor see from the code - pNew seems
1244*b1cdbd2cSJim Jagielski // to be set to NULL in C40_INSERT.
1245*b1cdbd2cSJim Jagielski ASSERT(pNew, "Table line just created set to NULL in C40_INSERT");
1246*b1cdbd2cSJim Jagielski
1247*b1cdbd2cSJim Jagielski if (pNew)
1248*b1cdbd2cSJim Jagielski {
1249*b1cdbd2cSJim Jagielski pBox->CreateNew( rTbl, *pNew, rSTbl );
1250*b1cdbd2cSJim Jagielski }
1251*b1cdbd2cSJim Jagielski
1252*b1cdbd2cSJim Jagielski if( pNext )
1253*b1cdbd2cSJim Jagielski pNext->CreateNew( rTbl, rParent, rSTbl );
1254*b1cdbd2cSJim Jagielski }
1255*b1cdbd2cSJim Jagielski
1256*b1cdbd2cSJim Jagielski
_SaveBox(_SaveBox * pPrev,const SwTableBox & rBox,_SaveTable & rSTbl)1257*b1cdbd2cSJim Jagielski _SaveBox::_SaveBox( _SaveBox* pPrev, const SwTableBox& rBox, _SaveTable& rSTbl )
1258*b1cdbd2cSJim Jagielski : pNext( 0 ), nSttNode( ULONG_MAX ), nRowSpan(0)
1259*b1cdbd2cSJim Jagielski {
1260*b1cdbd2cSJim Jagielski Ptrs.pLine = 0;
1261*b1cdbd2cSJim Jagielski
1262*b1cdbd2cSJim Jagielski if( pPrev )
1263*b1cdbd2cSJim Jagielski pPrev->pNext = this;
1264*b1cdbd2cSJim Jagielski
1265*b1cdbd2cSJim Jagielski nItemSet = rSTbl.AddFmt( rBox.GetFrmFmt(), false );
1266*b1cdbd2cSJim Jagielski
1267*b1cdbd2cSJim Jagielski if( rBox.GetSttNd() )
1268*b1cdbd2cSJim Jagielski {
1269*b1cdbd2cSJim Jagielski nSttNode = rBox.GetSttIdx();
1270*b1cdbd2cSJim Jagielski nRowSpan = rBox.getRowSpan();
1271*b1cdbd2cSJim Jagielski }
1272*b1cdbd2cSJim Jagielski else
1273*b1cdbd2cSJim Jagielski {
1274*b1cdbd2cSJim Jagielski Ptrs.pLine = new _SaveLine( 0, *rBox.GetTabLines()[ 0 ], rSTbl );
1275*b1cdbd2cSJim Jagielski
1276*b1cdbd2cSJim Jagielski _SaveLine* pLn = Ptrs.pLine;
1277*b1cdbd2cSJim Jagielski for( sal_uInt16 n = 1; n < rBox.GetTabLines().Count(); ++n )
1278*b1cdbd2cSJim Jagielski pLn = new _SaveLine( pLn, *rBox.GetTabLines()[ n ], rSTbl );
1279*b1cdbd2cSJim Jagielski }
1280*b1cdbd2cSJim Jagielski }
1281*b1cdbd2cSJim Jagielski
1282*b1cdbd2cSJim Jagielski
~_SaveBox()1283*b1cdbd2cSJim Jagielski _SaveBox::~_SaveBox()
1284*b1cdbd2cSJim Jagielski {
1285*b1cdbd2cSJim Jagielski if( ULONG_MAX == nSttNode ) // keine EndBox
1286*b1cdbd2cSJim Jagielski delete Ptrs.pLine;
1287*b1cdbd2cSJim Jagielski else
1288*b1cdbd2cSJim Jagielski delete Ptrs.pCntntAttrs;
1289*b1cdbd2cSJim Jagielski delete pNext;
1290*b1cdbd2cSJim Jagielski }
1291*b1cdbd2cSJim Jagielski
1292*b1cdbd2cSJim Jagielski
RestoreAttr(SwTableBox & rBox,_SaveTable & rSTbl)1293*b1cdbd2cSJim Jagielski void _SaveBox::RestoreAttr( SwTableBox& rBox, _SaveTable& rSTbl )
1294*b1cdbd2cSJim Jagielski {
1295*b1cdbd2cSJim Jagielski rSTbl.NewFrmFmt( 0, &rBox, nItemSet, rBox.GetFrmFmt() );
1296*b1cdbd2cSJim Jagielski
1297*b1cdbd2cSJim Jagielski if( ULONG_MAX == nSttNode ) // keine EndBox
1298*b1cdbd2cSJim Jagielski {
1299*b1cdbd2cSJim Jagielski if( !rBox.GetTabLines().Count() )
1300*b1cdbd2cSJim Jagielski {
1301*b1cdbd2cSJim Jagielski ASSERT( !this, "Anzahl der Lines hat sich veraendert" );
1302*b1cdbd2cSJim Jagielski }
1303*b1cdbd2cSJim Jagielski else
1304*b1cdbd2cSJim Jagielski {
1305*b1cdbd2cSJim Jagielski _SaveLine* pLn = Ptrs.pLine;
1306*b1cdbd2cSJim Jagielski for( sal_uInt16 n = 0; n < rBox.GetTabLines().Count(); ++n, pLn = pLn->pNext )
1307*b1cdbd2cSJim Jagielski {
1308*b1cdbd2cSJim Jagielski if( !pLn )
1309*b1cdbd2cSJim Jagielski {
1310*b1cdbd2cSJim Jagielski ASSERT( !this, "Anzahl der Lines hat sich veraendert" );
1311*b1cdbd2cSJim Jagielski break;
1312*b1cdbd2cSJim Jagielski }
1313*b1cdbd2cSJim Jagielski
1314*b1cdbd2cSJim Jagielski pLn->RestoreAttr( *rBox.GetTabLines()[ n ], rSTbl );
1315*b1cdbd2cSJim Jagielski }
1316*b1cdbd2cSJim Jagielski }
1317*b1cdbd2cSJim Jagielski }
1318*b1cdbd2cSJim Jagielski else if( rBox.GetSttNd() && rBox.GetSttIdx() == nSttNode )
1319*b1cdbd2cSJim Jagielski {
1320*b1cdbd2cSJim Jagielski if( Ptrs.pCntntAttrs )
1321*b1cdbd2cSJim Jagielski {
1322*b1cdbd2cSJim Jagielski SwNodes& rNds = rBox.GetFrmFmt()->GetDoc()->GetNodes();
1323*b1cdbd2cSJim Jagielski sal_uInt16 nSet = 0;
1324*b1cdbd2cSJim Jagielski sal_uLong nEnd = rBox.GetSttNd()->EndOfSectionIndex();
1325*b1cdbd2cSJim Jagielski for( sal_uLong n = nSttNode + 1; n < nEnd; ++n )
1326*b1cdbd2cSJim Jagielski {
1327*b1cdbd2cSJim Jagielski SwCntntNode* pCNd = rNds[ n ]->GetCntntNode();
1328*b1cdbd2cSJim Jagielski if( pCNd )
1329*b1cdbd2cSJim Jagielski {
1330*b1cdbd2cSJim Jagielski SfxItemSet* pSet = (*Ptrs.pCntntAttrs)[ nSet++ ];
1331*b1cdbd2cSJim Jagielski if( pSet )
1332*b1cdbd2cSJim Jagielski {
1333*b1cdbd2cSJim Jagielski sal_uInt16 *pRstAttr = aSave_BoxCntntSet;
1334*b1cdbd2cSJim Jagielski while( *pRstAttr )
1335*b1cdbd2cSJim Jagielski {
1336*b1cdbd2cSJim Jagielski pCNd->ResetAttr( *pRstAttr, *(pRstAttr+1) );
1337*b1cdbd2cSJim Jagielski pRstAttr += 2;
1338*b1cdbd2cSJim Jagielski }
1339*b1cdbd2cSJim Jagielski pCNd->SetAttr( *pSet );
1340*b1cdbd2cSJim Jagielski }
1341*b1cdbd2cSJim Jagielski else
1342*b1cdbd2cSJim Jagielski pCNd->ResetAllAttr();
1343*b1cdbd2cSJim Jagielski }
1344*b1cdbd2cSJim Jagielski }
1345*b1cdbd2cSJim Jagielski }
1346*b1cdbd2cSJim Jagielski }
1347*b1cdbd2cSJim Jagielski else
1348*b1cdbd2cSJim Jagielski {
1349*b1cdbd2cSJim Jagielski ASSERT( !this, "Box nicht mehr am gleichen Node" );
1350*b1cdbd2cSJim Jagielski }
1351*b1cdbd2cSJim Jagielski }
1352*b1cdbd2cSJim Jagielski
1353*b1cdbd2cSJim Jagielski
SaveCntntAttrs(SwDoc * pDoc)1354*b1cdbd2cSJim Jagielski void _SaveBox::SaveCntntAttrs( SwDoc* pDoc )
1355*b1cdbd2cSJim Jagielski {
1356*b1cdbd2cSJim Jagielski if( ULONG_MAX == nSttNode ) // keine EndBox
1357*b1cdbd2cSJim Jagielski {
1358*b1cdbd2cSJim Jagielski // weiter in der Line
1359*b1cdbd2cSJim Jagielski Ptrs.pLine->SaveCntntAttrs( pDoc );
1360*b1cdbd2cSJim Jagielski }
1361*b1cdbd2cSJim Jagielski else
1362*b1cdbd2cSJim Jagielski {
1363*b1cdbd2cSJim Jagielski sal_uLong nEnd = pDoc->GetNodes()[ nSttNode ]->EndOfSectionIndex();
1364*b1cdbd2cSJim Jagielski Ptrs.pCntntAttrs = new SfxItemSets( (sal_uInt8)(nEnd - nSttNode - 1 ), 5 );
1365*b1cdbd2cSJim Jagielski for( sal_uLong n = nSttNode + 1; n < nEnd; ++n )
1366*b1cdbd2cSJim Jagielski {
1367*b1cdbd2cSJim Jagielski SwCntntNode* pCNd = pDoc->GetNodes()[ n ]->GetCntntNode();
1368*b1cdbd2cSJim Jagielski if( pCNd )
1369*b1cdbd2cSJim Jagielski {
1370*b1cdbd2cSJim Jagielski SfxItemSet* pSet = 0;
1371*b1cdbd2cSJim Jagielski if( pCNd->HasSwAttrSet() )
1372*b1cdbd2cSJim Jagielski {
1373*b1cdbd2cSJim Jagielski pSet = new SfxItemSet( pDoc->GetAttrPool(),
1374*b1cdbd2cSJim Jagielski aSave_BoxCntntSet );
1375*b1cdbd2cSJim Jagielski pSet->Put( *pCNd->GetpSwAttrSet() );
1376*b1cdbd2cSJim Jagielski }
1377*b1cdbd2cSJim Jagielski
1378*b1cdbd2cSJim Jagielski Ptrs.pCntntAttrs->Insert( pSet, Ptrs.pCntntAttrs->Count() );
1379*b1cdbd2cSJim Jagielski }
1380*b1cdbd2cSJim Jagielski }
1381*b1cdbd2cSJim Jagielski }
1382*b1cdbd2cSJim Jagielski if( pNext )
1383*b1cdbd2cSJim Jagielski pNext->SaveCntntAttrs( pDoc );
1384*b1cdbd2cSJim Jagielski }
1385*b1cdbd2cSJim Jagielski
1386*b1cdbd2cSJim Jagielski
CreateNew(SwTable & rTbl,SwTableLine & rParent,_SaveTable & rSTbl)1387*b1cdbd2cSJim Jagielski void _SaveBox::CreateNew( SwTable& rTbl, SwTableLine& rParent, _SaveTable& rSTbl )
1388*b1cdbd2cSJim Jagielski {
1389*b1cdbd2cSJim Jagielski SwTableBoxFmt* pFmt = (SwTableBoxFmt*)rSTbl.aFrmFmts[ nItemSet ];
1390*b1cdbd2cSJim Jagielski if( !pFmt )
1391*b1cdbd2cSJim Jagielski {
1392*b1cdbd2cSJim Jagielski SwDoc* pDoc = rTbl.GetFrmFmt()->GetDoc();
1393*b1cdbd2cSJim Jagielski pFmt = pDoc->MakeTableBoxFmt();
1394*b1cdbd2cSJim Jagielski pFmt->SetFmtAttr( *rSTbl.aSets[ nItemSet ] );
1395*b1cdbd2cSJim Jagielski rSTbl.aFrmFmts.Replace( pFmt, nItemSet );
1396*b1cdbd2cSJim Jagielski }
1397*b1cdbd2cSJim Jagielski
1398*b1cdbd2cSJim Jagielski if( ULONG_MAX == nSttNode ) // keine EndBox
1399*b1cdbd2cSJim Jagielski {
1400*b1cdbd2cSJim Jagielski SwTableBox* pNew = new SwTableBox( pFmt, 1, &rParent );
1401*b1cdbd2cSJim Jagielski rParent.GetTabBoxes().C40_INSERT( SwTableBox, pNew, rParent.GetTabBoxes().Count() );
1402*b1cdbd2cSJim Jagielski
1403*b1cdbd2cSJim Jagielski Ptrs.pLine->CreateNew( rTbl, *pNew, rSTbl );
1404*b1cdbd2cSJim Jagielski }
1405*b1cdbd2cSJim Jagielski else
1406*b1cdbd2cSJim Jagielski {
1407*b1cdbd2cSJim Jagielski // Box zum StartNode in der alten Tabelle suchen
1408*b1cdbd2cSJim Jagielski SwTableBox* pBox = rTbl.GetTblBox( nSttNode );
1409*b1cdbd2cSJim Jagielski ASSERT( pBox, "Wo ist meine TabellenBox geblieben?" );
1410*b1cdbd2cSJim Jagielski
1411*b1cdbd2cSJim Jagielski SwFrmFmt* pOld = pBox->GetFrmFmt();
1412*b1cdbd2cSJim Jagielski pBox->RegisterToFormat( *pFmt );
1413*b1cdbd2cSJim Jagielski if( !pOld->GetDepends() )
1414*b1cdbd2cSJim Jagielski delete pOld;
1415*b1cdbd2cSJim Jagielski
1416*b1cdbd2cSJim Jagielski pBox->setRowSpan( nRowSpan );
1417*b1cdbd2cSJim Jagielski
1418*b1cdbd2cSJim Jagielski SwTableBoxes* pTBoxes = &pBox->GetUpper()->GetTabBoxes();
1419*b1cdbd2cSJim Jagielski pTBoxes->Remove( pTBoxes->C40_GETPOS( SwTableBox, pBox ) );
1420*b1cdbd2cSJim Jagielski
1421*b1cdbd2cSJim Jagielski pBox->SetUpper( &rParent );
1422*b1cdbd2cSJim Jagielski pTBoxes = &rParent.GetTabBoxes();
1423*b1cdbd2cSJim Jagielski pTBoxes->C40_INSERT( SwTableBox, pBox, pTBoxes->Count() );
1424*b1cdbd2cSJim Jagielski }
1425*b1cdbd2cSJim Jagielski
1426*b1cdbd2cSJim Jagielski if( pNext )
1427*b1cdbd2cSJim Jagielski pNext->CreateNew( rTbl, rParent, rSTbl );
1428*b1cdbd2cSJim Jagielski }
1429*b1cdbd2cSJim Jagielski
1430*b1cdbd2cSJim Jagielski
1431*b1cdbd2cSJim Jagielski //////////////////////////////////////////////////////////////////////////
1432*b1cdbd2cSJim Jagielski
1433*b1cdbd2cSJim Jagielski // UndoObject fuer Attribut Aenderung an der Tabelle
1434*b1cdbd2cSJim Jagielski
1435*b1cdbd2cSJim Jagielski
SwUndoAttrTbl(const SwTableNode & rTblNd,sal_Bool bClearTabCols)1436*b1cdbd2cSJim Jagielski SwUndoAttrTbl::SwUndoAttrTbl( const SwTableNode& rTblNd, sal_Bool bClearTabCols )
1437*b1cdbd2cSJim Jagielski : SwUndo( UNDO_TABLE_ATTR ),
1438*b1cdbd2cSJim Jagielski nSttNode( rTblNd.GetIndex() )
1439*b1cdbd2cSJim Jagielski {
1440*b1cdbd2cSJim Jagielski bClearTabCol = bClearTabCols;
1441*b1cdbd2cSJim Jagielski pSaveTbl = new _SaveTable( rTblNd.GetTable() );
1442*b1cdbd2cSJim Jagielski }
1443*b1cdbd2cSJim Jagielski
~SwUndoAttrTbl()1444*b1cdbd2cSJim Jagielski SwUndoAttrTbl::~SwUndoAttrTbl()
1445*b1cdbd2cSJim Jagielski {
1446*b1cdbd2cSJim Jagielski delete pSaveTbl;
1447*b1cdbd2cSJim Jagielski }
1448*b1cdbd2cSJim Jagielski
UndoImpl(::sw::UndoRedoContext & rContext)1449*b1cdbd2cSJim Jagielski void SwUndoAttrTbl::UndoImpl(::sw::UndoRedoContext & rContext)
1450*b1cdbd2cSJim Jagielski {
1451*b1cdbd2cSJim Jagielski SwDoc & rDoc = rContext.GetDoc();
1452*b1cdbd2cSJim Jagielski SwTableNode* pTblNd = rDoc.GetNodes()[ nSttNode ]->GetTableNode();
1453*b1cdbd2cSJim Jagielski ASSERT( pTblNd, "kein TabellenNode" );
1454*b1cdbd2cSJim Jagielski
1455*b1cdbd2cSJim Jagielski if (pTblNd)
1456*b1cdbd2cSJim Jagielski {
1457*b1cdbd2cSJim Jagielski _SaveTable* pOrig = new _SaveTable( pTblNd->GetTable() );
1458*b1cdbd2cSJim Jagielski pSaveTbl->RestoreAttr( pTblNd->GetTable() );
1459*b1cdbd2cSJim Jagielski delete pSaveTbl;
1460*b1cdbd2cSJim Jagielski pSaveTbl = pOrig;
1461*b1cdbd2cSJim Jagielski }
1462*b1cdbd2cSJim Jagielski
1463*b1cdbd2cSJim Jagielski if( bClearTabCol )
1464*b1cdbd2cSJim Jagielski ClearFEShellTabCols();
1465*b1cdbd2cSJim Jagielski }
1466*b1cdbd2cSJim Jagielski
RedoImpl(::sw::UndoRedoContext & rContext)1467*b1cdbd2cSJim Jagielski void SwUndoAttrTbl::RedoImpl(::sw::UndoRedoContext & rContext)
1468*b1cdbd2cSJim Jagielski {
1469*b1cdbd2cSJim Jagielski UndoImpl(rContext);
1470*b1cdbd2cSJim Jagielski }
1471*b1cdbd2cSJim Jagielski
1472*b1cdbd2cSJim Jagielski
1473*b1cdbd2cSJim Jagielski //////////////////////////////////////////////////////////////////////////
1474*b1cdbd2cSJim Jagielski
1475*b1cdbd2cSJim Jagielski // UndoObject fuer AutoFormat an der Tabelle
1476*b1cdbd2cSJim Jagielski
1477*b1cdbd2cSJim Jagielski
SwUndoTblAutoFmt(const SwTableNode & rTblNd,const SwTableAutoFmt & rAFmt)1478*b1cdbd2cSJim Jagielski SwUndoTblAutoFmt::SwUndoTblAutoFmt( const SwTableNode& rTblNd,
1479*b1cdbd2cSJim Jagielski const SwTableAutoFmt& rAFmt )
1480*b1cdbd2cSJim Jagielski : SwUndo( UNDO_TABLE_AUTOFMT ),
1481*b1cdbd2cSJim Jagielski nSttNode( rTblNd.GetIndex() ),
1482*b1cdbd2cSJim Jagielski bSaveCntntAttr( sal_False )
1483*b1cdbd2cSJim Jagielski {
1484*b1cdbd2cSJim Jagielski pSaveTbl = new _SaveTable( rTblNd.GetTable() );
1485*b1cdbd2cSJim Jagielski
1486*b1cdbd2cSJim Jagielski if( rAFmt.IsFont() || rAFmt.IsJustify() )
1487*b1cdbd2cSJim Jagielski {
1488*b1cdbd2cSJim Jagielski // dann auch noch ueber die ContentNodes der EndBoxen und
1489*b1cdbd2cSJim Jagielski // und alle Absatz-Attribute zusammen sammeln
1490*b1cdbd2cSJim Jagielski pSaveTbl->SaveCntntAttrs( (SwDoc*)rTblNd.GetDoc() );
1491*b1cdbd2cSJim Jagielski bSaveCntntAttr = sal_True;
1492*b1cdbd2cSJim Jagielski }
1493*b1cdbd2cSJim Jagielski }
1494*b1cdbd2cSJim Jagielski
~SwUndoTblAutoFmt()1495*b1cdbd2cSJim Jagielski SwUndoTblAutoFmt::~SwUndoTblAutoFmt()
1496*b1cdbd2cSJim Jagielski {
1497*b1cdbd2cSJim Jagielski delete pSaveTbl;
1498*b1cdbd2cSJim Jagielski }
1499*b1cdbd2cSJim Jagielski
SaveBoxCntnt(const SwTableBox & rBox)1500*b1cdbd2cSJim Jagielski void SwUndoTblAutoFmt::SaveBoxCntnt( const SwTableBox& rBox )
1501*b1cdbd2cSJim Jagielski {
1502*b1cdbd2cSJim Jagielski ::boost::shared_ptr<SwUndoTblNumFmt> const p(new SwUndoTblNumFmt(rBox));
1503*b1cdbd2cSJim Jagielski m_Undos.push_back(p);
1504*b1cdbd2cSJim Jagielski }
1505*b1cdbd2cSJim Jagielski
1506*b1cdbd2cSJim Jagielski
1507*b1cdbd2cSJim Jagielski void
UndoRedo(bool const bUndo,::sw::UndoRedoContext & rContext)1508*b1cdbd2cSJim Jagielski SwUndoTblAutoFmt::UndoRedo(bool const bUndo, ::sw::UndoRedoContext & rContext)
1509*b1cdbd2cSJim Jagielski {
1510*b1cdbd2cSJim Jagielski SwDoc & rDoc = rContext.GetDoc();
1511*b1cdbd2cSJim Jagielski SwTableNode* pTblNd = rDoc.GetNodes()[ nSttNode ]->GetTableNode();
1512*b1cdbd2cSJim Jagielski ASSERT( pTblNd, "kein TabellenNode" );
1513*b1cdbd2cSJim Jagielski
1514*b1cdbd2cSJim Jagielski _SaveTable* pOrig = new _SaveTable( pTblNd->GetTable() );
1515*b1cdbd2cSJim Jagielski // dann auch noch ueber die ContentNodes der EndBoxen und
1516*b1cdbd2cSJim Jagielski // und alle Absatz-Attribute zusammen sammeln
1517*b1cdbd2cSJim Jagielski if( bSaveCntntAttr )
1518*b1cdbd2cSJim Jagielski pOrig->SaveCntntAttrs( &rDoc );
1519*b1cdbd2cSJim Jagielski
1520*b1cdbd2cSJim Jagielski if (bUndo)
1521*b1cdbd2cSJim Jagielski {
1522*b1cdbd2cSJim Jagielski for (size_t n = m_Undos.size(); 0 < n; --n)
1523*b1cdbd2cSJim Jagielski {
1524*b1cdbd2cSJim Jagielski m_Undos.at(n-1)->UndoImpl(rContext);
1525*b1cdbd2cSJim Jagielski }
1526*b1cdbd2cSJim Jagielski }
1527*b1cdbd2cSJim Jagielski
1528*b1cdbd2cSJim Jagielski pSaveTbl->RestoreAttr( pTblNd->GetTable(), !bUndo );
1529*b1cdbd2cSJim Jagielski delete pSaveTbl;
1530*b1cdbd2cSJim Jagielski pSaveTbl = pOrig;
1531*b1cdbd2cSJim Jagielski }
1532*b1cdbd2cSJim Jagielski
UndoImpl(::sw::UndoRedoContext & rContext)1533*b1cdbd2cSJim Jagielski void SwUndoTblAutoFmt::UndoImpl(::sw::UndoRedoContext & rContext)
1534*b1cdbd2cSJim Jagielski {
1535*b1cdbd2cSJim Jagielski UndoRedo(true, rContext);
1536*b1cdbd2cSJim Jagielski }
1537*b1cdbd2cSJim Jagielski
RedoImpl(::sw::UndoRedoContext & rContext)1538*b1cdbd2cSJim Jagielski void SwUndoTblAutoFmt::RedoImpl(::sw::UndoRedoContext & rContext)
1539*b1cdbd2cSJim Jagielski {
1540*b1cdbd2cSJim Jagielski UndoRedo(false, rContext);
1541*b1cdbd2cSJim Jagielski }
1542*b1cdbd2cSJim Jagielski
1543*b1cdbd2cSJim Jagielski
1544*b1cdbd2cSJim Jagielski //////////////////////////////////////////////////////////////////////////
1545*b1cdbd2cSJim Jagielski
SwUndoTblNdsChg(SwUndoId nAction,const SwSelBoxes & rBoxes,const SwTableNode & rTblNd,long nMn,long nMx,sal_uInt16 nCnt,sal_Bool bFlg,sal_Bool bSmHght)1546*b1cdbd2cSJim Jagielski SwUndoTblNdsChg::SwUndoTblNdsChg( SwUndoId nAction,
1547*b1cdbd2cSJim Jagielski const SwSelBoxes& rBoxes,
1548*b1cdbd2cSJim Jagielski const SwTableNode& rTblNd,
1549*b1cdbd2cSJim Jagielski long nMn, long nMx,
1550*b1cdbd2cSJim Jagielski sal_uInt16 nCnt, sal_Bool bFlg, sal_Bool bSmHght )
1551*b1cdbd2cSJim Jagielski : SwUndo( nAction ),
1552*b1cdbd2cSJim Jagielski aBoxes( rBoxes.Count() < 255 ? (sal_uInt8)rBoxes.Count() : 255, 10 ),
1553*b1cdbd2cSJim Jagielski nMin( nMn ), nMax( nMx ),
1554*b1cdbd2cSJim Jagielski nSttNode( rTblNd.GetIndex() ), nCurrBox( 0 ),
1555*b1cdbd2cSJim Jagielski nCount( nCnt ), nRelDiff( 0 ), nAbsDiff( 0 ),
1556*b1cdbd2cSJim Jagielski nSetColType( USHRT_MAX ),
1557*b1cdbd2cSJim Jagielski bFlag( bFlg ),
1558*b1cdbd2cSJim Jagielski bSameHeight( bSmHght )
1559*b1cdbd2cSJim Jagielski {
1560*b1cdbd2cSJim Jagielski Ptrs.pNewSttNds = 0;
1561*b1cdbd2cSJim Jagielski
1562*b1cdbd2cSJim Jagielski const SwTable& rTbl = rTblNd.GetTable();
1563*b1cdbd2cSJim Jagielski pSaveTbl = new _SaveTable( rTbl );
1564*b1cdbd2cSJim Jagielski
1565*b1cdbd2cSJim Jagielski // und die Selektion merken
1566*b1cdbd2cSJim Jagielski for( sal_uInt16 n = 0; n < rBoxes.Count(); ++n )
1567*b1cdbd2cSJim Jagielski aBoxes.Insert( rBoxes[n]->GetSttIdx(), n );
1568*b1cdbd2cSJim Jagielski }
1569*b1cdbd2cSJim Jagielski
1570*b1cdbd2cSJim Jagielski
SwUndoTblNdsChg(SwUndoId nAction,const SwSelBoxes & rBoxes,const SwTableNode & rTblNd)1571*b1cdbd2cSJim Jagielski SwUndoTblNdsChg::SwUndoTblNdsChg( SwUndoId nAction,
1572*b1cdbd2cSJim Jagielski const SwSelBoxes& rBoxes,
1573*b1cdbd2cSJim Jagielski const SwTableNode& rTblNd )
1574*b1cdbd2cSJim Jagielski : SwUndo( nAction ),
1575*b1cdbd2cSJim Jagielski aBoxes( rBoxes.Count() < 255 ? (sal_uInt8)rBoxes.Count() : 255, 10 ),
1576*b1cdbd2cSJim Jagielski nMin( 0 ), nMax( 0 ),
1577*b1cdbd2cSJim Jagielski nSttNode( rTblNd.GetIndex() ), nCurrBox( 0 ),
1578*b1cdbd2cSJim Jagielski nCount( 0 ), nRelDiff( 0 ), nAbsDiff( 0 ),
1579*b1cdbd2cSJim Jagielski nSetColType( USHRT_MAX ),
1580*b1cdbd2cSJim Jagielski bFlag( sal_False ),
1581*b1cdbd2cSJim Jagielski bSameHeight( sal_False )
1582*b1cdbd2cSJim Jagielski {
1583*b1cdbd2cSJim Jagielski Ptrs.pNewSttNds = 0;
1584*b1cdbd2cSJim Jagielski
1585*b1cdbd2cSJim Jagielski const SwTable& rTbl = rTblNd.GetTable();
1586*b1cdbd2cSJim Jagielski pSaveTbl = new _SaveTable( rTbl );
1587*b1cdbd2cSJim Jagielski
1588*b1cdbd2cSJim Jagielski // und die Selektion merken
1589*b1cdbd2cSJim Jagielski for( sal_uInt16 n = 0; n < rBoxes.Count(); ++n )
1590*b1cdbd2cSJim Jagielski aBoxes.Insert( rBoxes[n]->GetSttIdx(), n );
1591*b1cdbd2cSJim Jagielski }
1592*b1cdbd2cSJim Jagielski
ReNewBoxes(const SwSelBoxes & rBoxes)1593*b1cdbd2cSJim Jagielski void SwUndoTblNdsChg::ReNewBoxes( const SwSelBoxes& rBoxes )
1594*b1cdbd2cSJim Jagielski {
1595*b1cdbd2cSJim Jagielski if( rBoxes.Count() != aBoxes.Count() )
1596*b1cdbd2cSJim Jagielski {
1597*b1cdbd2cSJim Jagielski aBoxes.Remove( 0, aBoxes.Count() );
1598*b1cdbd2cSJim Jagielski for( sal_uInt16 n = 0; n < rBoxes.Count(); ++n )
1599*b1cdbd2cSJim Jagielski aBoxes.Insert( rBoxes[n]->GetSttIdx(), n );
1600*b1cdbd2cSJim Jagielski }
1601*b1cdbd2cSJim Jagielski }
1602*b1cdbd2cSJim Jagielski
~SwUndoTblNdsChg()1603*b1cdbd2cSJim Jagielski SwUndoTblNdsChg::~SwUndoTblNdsChg()
1604*b1cdbd2cSJim Jagielski {
1605*b1cdbd2cSJim Jagielski delete pSaveTbl;
1606*b1cdbd2cSJim Jagielski
1607*b1cdbd2cSJim Jagielski if( IsDelBox() )
1608*b1cdbd2cSJim Jagielski delete Ptrs.pDelSects;
1609*b1cdbd2cSJim Jagielski else
1610*b1cdbd2cSJim Jagielski delete Ptrs.pNewSttNds;
1611*b1cdbd2cSJim Jagielski }
1612*b1cdbd2cSJim Jagielski
SaveNewBoxes(const SwTableNode & rTblNd,const SwTableSortBoxes & rOld)1613*b1cdbd2cSJim Jagielski void SwUndoTblNdsChg::SaveNewBoxes( const SwTableNode& rTblNd,
1614*b1cdbd2cSJim Jagielski const SwTableSortBoxes& rOld )
1615*b1cdbd2cSJim Jagielski {
1616*b1cdbd2cSJim Jagielski const SwTable& rTbl = rTblNd.GetTable();
1617*b1cdbd2cSJim Jagielski const SwTableSortBoxes& rTblBoxes = rTbl.GetTabSortBoxes();
1618*b1cdbd2cSJim Jagielski sal_uInt16 n;
1619*b1cdbd2cSJim Jagielski sal_uInt16 i;
1620*b1cdbd2cSJim Jagielski
1621*b1cdbd2cSJim Jagielski ASSERT( ! IsDelBox(), "falsche Action" );
1622*b1cdbd2cSJim Jagielski Ptrs.pNewSttNds = new SvULongs( (sal_uInt8)(rTblBoxes.Count() - rOld.Count()), 5 );
1623*b1cdbd2cSJim Jagielski
1624*b1cdbd2cSJim Jagielski for( n = 0, i = 0; n < rOld.Count(); ++i )
1625*b1cdbd2cSJim Jagielski {
1626*b1cdbd2cSJim Jagielski if( rOld[ n ] == rTblBoxes[ i ] )
1627*b1cdbd2cSJim Jagielski ++n;
1628*b1cdbd2cSJim Jagielski else
1629*b1cdbd2cSJim Jagielski // neue Box: sortiert einfuegen!!
1630*b1cdbd2cSJim Jagielski InsertSort( *Ptrs.pNewSttNds, rTblBoxes[ i ]->GetSttIdx() );
1631*b1cdbd2cSJim Jagielski }
1632*b1cdbd2cSJim Jagielski
1633*b1cdbd2cSJim Jagielski for( ; i < rTblBoxes.Count(); ++i )
1634*b1cdbd2cSJim Jagielski // neue Box: sortiert einfuegen!!
1635*b1cdbd2cSJim Jagielski InsertSort( *Ptrs.pNewSttNds, rTblBoxes[ i ]->GetSttIdx() );
1636*b1cdbd2cSJim Jagielski }
1637*b1cdbd2cSJim Jagielski
1638*b1cdbd2cSJim Jagielski
lcl_FindTableLine(const SwTable & rTable,const SwTableBox & rBox)1639*b1cdbd2cSJim Jagielski SwTableLine* lcl_FindTableLine( const SwTable& rTable,
1640*b1cdbd2cSJim Jagielski const SwTableBox& rBox )
1641*b1cdbd2cSJim Jagielski {
1642*b1cdbd2cSJim Jagielski SwTableLine* pRet = NULL;
1643*b1cdbd2cSJim Jagielski // i63949: For nested cells we have to take nLineNo - 1, too, not 0!
1644*b1cdbd2cSJim Jagielski const SwTableLines &rTableLines = ( rBox.GetUpper()->GetUpper() != NULL ) ?
1645*b1cdbd2cSJim Jagielski rBox.GetUpper()->GetUpper()->GetTabLines()
1646*b1cdbd2cSJim Jagielski : rTable.GetTabLines();
1647*b1cdbd2cSJim Jagielski const SwTableLine* pLine = rBox.GetUpper();
1648*b1cdbd2cSJim Jagielski sal_uInt16 nLineNo = rTableLines.C40_GETPOS( SwTableLine, pLine );
1649*b1cdbd2cSJim Jagielski pRet = rTableLines[nLineNo - 1];
1650*b1cdbd2cSJim Jagielski
1651*b1cdbd2cSJim Jagielski return pRet;
1652*b1cdbd2cSJim Jagielski }
1653*b1cdbd2cSJim Jagielski
lcl_FindParentLines(const SwTable & rTable,const SwTableBox & rBox)1654*b1cdbd2cSJim Jagielski const SwTableLines& lcl_FindParentLines( const SwTable& rTable,
1655*b1cdbd2cSJim Jagielski const SwTableBox& rBox )
1656*b1cdbd2cSJim Jagielski {
1657*b1cdbd2cSJim Jagielski const SwTableLines& rRet =
1658*b1cdbd2cSJim Jagielski ( rBox.GetUpper()->GetUpper() != NULL ) ?
1659*b1cdbd2cSJim Jagielski rBox.GetUpper()->GetUpper()->GetTabLines() :
1660*b1cdbd2cSJim Jagielski rTable.GetTabLines();
1661*b1cdbd2cSJim Jagielski
1662*b1cdbd2cSJim Jagielski return rRet;
1663*b1cdbd2cSJim Jagielski }
1664*b1cdbd2cSJim Jagielski
1665*b1cdbd2cSJim Jagielski
SaveNewBoxes(const SwTableNode & rTblNd,const SwTableSortBoxes & rOld,const SwSelBoxes & rBoxes,const SvULongs & rNodeCnts)1666*b1cdbd2cSJim Jagielski void SwUndoTblNdsChg::SaveNewBoxes( const SwTableNode& rTblNd,
1667*b1cdbd2cSJim Jagielski const SwTableSortBoxes& rOld,
1668*b1cdbd2cSJim Jagielski const SwSelBoxes& rBoxes,
1669*b1cdbd2cSJim Jagielski const SvULongs& rNodeCnts )
1670*b1cdbd2cSJim Jagielski {
1671*b1cdbd2cSJim Jagielski const SwTable& rTbl = rTblNd.GetTable();
1672*b1cdbd2cSJim Jagielski const SwTableSortBoxes& rTblBoxes = rTbl.GetTabSortBoxes();
1673*b1cdbd2cSJim Jagielski
1674*b1cdbd2cSJim Jagielski ASSERT( ! IsDelBox(), "falsche Action" );
1675*b1cdbd2cSJim Jagielski Ptrs.pNewSttNds = new SvULongs( (sal_uInt8)(rTblBoxes.Count() - rOld.Count()), 5 );
1676*b1cdbd2cSJim Jagielski
1677*b1cdbd2cSJim Jagielski ASSERT( rTbl.IsNewModel() || rOld.Count() + nCount * rBoxes.Count() == rTblBoxes.Count(),
1678*b1cdbd2cSJim Jagielski "unexpected boxes" );
1679*b1cdbd2cSJim Jagielski ASSERT( rOld.Count() <= rTblBoxes.Count(), "more unexpected boxes" );
1680*b1cdbd2cSJim Jagielski for( sal_uInt16 n = 0, i = 0; i < rTblBoxes.Count(); ++i )
1681*b1cdbd2cSJim Jagielski {
1682*b1cdbd2cSJim Jagielski if( ( n < rOld.Count() ) &&
1683*b1cdbd2cSJim Jagielski ( rOld[ n ] == rTblBoxes[ i ] ) )
1684*b1cdbd2cSJim Jagielski {
1685*b1cdbd2cSJim Jagielski // box already known? Then nothing to be done.
1686*b1cdbd2cSJim Jagielski ++n;
1687*b1cdbd2cSJim Jagielski }
1688*b1cdbd2cSJim Jagielski else
1689*b1cdbd2cSJim Jagielski {
1690*b1cdbd2cSJim Jagielski // new box found: insert (obey sort order)
1691*b1cdbd2cSJim Jagielski sal_uInt16 nInsPos;
1692*b1cdbd2cSJim Jagielski const SwTableBox* pBox = rTblBoxes[ i ];
1693*b1cdbd2cSJim Jagielski InsertSort( *Ptrs.pNewSttNds, pBox->GetSttIdx(), &nInsPos );
1694*b1cdbd2cSJim Jagielski
1695*b1cdbd2cSJim Jagielski // find the source box. It must be one in rBoxes.
1696*b1cdbd2cSJim Jagielski // We found the right one if it's in the same column as pBox.
1697*b1cdbd2cSJim Jagielski // No, if more than one selected cell in the same column has been splitted,
1698*b1cdbd2cSJim Jagielski // we have to look for the nearest one (i65201)!
1699*b1cdbd2cSJim Jagielski const SwTableBox* pSourceBox = NULL;
1700*b1cdbd2cSJim Jagielski const SwTableBox* pCheckBox = NULL;
1701*b1cdbd2cSJim Jagielski const SwTableLine* pBoxLine = pBox->GetUpper();
1702*b1cdbd2cSJim Jagielski sal_uInt16 nLineDiff = lcl_FindParentLines(rTbl,*pBox).C40_GETPOS(SwTableLine,pBoxLine);
1703*b1cdbd2cSJim Jagielski sal_uInt16 nLineNo = 0;
1704*b1cdbd2cSJim Jagielski for( sal_uInt16 j = 0; j < rBoxes.Count(); ++j )
1705*b1cdbd2cSJim Jagielski {
1706*b1cdbd2cSJim Jagielski pCheckBox = rBoxes[j];
1707*b1cdbd2cSJim Jagielski if( pCheckBox->GetUpper()->GetUpper() == pBox->GetUpper()->GetUpper() )
1708*b1cdbd2cSJim Jagielski {
1709*b1cdbd2cSJim Jagielski const SwTableLine* pCheckLine = pCheckBox->GetUpper();
1710*b1cdbd2cSJim Jagielski sal_uInt16 nCheckLine = lcl_FindParentLines( rTbl, *pCheckBox ).
1711*b1cdbd2cSJim Jagielski C40_GETPOS( SwTableLine, pCheckLine );
1712*b1cdbd2cSJim Jagielski if( ( !pSourceBox || nCheckLine > nLineNo ) && nCheckLine < nLineDiff )
1713*b1cdbd2cSJim Jagielski {
1714*b1cdbd2cSJim Jagielski nLineNo = nCheckLine;
1715*b1cdbd2cSJim Jagielski pSourceBox = pCheckBox;
1716*b1cdbd2cSJim Jagielski }
1717*b1cdbd2cSJim Jagielski }
1718*b1cdbd2cSJim Jagielski }
1719*b1cdbd2cSJim Jagielski
1720*b1cdbd2cSJim Jagielski // find the line number difference
1721*b1cdbd2cSJim Jagielski // (to help determine bNodesMoved flag below)
1722*b1cdbd2cSJim Jagielski nLineDiff = nLineDiff - nLineNo;
1723*b1cdbd2cSJim Jagielski ASSERT( pSourceBox, "Splitted source box not found!" );
1724*b1cdbd2cSJim Jagielski // find out how many nodes the source box used to have
1725*b1cdbd2cSJim Jagielski // (to help determine bNodesMoved flag below)
1726*b1cdbd2cSJim Jagielski sal_uInt16 nNdsPos = 0;
1727*b1cdbd2cSJim Jagielski while( rBoxes[ nNdsPos ] != pSourceBox )
1728*b1cdbd2cSJim Jagielski ++nNdsPos;
1729*b1cdbd2cSJim Jagielski sal_uLong nNodes = rNodeCnts[ nNdsPos ];
1730*b1cdbd2cSJim Jagielski
1731*b1cdbd2cSJim Jagielski // When a new table cell is created, it either gets a new
1732*b1cdbd2cSJim Jagielski // node, or it gets node(s) from elsewhere. The undo must
1733*b1cdbd2cSJim Jagielski // know, of course, and thus we must determine here just
1734*b1cdbd2cSJim Jagielski // where pBox's nodes are from:
1735*b1cdbd2cSJim Jagielski // If 1) the source box has lost nodes, and
1736*b1cdbd2cSJim Jagielski // 2) we're in the node range that got nodes
1737*b1cdbd2cSJim Jagielski // then pBox received nodes from elsewhere.
1738*b1cdbd2cSJim Jagielski // If bNodesMoved is set for pBox the undo must move the
1739*b1cdbd2cSJim Jagielski // boxes back, otherwise it must delete them.
1740*b1cdbd2cSJim Jagielski // The bNodesMoved flag is stored in a seperate array
1741*b1cdbd2cSJim Jagielski // which mirrors Ptrs.pNewSttNds, i.e. Ptrs.pNewSttNds[i]
1742*b1cdbd2cSJim Jagielski // and aMvBoxes[i] belong together.
1743*b1cdbd2cSJim Jagielski sal_Bool bNodesMoved =
1744*b1cdbd2cSJim Jagielski ( nNodes != ( pSourceBox->GetSttNd()->EndOfSectionIndex() -
1745*b1cdbd2cSJim Jagielski pSourceBox->GetSttIdx() ) )
1746*b1cdbd2cSJim Jagielski && ( nNodes - 1 > nLineDiff );
1747*b1cdbd2cSJim Jagielski aMvBoxes.insert( aMvBoxes.begin() + nInsPos, bNodesMoved );
1748*b1cdbd2cSJim Jagielski }
1749*b1cdbd2cSJim Jagielski }
1750*b1cdbd2cSJim Jagielski }
1751*b1cdbd2cSJim Jagielski
1752*b1cdbd2cSJim Jagielski
SaveSection(SwStartNode * pSttNd)1753*b1cdbd2cSJim Jagielski void SwUndoTblNdsChg::SaveSection( SwStartNode* pSttNd )
1754*b1cdbd2cSJim Jagielski {
1755*b1cdbd2cSJim Jagielski ASSERT( IsDelBox(), "falsche Action" );
1756*b1cdbd2cSJim Jagielski if( !Ptrs.pDelSects )
1757*b1cdbd2cSJim Jagielski Ptrs.pDelSects = new SwUndoSaveSections( 10, 5 );
1758*b1cdbd2cSJim Jagielski
1759*b1cdbd2cSJim Jagielski SwTableNode* pTblNd = pSttNd->FindTableNode();
1760*b1cdbd2cSJim Jagielski SwUndoSaveSection* pSave = new SwUndoSaveSection;
1761*b1cdbd2cSJim Jagielski pSave->SaveSection( pSttNd->GetDoc(), SwNodeIndex( *pSttNd ));
1762*b1cdbd2cSJim Jagielski
1763*b1cdbd2cSJim Jagielski Ptrs.pDelSects->Insert( pSave, Ptrs.pDelSects->Count() );
1764*b1cdbd2cSJim Jagielski nSttNode = pTblNd->GetIndex();
1765*b1cdbd2cSJim Jagielski }
1766*b1cdbd2cSJim Jagielski
1767*b1cdbd2cSJim Jagielski
UndoImpl(::sw::UndoRedoContext & rContext)1768*b1cdbd2cSJim Jagielski void SwUndoTblNdsChg::UndoImpl(::sw::UndoRedoContext & rContext)
1769*b1cdbd2cSJim Jagielski {
1770*b1cdbd2cSJim Jagielski SwDoc & rDoc = rContext.GetDoc();
1771*b1cdbd2cSJim Jagielski SwNodeIndex aIdx( rDoc.GetNodes(), nSttNode );
1772*b1cdbd2cSJim Jagielski
1773*b1cdbd2cSJim Jagielski SwTableNode *const pTblNd = aIdx.GetNode().GetTableNode();
1774*b1cdbd2cSJim Jagielski OSL_ENSURE( pTblNd, "SwUndoTblNdsChg: no TableNode" );
1775*b1cdbd2cSJim Jagielski
1776*b1cdbd2cSJim Jagielski SwTableFmlUpdate aMsgHnt( &pTblNd->GetTable() );
1777*b1cdbd2cSJim Jagielski aMsgHnt.eFlags = TBL_BOXPTR;
1778*b1cdbd2cSJim Jagielski rDoc.UpdateTblFlds( &aMsgHnt );
1779*b1cdbd2cSJim Jagielski
1780*b1cdbd2cSJim Jagielski CHECK_TABLE( pTblNd->GetTable() )
1781*b1cdbd2cSJim Jagielski
1782*b1cdbd2cSJim Jagielski _FndBox aTmpBox( 0, 0 );
1783*b1cdbd2cSJim Jagielski // ? TL_CHART2: notification or locking of controller required ?
1784*b1cdbd2cSJim Jagielski
1785*b1cdbd2cSJim Jagielski SwChartDataProvider *pPCD = rDoc.GetChartDataProvider();
1786*b1cdbd2cSJim Jagielski std::vector< SwTableBox* > aDelBoxes;
1787*b1cdbd2cSJim Jagielski if( IsDelBox() )
1788*b1cdbd2cSJim Jagielski {
1789*b1cdbd2cSJim Jagielski // Trick: die fehlenden Boxen in irgendeine Line einfuegen, beim
1790*b1cdbd2cSJim Jagielski // CreateNew werden sie korrekt verbunden.
1791*b1cdbd2cSJim Jagielski SwTableBox* pCpyBox = pTblNd->GetTable().GetTabSortBoxes()[0];
1792*b1cdbd2cSJim Jagielski SwTableBoxes& rLnBoxes = pCpyBox->GetUpper()->GetTabBoxes();
1793*b1cdbd2cSJim Jagielski
1794*b1cdbd2cSJim Jagielski // die Sections wieder herstellen
1795*b1cdbd2cSJim Jagielski for( sal_uInt16 n = Ptrs.pDelSects->Count(); n; )
1796*b1cdbd2cSJim Jagielski {
1797*b1cdbd2cSJim Jagielski SwUndoSaveSection* pSave = (*Ptrs.pDelSects)[ --n ];
1798*b1cdbd2cSJim Jagielski pSave->RestoreSection( &rDoc, &aIdx, SwTableBoxStartNode );
1799*b1cdbd2cSJim Jagielski if( pSave->GetHistory() )
1800*b1cdbd2cSJim Jagielski pSave->GetHistory()->Rollback( &rDoc );
1801*b1cdbd2cSJim Jagielski SwTableBox* pBox = new SwTableBox( (SwTableBoxFmt*)pCpyBox->GetFrmFmt(), aIdx,
1802*b1cdbd2cSJim Jagielski pCpyBox->GetUpper() );
1803*b1cdbd2cSJim Jagielski rLnBoxes.C40_INSERT( SwTableBox, pBox, rLnBoxes.Count() );
1804*b1cdbd2cSJim Jagielski }
1805*b1cdbd2cSJim Jagielski Ptrs.pDelSects->DeleteAndDestroy( 0, Ptrs.pDelSects->Count() );
1806*b1cdbd2cSJim Jagielski }
1807*b1cdbd2cSJim Jagielski else if( !aMvBoxes.empty() )
1808*b1cdbd2cSJim Jagielski {
1809*b1cdbd2cSJim Jagielski // dann muessen Nodes verschoben und nicht geloescht werden!
1810*b1cdbd2cSJim Jagielski // Dafuer brauchen wir aber ein temp Array
1811*b1cdbd2cSJim Jagielski SvULongs aTmp( 0, 5);
1812*b1cdbd2cSJim Jagielski aTmp.Insert( Ptrs.pNewSttNds, 0 );
1813*b1cdbd2cSJim Jagielski
1814*b1cdbd2cSJim Jagielski // von hinten anfangen
1815*b1cdbd2cSJim Jagielski for( sal_uInt16 n = aTmp.Count(); n; )
1816*b1cdbd2cSJim Jagielski {
1817*b1cdbd2cSJim Jagielski // Box aus der Tabellen-Struktur entfernen
1818*b1cdbd2cSJim Jagielski sal_uLong nIdx = aTmp[ --n ];
1819*b1cdbd2cSJim Jagielski SwTableBox* pBox = pTblNd->GetTable().GetTblBox( nIdx );
1820*b1cdbd2cSJim Jagielski ASSERT( pBox, "Wo ist meine TabellenBox geblieben?" );
1821*b1cdbd2cSJim Jagielski
1822*b1cdbd2cSJim Jagielski // TL_CHART2: notify chart about box to be removed
1823*b1cdbd2cSJim Jagielski if (pPCD)
1824*b1cdbd2cSJim Jagielski pPCD->DeleteBox( &pTblNd->GetTable(), *pBox );
1825*b1cdbd2cSJim Jagielski
1826*b1cdbd2cSJim Jagielski if( aMvBoxes[ n ] )
1827*b1cdbd2cSJim Jagielski {
1828*b1cdbd2cSJim Jagielski SwNodeRange aRg( *pBox->GetSttNd(), 1,
1829*b1cdbd2cSJim Jagielski *pBox->GetSttNd()->EndOfSectionNode() );
1830*b1cdbd2cSJim Jagielski
1831*b1cdbd2cSJim Jagielski SwTableLine* pLine = lcl_FindTableLine( pTblNd->GetTable(), *pBox );
1832*b1cdbd2cSJim Jagielski SwNodeIndex aInsPos( *(pLine->GetTabBoxes()[0]->GetSttNd()), 2 );
1833*b1cdbd2cSJim Jagielski
1834*b1cdbd2cSJim Jagielski // alle StartNode Indizies anpassen
1835*b1cdbd2cSJim Jagielski sal_uInt16 i = n;
1836*b1cdbd2cSJim Jagielski sal_uLong nSttIdx = aInsPos.GetIndex() - 2,
1837*b1cdbd2cSJim Jagielski nNdCnt = aRg.aEnd.GetIndex() - aRg.aStart.GetIndex();
1838*b1cdbd2cSJim Jagielski while( i && aTmp[ --i ] > nSttIdx )
1839*b1cdbd2cSJim Jagielski aTmp[ i ] += nNdCnt;
1840*b1cdbd2cSJim Jagielski
1841*b1cdbd2cSJim Jagielski // erst die Box loeschen
1842*b1cdbd2cSJim Jagielski delete pBox;
1843*b1cdbd2cSJim Jagielski // dann die Nodes verschieben,
1844*b1cdbd2cSJim Jagielski rDoc.GetNodes()._MoveNodes( aRg, rDoc.GetNodes(), aInsPos, sal_False );
1845*b1cdbd2cSJim Jagielski }
1846*b1cdbd2cSJim Jagielski else
1847*b1cdbd2cSJim Jagielski rDoc.DeleteSection( rDoc.GetNodes()[ nIdx ] );
1848*b1cdbd2cSJim Jagielski aDelBoxes.insert( aDelBoxes.end(), pBox );
1849*b1cdbd2cSJim Jagielski }
1850*b1cdbd2cSJim Jagielski }
1851*b1cdbd2cSJim Jagielski else
1852*b1cdbd2cSJim Jagielski {
1853*b1cdbd2cSJim Jagielski // Remove nodes from nodes array (backwards!)
1854*b1cdbd2cSJim Jagielski for( sal_uInt16 n = Ptrs.pNewSttNds->Count(); n; )
1855*b1cdbd2cSJim Jagielski {
1856*b1cdbd2cSJim Jagielski sal_uLong nIdx = (*Ptrs.pNewSttNds)[ --n ];
1857*b1cdbd2cSJim Jagielski SwTableBox* pBox = pTblNd->GetTable().GetTblBox( nIdx );
1858*b1cdbd2cSJim Jagielski ASSERT( pBox, "Where's my table box?" );
1859*b1cdbd2cSJim Jagielski // TL_CHART2: notify chart about box to be removed
1860*b1cdbd2cSJim Jagielski if (pPCD)
1861*b1cdbd2cSJim Jagielski pPCD->DeleteBox( &pTblNd->GetTable(), *pBox );
1862*b1cdbd2cSJim Jagielski aDelBoxes.insert( aDelBoxes.end(), pBox );
1863*b1cdbd2cSJim Jagielski rDoc.DeleteSection( rDoc.GetNodes()[ nIdx ] );
1864*b1cdbd2cSJim Jagielski }
1865*b1cdbd2cSJim Jagielski }
1866*b1cdbd2cSJim Jagielski // Remove boxes from table structure
1867*b1cdbd2cSJim Jagielski for( sal_uInt16 n = 0; n < aDelBoxes.size(); ++n )
1868*b1cdbd2cSJim Jagielski {
1869*b1cdbd2cSJim Jagielski SwTableBox* pCurrBox = aDelBoxes[n];
1870*b1cdbd2cSJim Jagielski SwTableBoxes* pTBoxes = &pCurrBox->GetUpper()->GetTabBoxes();
1871*b1cdbd2cSJim Jagielski pTBoxes->Remove( pTBoxes->C40_GETPOS( SwTableBox, pCurrBox ) );
1872*b1cdbd2cSJim Jagielski delete pCurrBox;
1873*b1cdbd2cSJim Jagielski }
1874*b1cdbd2cSJim Jagielski
1875*b1cdbd2cSJim Jagielski pSaveTbl->CreateNew( pTblNd->GetTable(), sal_True, sal_False );
1876*b1cdbd2cSJim Jagielski
1877*b1cdbd2cSJim Jagielski // TL_CHART2: need to inform chart of probably changed cell names
1878*b1cdbd2cSJim Jagielski rDoc.UpdateCharts( pTblNd->GetTable().GetFrmFmt()->GetName() );
1879*b1cdbd2cSJim Jagielski
1880*b1cdbd2cSJim Jagielski if( IsDelBox() )
1881*b1cdbd2cSJim Jagielski nSttNode = pTblNd->GetIndex();
1882*b1cdbd2cSJim Jagielski ClearFEShellTabCols();
1883*b1cdbd2cSJim Jagielski CHECK_TABLE( pTblNd->GetTable() )
1884*b1cdbd2cSJim Jagielski }
1885*b1cdbd2cSJim Jagielski
1886*b1cdbd2cSJim Jagielski
RedoImpl(::sw::UndoRedoContext & rContext)1887*b1cdbd2cSJim Jagielski void SwUndoTblNdsChg::RedoImpl(::sw::UndoRedoContext & rContext)
1888*b1cdbd2cSJim Jagielski {
1889*b1cdbd2cSJim Jagielski SwDoc & rDoc = rContext.GetDoc();
1890*b1cdbd2cSJim Jagielski
1891*b1cdbd2cSJim Jagielski SwTableNode* pTblNd = rDoc.GetNodes()[ nSttNode ]->GetTableNode();
1892*b1cdbd2cSJim Jagielski ASSERT( pTblNd, "kein TabellenNode" );
1893*b1cdbd2cSJim Jagielski CHECK_TABLE( pTblNd->GetTable() )
1894*b1cdbd2cSJim Jagielski
1895*b1cdbd2cSJim Jagielski SwSelBoxes aSelBoxes;
1896*b1cdbd2cSJim Jagielski for( sal_uInt16 n = 0; n < aBoxes.Count(); ++n )
1897*b1cdbd2cSJim Jagielski {
1898*b1cdbd2cSJim Jagielski SwTableBox* pBox = pTblNd->GetTable().GetTblBox( aBoxes[ n ] );
1899*b1cdbd2cSJim Jagielski aSelBoxes.Insert( pBox );
1900*b1cdbd2cSJim Jagielski }
1901*b1cdbd2cSJim Jagielski
1902*b1cdbd2cSJim Jagielski // SelBoxes erzeugen und InsertCell/-Row/SplitTbl aufrufen
1903*b1cdbd2cSJim Jagielski switch( GetId() )
1904*b1cdbd2cSJim Jagielski {
1905*b1cdbd2cSJim Jagielski case UNDO_TABLE_INSCOL:
1906*b1cdbd2cSJim Jagielski if( USHRT_MAX == nSetColType )
1907*b1cdbd2cSJim Jagielski rDoc.InsertCol( aSelBoxes, nCount, bFlag );
1908*b1cdbd2cSJim Jagielski else
1909*b1cdbd2cSJim Jagielski {
1910*b1cdbd2cSJim Jagielski SwTableBox* pBox = pTblNd->GetTable().GetTblBox( nCurrBox );
1911*b1cdbd2cSJim Jagielski rDoc.SetColRowWidthHeight( *pBox, nSetColType, nAbsDiff,
1912*b1cdbd2cSJim Jagielski nRelDiff );
1913*b1cdbd2cSJim Jagielski }
1914*b1cdbd2cSJim Jagielski break;
1915*b1cdbd2cSJim Jagielski
1916*b1cdbd2cSJim Jagielski case UNDO_TABLE_INSROW:
1917*b1cdbd2cSJim Jagielski if( USHRT_MAX == nSetColType )
1918*b1cdbd2cSJim Jagielski rDoc.InsertRow( aSelBoxes, nCount, bFlag );
1919*b1cdbd2cSJim Jagielski else
1920*b1cdbd2cSJim Jagielski {
1921*b1cdbd2cSJim Jagielski SwTable& rTbl = pTblNd->GetTable();
1922*b1cdbd2cSJim Jagielski SwTableBox* pBox = rTbl.GetTblBox( nCurrBox );
1923*b1cdbd2cSJim Jagielski TblChgMode eOldMode = rTbl.GetTblChgMode();
1924*b1cdbd2cSJim Jagielski rTbl.SetTblChgMode( (TblChgMode)nCount );
1925*b1cdbd2cSJim Jagielski rDoc.SetColRowWidthHeight( *pBox, nSetColType, nAbsDiff, nRelDiff );
1926*b1cdbd2cSJim Jagielski rTbl.SetTblChgMode( eOldMode );
1927*b1cdbd2cSJim Jagielski }
1928*b1cdbd2cSJim Jagielski break;
1929*b1cdbd2cSJim Jagielski
1930*b1cdbd2cSJim Jagielski case UNDO_TABLE_SPLIT:
1931*b1cdbd2cSJim Jagielski rDoc.SplitTbl( aSelBoxes, bFlag, nCount, bSameHeight );
1932*b1cdbd2cSJim Jagielski break;
1933*b1cdbd2cSJim Jagielski case UNDO_TABLE_DELBOX:
1934*b1cdbd2cSJim Jagielski case UNDO_ROW_DELETE:
1935*b1cdbd2cSJim Jagielski case UNDO_COL_DELETE:
1936*b1cdbd2cSJim Jagielski if( USHRT_MAX == nSetColType )
1937*b1cdbd2cSJim Jagielski {
1938*b1cdbd2cSJim Jagielski SwTableFmlUpdate aMsgHnt( &pTblNd->GetTable() );
1939*b1cdbd2cSJim Jagielski aMsgHnt.eFlags = TBL_BOXPTR;
1940*b1cdbd2cSJim Jagielski rDoc.UpdateTblFlds( &aMsgHnt );
1941*b1cdbd2cSJim Jagielski SwTable &rTable = pTblNd->GetTable();
1942*b1cdbd2cSJim Jagielski if( nMax > nMin && rTable.IsNewModel() )
1943*b1cdbd2cSJim Jagielski rTable.PrepareDeleteCol( nMin, nMax );
1944*b1cdbd2cSJim Jagielski rTable.DeleteSel( &rDoc, aSelBoxes, 0, this, sal_True, sal_True );
1945*b1cdbd2cSJim Jagielski }
1946*b1cdbd2cSJim Jagielski else
1947*b1cdbd2cSJim Jagielski {
1948*b1cdbd2cSJim Jagielski SwTable& rTbl = pTblNd->GetTable();
1949*b1cdbd2cSJim Jagielski
1950*b1cdbd2cSJim Jagielski SwTableFmlUpdate aMsgHnt( &rTbl );
1951*b1cdbd2cSJim Jagielski aMsgHnt.eFlags = TBL_BOXPTR;
1952*b1cdbd2cSJim Jagielski rDoc.UpdateTblFlds( &aMsgHnt );
1953*b1cdbd2cSJim Jagielski
1954*b1cdbd2cSJim Jagielski SwTableBox* pBox = rTbl.GetTblBox( nCurrBox );
1955*b1cdbd2cSJim Jagielski TblChgMode eOldMode = rTbl.GetTblChgMode();
1956*b1cdbd2cSJim Jagielski rTbl.SetTblChgMode( (TblChgMode)nCount );
1957*b1cdbd2cSJim Jagielski
1958*b1cdbd2cSJim Jagielski // need the SaveSections!
1959*b1cdbd2cSJim Jagielski rDoc.GetIDocumentUndoRedo().DoUndo( true );
1960*b1cdbd2cSJim Jagielski SwUndoTblNdsChg* pUndo = 0;
1961*b1cdbd2cSJim Jagielski
1962*b1cdbd2cSJim Jagielski switch( nSetColType & 0xff )
1963*b1cdbd2cSJim Jagielski {
1964*b1cdbd2cSJim Jagielski case nsTblChgWidthHeightType::WH_COL_LEFT:
1965*b1cdbd2cSJim Jagielski case nsTblChgWidthHeightType::WH_COL_RIGHT:
1966*b1cdbd2cSJim Jagielski case nsTblChgWidthHeightType::WH_CELL_LEFT:
1967*b1cdbd2cSJim Jagielski case nsTblChgWidthHeightType::WH_CELL_RIGHT:
1968*b1cdbd2cSJim Jagielski rTbl.SetColWidth( *pBox, nSetColType, nAbsDiff,
1969*b1cdbd2cSJim Jagielski nRelDiff, (SwUndo**)&pUndo );
1970*b1cdbd2cSJim Jagielski break;
1971*b1cdbd2cSJim Jagielski case nsTblChgWidthHeightType::WH_ROW_TOP:
1972*b1cdbd2cSJim Jagielski case nsTblChgWidthHeightType::WH_ROW_BOTTOM:
1973*b1cdbd2cSJim Jagielski case nsTblChgWidthHeightType::WH_CELL_TOP:
1974*b1cdbd2cSJim Jagielski case nsTblChgWidthHeightType::WH_CELL_BOTTOM:
1975*b1cdbd2cSJim Jagielski rTbl.SetRowHeight( *pBox, nSetColType, nAbsDiff,
1976*b1cdbd2cSJim Jagielski nRelDiff, (SwUndo**)&pUndo );
1977*b1cdbd2cSJim Jagielski break;
1978*b1cdbd2cSJim Jagielski }
1979*b1cdbd2cSJim Jagielski
1980*b1cdbd2cSJim Jagielski if( pUndo )
1981*b1cdbd2cSJim Jagielski {
1982*b1cdbd2cSJim Jagielski Ptrs.pDelSects->Insert( pUndo->Ptrs.pDelSects, 0 );
1983*b1cdbd2cSJim Jagielski pUndo->Ptrs.pDelSects->Remove( 0, pUndo->Ptrs.pDelSects->Count() );
1984*b1cdbd2cSJim Jagielski
1985*b1cdbd2cSJim Jagielski delete pUndo;
1986*b1cdbd2cSJim Jagielski }
1987*b1cdbd2cSJim Jagielski rDoc.GetIDocumentUndoRedo().DoUndo( false );
1988*b1cdbd2cSJim Jagielski
1989*b1cdbd2cSJim Jagielski rTbl.SetTblChgMode( eOldMode );
1990*b1cdbd2cSJim Jagielski }
1991*b1cdbd2cSJim Jagielski nSttNode = pTblNd->GetIndex();
1992*b1cdbd2cSJim Jagielski break;
1993*b1cdbd2cSJim Jagielski default:
1994*b1cdbd2cSJim Jagielski ;
1995*b1cdbd2cSJim Jagielski }
1996*b1cdbd2cSJim Jagielski ClearFEShellTabCols();
1997*b1cdbd2cSJim Jagielski CHECK_TABLE( pTblNd->GetTable() )
1998*b1cdbd2cSJim Jagielski }
1999*b1cdbd2cSJim Jagielski
2000*b1cdbd2cSJim Jagielski
2001*b1cdbd2cSJim Jagielski //////////////////////////////////////////////////////////////////////////
2002*b1cdbd2cSJim Jagielski
SwUndoTblMerge(const SwPaM & rTblSel)2003*b1cdbd2cSJim Jagielski SwUndoTblMerge::SwUndoTblMerge( const SwPaM& rTblSel )
2004*b1cdbd2cSJim Jagielski : SwUndo( UNDO_TABLE_MERGE ), SwUndRng( rTblSel ), pHistory( 0 )
2005*b1cdbd2cSJim Jagielski {
2006*b1cdbd2cSJim Jagielski const SwTableNode* pTblNd = rTblSel.GetNode()->FindTableNode();
2007*b1cdbd2cSJim Jagielski ASSERT( pTblNd, "Wo ist TabllenNode" )
2008*b1cdbd2cSJim Jagielski pSaveTbl = new _SaveTable( pTblNd->GetTable() );
2009*b1cdbd2cSJim Jagielski pMoves = new SwUndoMoves;
2010*b1cdbd2cSJim Jagielski nTblNode = pTblNd->GetIndex();
2011*b1cdbd2cSJim Jagielski }
2012*b1cdbd2cSJim Jagielski
~SwUndoTblMerge()2013*b1cdbd2cSJim Jagielski SwUndoTblMerge::~SwUndoTblMerge()
2014*b1cdbd2cSJim Jagielski {
2015*b1cdbd2cSJim Jagielski delete pSaveTbl;
2016*b1cdbd2cSJim Jagielski delete pMoves;
2017*b1cdbd2cSJim Jagielski delete pHistory;
2018*b1cdbd2cSJim Jagielski }
2019*b1cdbd2cSJim Jagielski
UndoImpl(::sw::UndoRedoContext & rContext)2020*b1cdbd2cSJim Jagielski void SwUndoTblMerge::UndoImpl(::sw::UndoRedoContext & rContext)
2021*b1cdbd2cSJim Jagielski {
2022*b1cdbd2cSJim Jagielski SwDoc & rDoc = rContext.GetDoc();
2023*b1cdbd2cSJim Jagielski SwNodeIndex aIdx( rDoc.GetNodes(), nTblNode );
2024*b1cdbd2cSJim Jagielski
2025*b1cdbd2cSJim Jagielski SwTableNode *const pTblNd = aIdx.GetNode().GetTableNode();
2026*b1cdbd2cSJim Jagielski OSL_ENSURE( pTblNd, "SwUndoTblMerge: no TableNode" );
2027*b1cdbd2cSJim Jagielski
2028*b1cdbd2cSJim Jagielski SwTableFmlUpdate aMsgHnt( &pTblNd->GetTable() );
2029*b1cdbd2cSJim Jagielski aMsgHnt.eFlags = TBL_BOXPTR;
2030*b1cdbd2cSJim Jagielski rDoc.UpdateTblFlds( &aMsgHnt );
2031*b1cdbd2cSJim Jagielski
2032*b1cdbd2cSJim Jagielski _FndBox aTmpBox( 0, 0 );
2033*b1cdbd2cSJim Jagielski // ? TL_CHART2: notification or locking of controller required ?
2034*b1cdbd2cSJim Jagielski
2035*b1cdbd2cSJim Jagielski
2036*b1cdbd2cSJim Jagielski // 1. die geloeschten Boxen wiederherstellen:
2037*b1cdbd2cSJim Jagielski
2038*b1cdbd2cSJim Jagielski // Trick: die fehlenden Boxen in irgendeine Line einfuegen, beim
2039*b1cdbd2cSJim Jagielski // CreateNew werden sie korrekt verbunden.
2040*b1cdbd2cSJim Jagielski SwTableBox *pBox, *pCpyBox = pTblNd->GetTable().GetTabSortBoxes()[0];
2041*b1cdbd2cSJim Jagielski SwTableBoxes& rLnBoxes = pCpyBox->GetUpper()->GetTabBoxes();
2042*b1cdbd2cSJim Jagielski
2043*b1cdbd2cSJim Jagielski DUMPDOC( &rDoc, "d:\\tmp\\tab_a.db" )
2044*b1cdbd2cSJim Jagielski CHECKTABLE(pTblNd->GetTable())
2045*b1cdbd2cSJim Jagielski
2046*b1cdbd2cSJim Jagielski SwSelBoxes aSelBoxes;
2047*b1cdbd2cSJim Jagielski SwTxtFmtColl* pColl = rDoc.GetTxtCollFromPool( RES_POOLCOLL_STANDARD );
2048*b1cdbd2cSJim Jagielski sal_uInt16 n;
2049*b1cdbd2cSJim Jagielski
2050*b1cdbd2cSJim Jagielski for( n = 0; n < aBoxes.Count(); ++n )
2051*b1cdbd2cSJim Jagielski {
2052*b1cdbd2cSJim Jagielski aIdx = aBoxes[ n ];
2053*b1cdbd2cSJim Jagielski SwStartNode* pSttNd = rDoc.GetNodes().MakeTextSection( aIdx,
2054*b1cdbd2cSJim Jagielski SwTableBoxStartNode, pColl );
2055*b1cdbd2cSJim Jagielski pBox = new SwTableBox( (SwTableBoxFmt*)pCpyBox->GetFrmFmt(), *pSttNd,
2056*b1cdbd2cSJim Jagielski pCpyBox->GetUpper() );
2057*b1cdbd2cSJim Jagielski rLnBoxes.C40_INSERT( SwTableBox, pBox, rLnBoxes.Count() );
2058*b1cdbd2cSJim Jagielski
2059*b1cdbd2cSJim Jagielski aSelBoxes.Insert( pBox );
2060*b1cdbd2cSJim Jagielski }
2061*b1cdbd2cSJim Jagielski
2062*b1cdbd2cSJim Jagielski DUMPDOC( &rDoc, "d:\\tmp\\tab_b.db" )
2063*b1cdbd2cSJim Jagielski CHECKTABLE(pTblNd->GetTable())
2064*b1cdbd2cSJim Jagielski
2065*b1cdbd2cSJim Jagielski SwChartDataProvider *pPCD = rDoc.GetChartDataProvider();
2066*b1cdbd2cSJim Jagielski // 2. die eingefuegten Boxen loeschen
2067*b1cdbd2cSJim Jagielski // die Nodes loeschen (von Hinten!!)
2068*b1cdbd2cSJim Jagielski for( n = aNewSttNds.Count(); n; )
2069*b1cdbd2cSJim Jagielski {
2070*b1cdbd2cSJim Jagielski // Box aus der Tabellen-Struktur entfernen
2071*b1cdbd2cSJim Jagielski sal_uLong nIdx = aNewSttNds[ --n ];
2072*b1cdbd2cSJim Jagielski
2073*b1cdbd2cSJim Jagielski if( !nIdx && n )
2074*b1cdbd2cSJim Jagielski {
2075*b1cdbd2cSJim Jagielski nIdx = aNewSttNds[ --n ];
2076*b1cdbd2cSJim Jagielski pBox = pTblNd->GetTable().GetTblBox( nIdx );
2077*b1cdbd2cSJim Jagielski ASSERT( pBox, "Wo ist meine TabellenBox geblieben?" );
2078*b1cdbd2cSJim Jagielski
2079*b1cdbd2cSJim Jagielski if( !pSaveTbl->IsNewModel() )
2080*b1cdbd2cSJim Jagielski rDoc.GetNodes().MakeTxtNode( SwNodeIndex(
2081*b1cdbd2cSJim Jagielski *pBox->GetSttNd()->EndOfSectionNode() ), pColl );
2082*b1cdbd2cSJim Jagielski
2083*b1cdbd2cSJim Jagielski // das war der Trenner, -> die verschobenen herstellen
2084*b1cdbd2cSJim Jagielski for( sal_uInt16 i = pMoves->Count(); i; )
2085*b1cdbd2cSJim Jagielski {
2086*b1cdbd2cSJim Jagielski SwTxtNode* pTxtNd = 0;
2087*b1cdbd2cSJim Jagielski sal_uInt16 nDelPos = 0;
2088*b1cdbd2cSJim Jagielski SwUndoMove* pUndo = (*pMoves)[ --i ];
2089*b1cdbd2cSJim Jagielski if( !pUndo->IsMoveRange() )
2090*b1cdbd2cSJim Jagielski {
2091*b1cdbd2cSJim Jagielski pTxtNd = rDoc.GetNodes()[ pUndo->GetDestSttNode() ]->GetTxtNode();
2092*b1cdbd2cSJim Jagielski nDelPos = pUndo->GetDestSttCntnt() - 1;
2093*b1cdbd2cSJim Jagielski }
2094*b1cdbd2cSJim Jagielski pUndo->UndoImpl(rContext);
2095*b1cdbd2cSJim Jagielski if( pUndo->IsMoveRange() )
2096*b1cdbd2cSJim Jagielski {
2097*b1cdbd2cSJim Jagielski // den ueberfluessigen Node loeschen
2098*b1cdbd2cSJim Jagielski aIdx = pUndo->GetEndNode();
2099*b1cdbd2cSJim Jagielski SwCntntNode *pCNd = aIdx.GetNode().GetCntntNode();
2100*b1cdbd2cSJim Jagielski if( pCNd )
2101*b1cdbd2cSJim Jagielski {
2102*b1cdbd2cSJim Jagielski SwNodeIndex aTmp( aIdx, -1 );
2103*b1cdbd2cSJim Jagielski SwCntntNode *pMove = aTmp.GetNode().GetCntntNode();
2104*b1cdbd2cSJim Jagielski if( pMove )
2105*b1cdbd2cSJim Jagielski pCNd->MoveTo( *pMove );
2106*b1cdbd2cSJim Jagielski }
2107*b1cdbd2cSJim Jagielski rDoc.GetNodes().Delete( aIdx, 1 );
2108*b1cdbd2cSJim Jagielski }
2109*b1cdbd2cSJim Jagielski else if( pTxtNd )
2110*b1cdbd2cSJim Jagielski {
2111*b1cdbd2cSJim Jagielski // evt. noch ueberflussige Attribute loeschen
2112*b1cdbd2cSJim Jagielski SwIndex aTmpIdx( pTxtNd, nDelPos );
2113*b1cdbd2cSJim Jagielski if( pTxtNd->GetpSwpHints() && pTxtNd->GetpSwpHints()->Count() )
2114*b1cdbd2cSJim Jagielski pTxtNd->RstTxtAttr( aTmpIdx, pTxtNd->GetTxt().Len() - nDelPos + 1 );
2115*b1cdbd2cSJim Jagielski // das Trennzeichen loeschen
2116*b1cdbd2cSJim Jagielski pTxtNd->EraseText( aTmpIdx, 1 );
2117*b1cdbd2cSJim Jagielski }
2118*b1cdbd2cSJim Jagielski DUMPDOC( &rDoc, String( "d:\\tmp\\tab_") + String( aNewSttNds.Count() - i ) +
2119*b1cdbd2cSJim Jagielski String(".db") )
2120*b1cdbd2cSJim Jagielski }
2121*b1cdbd2cSJim Jagielski nIdx = pBox->GetSttIdx();
2122*b1cdbd2cSJim Jagielski }
2123*b1cdbd2cSJim Jagielski else
2124*b1cdbd2cSJim Jagielski pBox = pTblNd->GetTable().GetTblBox( nIdx );
2125*b1cdbd2cSJim Jagielski
2126*b1cdbd2cSJim Jagielski if( !pSaveTbl->IsNewModel() )
2127*b1cdbd2cSJim Jagielski {
2128*b1cdbd2cSJim Jagielski // TL_CHART2: notify chart about box to be removed
2129*b1cdbd2cSJim Jagielski if (pPCD)
2130*b1cdbd2cSJim Jagielski pPCD->DeleteBox( &pTblNd->GetTable(), *pBox );
2131*b1cdbd2cSJim Jagielski
2132*b1cdbd2cSJim Jagielski SwTableBoxes* pTBoxes = &pBox->GetUpper()->GetTabBoxes();
2133*b1cdbd2cSJim Jagielski pTBoxes->Remove( pTBoxes->C40_GETPOS( SwTableBox, pBox ) );
2134*b1cdbd2cSJim Jagielski
2135*b1cdbd2cSJim Jagielski
2136*b1cdbd2cSJim Jagielski // Indizies aus dem Bereich loeschen
2137*b1cdbd2cSJim Jagielski {
2138*b1cdbd2cSJim Jagielski SwNodeIndex aTmpIdx( *pBox->GetSttNd() );
2139*b1cdbd2cSJim Jagielski rDoc.CorrAbs( SwNodeIndex( aTmpIdx, 1 ),
2140*b1cdbd2cSJim Jagielski SwNodeIndex( *aTmpIdx.GetNode().EndOfSectionNode() ),
2141*b1cdbd2cSJim Jagielski SwPosition( aTmpIdx, SwIndex( 0, 0 )), sal_True );
2142*b1cdbd2cSJim Jagielski }
2143*b1cdbd2cSJim Jagielski
2144*b1cdbd2cSJim Jagielski delete pBox;
2145*b1cdbd2cSJim Jagielski rDoc.DeleteSection( rDoc.GetNodes()[ nIdx ] );
2146*b1cdbd2cSJim Jagielski }
2147*b1cdbd2cSJim Jagielski }
2148*b1cdbd2cSJim Jagielski DUMPDOC( &rDoc, "d:\\tmp\\tab_z.db" )
2149*b1cdbd2cSJim Jagielski CHECKTABLE(pTblNd->GetTable())
2150*b1cdbd2cSJim Jagielski
2151*b1cdbd2cSJim Jagielski
2152*b1cdbd2cSJim Jagielski pSaveTbl->CreateNew( pTblNd->GetTable(), sal_True, sal_False );
2153*b1cdbd2cSJim Jagielski
2154*b1cdbd2cSJim Jagielski // TL_CHART2: need to inform chart of probably changed cell names
2155*b1cdbd2cSJim Jagielski rDoc.UpdateCharts( pTblNd->GetTable().GetFrmFmt()->GetName() );
2156*b1cdbd2cSJim Jagielski
2157*b1cdbd2cSJim Jagielski if( pHistory )
2158*b1cdbd2cSJim Jagielski {
2159*b1cdbd2cSJim Jagielski pHistory->TmpRollback( &rDoc, 0 );
2160*b1cdbd2cSJim Jagielski pHistory->SetTmpEnd( pHistory->Count() );
2161*b1cdbd2cSJim Jagielski }
2162*b1cdbd2cSJim Jagielski // nTblNode = pTblNd->GetIndex();
2163*b1cdbd2cSJim Jagielski
2164*b1cdbd2cSJim Jagielski SwPaM *const pPam(& rContext.GetCursorSupplier().CreateNewShellCursor());
2165*b1cdbd2cSJim Jagielski pPam->DeleteMark();
2166*b1cdbd2cSJim Jagielski pPam->GetPoint()->nNode = nSttNode;
2167*b1cdbd2cSJim Jagielski pPam->GetPoint()->nContent.Assign( pPam->GetCntntNode(), nSttCntnt );
2168*b1cdbd2cSJim Jagielski pPam->SetMark();
2169*b1cdbd2cSJim Jagielski pPam->DeleteMark();
2170*b1cdbd2cSJim Jagielski
2171*b1cdbd2cSJim Jagielski CHECKTABLE(pTblNd->GetTable())
2172*b1cdbd2cSJim Jagielski ClearFEShellTabCols();
2173*b1cdbd2cSJim Jagielski }
2174*b1cdbd2cSJim Jagielski
RedoImpl(::sw::UndoRedoContext & rContext)2175*b1cdbd2cSJim Jagielski void SwUndoTblMerge::RedoImpl(::sw::UndoRedoContext & rContext)
2176*b1cdbd2cSJim Jagielski {
2177*b1cdbd2cSJim Jagielski SwDoc & rDoc = rContext.GetDoc();
2178*b1cdbd2cSJim Jagielski SwPaM & rPam( AddUndoRedoPaM(rContext) );
2179*b1cdbd2cSJim Jagielski rDoc.MergeTbl(rPam);
2180*b1cdbd2cSJim Jagielski }
2181*b1cdbd2cSJim Jagielski
MoveBoxCntnt(SwDoc * pDoc,SwNodeRange & rRg,SwNodeIndex & rPos)2182*b1cdbd2cSJim Jagielski void SwUndoTblMerge::MoveBoxCntnt( SwDoc* pDoc, SwNodeRange& rRg, SwNodeIndex& rPos )
2183*b1cdbd2cSJim Jagielski {
2184*b1cdbd2cSJim Jagielski SwNodeIndex aTmp( rRg.aStart, -1 ), aTmp2( rPos, -1 );
2185*b1cdbd2cSJim Jagielski SwUndoMove* pUndo = new SwUndoMove( pDoc, rRg, rPos );
2186*b1cdbd2cSJim Jagielski ::sw::UndoGuard const undoGuard(pDoc->GetIDocumentUndoRedo());
2187*b1cdbd2cSJim Jagielski pDoc->MoveNodeRange( rRg, rPos, (pSaveTbl->IsNewModel()) ?
2188*b1cdbd2cSJim Jagielski IDocumentContentOperations::DOC_NO_DELFRMS :
2189*b1cdbd2cSJim Jagielski IDocumentContentOperations::DOC_MOVEDEFAULT );
2190*b1cdbd2cSJim Jagielski aTmp++;
2191*b1cdbd2cSJim Jagielski aTmp2++;
2192*b1cdbd2cSJim Jagielski pUndo->SetDestRange( aTmp2, rPos, aTmp );
2193*b1cdbd2cSJim Jagielski
2194*b1cdbd2cSJim Jagielski pMoves->Insert( pUndo, pMoves->Count() );
2195*b1cdbd2cSJim Jagielski }
2196*b1cdbd2cSJim Jagielski
SetSelBoxes(const SwSelBoxes & rBoxes)2197*b1cdbd2cSJim Jagielski void SwUndoTblMerge::SetSelBoxes( const SwSelBoxes& rBoxes )
2198*b1cdbd2cSJim Jagielski {
2199*b1cdbd2cSJim Jagielski // die Selektion merken
2200*b1cdbd2cSJim Jagielski for( sal_uInt16 n = 0; n < rBoxes.Count(); ++n )
2201*b1cdbd2cSJim Jagielski InsertSort( aBoxes, rBoxes[n]->GetSttIdx() );
2202*b1cdbd2cSJim Jagielski
2203*b1cdbd2cSJim Jagielski // als Trennung fuers einfuegen neuer Boxen nach dem Verschieben!
2204*b1cdbd2cSJim Jagielski aNewSttNds.Insert( (sal_uLong)0, aNewSttNds.Count() );
2205*b1cdbd2cSJim Jagielski
2206*b1cdbd2cSJim Jagielski // The new table model does not delete overlapped cells (by row span),
2207*b1cdbd2cSJim Jagielski // so the rBoxes array might be empty even some cells have been merged.
2208*b1cdbd2cSJim Jagielski if( rBoxes.Count() )
2209*b1cdbd2cSJim Jagielski nTblNode = rBoxes[ 0 ]->GetSttNd()->FindTableNode()->GetIndex();
2210*b1cdbd2cSJim Jagielski }
2211*b1cdbd2cSJim Jagielski
SaveCollection(const SwTableBox & rBox)2212*b1cdbd2cSJim Jagielski void SwUndoTblMerge::SaveCollection( const SwTableBox& rBox )
2213*b1cdbd2cSJim Jagielski {
2214*b1cdbd2cSJim Jagielski if( !pHistory )
2215*b1cdbd2cSJim Jagielski pHistory = new SwHistory;
2216*b1cdbd2cSJim Jagielski
2217*b1cdbd2cSJim Jagielski SwNodeIndex aIdx( *rBox.GetSttNd(), 1 );
2218*b1cdbd2cSJim Jagielski SwCntntNode* pCNd = aIdx.GetNode().GetCntntNode();
2219*b1cdbd2cSJim Jagielski if( !pCNd )
2220*b1cdbd2cSJim Jagielski pCNd = aIdx.GetNodes().GoNext( &aIdx );
2221*b1cdbd2cSJim Jagielski
2222*b1cdbd2cSJim Jagielski pHistory->Add( pCNd->GetFmtColl(), aIdx.GetIndex(), pCNd->GetNodeType());
2223*b1cdbd2cSJim Jagielski if( pCNd->HasSwAttrSet() )
2224*b1cdbd2cSJim Jagielski pHistory->CopyFmtAttr( *pCNd->GetpSwAttrSet(), aIdx.GetIndex() );
2225*b1cdbd2cSJim Jagielski }
2226*b1cdbd2cSJim Jagielski
2227*b1cdbd2cSJim Jagielski
2228*b1cdbd2cSJim Jagielski //////////////////////////////////////////////////////////////////////////
2229*b1cdbd2cSJim Jagielski
SwUndoTblNumFmt(const SwTableBox & rBox,const SfxItemSet * pNewSet)2230*b1cdbd2cSJim Jagielski SwUndoTblNumFmt::SwUndoTblNumFmt( const SwTableBox& rBox,
2231*b1cdbd2cSJim Jagielski const SfxItemSet* pNewSet )
2232*b1cdbd2cSJim Jagielski : SwUndo( UNDO_TBLNUMFMT ),
2233*b1cdbd2cSJim Jagielski pBoxSet( 0 ), pHistory( 0 ), nFmtIdx( NUMBERFORMAT_TEXT )
2234*b1cdbd2cSJim Jagielski {
2235*b1cdbd2cSJim Jagielski bNewFmt = bNewFml = bNewValue = sal_False;
2236*b1cdbd2cSJim Jagielski nNode = rBox.GetSttIdx();
2237*b1cdbd2cSJim Jagielski
2238*b1cdbd2cSJim Jagielski nNdPos = rBox.IsValidNumTxtNd( 0 == pNewSet );
2239*b1cdbd2cSJim Jagielski SwDoc* pDoc = rBox.GetFrmFmt()->GetDoc();
2240*b1cdbd2cSJim Jagielski
2241*b1cdbd2cSJim Jagielski if( ULONG_MAX != nNdPos )
2242*b1cdbd2cSJim Jagielski {
2243*b1cdbd2cSJim Jagielski SwTxtNode* pTNd = pDoc->GetNodes()[ nNdPos ]->GetTxtNode();
2244*b1cdbd2cSJim Jagielski
2245*b1cdbd2cSJim Jagielski pHistory = new SwHistory;
2246*b1cdbd2cSJim Jagielski SwRegHistory aRHst( *rBox.GetSttNd(), pHistory );
2247*b1cdbd2cSJim Jagielski // always save all text atttibutes because of possibly overlapping
2248*b1cdbd2cSJim Jagielski // areas of on/off
2249*b1cdbd2cSJim Jagielski pHistory->CopyAttr( pTNd->GetpSwpHints(), nNdPos, 0,
2250*b1cdbd2cSJim Jagielski pTNd->GetTxt().Len(), true );
2251*b1cdbd2cSJim Jagielski
2252*b1cdbd2cSJim Jagielski if( pTNd->HasSwAttrSet() )
2253*b1cdbd2cSJim Jagielski pHistory->CopyFmtAttr( *pTNd->GetpSwAttrSet(), nNdPos );
2254*b1cdbd2cSJim Jagielski
2255*b1cdbd2cSJim Jagielski aStr = pTNd->GetTxt();
2256*b1cdbd2cSJim Jagielski if( pTNd->GetpSwpHints() )
2257*b1cdbd2cSJim Jagielski pTNd->GetpSwpHints()->DeRegister();
2258*b1cdbd2cSJim Jagielski }
2259*b1cdbd2cSJim Jagielski
2260*b1cdbd2cSJim Jagielski pBoxSet = new SfxItemSet( pDoc->GetAttrPool(), aTableBoxSetRange );
2261*b1cdbd2cSJim Jagielski pBoxSet->Put( rBox.GetFrmFmt()->GetAttrSet() );
2262*b1cdbd2cSJim Jagielski
2263*b1cdbd2cSJim Jagielski if( pNewSet )
2264*b1cdbd2cSJim Jagielski {
2265*b1cdbd2cSJim Jagielski const SfxPoolItem* pItem;
2266*b1cdbd2cSJim Jagielski if( SFX_ITEM_SET == pNewSet->GetItemState( RES_BOXATR_FORMAT,
2267*b1cdbd2cSJim Jagielski sal_False, &pItem ))
2268*b1cdbd2cSJim Jagielski {
2269*b1cdbd2cSJim Jagielski bNewFmt = sal_True;
2270*b1cdbd2cSJim Jagielski nNewFmtIdx = ((SwTblBoxNumFormat*)pItem)->GetValue();
2271*b1cdbd2cSJim Jagielski }
2272*b1cdbd2cSJim Jagielski if( SFX_ITEM_SET == pNewSet->GetItemState( RES_BOXATR_FORMULA,
2273*b1cdbd2cSJim Jagielski sal_False, &pItem ))
2274*b1cdbd2cSJim Jagielski {
2275*b1cdbd2cSJim Jagielski bNewFml = sal_True;
2276*b1cdbd2cSJim Jagielski aNewFml = ((SwTblBoxFormula*)pItem)->GetFormula();
2277*b1cdbd2cSJim Jagielski }
2278*b1cdbd2cSJim Jagielski if( SFX_ITEM_SET == pNewSet->GetItemState( RES_BOXATR_VALUE,
2279*b1cdbd2cSJim Jagielski sal_False, &pItem ))
2280*b1cdbd2cSJim Jagielski {
2281*b1cdbd2cSJim Jagielski bNewValue = sal_True;
2282*b1cdbd2cSJim Jagielski fNewNum = ((SwTblBoxValue*)pItem)->GetValue();
2283*b1cdbd2cSJim Jagielski }
2284*b1cdbd2cSJim Jagielski }
2285*b1cdbd2cSJim Jagielski
2286*b1cdbd2cSJim Jagielski // wird die History ueberhaupt benoetigt ??
2287*b1cdbd2cSJim Jagielski if( pHistory && !pHistory->Count() )
2288*b1cdbd2cSJim Jagielski DELETEZ( pHistory );
2289*b1cdbd2cSJim Jagielski }
2290*b1cdbd2cSJim Jagielski
~SwUndoTblNumFmt()2291*b1cdbd2cSJim Jagielski SwUndoTblNumFmt::~SwUndoTblNumFmt()
2292*b1cdbd2cSJim Jagielski {
2293*b1cdbd2cSJim Jagielski delete pHistory;
2294*b1cdbd2cSJim Jagielski delete pBoxSet;
2295*b1cdbd2cSJim Jagielski }
2296*b1cdbd2cSJim Jagielski
UndoImpl(::sw::UndoRedoContext & rContext)2297*b1cdbd2cSJim Jagielski void SwUndoTblNumFmt::UndoImpl(::sw::UndoRedoContext & rContext)
2298*b1cdbd2cSJim Jagielski {
2299*b1cdbd2cSJim Jagielski ASSERT( pBoxSet, "Where's the stored item set?" )
2300*b1cdbd2cSJim Jagielski
2301*b1cdbd2cSJim Jagielski SwDoc & rDoc = rContext.GetDoc();
2302*b1cdbd2cSJim Jagielski SwStartNode* pSttNd = rDoc.GetNodes()[ nNode ]->
2303*b1cdbd2cSJim Jagielski FindSttNodeByType( SwTableBoxStartNode );
2304*b1cdbd2cSJim Jagielski ASSERT( pSttNd, "ohne StartNode kein TabellenBox" );
2305*b1cdbd2cSJim Jagielski SwTableBox* pBox = pSttNd->FindTableNode()->GetTable().GetTblBox(
2306*b1cdbd2cSJim Jagielski pSttNd->GetIndex() );
2307*b1cdbd2cSJim Jagielski ASSERT( pBox, "keine TabellenBox gefunden" );
2308*b1cdbd2cSJim Jagielski
2309*b1cdbd2cSJim Jagielski SwTableBoxFmt* pFmt = rDoc.MakeTableBoxFmt();
2310*b1cdbd2cSJim Jagielski pFmt->SetFmtAttr( *pBoxSet );
2311*b1cdbd2cSJim Jagielski pBox->ChgFrmFmt( pFmt );
2312*b1cdbd2cSJim Jagielski
2313*b1cdbd2cSJim Jagielski if( ULONG_MAX == nNdPos )
2314*b1cdbd2cSJim Jagielski return;
2315*b1cdbd2cSJim Jagielski
2316*b1cdbd2cSJim Jagielski SwTxtNode* pTxtNd = rDoc.GetNodes()[ nNdPos ]->GetTxtNode();
2317*b1cdbd2cSJim Jagielski // wenn mehr als ein Node geloescht wurde, dann wurden auch
2318*b1cdbd2cSJim Jagielski // alle "Node"-Attribute gespeichert
2319*b1cdbd2cSJim Jagielski if( pTxtNd->HasSwAttrSet() )
2320*b1cdbd2cSJim Jagielski pTxtNd->ResetAllAttr();
2321*b1cdbd2cSJim Jagielski
2322*b1cdbd2cSJim Jagielski if( pTxtNd->GetpSwpHints() && aStr.Len() )
2323*b1cdbd2cSJim Jagielski pTxtNd->ClearSwpHintsArr( true );
2324*b1cdbd2cSJim Jagielski
2325*b1cdbd2cSJim Jagielski // ChgTextToNum(..) only acts when the strings are different. We
2326*b1cdbd2cSJim Jagielski // need to do the same here.
2327*b1cdbd2cSJim Jagielski if( pTxtNd->GetTxt() != aStr )
2328*b1cdbd2cSJim Jagielski {
2329*b1cdbd2cSJim Jagielski rDoc.DeleteRedline( *( pBox->GetSttNd() ), false, USHRT_MAX );
2330*b1cdbd2cSJim Jagielski
2331*b1cdbd2cSJim Jagielski SwIndex aIdx( pTxtNd, 0 );
2332*b1cdbd2cSJim Jagielski if( aStr.Len() )
2333*b1cdbd2cSJim Jagielski {
2334*b1cdbd2cSJim Jagielski pTxtNd->EraseText( aIdx );
2335*b1cdbd2cSJim Jagielski pTxtNd->InsertText( aStr, aIdx,
2336*b1cdbd2cSJim Jagielski IDocumentContentOperations::INS_NOHINTEXPAND );
2337*b1cdbd2cSJim Jagielski }
2338*b1cdbd2cSJim Jagielski }
2339*b1cdbd2cSJim Jagielski
2340*b1cdbd2cSJim Jagielski if( pHistory )
2341*b1cdbd2cSJim Jagielski {
2342*b1cdbd2cSJim Jagielski sal_uInt16 nTmpEnd = pHistory->GetTmpEnd();
2343*b1cdbd2cSJim Jagielski pHistory->TmpRollback( &rDoc, 0 );
2344*b1cdbd2cSJim Jagielski pHistory->SetTmpEnd( nTmpEnd );
2345*b1cdbd2cSJim Jagielski }
2346*b1cdbd2cSJim Jagielski
2347*b1cdbd2cSJim Jagielski SwPaM *const pPam(& rContext.GetCursorSupplier().CreateNewShellCursor());
2348*b1cdbd2cSJim Jagielski pPam->DeleteMark();
2349*b1cdbd2cSJim Jagielski pPam->GetPoint()->nNode = nNode + 1;
2350*b1cdbd2cSJim Jagielski pPam->GetPoint()->nContent.Assign( pTxtNd, 0 );
2351*b1cdbd2cSJim Jagielski }
2352*b1cdbd2cSJim Jagielski
2353*b1cdbd2cSJim Jagielski /** switch the RedlineMode on the given document, using
2354*b1cdbd2cSJim Jagielski * SetRedlineMode_intern. This class set the mode in the constructor,
2355*b1cdbd2cSJim Jagielski * and changes it back in the destructor, i.e. it uses the
2356*b1cdbd2cSJim Jagielski * initialization-is-resource-acquisition idiom.
2357*b1cdbd2cSJim Jagielski */
2358*b1cdbd2cSJim Jagielski class RedlineModeInternGuard
2359*b1cdbd2cSJim Jagielski {
2360*b1cdbd2cSJim Jagielski SwDoc& mrDoc;
2361*b1cdbd2cSJim Jagielski RedlineMode_t meOldRedlineMode;
2362*b1cdbd2cSJim Jagielski
2363*b1cdbd2cSJim Jagielski public:
2364*b1cdbd2cSJim Jagielski RedlineModeInternGuard(
2365*b1cdbd2cSJim Jagielski SwDoc& rDoc, /// change mode of this document
2366*b1cdbd2cSJim Jagielski RedlineMode_t eNewRedlineMode, /// new redline mode
2367*b1cdbd2cSJim Jagielski RedlineMode_t eRedlineModeMask = (RedlineMode_t)(nsRedlineMode_t::REDLINE_ON | nsRedlineMode_t::REDLINE_IGNORE /*change only bits set in this mask*/));
2368*b1cdbd2cSJim Jagielski
2369*b1cdbd2cSJim Jagielski ~RedlineModeInternGuard();
2370*b1cdbd2cSJim Jagielski };
2371*b1cdbd2cSJim Jagielski
RedlineModeInternGuard(SwDoc & rDoc,RedlineMode_t eNewRedlineMode,RedlineMode_t eRedlineModeMask)2372*b1cdbd2cSJim Jagielski RedlineModeInternGuard::RedlineModeInternGuard(
2373*b1cdbd2cSJim Jagielski SwDoc& rDoc,
2374*b1cdbd2cSJim Jagielski RedlineMode_t eNewRedlineMode,
2375*b1cdbd2cSJim Jagielski RedlineMode_t eRedlineModeMask )
2376*b1cdbd2cSJim Jagielski : mrDoc( rDoc ),
2377*b1cdbd2cSJim Jagielski meOldRedlineMode( rDoc.GetRedlineMode() )
2378*b1cdbd2cSJim Jagielski {
2379*b1cdbd2cSJim Jagielski mrDoc.SetRedlineMode_intern((RedlineMode_t)( ( meOldRedlineMode & ~eRedlineModeMask ) |
2380*b1cdbd2cSJim Jagielski ( eNewRedlineMode & eRedlineModeMask ) ));
2381*b1cdbd2cSJim Jagielski }
2382*b1cdbd2cSJim Jagielski
~RedlineModeInternGuard()2383*b1cdbd2cSJim Jagielski RedlineModeInternGuard::~RedlineModeInternGuard()
2384*b1cdbd2cSJim Jagielski {
2385*b1cdbd2cSJim Jagielski mrDoc.SetRedlineMode_intern( meOldRedlineMode );
2386*b1cdbd2cSJim Jagielski }
2387*b1cdbd2cSJim Jagielski
2388*b1cdbd2cSJim Jagielski
2389*b1cdbd2cSJim Jagielski
RedoImpl(::sw::UndoRedoContext & rContext)2390*b1cdbd2cSJim Jagielski void SwUndoTblNumFmt::RedoImpl(::sw::UndoRedoContext & rContext)
2391*b1cdbd2cSJim Jagielski {
2392*b1cdbd2cSJim Jagielski // konnte die Box veraendert werden ?
2393*b1cdbd2cSJim Jagielski if( !pBoxSet )
2394*b1cdbd2cSJim Jagielski return ;
2395*b1cdbd2cSJim Jagielski
2396*b1cdbd2cSJim Jagielski SwDoc & rDoc = rContext.GetDoc();
2397*b1cdbd2cSJim Jagielski SwPaM *const pPam(& rContext.GetCursorSupplier().CreateNewShellCursor());
2398*b1cdbd2cSJim Jagielski
2399*b1cdbd2cSJim Jagielski pPam->DeleteMark();
2400*b1cdbd2cSJim Jagielski pPam->GetPoint()->nNode = nNode;
2401*b1cdbd2cSJim Jagielski
2402*b1cdbd2cSJim Jagielski SwNode * pNd = & pPam->GetPoint()->nNode.GetNode();
2403*b1cdbd2cSJim Jagielski SwStartNode* pSttNd = pNd->FindSttNodeByType( SwTableBoxStartNode );
2404*b1cdbd2cSJim Jagielski ASSERT( pSttNd, "ohne StartNode kein TabellenBox" );
2405*b1cdbd2cSJim Jagielski SwTableBox* pBox = pSttNd->FindTableNode()->GetTable().GetTblBox(
2406*b1cdbd2cSJim Jagielski pSttNd->GetIndex() );
2407*b1cdbd2cSJim Jagielski ASSERT( pBox, "keine TabellenBox gefunden" );
2408*b1cdbd2cSJim Jagielski
2409*b1cdbd2cSJim Jagielski SwFrmFmt* pBoxFmt = pBox->ClaimFrmFmt();
2410*b1cdbd2cSJim Jagielski if( bNewFmt || bNewFml || bNewValue )
2411*b1cdbd2cSJim Jagielski {
2412*b1cdbd2cSJim Jagielski SfxItemSet aBoxSet( rDoc.GetAttrPool(),
2413*b1cdbd2cSJim Jagielski RES_BOXATR_FORMAT, RES_BOXATR_VALUE );
2414*b1cdbd2cSJim Jagielski
2415*b1cdbd2cSJim Jagielski // JP 15.01.99: Nur Attribute zuruecksetzen reicht nicht.
2416*b1cdbd2cSJim Jagielski // Sorge dafuer, das der Text auch entsprechend
2417*b1cdbd2cSJim Jagielski // formatiert wird!
2418*b1cdbd2cSJim Jagielski pBoxFmt->LockModify();
2419*b1cdbd2cSJim Jagielski
2420*b1cdbd2cSJim Jagielski if( bNewFml )
2421*b1cdbd2cSJim Jagielski aBoxSet.Put( SwTblBoxFormula( aNewFml ));
2422*b1cdbd2cSJim Jagielski else
2423*b1cdbd2cSJim Jagielski pBoxFmt->ResetFmtAttr( RES_BOXATR_FORMULA );
2424*b1cdbd2cSJim Jagielski if( bNewFmt )
2425*b1cdbd2cSJim Jagielski aBoxSet.Put( SwTblBoxNumFormat( nNewFmtIdx ));
2426*b1cdbd2cSJim Jagielski else
2427*b1cdbd2cSJim Jagielski pBoxFmt->ResetFmtAttr( RES_BOXATR_FORMAT );
2428*b1cdbd2cSJim Jagielski if( bNewValue )
2429*b1cdbd2cSJim Jagielski aBoxSet.Put( SwTblBoxValue( fNewNum ));
2430*b1cdbd2cSJim Jagielski else
2431*b1cdbd2cSJim Jagielski pBoxFmt->ResetFmtAttr( RES_BOXATR_VALUE );
2432*b1cdbd2cSJim Jagielski pBoxFmt->UnlockModify();
2433*b1cdbd2cSJim Jagielski
2434*b1cdbd2cSJim Jagielski // dvo: When redlining is (was) enabled, setting the attribute
2435*b1cdbd2cSJim Jagielski // will also change the cell content. To allow this, the
2436*b1cdbd2cSJim Jagielski // REDLINE_IGNORE flag must be removed during Redo. #108450#
2437*b1cdbd2cSJim Jagielski RedlineModeInternGuard aGuard( rDoc, nsRedlineMode_t::REDLINE_NONE, nsRedlineMode_t::REDLINE_IGNORE );
2438*b1cdbd2cSJim Jagielski pBoxFmt->SetFmtAttr( aBoxSet );
2439*b1cdbd2cSJim Jagielski }
2440*b1cdbd2cSJim Jagielski else if( NUMBERFORMAT_TEXT != nFmtIdx )
2441*b1cdbd2cSJim Jagielski {
2442*b1cdbd2cSJim Jagielski SfxItemSet aBoxSet( rDoc.GetAttrPool(),
2443*b1cdbd2cSJim Jagielski RES_BOXATR_FORMAT, RES_BOXATR_VALUE );
2444*b1cdbd2cSJim Jagielski
2445*b1cdbd2cSJim Jagielski aBoxSet.Put( SwTblBoxNumFormat( nFmtIdx ));
2446*b1cdbd2cSJim Jagielski aBoxSet.Put( SwTblBoxValue( fNum ));
2447*b1cdbd2cSJim Jagielski
2448*b1cdbd2cSJim Jagielski // JP 15.01.99: Nur Attribute zuruecksetzen reicht nicht.
2449*b1cdbd2cSJim Jagielski // Sorge dafuer, das der Text auch entsprechend
2450*b1cdbd2cSJim Jagielski // formatiert wird!
2451*b1cdbd2cSJim Jagielski pBoxFmt->LockModify();
2452*b1cdbd2cSJim Jagielski pBoxFmt->ResetFmtAttr( RES_BOXATR_FORMULA );
2453*b1cdbd2cSJim Jagielski pBoxFmt->UnlockModify();
2454*b1cdbd2cSJim Jagielski
2455*b1cdbd2cSJim Jagielski // dvo: When redlining is (was) enabled, setting the attribute
2456*b1cdbd2cSJim Jagielski // will also change the cell content. To allow this, the
2457*b1cdbd2cSJim Jagielski // REDLINE_IGNORE flag must be removed during Redo. #108450#
2458*b1cdbd2cSJim Jagielski RedlineModeInternGuard aGuard( rDoc, nsRedlineMode_t::REDLINE_NONE, nsRedlineMode_t::REDLINE_IGNORE );
2459*b1cdbd2cSJim Jagielski pBoxFmt->SetFmtAttr( aBoxSet );
2460*b1cdbd2cSJim Jagielski }
2461*b1cdbd2cSJim Jagielski else
2462*b1cdbd2cSJim Jagielski {
2463*b1cdbd2cSJim Jagielski // es ist keine Zahl
2464*b1cdbd2cSJim Jagielski
2465*b1cdbd2cSJim Jagielski // JP 15.01.99: Nur Attribute zuruecksetzen reicht nicht.
2466*b1cdbd2cSJim Jagielski // Sorge dafuer, das der Text auch entsprechend
2467*b1cdbd2cSJim Jagielski // formatiert wird!
2468*b1cdbd2cSJim Jagielski pBoxFmt->SetFmtAttr( *GetDfltAttr( RES_BOXATR_FORMAT ));
2469*b1cdbd2cSJim Jagielski
2470*b1cdbd2cSJim Jagielski pBoxFmt->ResetFmtAttr( RES_BOXATR_FORMAT, RES_BOXATR_VALUE );
2471*b1cdbd2cSJim Jagielski }
2472*b1cdbd2cSJim Jagielski
2473*b1cdbd2cSJim Jagielski if( bNewFml )
2474*b1cdbd2cSJim Jagielski {
2475*b1cdbd2cSJim Jagielski // egal was gesetzt wurde, ein Update der Tabelle macht sich immer gut
2476*b1cdbd2cSJim Jagielski SwTableFmlUpdate aTblUpdate( &pSttNd->FindTableNode()->GetTable() );
2477*b1cdbd2cSJim Jagielski rDoc.UpdateTblFlds( &aTblUpdate );
2478*b1cdbd2cSJim Jagielski }
2479*b1cdbd2cSJim Jagielski
2480*b1cdbd2cSJim Jagielski if( !pNd->IsCntntNode() )
2481*b1cdbd2cSJim Jagielski pNd = rDoc.GetNodes().GoNext( &pPam->GetPoint()->nNode );
2482*b1cdbd2cSJim Jagielski pPam->GetPoint()->nContent.Assign( (SwCntntNode*)pNd, 0 );
2483*b1cdbd2cSJim Jagielski }
2484*b1cdbd2cSJim Jagielski
SetBox(const SwTableBox & rBox)2485*b1cdbd2cSJim Jagielski void SwUndoTblNumFmt::SetBox( const SwTableBox& rBox )
2486*b1cdbd2cSJim Jagielski {
2487*b1cdbd2cSJim Jagielski nNode = rBox.GetSttIdx();
2488*b1cdbd2cSJim Jagielski }
2489*b1cdbd2cSJim Jagielski
2490*b1cdbd2cSJim Jagielski
2491*b1cdbd2cSJim Jagielski //////////////////////////////////////////////////////////////////////////
2492*b1cdbd2cSJim Jagielski
_UndoTblCpyTbl_Entry(const SwTableBox & rBox)2493*b1cdbd2cSJim Jagielski _UndoTblCpyTbl_Entry::_UndoTblCpyTbl_Entry( const SwTableBox& rBox )
2494*b1cdbd2cSJim Jagielski : nBoxIdx( rBox.GetSttIdx() ), nOffset( 0 ),
2495*b1cdbd2cSJim Jagielski pBoxNumAttr( 0 ), pUndo( 0 ), bJoin( false )
2496*b1cdbd2cSJim Jagielski {
2497*b1cdbd2cSJim Jagielski }
2498*b1cdbd2cSJim Jagielski
~_UndoTblCpyTbl_Entry()2499*b1cdbd2cSJim Jagielski _UndoTblCpyTbl_Entry::~_UndoTblCpyTbl_Entry()
2500*b1cdbd2cSJim Jagielski {
2501*b1cdbd2cSJim Jagielski delete pUndo;
2502*b1cdbd2cSJim Jagielski delete pBoxNumAttr;
2503*b1cdbd2cSJim Jagielski }
2504*b1cdbd2cSJim Jagielski
2505*b1cdbd2cSJim Jagielski
SwUndoTblCpyTbl()2506*b1cdbd2cSJim Jagielski SwUndoTblCpyTbl::SwUndoTblCpyTbl()
2507*b1cdbd2cSJim Jagielski : SwUndo( UNDO_TBLCPYTBL ), pInsRowUndo( 0 )
2508*b1cdbd2cSJim Jagielski {
2509*b1cdbd2cSJim Jagielski pArr = new _UndoTblCpyTbl_Entries;
2510*b1cdbd2cSJim Jagielski }
2511*b1cdbd2cSJim Jagielski
~SwUndoTblCpyTbl()2512*b1cdbd2cSJim Jagielski SwUndoTblCpyTbl::~SwUndoTblCpyTbl()
2513*b1cdbd2cSJim Jagielski {
2514*b1cdbd2cSJim Jagielski delete pArr;
2515*b1cdbd2cSJim Jagielski delete pInsRowUndo;
2516*b1cdbd2cSJim Jagielski }
2517*b1cdbd2cSJim Jagielski
UndoImpl(::sw::UndoRedoContext & rContext)2518*b1cdbd2cSJim Jagielski void SwUndoTblCpyTbl::UndoImpl(::sw::UndoRedoContext & rContext)
2519*b1cdbd2cSJim Jagielski {
2520*b1cdbd2cSJim Jagielski SwDoc & rDoc = rContext.GetDoc();
2521*b1cdbd2cSJim Jagielski _DEBUG_REDLINE( &rDoc )
2522*b1cdbd2cSJim Jagielski
2523*b1cdbd2cSJim Jagielski SwTableNode* pTblNd = 0;
2524*b1cdbd2cSJim Jagielski for( sal_uInt16 n = pArr->Count(); n; )
2525*b1cdbd2cSJim Jagielski {
2526*b1cdbd2cSJim Jagielski _UndoTblCpyTbl_Entry* pEntry = (*pArr)[ --n ];
2527*b1cdbd2cSJim Jagielski sal_uLong nSttPos = pEntry->nBoxIdx + pEntry->nOffset;
2528*b1cdbd2cSJim Jagielski SwStartNode* pSNd = rDoc.GetNodes()[ nSttPos ]->StartOfSectionNode();
2529*b1cdbd2cSJim Jagielski if( !pTblNd )
2530*b1cdbd2cSJim Jagielski pTblNd = pSNd->FindTableNode();
2531*b1cdbd2cSJim Jagielski
2532*b1cdbd2cSJim Jagielski SwTableBox& rBox = *pTblNd->GetTable().GetTblBox( nSttPos );
2533*b1cdbd2cSJim Jagielski
2534*b1cdbd2cSJim Jagielski SwNodeIndex aInsIdx( *rBox.GetSttNd(), 1 );
2535*b1cdbd2cSJim Jagielski rDoc.GetNodes().MakeTxtNode( aInsIdx, (SwTxtFmtColl*)rDoc.GetDfltTxtFmtColl() );
2536*b1cdbd2cSJim Jagielski
2537*b1cdbd2cSJim Jagielski // b62341295: Redline for copying tables
2538*b1cdbd2cSJim Jagielski const SwNode *pEndNode = rBox.GetSttNd()->EndOfSectionNode();
2539*b1cdbd2cSJim Jagielski SwPaM aPam( aInsIdx.GetNode(), *pEndNode );
2540*b1cdbd2cSJim Jagielski SwUndoDelete* pUndo = 0;
2541*b1cdbd2cSJim Jagielski
2542*b1cdbd2cSJim Jagielski if( IDocumentRedlineAccess::IsRedlineOn( GetRedlineMode() ) )
2543*b1cdbd2cSJim Jagielski {
2544*b1cdbd2cSJim Jagielski bool bDeleteCompleteParagraph = false;
2545*b1cdbd2cSJim Jagielski bool bShiftPam = false;
2546*b1cdbd2cSJim Jagielski // There are a couple of different situations to consider during redlining
2547*b1cdbd2cSJim Jagielski if( pEntry->pUndo )
2548*b1cdbd2cSJim Jagielski {
2549*b1cdbd2cSJim Jagielski SwUndoDelete *const pUndoDelete =
2550*b1cdbd2cSJim Jagielski dynamic_cast<SwUndoDelete*>(pEntry->pUndo);
2551*b1cdbd2cSJim Jagielski SwUndoRedlineDelete *const pUndoRedlineDelete =
2552*b1cdbd2cSJim Jagielski dynamic_cast<SwUndoRedlineDelete*>(pEntry->pUndo);
2553*b1cdbd2cSJim Jagielski OSL_ASSERT(pUndoDelete || pUndoRedlineDelete);
2554*b1cdbd2cSJim Jagielski if (pUndoRedlineDelete)
2555*b1cdbd2cSJim Jagielski {
2556*b1cdbd2cSJim Jagielski // The old content was not empty or he has been merged with the new content
2557*b1cdbd2cSJim Jagielski bDeleteCompleteParagraph = !pEntry->bJoin; // bJoin is set when merged
2558*b1cdbd2cSJim Jagielski // Set aTmpIdx to the beginning fo the old content
2559*b1cdbd2cSJim Jagielski SwNodeIndex aTmpIdx( *pEndNode,
2560*b1cdbd2cSJim Jagielski pUndoRedlineDelete->NodeDiff()-1 );
2561*b1cdbd2cSJim Jagielski SwTxtNode *pTxt = aTmpIdx.GetNode().GetTxtNode();
2562*b1cdbd2cSJim Jagielski if( pTxt )
2563*b1cdbd2cSJim Jagielski {
2564*b1cdbd2cSJim Jagielski aPam.GetPoint()->nNode = *pTxt;
2565*b1cdbd2cSJim Jagielski aPam.GetPoint()->nContent.Assign( pTxt,
2566*b1cdbd2cSJim Jagielski pUndoRedlineDelete->ContentStart() );
2567*b1cdbd2cSJim Jagielski }
2568*b1cdbd2cSJim Jagielski else
2569*b1cdbd2cSJim Jagielski *aPam.GetPoint() = SwPosition( aTmpIdx );
2570*b1cdbd2cSJim Jagielski }
2571*b1cdbd2cSJim Jagielski else if (pUndoDelete && pUndoDelete->IsDelFullPara())
2572*b1cdbd2cSJim Jagielski {
2573*b1cdbd2cSJim Jagielski // When the old content was an empty paragraph, but could not be joined
2574*b1cdbd2cSJim Jagielski // with the new content (e.g. because of a section or table)
2575*b1cdbd2cSJim Jagielski // We "save" the aPam.Point, we go one step backwards (because later on the
2576*b1cdbd2cSJim Jagielski // empty paragraph will be inserted by the undo) and set the "ShiftPam-flag
2577*b1cdbd2cSJim Jagielski // for step forward later on.
2578*b1cdbd2cSJim Jagielski bDeleteCompleteParagraph = true;
2579*b1cdbd2cSJim Jagielski bShiftPam = true;
2580*b1cdbd2cSJim Jagielski SwNodeIndex aTmpIdx( *pEndNode, -1 );
2581*b1cdbd2cSJim Jagielski SwTxtNode *pTxt = aTmpIdx.GetNode().GetTxtNode();
2582*b1cdbd2cSJim Jagielski if( pTxt )
2583*b1cdbd2cSJim Jagielski {
2584*b1cdbd2cSJim Jagielski aPam.GetPoint()->nNode = *pTxt;
2585*b1cdbd2cSJim Jagielski aPam.GetPoint()->nContent.Assign( pTxt, 0 );
2586*b1cdbd2cSJim Jagielski }
2587*b1cdbd2cSJim Jagielski else
2588*b1cdbd2cSJim Jagielski *aPam.GetPoint() = SwPosition( aTmpIdx );
2589*b1cdbd2cSJim Jagielski }
2590*b1cdbd2cSJim Jagielski }
2591*b1cdbd2cSJim Jagielski rDoc.DeleteRedline( aPam, true, USHRT_MAX );
2592*b1cdbd2cSJim Jagielski
2593*b1cdbd2cSJim Jagielski if( pEntry->pUndo )
2594*b1cdbd2cSJim Jagielski {
2595*b1cdbd2cSJim Jagielski pEntry->pUndo->UndoImpl(rContext);
2596*b1cdbd2cSJim Jagielski delete pEntry->pUndo;
2597*b1cdbd2cSJim Jagielski pEntry->pUndo = 0;
2598*b1cdbd2cSJim Jagielski }
2599*b1cdbd2cSJim Jagielski if( bShiftPam )
2600*b1cdbd2cSJim Jagielski {
2601*b1cdbd2cSJim Jagielski // The aPam.Point is at the moment at the last position of the new content and has to be
2602*b1cdbd2cSJim Jagielski // moved to the first postion of the old content for the SwUndoDelete operation
2603*b1cdbd2cSJim Jagielski SwNodeIndex aTmpIdx( aPam.GetPoint()->nNode, 1 );
2604*b1cdbd2cSJim Jagielski SwTxtNode *pTxt = aTmpIdx.GetNode().GetTxtNode();
2605*b1cdbd2cSJim Jagielski if( pTxt )
2606*b1cdbd2cSJim Jagielski {
2607*b1cdbd2cSJim Jagielski aPam.GetPoint()->nNode = *pTxt;
2608*b1cdbd2cSJim Jagielski aPam.GetPoint()->nContent.Assign( pTxt, 0 );
2609*b1cdbd2cSJim Jagielski }
2610*b1cdbd2cSJim Jagielski else
2611*b1cdbd2cSJim Jagielski *aPam.GetPoint() = SwPosition( aTmpIdx );
2612*b1cdbd2cSJim Jagielski }
2613*b1cdbd2cSJim Jagielski pUndo = new SwUndoDelete( aPam, bDeleteCompleteParagraph, sal_True );
2614*b1cdbd2cSJim Jagielski }
2615*b1cdbd2cSJim Jagielski else
2616*b1cdbd2cSJim Jagielski {
2617*b1cdbd2cSJim Jagielski pUndo = new SwUndoDelete( aPam, true );
2618*b1cdbd2cSJim Jagielski if( pEntry->pUndo )
2619*b1cdbd2cSJim Jagielski {
2620*b1cdbd2cSJim Jagielski pEntry->pUndo->UndoImpl(rContext);
2621*b1cdbd2cSJim Jagielski delete pEntry->pUndo;
2622*b1cdbd2cSJim Jagielski pEntry->pUndo = 0;
2623*b1cdbd2cSJim Jagielski }
2624*b1cdbd2cSJim Jagielski }
2625*b1cdbd2cSJim Jagielski pEntry->pUndo = pUndo;
2626*b1cdbd2cSJim Jagielski
2627*b1cdbd2cSJim Jagielski aInsIdx = rBox.GetSttIdx() + 1;
2628*b1cdbd2cSJim Jagielski rDoc.GetNodes().Delete( aInsIdx, 1 );
2629*b1cdbd2cSJim Jagielski
2630*b1cdbd2cSJim Jagielski SfxItemSet aTmpSet( rDoc.GetAttrPool(), RES_BOXATR_FORMAT, RES_BOXATR_VALUE,
2631*b1cdbd2cSJim Jagielski RES_VERT_ORIENT, RES_VERT_ORIENT, 0 );
2632*b1cdbd2cSJim Jagielski aTmpSet.Put( rBox.GetFrmFmt()->GetAttrSet() );
2633*b1cdbd2cSJim Jagielski if( aTmpSet.Count() )
2634*b1cdbd2cSJim Jagielski {
2635*b1cdbd2cSJim Jagielski SwFrmFmt* pBoxFmt = rBox.ClaimFrmFmt();
2636*b1cdbd2cSJim Jagielski pBoxFmt->ResetFmtAttr( RES_BOXATR_FORMAT, RES_BOXATR_VALUE );
2637*b1cdbd2cSJim Jagielski pBoxFmt->ResetFmtAttr( RES_VERT_ORIENT );
2638*b1cdbd2cSJim Jagielski }
2639*b1cdbd2cSJim Jagielski
2640*b1cdbd2cSJim Jagielski if( pEntry->pBoxNumAttr )
2641*b1cdbd2cSJim Jagielski {
2642*b1cdbd2cSJim Jagielski rBox.ClaimFrmFmt()->SetFmtAttr( *pEntry->pBoxNumAttr );
2643*b1cdbd2cSJim Jagielski delete pEntry->pBoxNumAttr, pEntry->pBoxNumAttr = 0;
2644*b1cdbd2cSJim Jagielski }
2645*b1cdbd2cSJim Jagielski
2646*b1cdbd2cSJim Jagielski if( aTmpSet.Count() )
2647*b1cdbd2cSJim Jagielski {
2648*b1cdbd2cSJim Jagielski pEntry->pBoxNumAttr = new SfxItemSet( rDoc.GetAttrPool(),
2649*b1cdbd2cSJim Jagielski RES_BOXATR_FORMAT, RES_BOXATR_VALUE,
2650*b1cdbd2cSJim Jagielski RES_VERT_ORIENT, RES_VERT_ORIENT, 0 );
2651*b1cdbd2cSJim Jagielski pEntry->pBoxNumAttr->Put( aTmpSet );
2652*b1cdbd2cSJim Jagielski }
2653*b1cdbd2cSJim Jagielski
2654*b1cdbd2cSJim Jagielski pEntry->nOffset = rBox.GetSttIdx() - pEntry->nBoxIdx;
2655*b1cdbd2cSJim Jagielski }
2656*b1cdbd2cSJim Jagielski
2657*b1cdbd2cSJim Jagielski if( pInsRowUndo )
2658*b1cdbd2cSJim Jagielski {
2659*b1cdbd2cSJim Jagielski pInsRowUndo->UndoImpl(rContext);
2660*b1cdbd2cSJim Jagielski }
2661*b1cdbd2cSJim Jagielski _DEBUG_REDLINE( &rDoc )
2662*b1cdbd2cSJim Jagielski }
2663*b1cdbd2cSJim Jagielski
RedoImpl(::sw::UndoRedoContext & rContext)2664*b1cdbd2cSJim Jagielski void SwUndoTblCpyTbl::RedoImpl(::sw::UndoRedoContext & rContext)
2665*b1cdbd2cSJim Jagielski {
2666*b1cdbd2cSJim Jagielski SwDoc & rDoc = rContext.GetDoc();
2667*b1cdbd2cSJim Jagielski _DEBUG_REDLINE( &rDoc )
2668*b1cdbd2cSJim Jagielski
2669*b1cdbd2cSJim Jagielski if( pInsRowUndo )
2670*b1cdbd2cSJim Jagielski {
2671*b1cdbd2cSJim Jagielski pInsRowUndo->RedoImpl(rContext);
2672*b1cdbd2cSJim Jagielski }
2673*b1cdbd2cSJim Jagielski
2674*b1cdbd2cSJim Jagielski SwTableNode* pTblNd = 0;
2675*b1cdbd2cSJim Jagielski for( sal_uInt16 n = 0; n < pArr->Count(); ++n )
2676*b1cdbd2cSJim Jagielski {
2677*b1cdbd2cSJim Jagielski _UndoTblCpyTbl_Entry* pEntry = (*pArr)[ n ];
2678*b1cdbd2cSJim Jagielski sal_uLong nSttPos = pEntry->nBoxIdx + pEntry->nOffset;
2679*b1cdbd2cSJim Jagielski SwStartNode* pSNd = rDoc.GetNodes()[ nSttPos ]->StartOfSectionNode();
2680*b1cdbd2cSJim Jagielski if( !pTblNd )
2681*b1cdbd2cSJim Jagielski pTblNd = pSNd->FindTableNode();
2682*b1cdbd2cSJim Jagielski
2683*b1cdbd2cSJim Jagielski SwTableBox& rBox = *pTblNd->GetTable().GetTblBox( nSttPos );
2684*b1cdbd2cSJim Jagielski
2685*b1cdbd2cSJim Jagielski SwNodeIndex aInsIdx( *rBox.GetSttNd(), 1 );
2686*b1cdbd2cSJim Jagielski
2687*b1cdbd2cSJim Jagielski // b62341295: Redline for copying tables - Start.
2688*b1cdbd2cSJim Jagielski rDoc.GetNodes().MakeTxtNode( aInsIdx, (SwTxtFmtColl*)rDoc.GetDfltTxtFmtColl() );
2689*b1cdbd2cSJim Jagielski SwPaM aPam( aInsIdx.GetNode(), *rBox.GetSttNd()->EndOfSectionNode());
2690*b1cdbd2cSJim Jagielski SwUndo* pUndo = IDocumentRedlineAccess::IsRedlineOn( GetRedlineMode() ) ? 0 : new SwUndoDelete( aPam, sal_True );
2691*b1cdbd2cSJim Jagielski if( pEntry->pUndo )
2692*b1cdbd2cSJim Jagielski {
2693*b1cdbd2cSJim Jagielski pEntry->pUndo->UndoImpl(rContext);
2694*b1cdbd2cSJim Jagielski if( IDocumentRedlineAccess::IsRedlineOn( GetRedlineMode() ) )
2695*b1cdbd2cSJim Jagielski {
2696*b1cdbd2cSJim Jagielski // PrepareRedline has to be called with the beginning of the old content
2697*b1cdbd2cSJim Jagielski // When new and old content has been joined, the rIter.pAktPam has been set
2698*b1cdbd2cSJim Jagielski // by the Undo operation to this point.
2699*b1cdbd2cSJim Jagielski // Otherwise aInsIdx has been moved during the Undo operation
2700*b1cdbd2cSJim Jagielski if( pEntry->bJoin )
2701*b1cdbd2cSJim Jagielski {
2702*b1cdbd2cSJim Jagielski SwPaM const& rLastPam =
2703*b1cdbd2cSJim Jagielski rContext.GetCursorSupplier().GetCurrentShellCursor();
2704*b1cdbd2cSJim Jagielski pUndo = PrepareRedline( &rDoc, rBox, *rLastPam.GetPoint(),
2705*b1cdbd2cSJim Jagielski pEntry->bJoin, true );
2706*b1cdbd2cSJim Jagielski }
2707*b1cdbd2cSJim Jagielski else
2708*b1cdbd2cSJim Jagielski {
2709*b1cdbd2cSJim Jagielski SwPosition aTmpPos( aInsIdx );
2710*b1cdbd2cSJim Jagielski pUndo = PrepareRedline( &rDoc, rBox, aTmpPos, pEntry->bJoin, true );
2711*b1cdbd2cSJim Jagielski }
2712*b1cdbd2cSJim Jagielski }
2713*b1cdbd2cSJim Jagielski delete pEntry->pUndo;
2714*b1cdbd2cSJim Jagielski pEntry->pUndo = 0;
2715*b1cdbd2cSJim Jagielski }
2716*b1cdbd2cSJim Jagielski pEntry->pUndo = pUndo;
2717*b1cdbd2cSJim Jagielski // b62341295: Redline for copying tables - End.
2718*b1cdbd2cSJim Jagielski
2719*b1cdbd2cSJim Jagielski aInsIdx = rBox.GetSttIdx() + 1;
2720*b1cdbd2cSJim Jagielski rDoc.GetNodes().Delete( aInsIdx, 1 );
2721*b1cdbd2cSJim Jagielski
2722*b1cdbd2cSJim Jagielski SfxItemSet aTmpSet( rDoc.GetAttrPool(), RES_BOXATR_FORMAT, RES_BOXATR_VALUE,
2723*b1cdbd2cSJim Jagielski RES_VERT_ORIENT, RES_VERT_ORIENT, 0 );
2724*b1cdbd2cSJim Jagielski aTmpSet.Put( rBox.GetFrmFmt()->GetAttrSet() );
2725*b1cdbd2cSJim Jagielski if( aTmpSet.Count() )
2726*b1cdbd2cSJim Jagielski {
2727*b1cdbd2cSJim Jagielski SwFrmFmt* pBoxFmt = rBox.ClaimFrmFmt();
2728*b1cdbd2cSJim Jagielski pBoxFmt->ResetFmtAttr( RES_BOXATR_FORMAT, RES_BOXATR_VALUE );
2729*b1cdbd2cSJim Jagielski pBoxFmt->ResetFmtAttr( RES_VERT_ORIENT );
2730*b1cdbd2cSJim Jagielski }
2731*b1cdbd2cSJim Jagielski if( pEntry->pBoxNumAttr )
2732*b1cdbd2cSJim Jagielski {
2733*b1cdbd2cSJim Jagielski rBox.ClaimFrmFmt()->SetFmtAttr( *pEntry->pBoxNumAttr );
2734*b1cdbd2cSJim Jagielski delete pEntry->pBoxNumAttr, pEntry->pBoxNumAttr = 0;
2735*b1cdbd2cSJim Jagielski }
2736*b1cdbd2cSJim Jagielski
2737*b1cdbd2cSJim Jagielski if( aTmpSet.Count() )
2738*b1cdbd2cSJim Jagielski {
2739*b1cdbd2cSJim Jagielski pEntry->pBoxNumAttr = new SfxItemSet( rDoc.GetAttrPool(),
2740*b1cdbd2cSJim Jagielski RES_BOXATR_FORMAT, RES_BOXATR_VALUE,
2741*b1cdbd2cSJim Jagielski RES_VERT_ORIENT, RES_VERT_ORIENT, 0 );
2742*b1cdbd2cSJim Jagielski pEntry->pBoxNumAttr->Put( aTmpSet );
2743*b1cdbd2cSJim Jagielski }
2744*b1cdbd2cSJim Jagielski
2745*b1cdbd2cSJim Jagielski pEntry->nOffset = rBox.GetSttIdx() - pEntry->nBoxIdx;
2746*b1cdbd2cSJim Jagielski }
2747*b1cdbd2cSJim Jagielski _DEBUG_REDLINE( &rDoc )
2748*b1cdbd2cSJim Jagielski }
2749*b1cdbd2cSJim Jagielski
AddBoxBefore(const SwTableBox & rBox,sal_Bool bDelCntnt)2750*b1cdbd2cSJim Jagielski void SwUndoTblCpyTbl::AddBoxBefore( const SwTableBox& rBox, sal_Bool bDelCntnt )
2751*b1cdbd2cSJim Jagielski {
2752*b1cdbd2cSJim Jagielski if( pArr->Count() && !bDelCntnt )
2753*b1cdbd2cSJim Jagielski return;
2754*b1cdbd2cSJim Jagielski
2755*b1cdbd2cSJim Jagielski _UndoTblCpyTbl_Entry* pEntry = new _UndoTblCpyTbl_Entry( rBox );
2756*b1cdbd2cSJim Jagielski pArr->Insert( pEntry, pArr->Count() );
2757*b1cdbd2cSJim Jagielski
2758*b1cdbd2cSJim Jagielski SwDoc* pDoc = rBox.GetFrmFmt()->GetDoc();
2759*b1cdbd2cSJim Jagielski _DEBUG_REDLINE( pDoc )
2760*b1cdbd2cSJim Jagielski if( bDelCntnt )
2761*b1cdbd2cSJim Jagielski {
2762*b1cdbd2cSJim Jagielski SwNodeIndex aInsIdx( *rBox.GetSttNd(), 1 );
2763*b1cdbd2cSJim Jagielski pDoc->GetNodes().MakeTxtNode( aInsIdx, (SwTxtFmtColl*)pDoc->GetDfltTxtFmtColl() );
2764*b1cdbd2cSJim Jagielski SwPaM aPam( aInsIdx.GetNode(), *rBox.GetSttNd()->EndOfSectionNode() );
2765*b1cdbd2cSJim Jagielski
2766*b1cdbd2cSJim Jagielski if( !pDoc->IsRedlineOn() )
2767*b1cdbd2cSJim Jagielski pEntry->pUndo = new SwUndoDelete( aPam, sal_True );
2768*b1cdbd2cSJim Jagielski }
2769*b1cdbd2cSJim Jagielski
2770*b1cdbd2cSJim Jagielski pEntry->pBoxNumAttr = new SfxItemSet( pDoc->GetAttrPool(),
2771*b1cdbd2cSJim Jagielski RES_BOXATR_FORMAT, RES_BOXATR_VALUE,
2772*b1cdbd2cSJim Jagielski RES_VERT_ORIENT, RES_VERT_ORIENT, 0 );
2773*b1cdbd2cSJim Jagielski pEntry->pBoxNumAttr->Put( rBox.GetFrmFmt()->GetAttrSet() );
2774*b1cdbd2cSJim Jagielski if( !pEntry->pBoxNumAttr->Count() )
2775*b1cdbd2cSJim Jagielski delete pEntry->pBoxNumAttr, pEntry->pBoxNumAttr = 0;
2776*b1cdbd2cSJim Jagielski _DEBUG_REDLINE( pDoc )
2777*b1cdbd2cSJim Jagielski }
2778*b1cdbd2cSJim Jagielski
AddBoxAfter(const SwTableBox & rBox,const SwNodeIndex & rIdx,sal_Bool bDelCntnt)2779*b1cdbd2cSJim Jagielski void SwUndoTblCpyTbl::AddBoxAfter( const SwTableBox& rBox, const SwNodeIndex& rIdx, sal_Bool bDelCntnt )
2780*b1cdbd2cSJim Jagielski {
2781*b1cdbd2cSJim Jagielski _UndoTblCpyTbl_Entry* pEntry = (*pArr)[ pArr->Count() - 1 ];
2782*b1cdbd2cSJim Jagielski
2783*b1cdbd2cSJim Jagielski // wurde der Inhalt geloescht, so loesche jetzt auch noch den temp.
2784*b1cdbd2cSJim Jagielski // erzeugten Node
2785*b1cdbd2cSJim Jagielski if( bDelCntnt )
2786*b1cdbd2cSJim Jagielski {
2787*b1cdbd2cSJim Jagielski SwDoc* pDoc = rBox.GetFrmFmt()->GetDoc();
2788*b1cdbd2cSJim Jagielski _DEBUG_REDLINE( pDoc )
2789*b1cdbd2cSJim Jagielski
2790*b1cdbd2cSJim Jagielski if( pDoc->IsRedlineOn() )
2791*b1cdbd2cSJim Jagielski {
2792*b1cdbd2cSJim Jagielski SwPosition aTmpPos( rIdx );
2793*b1cdbd2cSJim Jagielski pEntry->pUndo = PrepareRedline( pDoc, rBox, aTmpPos, pEntry->bJoin, false );
2794*b1cdbd2cSJim Jagielski }
2795*b1cdbd2cSJim Jagielski SwNodeIndex aDelIdx( *rBox.GetSttNd(), 1 );
2796*b1cdbd2cSJim Jagielski rBox.GetFrmFmt()->GetDoc()->GetNodes().Delete( aDelIdx, 1 );
2797*b1cdbd2cSJim Jagielski _DEBUG_REDLINE( pDoc )
2798*b1cdbd2cSJim Jagielski }
2799*b1cdbd2cSJim Jagielski
2800*b1cdbd2cSJim Jagielski pEntry->nOffset = rBox.GetSttIdx() - pEntry->nBoxIdx;
2801*b1cdbd2cSJim Jagielski }
2802*b1cdbd2cSJim Jagielski
2803*b1cdbd2cSJim Jagielski // PrepareRedline is called from AddBoxAfter() and from Redo() in slightly different situations.
2804*b1cdbd2cSJim Jagielski // bRedo is set by calling from Redo()
2805*b1cdbd2cSJim Jagielski // rJoin is false by calling from AddBoxAfter() and will be set if the old and new content has
2806*b1cdbd2cSJim Jagielski // been merged.
2807*b1cdbd2cSJim Jagielski // rJoin is true if Redo() is calling and the content has already been merged
2808*b1cdbd2cSJim Jagielski
PrepareRedline(SwDoc * pDoc,const SwTableBox & rBox,const SwPosition & rPos,bool & rJoin,bool bRedo)2809*b1cdbd2cSJim Jagielski SwUndo* SwUndoTblCpyTbl::PrepareRedline( SwDoc* pDoc, const SwTableBox& rBox,
2810*b1cdbd2cSJim Jagielski const SwPosition& rPos, bool& rJoin, bool bRedo )
2811*b1cdbd2cSJim Jagielski {
2812*b1cdbd2cSJim Jagielski SwUndo *pUndo = 0;
2813*b1cdbd2cSJim Jagielski // b62341295: Redline for copying tables
2814*b1cdbd2cSJim Jagielski // What's to do?
2815*b1cdbd2cSJim Jagielski // Mark the cell content before rIdx as insertion,
2816*b1cdbd2cSJim Jagielski // mark the cell content behind rIdx as deletion
2817*b1cdbd2cSJim Jagielski // merge text nodes at rIdx if possible
2818*b1cdbd2cSJim Jagielski RedlineMode_t eOld = pDoc->GetRedlineMode();
2819*b1cdbd2cSJim Jagielski pDoc->SetRedlineMode_intern((RedlineMode_t)( ( eOld | nsRedlineMode_t::REDLINE_DONTCOMBINE_REDLINES ) &
2820*b1cdbd2cSJim Jagielski ~nsRedlineMode_t::REDLINE_IGNORE ));
2821*b1cdbd2cSJim Jagielski SwPosition aInsertEnd( rPos );
2822*b1cdbd2cSJim Jagielski SwTxtNode* pTxt;
2823*b1cdbd2cSJim Jagielski if( !rJoin )
2824*b1cdbd2cSJim Jagielski {
2825*b1cdbd2cSJim Jagielski // If the content is not merged, the end of the insertion is at the end of the node
2826*b1cdbd2cSJim Jagielski // _before_ the given position rPos
2827*b1cdbd2cSJim Jagielski --aInsertEnd.nNode;
2828*b1cdbd2cSJim Jagielski pTxt = aInsertEnd.nNode.GetNode().GetTxtNode();
2829*b1cdbd2cSJim Jagielski if( pTxt )
2830*b1cdbd2cSJim Jagielski {
2831*b1cdbd2cSJim Jagielski aInsertEnd.nContent.Assign( pTxt, pTxt->GetTxt().Len() );
2832*b1cdbd2cSJim Jagielski if( !bRedo && rPos.nNode.GetNode().GetTxtNode() )
2833*b1cdbd2cSJim Jagielski { // Try to merge, if not called by Redo()
2834*b1cdbd2cSJim Jagielski rJoin = true;
2835*b1cdbd2cSJim Jagielski pTxt->JoinNext();
2836*b1cdbd2cSJim Jagielski }
2837*b1cdbd2cSJim Jagielski }
2838*b1cdbd2cSJim Jagielski else
2839*b1cdbd2cSJim Jagielski aInsertEnd.nContent = SwIndex( 0 );
2840*b1cdbd2cSJim Jagielski }
2841*b1cdbd2cSJim Jagielski // For joined (merged) contents the start of deletionm and end of insertion are identical
2842*b1cdbd2cSJim Jagielski // otherwise adjacent nodes.
2843*b1cdbd2cSJim Jagielski SwPosition aDeleteStart( rJoin ? aInsertEnd : rPos );
2844*b1cdbd2cSJim Jagielski if( !rJoin )
2845*b1cdbd2cSJim Jagielski {
2846*b1cdbd2cSJim Jagielski pTxt = aDeleteStart.nNode.GetNode().GetTxtNode();
2847*b1cdbd2cSJim Jagielski if( pTxt )
2848*b1cdbd2cSJim Jagielski aDeleteStart.nContent.Assign( pTxt, 0 );
2849*b1cdbd2cSJim Jagielski }
2850*b1cdbd2cSJim Jagielski SwPosition aCellEnd( SwNodeIndex( *rBox.GetSttNd()->EndOfSectionNode(), -1 ) );
2851*b1cdbd2cSJim Jagielski pTxt = aCellEnd.nNode.GetNode().GetTxtNode();
2852*b1cdbd2cSJim Jagielski if( pTxt )
2853*b1cdbd2cSJim Jagielski aCellEnd.nContent.Assign( pTxt, pTxt->GetTxt().Len() );
2854*b1cdbd2cSJim Jagielski if( aDeleteStart != aCellEnd )
2855*b1cdbd2cSJim Jagielski { // If the old (deleted) part is not empty, here we are...
2856*b1cdbd2cSJim Jagielski SwPaM aDeletePam( aDeleteStart, aCellEnd );
2857*b1cdbd2cSJim Jagielski pUndo = new SwUndoRedlineDelete( aDeletePam, UNDO_DELETE );
2858*b1cdbd2cSJim Jagielski pDoc->AppendRedline( new SwRedline( nsRedlineType_t::REDLINE_DELETE, aDeletePam ), true );
2859*b1cdbd2cSJim Jagielski }
2860*b1cdbd2cSJim Jagielski else if( !rJoin ) // If the old part is empty and joined, we are finished
2861*b1cdbd2cSJim Jagielski { // if it is not joined, we have to delete this empty paragraph
2862*b1cdbd2cSJim Jagielski aCellEnd = SwPosition(
2863*b1cdbd2cSJim Jagielski SwNodeIndex( *rBox.GetSttNd()->EndOfSectionNode() ));
2864*b1cdbd2cSJim Jagielski SwPaM aTmpPam( aDeleteStart, aCellEnd );
2865*b1cdbd2cSJim Jagielski pUndo = new SwUndoDelete( aTmpPam, sal_True );
2866*b1cdbd2cSJim Jagielski }
2867*b1cdbd2cSJim Jagielski SwPosition aCellStart( SwNodeIndex( *rBox.GetSttNd(), 2 ) );
2868*b1cdbd2cSJim Jagielski pTxt = aCellStart.nNode.GetNode().GetTxtNode();
2869*b1cdbd2cSJim Jagielski if( pTxt )
2870*b1cdbd2cSJim Jagielski aCellStart.nContent.Assign( pTxt, 0 );
2871*b1cdbd2cSJim Jagielski if( aCellStart != aInsertEnd ) // An empty insertion will not been marked
2872*b1cdbd2cSJim Jagielski {
2873*b1cdbd2cSJim Jagielski SwPaM aTmpPam( aCellStart, aInsertEnd );
2874*b1cdbd2cSJim Jagielski pDoc->AppendRedline( new SwRedline( nsRedlineType_t::REDLINE_INSERT, aTmpPam ), true );
2875*b1cdbd2cSJim Jagielski }
2876*b1cdbd2cSJim Jagielski
2877*b1cdbd2cSJim Jagielski pDoc->SetRedlineMode_intern( eOld );
2878*b1cdbd2cSJim Jagielski return pUndo;
2879*b1cdbd2cSJim Jagielski }
2880*b1cdbd2cSJim Jagielski
2881*b1cdbd2cSJim Jagielski
InsertRow(SwTable & rTbl,const SwSelBoxes & rBoxes,sal_uInt16 nCnt)2882*b1cdbd2cSJim Jagielski sal_Bool SwUndoTblCpyTbl::InsertRow( SwTable& rTbl, const SwSelBoxes& rBoxes,
2883*b1cdbd2cSJim Jagielski sal_uInt16 nCnt )
2884*b1cdbd2cSJim Jagielski {
2885*b1cdbd2cSJim Jagielski SwTableNode* pTblNd = (SwTableNode*)rTbl.GetTabSortBoxes()[0]->
2886*b1cdbd2cSJim Jagielski GetSttNd()->FindTableNode();
2887*b1cdbd2cSJim Jagielski
2888*b1cdbd2cSJim Jagielski SwTableSortBoxes aTmpLst( 0, 5 );
2889*b1cdbd2cSJim Jagielski pInsRowUndo = new SwUndoTblNdsChg( UNDO_TABLE_INSROW, rBoxes, *pTblNd,
2890*b1cdbd2cSJim Jagielski 0, 0, nCnt, sal_True, sal_False );
2891*b1cdbd2cSJim Jagielski aTmpLst.Insert( &rTbl.GetTabSortBoxes(), 0, rTbl.GetTabSortBoxes().Count() );
2892*b1cdbd2cSJim Jagielski
2893*b1cdbd2cSJim Jagielski sal_Bool bRet = rTbl.InsertRow( rTbl.GetFrmFmt()->GetDoc(), rBoxes, nCnt, sal_True );
2894*b1cdbd2cSJim Jagielski if( bRet )
2895*b1cdbd2cSJim Jagielski pInsRowUndo->SaveNewBoxes( *pTblNd, aTmpLst );
2896*b1cdbd2cSJim Jagielski else
2897*b1cdbd2cSJim Jagielski delete pInsRowUndo, pInsRowUndo = 0;
2898*b1cdbd2cSJim Jagielski return bRet;
2899*b1cdbd2cSJim Jagielski }
2900*b1cdbd2cSJim Jagielski
IsEmpty() const2901*b1cdbd2cSJim Jagielski sal_Bool SwUndoTblCpyTbl::IsEmpty() const
2902*b1cdbd2cSJim Jagielski {
2903*b1cdbd2cSJim Jagielski return !pInsRowUndo && !pArr->Count();
2904*b1cdbd2cSJim Jagielski }
2905*b1cdbd2cSJim Jagielski
2906*b1cdbd2cSJim Jagielski
2907*b1cdbd2cSJim Jagielski //////////////////////////////////////////////////////////////////////////
2908*b1cdbd2cSJim Jagielski
SwUndoCpyTbl()2909*b1cdbd2cSJim Jagielski SwUndoCpyTbl::SwUndoCpyTbl()
2910*b1cdbd2cSJim Jagielski : SwUndo( UNDO_CPYTBL ), pDel( 0 ), nTblNode( 0 )
2911*b1cdbd2cSJim Jagielski {
2912*b1cdbd2cSJim Jagielski }
2913*b1cdbd2cSJim Jagielski
~SwUndoCpyTbl()2914*b1cdbd2cSJim Jagielski SwUndoCpyTbl::~SwUndoCpyTbl()
2915*b1cdbd2cSJim Jagielski {
2916*b1cdbd2cSJim Jagielski delete pDel;
2917*b1cdbd2cSJim Jagielski }
2918*b1cdbd2cSJim Jagielski
UndoImpl(::sw::UndoRedoContext & rContext)2919*b1cdbd2cSJim Jagielski void SwUndoCpyTbl::UndoImpl(::sw::UndoRedoContext & rContext)
2920*b1cdbd2cSJim Jagielski {
2921*b1cdbd2cSJim Jagielski SwDoc & rDoc = rContext.GetDoc();
2922*b1cdbd2cSJim Jagielski SwTableNode* pTNd = rDoc.GetNodes()[ nTblNode ]->GetTableNode();
2923*b1cdbd2cSJim Jagielski
2924*b1cdbd2cSJim Jagielski // harte SeitenUmbrueche am nachfolgenden Node verschieben
2925*b1cdbd2cSJim Jagielski SwCntntNode* pNextNd = rDoc.GetNodes()[ pTNd->EndOfSectionIndex()+1 ]->GetCntntNode();
2926*b1cdbd2cSJim Jagielski if( pNextNd )
2927*b1cdbd2cSJim Jagielski {
2928*b1cdbd2cSJim Jagielski SwFrmFmt* pTableFmt = pTNd->GetTable().GetFrmFmt();
2929*b1cdbd2cSJim Jagielski const SfxPoolItem *pItem;
2930*b1cdbd2cSJim Jagielski
2931*b1cdbd2cSJim Jagielski if( SFX_ITEM_SET == pTableFmt->GetItemState( RES_PAGEDESC,
2932*b1cdbd2cSJim Jagielski sal_False, &pItem ) )
2933*b1cdbd2cSJim Jagielski pNextNd->SetAttr( *pItem );
2934*b1cdbd2cSJim Jagielski
2935*b1cdbd2cSJim Jagielski if( SFX_ITEM_SET == pTableFmt->GetItemState( RES_BREAK,
2936*b1cdbd2cSJim Jagielski sal_False, &pItem ) )
2937*b1cdbd2cSJim Jagielski pNextNd->SetAttr( *pItem );
2938*b1cdbd2cSJim Jagielski }
2939*b1cdbd2cSJim Jagielski
2940*b1cdbd2cSJim Jagielski SwPaM aPam( *pTNd, *pTNd->EndOfSectionNode(), 0 , 1 );
2941*b1cdbd2cSJim Jagielski pDel = new SwUndoDelete( aPam, sal_True );
2942*b1cdbd2cSJim Jagielski }
2943*b1cdbd2cSJim Jagielski
RedoImpl(::sw::UndoRedoContext & rContext)2944*b1cdbd2cSJim Jagielski void SwUndoCpyTbl::RedoImpl(::sw::UndoRedoContext & rContext)
2945*b1cdbd2cSJim Jagielski {
2946*b1cdbd2cSJim Jagielski pDel->UndoImpl(rContext);
2947*b1cdbd2cSJim Jagielski delete pDel, pDel = 0;
2948*b1cdbd2cSJim Jagielski }
2949*b1cdbd2cSJim Jagielski
2950*b1cdbd2cSJim Jagielski
2951*b1cdbd2cSJim Jagielski //////////////////////////////////////////////////////////////////////////
2952*b1cdbd2cSJim Jagielski
SwUndoSplitTbl(const SwTableNode & rTblNd,SwSaveRowSpan * pRowSp,sal_uInt16 eMode,sal_Bool bNewSize)2953*b1cdbd2cSJim Jagielski SwUndoSplitTbl::SwUndoSplitTbl( const SwTableNode& rTblNd,
2954*b1cdbd2cSJim Jagielski SwSaveRowSpan* pRowSp, sal_uInt16 eMode, sal_Bool bNewSize )
2955*b1cdbd2cSJim Jagielski : SwUndo( UNDO_SPLIT_TABLE ),
2956*b1cdbd2cSJim Jagielski nTblNode( rTblNd.GetIndex() ), nOffset( 0 ), mpSaveRowSpan( pRowSp ), pSavTbl( 0 ),
2957*b1cdbd2cSJim Jagielski pHistory( 0 ), nMode( eMode ), nFmlEnd( 0 ), bCalcNewSize( bNewSize )
2958*b1cdbd2cSJim Jagielski {
2959*b1cdbd2cSJim Jagielski switch( nMode )
2960*b1cdbd2cSJim Jagielski {
2961*b1cdbd2cSJim Jagielski case HEADLINE_BOXATRCOLLCOPY:
2962*b1cdbd2cSJim Jagielski pHistory = new SwHistory;
2963*b1cdbd2cSJim Jagielski // kein break;
2964*b1cdbd2cSJim Jagielski case HEADLINE_BORDERCOPY:
2965*b1cdbd2cSJim Jagielski case HEADLINE_BOXATTRCOPY:
2966*b1cdbd2cSJim Jagielski pSavTbl = new _SaveTable( rTblNd.GetTable(), 1, sal_False );
2967*b1cdbd2cSJim Jagielski break;
2968*b1cdbd2cSJim Jagielski }
2969*b1cdbd2cSJim Jagielski }
2970*b1cdbd2cSJim Jagielski
~SwUndoSplitTbl()2971*b1cdbd2cSJim Jagielski SwUndoSplitTbl::~SwUndoSplitTbl()
2972*b1cdbd2cSJim Jagielski {
2973*b1cdbd2cSJim Jagielski delete pSavTbl;
2974*b1cdbd2cSJim Jagielski delete pHistory;
2975*b1cdbd2cSJim Jagielski delete mpSaveRowSpan;
2976*b1cdbd2cSJim Jagielski }
2977*b1cdbd2cSJim Jagielski
UndoImpl(::sw::UndoRedoContext & rContext)2978*b1cdbd2cSJim Jagielski void SwUndoSplitTbl::UndoImpl(::sw::UndoRedoContext & rContext)
2979*b1cdbd2cSJim Jagielski {
2980*b1cdbd2cSJim Jagielski SwDoc *const pDoc = & rContext.GetDoc();
2981*b1cdbd2cSJim Jagielski SwPaM *const pPam(& rContext.GetCursorSupplier().CreateNewShellCursor());
2982*b1cdbd2cSJim Jagielski
2983*b1cdbd2cSJim Jagielski pPam->DeleteMark();
2984*b1cdbd2cSJim Jagielski SwNodeIndex& rIdx = pPam->GetPoint()->nNode;
2985*b1cdbd2cSJim Jagielski rIdx = nTblNode + nOffset;
2986*b1cdbd2cSJim Jagielski
2987*b1cdbd2cSJim Jagielski //Den implizit erzeugten Absatz wieder entfernen.
2988*b1cdbd2cSJim Jagielski pDoc->GetNodes().Delete( rIdx, 1 );
2989*b1cdbd2cSJim Jagielski
2990*b1cdbd2cSJim Jagielski rIdx = nTblNode + nOffset;
2991*b1cdbd2cSJim Jagielski SwTableNode* pTblNd = rIdx.GetNode().GetTableNode();
2992*b1cdbd2cSJim Jagielski SwTable& rTbl = pTblNd->GetTable();
2993*b1cdbd2cSJim Jagielski
2994*b1cdbd2cSJim Jagielski SwTableFmlUpdate aMsgHnt( &rTbl );
2995*b1cdbd2cSJim Jagielski aMsgHnt.eFlags = TBL_BOXPTR;
2996*b1cdbd2cSJim Jagielski pDoc->UpdateTblFlds( &aMsgHnt );
2997*b1cdbd2cSJim Jagielski
2998*b1cdbd2cSJim Jagielski switch( nMode )
2999*b1cdbd2cSJim Jagielski {
3000*b1cdbd2cSJim Jagielski case HEADLINE_BOXATRCOLLCOPY:
3001*b1cdbd2cSJim Jagielski if( pHistory )
3002*b1cdbd2cSJim Jagielski pHistory->TmpRollback( pDoc, nFmlEnd );
3003*b1cdbd2cSJim Jagielski
3004*b1cdbd2cSJim Jagielski // kein break
3005*b1cdbd2cSJim Jagielski case HEADLINE_BOXATTRCOPY:
3006*b1cdbd2cSJim Jagielski case HEADLINE_BORDERCOPY:
3007*b1cdbd2cSJim Jagielski {
3008*b1cdbd2cSJim Jagielski pSavTbl->CreateNew( rTbl, sal_False );
3009*b1cdbd2cSJim Jagielski pSavTbl->RestoreAttr( rTbl );
3010*b1cdbd2cSJim Jagielski }
3011*b1cdbd2cSJim Jagielski break;
3012*b1cdbd2cSJim Jagielski
3013*b1cdbd2cSJim Jagielski case HEADLINE_CNTNTCOPY:
3014*b1cdbd2cSJim Jagielski // die erzeugte 1. Line muss wieder entfernt werden
3015*b1cdbd2cSJim Jagielski {
3016*b1cdbd2cSJim Jagielski SwSelBoxes aSelBoxes;
3017*b1cdbd2cSJim Jagielski SwTableBox* pBox = rTbl.GetTblBox( nTblNode + nOffset + 1 );
3018*b1cdbd2cSJim Jagielski rTbl.SelLineFromBox( pBox, aSelBoxes, sal_True );
3019*b1cdbd2cSJim Jagielski _FndBox aTmpBox( 0, 0 );
3020*b1cdbd2cSJim Jagielski aTmpBox.SetTableLines( aSelBoxes, rTbl );
3021*b1cdbd2cSJim Jagielski aTmpBox.DelFrms( rTbl );
3022*b1cdbd2cSJim Jagielski rTbl.DeleteSel( pDoc, aSelBoxes, 0, 0, sal_False, sal_False );
3023*b1cdbd2cSJim Jagielski }
3024*b1cdbd2cSJim Jagielski break;
3025*b1cdbd2cSJim Jagielski }
3026*b1cdbd2cSJim Jagielski
3027*b1cdbd2cSJim Jagielski pDoc->GetNodes().MergeTable( rIdx );
3028*b1cdbd2cSJim Jagielski
3029*b1cdbd2cSJim Jagielski if( pHistory )
3030*b1cdbd2cSJim Jagielski {
3031*b1cdbd2cSJim Jagielski pHistory->TmpRollback( pDoc, 0 );
3032*b1cdbd2cSJim Jagielski pHistory->SetTmpEnd( pHistory->Count() );
3033*b1cdbd2cSJim Jagielski }
3034*b1cdbd2cSJim Jagielski if( mpSaveRowSpan )
3035*b1cdbd2cSJim Jagielski {
3036*b1cdbd2cSJim Jagielski pTblNd = rIdx.GetNode().FindTableNode();
3037*b1cdbd2cSJim Jagielski if( pTblNd )
3038*b1cdbd2cSJim Jagielski pTblNd->GetTable().RestoreRowSpan( *mpSaveRowSpan );
3039*b1cdbd2cSJim Jagielski }
3040*b1cdbd2cSJim Jagielski ClearFEShellTabCols();
3041*b1cdbd2cSJim Jagielski }
3042*b1cdbd2cSJim Jagielski
RedoImpl(::sw::UndoRedoContext & rContext)3043*b1cdbd2cSJim Jagielski void SwUndoSplitTbl::RedoImpl(::sw::UndoRedoContext & rContext)
3044*b1cdbd2cSJim Jagielski {
3045*b1cdbd2cSJim Jagielski SwDoc *const pDoc = & rContext.GetDoc();
3046*b1cdbd2cSJim Jagielski SwPaM *const pPam(& rContext.GetCursorSupplier().CreateNewShellCursor());
3047*b1cdbd2cSJim Jagielski
3048*b1cdbd2cSJim Jagielski pPam->DeleteMark();
3049*b1cdbd2cSJim Jagielski pPam->GetPoint()->nNode = nTblNode;
3050*b1cdbd2cSJim Jagielski pDoc->SplitTable( *pPam->GetPoint(), nMode, bCalcNewSize );
3051*b1cdbd2cSJim Jagielski
3052*b1cdbd2cSJim Jagielski ClearFEShellTabCols();
3053*b1cdbd2cSJim Jagielski }
3054*b1cdbd2cSJim Jagielski
RepeatImpl(::sw::RepeatContext & rContext)3055*b1cdbd2cSJim Jagielski void SwUndoSplitTbl::RepeatImpl(::sw::RepeatContext & rContext)
3056*b1cdbd2cSJim Jagielski {
3057*b1cdbd2cSJim Jagielski SwPaM *const pPam = & rContext.GetRepeatPaM();
3058*b1cdbd2cSJim Jagielski SwDoc *const pDoc = & rContext.GetDoc();
3059*b1cdbd2cSJim Jagielski
3060*b1cdbd2cSJim Jagielski pDoc->SplitTable( *pPam->GetPoint(), nMode, bCalcNewSize );
3061*b1cdbd2cSJim Jagielski ClearFEShellTabCols();
3062*b1cdbd2cSJim Jagielski }
3063*b1cdbd2cSJim Jagielski
SaveFormula(SwHistory & rHistory)3064*b1cdbd2cSJim Jagielski void SwUndoSplitTbl::SaveFormula( SwHistory& rHistory )
3065*b1cdbd2cSJim Jagielski {
3066*b1cdbd2cSJim Jagielski if( !pHistory )
3067*b1cdbd2cSJim Jagielski pHistory = new SwHistory;
3068*b1cdbd2cSJim Jagielski
3069*b1cdbd2cSJim Jagielski nFmlEnd = rHistory.Count();
3070*b1cdbd2cSJim Jagielski pHistory->Move( 0, &rHistory );
3071*b1cdbd2cSJim Jagielski }
3072*b1cdbd2cSJim Jagielski
3073*b1cdbd2cSJim Jagielski
3074*b1cdbd2cSJim Jagielski //////////////////////////////////////////////////////////////////////////
3075*b1cdbd2cSJim Jagielski
SwUndoMergeTbl(const SwTableNode & rTblNd,const SwTableNode & rDelTblNd,sal_Bool bWithPrv,sal_uInt16 nMd)3076*b1cdbd2cSJim Jagielski SwUndoMergeTbl::SwUndoMergeTbl( const SwTableNode& rTblNd,
3077*b1cdbd2cSJim Jagielski const SwTableNode& rDelTblNd,
3078*b1cdbd2cSJim Jagielski sal_Bool bWithPrv, sal_uInt16 nMd )
3079*b1cdbd2cSJim Jagielski : SwUndo( UNDO_MERGE_TABLE ), pSavTbl( 0 ),
3080*b1cdbd2cSJim Jagielski pHistory( 0 ), nMode( nMd ), bWithPrev( bWithPrv )
3081*b1cdbd2cSJim Jagielski {
3082*b1cdbd2cSJim Jagielski // Endnode der letzen Tabellenzelle merken, die auf der Position verbleibt
3083*b1cdbd2cSJim Jagielski if( bWithPrev )
3084*b1cdbd2cSJim Jagielski nTblNode = rDelTblNd.EndOfSectionIndex() - 1;
3085*b1cdbd2cSJim Jagielski else
3086*b1cdbd2cSJim Jagielski nTblNode = rTblNd.EndOfSectionIndex() - 1;
3087*b1cdbd2cSJim Jagielski
3088*b1cdbd2cSJim Jagielski aName = rDelTblNd.GetTable().GetFrmFmt()->GetName();
3089*b1cdbd2cSJim Jagielski pSavTbl = new _SaveTable( rDelTblNd.GetTable() );
3090*b1cdbd2cSJim Jagielski
3091*b1cdbd2cSJim Jagielski pSavHdl = bWithPrev ? new _SaveTable( rTblNd.GetTable(), 1 ) : 0;
3092*b1cdbd2cSJim Jagielski }
3093*b1cdbd2cSJim Jagielski
~SwUndoMergeTbl()3094*b1cdbd2cSJim Jagielski SwUndoMergeTbl::~SwUndoMergeTbl()
3095*b1cdbd2cSJim Jagielski {
3096*b1cdbd2cSJim Jagielski delete pSavTbl;
3097*b1cdbd2cSJim Jagielski delete pSavHdl;
3098*b1cdbd2cSJim Jagielski delete pHistory;
3099*b1cdbd2cSJim Jagielski }
3100*b1cdbd2cSJim Jagielski
UndoImpl(::sw::UndoRedoContext & rContext)3101*b1cdbd2cSJim Jagielski void SwUndoMergeTbl::UndoImpl(::sw::UndoRedoContext & rContext)
3102*b1cdbd2cSJim Jagielski {
3103*b1cdbd2cSJim Jagielski SwDoc *const pDoc = & rContext.GetDoc();
3104*b1cdbd2cSJim Jagielski SwPaM *const pPam(& rContext.GetCursorSupplier().CreateNewShellCursor());
3105*b1cdbd2cSJim Jagielski
3106*b1cdbd2cSJim Jagielski pPam->DeleteMark();
3107*b1cdbd2cSJim Jagielski SwNodeIndex& rIdx = pPam->GetPoint()->nNode;
3108*b1cdbd2cSJim Jagielski rIdx = nTblNode;
3109*b1cdbd2cSJim Jagielski
3110*b1cdbd2cSJim Jagielski SwTableNode* pTblNd = rIdx.GetNode().FindTableNode();
3111*b1cdbd2cSJim Jagielski SwTable* pTbl = &pTblNd->GetTable();
3112*b1cdbd2cSJim Jagielski
3113*b1cdbd2cSJim Jagielski SwTableFmlUpdate aMsgHnt( pTbl );
3114*b1cdbd2cSJim Jagielski aMsgHnt.eFlags = TBL_BOXPTR;
3115*b1cdbd2cSJim Jagielski pDoc->UpdateTblFlds( &aMsgHnt );
3116*b1cdbd2cSJim Jagielski
3117*b1cdbd2cSJim Jagielski //Lines fuer das Layout-Update herausuchen.
3118*b1cdbd2cSJim Jagielski _FndBox aFndBox( 0, 0 );
3119*b1cdbd2cSJim Jagielski aFndBox.SetTableLines( *pTbl );
3120*b1cdbd2cSJim Jagielski aFndBox.DelFrms( *pTbl );
3121*b1cdbd2cSJim Jagielski // ? TL_CHART2: notification or locking of controller required ?
3122*b1cdbd2cSJim Jagielski
3123*b1cdbd2cSJim Jagielski SwTableNode* pNew = pDoc->GetNodes().SplitTable( rIdx, sal_True, sal_False );
3124*b1cdbd2cSJim Jagielski
3125*b1cdbd2cSJim Jagielski //Layout updaten
3126*b1cdbd2cSJim Jagielski aFndBox.MakeFrms( *pTbl );
3127*b1cdbd2cSJim Jagielski // ? TL_CHART2: notification or locking of controller required ?
3128*b1cdbd2cSJim Jagielski
3129*b1cdbd2cSJim Jagielski if( bWithPrev )
3130*b1cdbd2cSJim Jagielski {
3131*b1cdbd2cSJim Jagielski // den Namen umsetzen
3132*b1cdbd2cSJim Jagielski pNew->GetTable().GetFrmFmt()->SetName( pTbl->GetFrmFmt()->GetName() );
3133*b1cdbd2cSJim Jagielski pSavHdl->RestoreAttr( pNew->GetTable() );
3134*b1cdbd2cSJim Jagielski }
3135*b1cdbd2cSJim Jagielski else
3136*b1cdbd2cSJim Jagielski pTbl = &pNew->GetTable();
3137*b1cdbd2cSJim Jagielski pTbl->GetFrmFmt()->SetName( aName );
3138*b1cdbd2cSJim Jagielski
3139*b1cdbd2cSJim Jagielski // pSavTbl->CreateNew( *pTbl, sal_False );
3140*b1cdbd2cSJim Jagielski pSavTbl->RestoreAttr( *pTbl );
3141*b1cdbd2cSJim Jagielski
3142*b1cdbd2cSJim Jagielski
3143*b1cdbd2cSJim Jagielski if( pHistory )
3144*b1cdbd2cSJim Jagielski {
3145*b1cdbd2cSJim Jagielski pHistory->TmpRollback( pDoc, 0 );
3146*b1cdbd2cSJim Jagielski pHistory->SetTmpEnd( pHistory->Count() );
3147*b1cdbd2cSJim Jagielski }
3148*b1cdbd2cSJim Jagielski
3149*b1cdbd2cSJim Jagielski // fuer die neue Tabelle die Frames anlegen
3150*b1cdbd2cSJim Jagielski SwNodeIndex aTmpIdx( *pNew );
3151*b1cdbd2cSJim Jagielski pNew->MakeFrms( &aTmpIdx );
3152*b1cdbd2cSJim Jagielski
3153*b1cdbd2cSJim Jagielski // Cursor irgendwo in den Content stellen
3154*b1cdbd2cSJim Jagielski SwCntntNode* pCNd = pDoc->GetNodes().GoNext( &rIdx );
3155*b1cdbd2cSJim Jagielski pPam->GetPoint()->nContent.Assign( pCNd, 0 );
3156*b1cdbd2cSJim Jagielski
3157*b1cdbd2cSJim Jagielski ClearFEShellTabCols();
3158*b1cdbd2cSJim Jagielski
3159*b1cdbd2cSJim Jagielski // TL_CHART2: need to inform chart of probably changed cell names
3160*b1cdbd2cSJim Jagielski SwChartDataProvider *pPCD = pDoc->GetChartDataProvider();
3161*b1cdbd2cSJim Jagielski if (pPCD)
3162*b1cdbd2cSJim Jagielski {
3163*b1cdbd2cSJim Jagielski pDoc->UpdateCharts( pTbl->GetFrmFmt()->GetName() );
3164*b1cdbd2cSJim Jagielski pDoc->UpdateCharts( pNew->GetTable().GetFrmFmt()->GetName() );
3165*b1cdbd2cSJim Jagielski }
3166*b1cdbd2cSJim Jagielski }
3167*b1cdbd2cSJim Jagielski
RedoImpl(::sw::UndoRedoContext & rContext)3168*b1cdbd2cSJim Jagielski void SwUndoMergeTbl::RedoImpl(::sw::UndoRedoContext & rContext)
3169*b1cdbd2cSJim Jagielski {
3170*b1cdbd2cSJim Jagielski SwDoc *const pDoc = & rContext.GetDoc();
3171*b1cdbd2cSJim Jagielski SwPaM *const pPam(& rContext.GetCursorSupplier().CreateNewShellCursor());
3172*b1cdbd2cSJim Jagielski
3173*b1cdbd2cSJim Jagielski pPam->DeleteMark();
3174*b1cdbd2cSJim Jagielski pPam->GetPoint()->nNode = nTblNode;
3175*b1cdbd2cSJim Jagielski if( bWithPrev )
3176*b1cdbd2cSJim Jagielski pPam->GetPoint()->nNode = nTblNode + 3;
3177*b1cdbd2cSJim Jagielski else
3178*b1cdbd2cSJim Jagielski pPam->GetPoint()->nNode = nTblNode;
3179*b1cdbd2cSJim Jagielski
3180*b1cdbd2cSJim Jagielski pDoc->MergeTable( *pPam->GetPoint(), bWithPrev, nMode );
3181*b1cdbd2cSJim Jagielski
3182*b1cdbd2cSJim Jagielski ClearFEShellTabCols();
3183*b1cdbd2cSJim Jagielski }
3184*b1cdbd2cSJim Jagielski
RepeatImpl(::sw::RepeatContext & rContext)3185*b1cdbd2cSJim Jagielski void SwUndoMergeTbl::RepeatImpl(::sw::RepeatContext & rContext)
3186*b1cdbd2cSJim Jagielski {
3187*b1cdbd2cSJim Jagielski SwDoc *const pDoc = & rContext.GetDoc();
3188*b1cdbd2cSJim Jagielski SwPaM *const pPam = & rContext.GetRepeatPaM();
3189*b1cdbd2cSJim Jagielski
3190*b1cdbd2cSJim Jagielski pDoc->MergeTable( *pPam->GetPoint(), bWithPrev, nMode );
3191*b1cdbd2cSJim Jagielski ClearFEShellTabCols();
3192*b1cdbd2cSJim Jagielski }
3193*b1cdbd2cSJim Jagielski
SaveFormula(SwHistory & rHistory)3194*b1cdbd2cSJim Jagielski void SwUndoMergeTbl::SaveFormula( SwHistory& rHistory )
3195*b1cdbd2cSJim Jagielski {
3196*b1cdbd2cSJim Jagielski if( !pHistory )
3197*b1cdbd2cSJim Jagielski pHistory = new SwHistory;
3198*b1cdbd2cSJim Jagielski pHistory->Move( 0, &rHistory );
3199*b1cdbd2cSJim Jagielski }
3200*b1cdbd2cSJim Jagielski
3201*b1cdbd2cSJim Jagielski
3202*b1cdbd2cSJim Jagielski //////////////////////////////////////////////////////////////////////////
3203*b1cdbd2cSJim Jagielski
InsertSort(SvUShorts & rArr,sal_uInt16 nIdx,sal_uInt16 * pInsPos)3204*b1cdbd2cSJim Jagielski void InsertSort( SvUShorts& rArr, sal_uInt16 nIdx, sal_uInt16* pInsPos )
3205*b1cdbd2cSJim Jagielski {
3206*b1cdbd2cSJim Jagielski sal_uInt16 nO = rArr.Count(), nM, nU = 0;
3207*b1cdbd2cSJim Jagielski if( nO > 0 )
3208*b1cdbd2cSJim Jagielski {
3209*b1cdbd2cSJim Jagielski nO--;
3210*b1cdbd2cSJim Jagielski while( nU <= nO )
3211*b1cdbd2cSJim Jagielski {
3212*b1cdbd2cSJim Jagielski nM = nU + ( nO - nU ) / 2;
3213*b1cdbd2cSJim Jagielski if( *(rArr.GetData() + nM) == nIdx )
3214*b1cdbd2cSJim Jagielski {
3215*b1cdbd2cSJim Jagielski ASSERT( sal_False, "Index ist schon vorhanden, darf nie sein!" );
3216*b1cdbd2cSJim Jagielski return;
3217*b1cdbd2cSJim Jagielski }
3218*b1cdbd2cSJim Jagielski if( *(rArr.GetData() + nM) < nIdx )
3219*b1cdbd2cSJim Jagielski nU = nM + 1;
3220*b1cdbd2cSJim Jagielski else if( nM == 0 )
3221*b1cdbd2cSJim Jagielski break;
3222*b1cdbd2cSJim Jagielski else
3223*b1cdbd2cSJim Jagielski nO = nM - 1;
3224*b1cdbd2cSJim Jagielski }
3225*b1cdbd2cSJim Jagielski }
3226*b1cdbd2cSJim Jagielski rArr.Insert( nIdx, nU );
3227*b1cdbd2cSJim Jagielski if( pInsPos )
3228*b1cdbd2cSJim Jagielski *pInsPos = nU;
3229*b1cdbd2cSJim Jagielski }
3230*b1cdbd2cSJim Jagielski
InsertSort(SvULongs & rArr,sal_uLong nIdx,sal_uInt16 * pInsPos)3231*b1cdbd2cSJim Jagielski void InsertSort( SvULongs& rArr, sal_uLong nIdx, sal_uInt16* pInsPos )
3232*b1cdbd2cSJim Jagielski {
3233*b1cdbd2cSJim Jagielski sal_uInt16 nO = rArr.Count(), nM, nU = 0;
3234*b1cdbd2cSJim Jagielski if( nO > 0 )
3235*b1cdbd2cSJim Jagielski {
3236*b1cdbd2cSJim Jagielski nO--;
3237*b1cdbd2cSJim Jagielski while( nU <= nO )
3238*b1cdbd2cSJim Jagielski {
3239*b1cdbd2cSJim Jagielski nM = nU + ( nO - nU ) / 2;
3240*b1cdbd2cSJim Jagielski if( *(rArr.GetData() + nM) == nIdx )
3241*b1cdbd2cSJim Jagielski {
3242*b1cdbd2cSJim Jagielski ASSERT( sal_False, "Index ist schon vorhanden, darf nie sein!" );
3243*b1cdbd2cSJim Jagielski return;
3244*b1cdbd2cSJim Jagielski }
3245*b1cdbd2cSJim Jagielski if( *(rArr.GetData() + nM) < nIdx )
3246*b1cdbd2cSJim Jagielski nU = nM + 1;
3247*b1cdbd2cSJim Jagielski else if( nM == 0 )
3248*b1cdbd2cSJim Jagielski break;
3249*b1cdbd2cSJim Jagielski else
3250*b1cdbd2cSJim Jagielski nO = nM - 1;
3251*b1cdbd2cSJim Jagielski }
3252*b1cdbd2cSJim Jagielski }
3253*b1cdbd2cSJim Jagielski rArr.Insert( nIdx, nU );
3254*b1cdbd2cSJim Jagielski if( pInsPos )
3255*b1cdbd2cSJim Jagielski *pInsPos = nU;
3256*b1cdbd2cSJim Jagielski }
3257*b1cdbd2cSJim Jagielski
3258*b1cdbd2cSJim Jagielski #if defined( JP_DEBUG ) && defined(DBG_UTIL)
3259*b1cdbd2cSJim Jagielski
3260*b1cdbd2cSJim Jagielski
DumpDoc(SwDoc * pDoc,const String & rFileNm)3261*b1cdbd2cSJim Jagielski void DumpDoc( SwDoc* pDoc, const String& rFileNm )
3262*b1cdbd2cSJim Jagielski {
3263*b1cdbd2cSJim Jagielski Writer* pWrt = SwIoSystem::GetWriter( "DEBUG" );
3264*b1cdbd2cSJim Jagielski if( pWrt )
3265*b1cdbd2cSJim Jagielski {
3266*b1cdbd2cSJim Jagielski SvFileStream aStream( rFileNm, STREAM_STD_WRITE );
3267*b1cdbd2cSJim Jagielski SwPaM* pPam = new SwPaM( pDoc, SwPosition( pDoc->GetNodes().EndOfContent ,
3268*b1cdbd2cSJim Jagielski pDoc->GetNodes().EndOfContent ));
3269*b1cdbd2cSJim Jagielski pPam->Move( fnMoveBackward, fnGoDoc );
3270*b1cdbd2cSJim Jagielski pPam->SetMark();
3271*b1cdbd2cSJim Jagielski pPam->Move( fnMoveForward, fnGoDoc );
3272*b1cdbd2cSJim Jagielski
3273*b1cdbd2cSJim Jagielski pWrt->Write( pPam, *pDoc, aStream, rFileNm.GetStr() );
3274*b1cdbd2cSJim Jagielski
3275*b1cdbd2cSJim Jagielski delete pPam;
3276*b1cdbd2cSJim Jagielski }
3277*b1cdbd2cSJim Jagielski }
CheckTable(const SwTable & rTbl)3278*b1cdbd2cSJim Jagielski void CheckTable( const SwTable& rTbl )
3279*b1cdbd2cSJim Jagielski {
3280*b1cdbd2cSJim Jagielski const SwNodes& rNds = rTbl.GetFrmFmt()->GetDoc()->GetNodes();
3281*b1cdbd2cSJim Jagielski const SwTableSortBoxes& rSrtArr = pTblNd->GetTable().GetTabSortBoxes();
3282*b1cdbd2cSJim Jagielski for( sal_uInt16 n = 0; n < rSrtArr.Count(); ++n )
3283*b1cdbd2cSJim Jagielski {
3284*b1cdbd2cSJim Jagielski const SwTableBox* pBox = rSrtArr[ n ];
3285*b1cdbd2cSJim Jagielski const SwNode* pNd = pBox->GetSttNd();
3286*b1cdbd2cSJim Jagielski ASSERT( rNds[ *pBox->GetSttIdx() ] == pNd, "Box mit falchem StartNode" );
3287*b1cdbd2cSJim Jagielski }
3288*b1cdbd2cSJim Jagielski }
3289*b1cdbd2cSJim Jagielski #endif
3290*b1cdbd2cSJim Jagielski
3291*b1cdbd2cSJim Jagielski
3292