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
25*b1cdbd2cSJim Jagielski // MARKER(update_precomp.py): autogen include statement, do not remove
26*b1cdbd2cSJim Jagielski #include "precompiled_sw.hxx"
27*b1cdbd2cSJim Jagielski
28*b1cdbd2cSJim Jagielski #include <com/sun/star/chart2/XChartDocument.hpp>
29*b1cdbd2cSJim Jagielski #include <hintids.hxx>
30*b1cdbd2cSJim Jagielski #include <editeng/lrspitem.hxx>
31*b1cdbd2cSJim Jagielski #include <editeng/brkitem.hxx>
32*b1cdbd2cSJim Jagielski #include <editeng/protitem.hxx>
33*b1cdbd2cSJim Jagielski #include <editeng/boxitem.hxx>
34*b1cdbd2cSJim Jagielski #include <editeng/shaditem.hxx>
35*b1cdbd2cSJim Jagielski #include <fmtfsize.hxx>
36*b1cdbd2cSJim Jagielski #include <fmtornt.hxx>
37*b1cdbd2cSJim Jagielski #include <fmtfordr.hxx>
38*b1cdbd2cSJim Jagielski #include <fmtpdsc.hxx>
39*b1cdbd2cSJim Jagielski #include <fmtanchr.hxx>
40*b1cdbd2cSJim Jagielski #include <fmtlsplt.hxx>
41*b1cdbd2cSJim Jagielski #include <frmatr.hxx>
42*b1cdbd2cSJim Jagielski #include <charatr.hxx>
43*b1cdbd2cSJim Jagielski #include <cellfrm.hxx>
44*b1cdbd2cSJim Jagielski #include <pagefrm.hxx>
45*b1cdbd2cSJim Jagielski #include <tabcol.hxx>
46*b1cdbd2cSJim Jagielski #include <doc.hxx>
47*b1cdbd2cSJim Jagielski #include <IDocumentUndoRedo.hxx>
48*b1cdbd2cSJim Jagielski #include <UndoManager.hxx>
49*b1cdbd2cSJim Jagielski #include <cntfrm.hxx>
50*b1cdbd2cSJim Jagielski #include <pam.hxx>
51*b1cdbd2cSJim Jagielski #include <swcrsr.hxx>
52*b1cdbd2cSJim Jagielski #include <viscrs.hxx>
53*b1cdbd2cSJim Jagielski #include <swtable.hxx>
54*b1cdbd2cSJim Jagielski #include <ndtxt.hxx>
55*b1cdbd2cSJim Jagielski #include <swundo.hxx>
56*b1cdbd2cSJim Jagielski #include <tblsel.hxx>
57*b1cdbd2cSJim Jagielski #include <fldbas.hxx>
58*b1cdbd2cSJim Jagielski #include <poolfmt.hxx>
59*b1cdbd2cSJim Jagielski #include <tabfrm.hxx>
60*b1cdbd2cSJim Jagielski #include <UndoCore.hxx>
61*b1cdbd2cSJim Jagielski #include <UndoRedline.hxx>
62*b1cdbd2cSJim Jagielski #include <UndoDelete.hxx>
63*b1cdbd2cSJim Jagielski #include <UndoTable.hxx>
64*b1cdbd2cSJim Jagielski #include <hints.hxx>
65*b1cdbd2cSJim Jagielski #include <tblafmt.hxx>
66*b1cdbd2cSJim Jagielski #include <swcache.hxx>
67*b1cdbd2cSJim Jagielski #include <ddefld.hxx>
68*b1cdbd2cSJim Jagielski #include <frminf.hxx>
69*b1cdbd2cSJim Jagielski #include <cellatr.hxx>
70*b1cdbd2cSJim Jagielski #include <swtblfmt.hxx>
71*b1cdbd2cSJim Jagielski #include <swddetbl.hxx>
72*b1cdbd2cSJim Jagielski #include <mvsave.hxx>
73*b1cdbd2cSJim Jagielski #include <docary.hxx>
74*b1cdbd2cSJim Jagielski #include <redline.hxx>
75*b1cdbd2cSJim Jagielski #include <rolbck.hxx>
76*b1cdbd2cSJim Jagielski #include <tblrwcl.hxx>
77*b1cdbd2cSJim Jagielski #include <editsh.hxx>
78*b1cdbd2cSJim Jagielski #include <txtfrm.hxx>
79*b1cdbd2cSJim Jagielski #include <ftnfrm.hxx>
80*b1cdbd2cSJim Jagielski #include <section.hxx>
81*b1cdbd2cSJim Jagielski #include <frmtool.hxx>
82*b1cdbd2cSJim Jagielski #include <node2lay.hxx>
83*b1cdbd2cSJim Jagielski #include <comcore.hrc>
84*b1cdbd2cSJim Jagielski #include "docsh.hxx"
85*b1cdbd2cSJim Jagielski #include <tabcol.hxx>
86*b1cdbd2cSJim Jagielski #include <unochart.hxx>
87*b1cdbd2cSJim Jagielski #include <node.hxx>
88*b1cdbd2cSJim Jagielski #include <ndtxt.hxx>
89*b1cdbd2cSJim Jagielski #include <map>
90*b1cdbd2cSJim Jagielski #include <algorithm>
91*b1cdbd2cSJim Jagielski #include <rootfrm.hxx>
92*b1cdbd2cSJim Jagielski #include <fldupde.hxx>
93*b1cdbd2cSJim Jagielski #include <switerator.hxx>
94*b1cdbd2cSJim Jagielski
95*b1cdbd2cSJim Jagielski #ifndef DBG_UTIL
96*b1cdbd2cSJim Jagielski #define CHECK_TABLE(t)
97*b1cdbd2cSJim Jagielski #else
98*b1cdbd2cSJim Jagielski #ifdef DEBUG
99*b1cdbd2cSJim Jagielski #define CHECK_TABLE(t) (t).CheckConsistency();
100*b1cdbd2cSJim Jagielski #else
101*b1cdbd2cSJim Jagielski #define CHECK_TABLE(t)
102*b1cdbd2cSJim Jagielski #endif
103*b1cdbd2cSJim Jagielski #endif
104*b1cdbd2cSJim Jagielski
105*b1cdbd2cSJim Jagielski
106*b1cdbd2cSJim Jagielski using namespace ::com::sun::star;
107*b1cdbd2cSJim Jagielski
108*b1cdbd2cSJim Jagielski // #i17764# delete table redlines when modifying the table structure?
109*b1cdbd2cSJim Jagielski // #define DEL_TABLE_REDLINES 1
110*b1cdbd2cSJim Jagielski
111*b1cdbd2cSJim Jagielski const sal_Unicode T2T_PARA = 0x0a;
112*b1cdbd2cSJim Jagielski
113*b1cdbd2cSJim Jagielski extern void ClearFEShellTabCols();
114*b1cdbd2cSJim Jagielski
115*b1cdbd2cSJim Jagielski // steht im gctable.cxx
116*b1cdbd2cSJim Jagielski extern sal_Bool lcl_GC_Line_Border( const SwTableLine*& , void* pPara );
117*b1cdbd2cSJim Jagielski
118*b1cdbd2cSJim Jagielski #ifdef DEL_TABLE_REDLINES
119*b1cdbd2cSJim Jagielski class lcl_DelRedlines
120*b1cdbd2cSJim Jagielski {
121*b1cdbd2cSJim Jagielski SwDoc* pDoc;
122*b1cdbd2cSJim Jagielski public:
123*b1cdbd2cSJim Jagielski lcl_DelRedlines( const SwTableNode& rNd, sal_Bool bCheckForOwnRedline );
124*b1cdbd2cSJim Jagielski lcl_DelRedlines( SwPaM& rPam );
125*b1cdbd2cSJim Jagielski
~lcl_DelRedlines()126*b1cdbd2cSJim Jagielski ~lcl_DelRedlines() { pDoc->EndUndo(UNDO_EMPTY, NULL); }
127*b1cdbd2cSJim Jagielski };
128*b1cdbd2cSJim Jagielski
lcl_DelRedlines(SwPaM & rPam)129*b1cdbd2cSJim Jagielski lcl_DelRedlines::lcl_DelRedlines( SwPaM & rPam) : pDoc( rPam.GetDoc() )
130*b1cdbd2cSJim Jagielski {
131*b1cdbd2cSJim Jagielski pDoc->GetIDocumentUndoRedo().StartUndo(UNDO_EMPTY, NULL);
132*b1cdbd2cSJim Jagielski if( !pDoc->IsIgnoreRedline() && pDoc->GetRedlineTbl().Count() )
133*b1cdbd2cSJim Jagielski pDoc->AcceptRedline( rPam, true );
134*b1cdbd2cSJim Jagielski }
135*b1cdbd2cSJim Jagielski #endif
136*b1cdbd2cSJim Jagielski
lcl_SetDfltBoxAttr(SwFrmFmt & rFmt,sal_uInt8 nId)137*b1cdbd2cSJim Jagielski void lcl_SetDfltBoxAttr( SwFrmFmt& rFmt, sal_uInt8 nId )
138*b1cdbd2cSJim Jagielski {
139*b1cdbd2cSJim Jagielski sal_Bool bTop = sal_False, bBottom = sal_False, bLeft = sal_False, bRight = sal_False;
140*b1cdbd2cSJim Jagielski switch ( nId )
141*b1cdbd2cSJim Jagielski {
142*b1cdbd2cSJim Jagielski case 0: bTop = bBottom = bLeft = sal_True; break;
143*b1cdbd2cSJim Jagielski case 1: bTop = bBottom = bLeft = bRight = sal_True; break;
144*b1cdbd2cSJim Jagielski case 2: bBottom = bLeft = sal_True; break;
145*b1cdbd2cSJim Jagielski case 3: bBottom = bLeft = bRight = sal_True; break;
146*b1cdbd2cSJim Jagielski }
147*b1cdbd2cSJim Jagielski
148*b1cdbd2cSJim Jagielski const sal_Bool bHTML = rFmt.getIDocumentSettingAccess()->get(IDocumentSettingAccess::HTML_MODE);
149*b1cdbd2cSJim Jagielski Color aCol( bHTML ? COL_GRAY : COL_BLACK );
150*b1cdbd2cSJim Jagielski SvxBorderLine aLine( &aCol, DEF_LINE_WIDTH_0 );
151*b1cdbd2cSJim Jagielski if ( bHTML )
152*b1cdbd2cSJim Jagielski {
153*b1cdbd2cSJim Jagielski aLine.SetOutWidth( DEF_DOUBLE_LINE7_OUT );
154*b1cdbd2cSJim Jagielski aLine.SetInWidth ( DEF_DOUBLE_LINE7_IN );
155*b1cdbd2cSJim Jagielski aLine.SetDistance( DEF_DOUBLE_LINE7_DIST);
156*b1cdbd2cSJim Jagielski }
157*b1cdbd2cSJim Jagielski SvxBoxItem aBox(RES_BOX); aBox.SetDistance( 55 );
158*b1cdbd2cSJim Jagielski if ( bTop )
159*b1cdbd2cSJim Jagielski aBox.SetLine( &aLine, BOX_LINE_TOP );
160*b1cdbd2cSJim Jagielski if ( bBottom )
161*b1cdbd2cSJim Jagielski aBox.SetLine( &aLine, BOX_LINE_BOTTOM );
162*b1cdbd2cSJim Jagielski if ( bLeft )
163*b1cdbd2cSJim Jagielski aBox.SetLine( &aLine, BOX_LINE_LEFT );
164*b1cdbd2cSJim Jagielski if ( bRight )
165*b1cdbd2cSJim Jagielski aBox.SetLine( &aLine, BOX_LINE_RIGHT );
166*b1cdbd2cSJim Jagielski rFmt.SetFmtAttr( aBox );
167*b1cdbd2cSJim Jagielski }
168*b1cdbd2cSJim Jagielski
lcl_SetDfltBoxAttr(SwTableBox & rBox,SvPtrarr & rBoxFmtArr,sal_uInt8 nId,const SwTableAutoFmt * pAutoFmt=0)169*b1cdbd2cSJim Jagielski void lcl_SetDfltBoxAttr( SwTableBox& rBox, SvPtrarr &rBoxFmtArr, sal_uInt8 nId,
170*b1cdbd2cSJim Jagielski const SwTableAutoFmt* pAutoFmt = 0 )
171*b1cdbd2cSJim Jagielski {
172*b1cdbd2cSJim Jagielski SvPtrarr* pArr = (SvPtrarr*)rBoxFmtArr[ nId ];
173*b1cdbd2cSJim Jagielski if( !pArr )
174*b1cdbd2cSJim Jagielski {
175*b1cdbd2cSJim Jagielski pArr = new SvPtrarr;
176*b1cdbd2cSJim Jagielski rBoxFmtArr.Replace( pArr, nId );
177*b1cdbd2cSJim Jagielski }
178*b1cdbd2cSJim Jagielski
179*b1cdbd2cSJim Jagielski SwTableBoxFmt* pNewBoxFmt = 0;
180*b1cdbd2cSJim Jagielski SwFrmFmt* pBoxFmt = rBox.GetFrmFmt();
181*b1cdbd2cSJim Jagielski for( sal_uInt16 n = 0; n < pArr->Count(); n += 2 )
182*b1cdbd2cSJim Jagielski if( pArr->GetObject( n ) == pBoxFmt )
183*b1cdbd2cSJim Jagielski {
184*b1cdbd2cSJim Jagielski pNewBoxFmt = (SwTableBoxFmt*)pArr->GetObject( n + 1 );
185*b1cdbd2cSJim Jagielski break;
186*b1cdbd2cSJim Jagielski }
187*b1cdbd2cSJim Jagielski
188*b1cdbd2cSJim Jagielski if( !pNewBoxFmt )
189*b1cdbd2cSJim Jagielski {
190*b1cdbd2cSJim Jagielski SwDoc* pDoc = pBoxFmt->GetDoc();
191*b1cdbd2cSJim Jagielski // das Format ist also nicht vorhanden, also neu erzeugen
192*b1cdbd2cSJim Jagielski pNewBoxFmt = pDoc->MakeTableBoxFmt();
193*b1cdbd2cSJim Jagielski pNewBoxFmt->SetFmtAttr( pBoxFmt->GetAttrSet().Get( RES_FRM_SIZE ) );
194*b1cdbd2cSJim Jagielski
195*b1cdbd2cSJim Jagielski if( pAutoFmt )
196*b1cdbd2cSJim Jagielski pAutoFmt->UpdateToSet( nId, (SfxItemSet&)pNewBoxFmt->GetAttrSet(),
197*b1cdbd2cSJim Jagielski SwTableAutoFmt::UPDATE_BOX,
198*b1cdbd2cSJim Jagielski pDoc->GetNumberFormatter( sal_True ) );
199*b1cdbd2cSJim Jagielski else
200*b1cdbd2cSJim Jagielski ::lcl_SetDfltBoxAttr( *pNewBoxFmt, nId );
201*b1cdbd2cSJim Jagielski
202*b1cdbd2cSJim Jagielski void* p = pBoxFmt;
203*b1cdbd2cSJim Jagielski pArr->Insert( p, pArr->Count() );
204*b1cdbd2cSJim Jagielski p = pNewBoxFmt;
205*b1cdbd2cSJim Jagielski pArr->Insert( p, pArr->Count() );
206*b1cdbd2cSJim Jagielski }
207*b1cdbd2cSJim Jagielski rBox.ChgFrmFmt( pNewBoxFmt );
208*b1cdbd2cSJim Jagielski }
209*b1cdbd2cSJim Jagielski
lcl_CreateDfltBoxFmt(SwDoc & rDoc,SvPtrarr & rBoxFmtArr,sal_uInt16 nCols,sal_uInt8 nId)210*b1cdbd2cSJim Jagielski SwTableBoxFmt *lcl_CreateDfltBoxFmt( SwDoc &rDoc, SvPtrarr &rBoxFmtArr,
211*b1cdbd2cSJim Jagielski sal_uInt16 nCols, sal_uInt8 nId )
212*b1cdbd2cSJim Jagielski {
213*b1cdbd2cSJim Jagielski if ( !rBoxFmtArr[nId] )
214*b1cdbd2cSJim Jagielski {
215*b1cdbd2cSJim Jagielski SwTableBoxFmt* pBoxFmt = rDoc.MakeTableBoxFmt();
216*b1cdbd2cSJim Jagielski if( USHRT_MAX != nCols )
217*b1cdbd2cSJim Jagielski pBoxFmt->SetFmtAttr( SwFmtFrmSize( ATT_VAR_SIZE,
218*b1cdbd2cSJim Jagielski USHRT_MAX / nCols, 0 ));
219*b1cdbd2cSJim Jagielski ::lcl_SetDfltBoxAttr( *pBoxFmt, nId );
220*b1cdbd2cSJim Jagielski rBoxFmtArr.Replace( pBoxFmt, nId );
221*b1cdbd2cSJim Jagielski }
222*b1cdbd2cSJim Jagielski return (SwTableBoxFmt*)rBoxFmtArr[nId];
223*b1cdbd2cSJim Jagielski }
224*b1cdbd2cSJim Jagielski
lcl_CreateAFmtBoxFmt(SwDoc & rDoc,SvPtrarr & rBoxFmtArr,const SwTableAutoFmt & rAutoFmt,sal_uInt16 nCols,sal_uInt8 nId)225*b1cdbd2cSJim Jagielski SwTableBoxFmt *lcl_CreateAFmtBoxFmt( SwDoc &rDoc, SvPtrarr &rBoxFmtArr,
226*b1cdbd2cSJim Jagielski const SwTableAutoFmt& rAutoFmt,
227*b1cdbd2cSJim Jagielski sal_uInt16 nCols, sal_uInt8 nId )
228*b1cdbd2cSJim Jagielski {
229*b1cdbd2cSJim Jagielski if( !rBoxFmtArr[nId] )
230*b1cdbd2cSJim Jagielski {
231*b1cdbd2cSJim Jagielski SwTableBoxFmt* pBoxFmt = rDoc.MakeTableBoxFmt();
232*b1cdbd2cSJim Jagielski rAutoFmt.UpdateToSet( nId, (SfxItemSet&)pBoxFmt->GetAttrSet(),
233*b1cdbd2cSJim Jagielski SwTableAutoFmt::UPDATE_BOX,
234*b1cdbd2cSJim Jagielski rDoc.GetNumberFormatter( sal_True ) );
235*b1cdbd2cSJim Jagielski if( USHRT_MAX != nCols )
236*b1cdbd2cSJim Jagielski pBoxFmt->SetFmtAttr( SwFmtFrmSize( ATT_VAR_SIZE,
237*b1cdbd2cSJim Jagielski USHRT_MAX / nCols, 0 ));
238*b1cdbd2cSJim Jagielski rBoxFmtArr.Replace( pBoxFmt, nId );
239*b1cdbd2cSJim Jagielski }
240*b1cdbd2cSJim Jagielski return (SwTableBoxFmt*)rBoxFmtArr[nId];
241*b1cdbd2cSJim Jagielski }
242*b1cdbd2cSJim Jagielski
IsIdxInTbl(const SwNodeIndex & rIdx)243*b1cdbd2cSJim Jagielski SwTableNode* SwDoc::IsIdxInTbl(const SwNodeIndex& rIdx)
244*b1cdbd2cSJim Jagielski {
245*b1cdbd2cSJim Jagielski SwTableNode* pTableNd = 0;
246*b1cdbd2cSJim Jagielski sal_uLong nIndex = rIdx.GetIndex();
247*b1cdbd2cSJim Jagielski do {
248*b1cdbd2cSJim Jagielski SwNode* pNd = (SwNode*)GetNodes()[ nIndex ]->StartOfSectionNode();
249*b1cdbd2cSJim Jagielski if( 0 != ( pTableNd = pNd->GetTableNode() ) )
250*b1cdbd2cSJim Jagielski break;
251*b1cdbd2cSJim Jagielski
252*b1cdbd2cSJim Jagielski nIndex = pNd->GetIndex();
253*b1cdbd2cSJim Jagielski } while ( nIndex );
254*b1cdbd2cSJim Jagielski return pTableNd;
255*b1cdbd2cSJim Jagielski }
256*b1cdbd2cSJim Jagielski
257*b1cdbd2cSJim Jagielski
258*b1cdbd2cSJim Jagielski // --------------- einfuegen einer neuen Box --------------
259*b1cdbd2cSJim Jagielski
260*b1cdbd2cSJim Jagielski // fuege in der Line, vor der InsPos eine neue Box ein.
261*b1cdbd2cSJim Jagielski
InsBoxen(SwTableNode * pTblNd,SwTableLine * pLine,SwTableBoxFmt * pBoxFmt,SwTxtFmtColl * pTxtColl,const SfxItemSet * pAutoAttr,sal_uInt16 nInsPos,sal_uInt16 nCnt)262*b1cdbd2cSJim Jagielski sal_Bool SwNodes::InsBoxen( SwTableNode* pTblNd,
263*b1cdbd2cSJim Jagielski SwTableLine* pLine,
264*b1cdbd2cSJim Jagielski SwTableBoxFmt* pBoxFmt,
265*b1cdbd2cSJim Jagielski SwTxtFmtColl* pTxtColl,
266*b1cdbd2cSJim Jagielski const SfxItemSet* pAutoAttr,
267*b1cdbd2cSJim Jagielski sal_uInt16 nInsPos,
268*b1cdbd2cSJim Jagielski sal_uInt16 nCnt )
269*b1cdbd2cSJim Jagielski {
270*b1cdbd2cSJim Jagielski if( !nCnt )
271*b1cdbd2cSJim Jagielski return sal_False;
272*b1cdbd2cSJim Jagielski ASSERT( pLine, "keine gueltige Zeile" );
273*b1cdbd2cSJim Jagielski
274*b1cdbd2cSJim Jagielski // Index hinter die letzte Box der Line
275*b1cdbd2cSJim Jagielski sal_uLong nIdxPos = 0;
276*b1cdbd2cSJim Jagielski SwTableBox *pPrvBox = 0, *pNxtBox = 0;
277*b1cdbd2cSJim Jagielski if( pLine->GetTabBoxes().Count() )
278*b1cdbd2cSJim Jagielski {
279*b1cdbd2cSJim Jagielski if( nInsPos < pLine->GetTabBoxes().Count() )
280*b1cdbd2cSJim Jagielski {
281*b1cdbd2cSJim Jagielski if( 0 == (pPrvBox = pLine->FindPreviousBox( pTblNd->GetTable(),
282*b1cdbd2cSJim Jagielski pLine->GetTabBoxes()[ nInsPos ] )))
283*b1cdbd2cSJim Jagielski pPrvBox = pLine->FindPreviousBox( pTblNd->GetTable() );
284*b1cdbd2cSJim Jagielski }
285*b1cdbd2cSJim Jagielski else if( 0 == ( pNxtBox = pLine->FindNextBox( pTblNd->GetTable(),
286*b1cdbd2cSJim Jagielski pLine->GetTabBoxes()[ nInsPos-1 ] )))
287*b1cdbd2cSJim Jagielski pNxtBox = pLine->FindNextBox( pTblNd->GetTable() );
288*b1cdbd2cSJim Jagielski }
289*b1cdbd2cSJim Jagielski else if( 0 == ( pNxtBox = pLine->FindNextBox( pTblNd->GetTable() )))
290*b1cdbd2cSJim Jagielski pPrvBox = pLine->FindPreviousBox( pTblNd->GetTable() );
291*b1cdbd2cSJim Jagielski
292*b1cdbd2cSJim Jagielski if( !pPrvBox && !pNxtBox )
293*b1cdbd2cSJim Jagielski {
294*b1cdbd2cSJim Jagielski sal_Bool bSetIdxPos = sal_True;
295*b1cdbd2cSJim Jagielski if( pTblNd->GetTable().GetTabLines().Count() && !nInsPos )
296*b1cdbd2cSJim Jagielski {
297*b1cdbd2cSJim Jagielski const SwTableLine* pTblLn = pLine;
298*b1cdbd2cSJim Jagielski while( pTblLn->GetUpper() )
299*b1cdbd2cSJim Jagielski pTblLn = pTblLn->GetUpper()->GetUpper();
300*b1cdbd2cSJim Jagielski
301*b1cdbd2cSJim Jagielski if( pTblNd->GetTable().GetTabLines()[ 0 ] == pTblLn )
302*b1cdbd2cSJim Jagielski {
303*b1cdbd2cSJim Jagielski // also vor die erste Box der Tabelle
304*b1cdbd2cSJim Jagielski while( ( pNxtBox = pLine->GetTabBoxes()[0])->GetTabLines().Count() )
305*b1cdbd2cSJim Jagielski pLine = pNxtBox->GetTabLines()[0];
306*b1cdbd2cSJim Jagielski nIdxPos = pNxtBox->GetSttIdx();
307*b1cdbd2cSJim Jagielski bSetIdxPos = sal_False;
308*b1cdbd2cSJim Jagielski }
309*b1cdbd2cSJim Jagielski }
310*b1cdbd2cSJim Jagielski if( bSetIdxPos )
311*b1cdbd2cSJim Jagielski // Tabelle ohne irgendeinen Inhalt oder am Ende, also vors Ende
312*b1cdbd2cSJim Jagielski nIdxPos = pTblNd->EndOfSectionIndex();
313*b1cdbd2cSJim Jagielski }
314*b1cdbd2cSJim Jagielski else if( pNxtBox ) // es gibt einen Nachfolger
315*b1cdbd2cSJim Jagielski nIdxPos = pNxtBox->GetSttIdx();
316*b1cdbd2cSJim Jagielski else // es gibt einen Vorgaenger
317*b1cdbd2cSJim Jagielski nIdxPos = pPrvBox->GetSttNd()->EndOfSectionIndex() + 1;
318*b1cdbd2cSJim Jagielski
319*b1cdbd2cSJim Jagielski SwNodeIndex aEndIdx( *this, nIdxPos );
320*b1cdbd2cSJim Jagielski for( sal_uInt16 n = 0; n < nCnt; ++n )
321*b1cdbd2cSJim Jagielski {
322*b1cdbd2cSJim Jagielski SwStartNode* pSttNd = new SwStartNode( aEndIdx, ND_STARTNODE,
323*b1cdbd2cSJim Jagielski SwTableBoxStartNode );
324*b1cdbd2cSJim Jagielski pSttNd->pStartOfSection = pTblNd;
325*b1cdbd2cSJim Jagielski new SwEndNode( aEndIdx, *pSttNd );
326*b1cdbd2cSJim Jagielski
327*b1cdbd2cSJim Jagielski pPrvBox = new SwTableBox( pBoxFmt, *pSttNd, pLine );
328*b1cdbd2cSJim Jagielski
329*b1cdbd2cSJim Jagielski SwTableBoxes & rTabBoxes = pLine->GetTabBoxes();
330*b1cdbd2cSJim Jagielski sal_uInt16 nRealInsPos = nInsPos + n;
331*b1cdbd2cSJim Jagielski if (nRealInsPos > rTabBoxes.Count())
332*b1cdbd2cSJim Jagielski nRealInsPos = rTabBoxes.Count();
333*b1cdbd2cSJim Jagielski
334*b1cdbd2cSJim Jagielski rTabBoxes.C40_INSERT( SwTableBox, pPrvBox, nRealInsPos );
335*b1cdbd2cSJim Jagielski
336*b1cdbd2cSJim Jagielski //if( NO_NUMBERING == pTxtColl->GetOutlineLevel()//#outline level,zhaojianwei
337*b1cdbd2cSJim Jagielski if( ! pTxtColl->IsAssignedToListLevelOfOutlineStyle()//<-end,zhaojianwei
338*b1cdbd2cSJim Jagielski //FEATURE::CONDCOLL
339*b1cdbd2cSJim Jagielski && RES_CONDTXTFMTCOLL != pTxtColl->Which()
340*b1cdbd2cSJim Jagielski //FEATURE::CONDCOLL
341*b1cdbd2cSJim Jagielski )
342*b1cdbd2cSJim Jagielski new SwTxtNode( SwNodeIndex( *pSttNd->EndOfSectionNode() ),
343*b1cdbd2cSJim Jagielski pTxtColl, pAutoAttr );
344*b1cdbd2cSJim Jagielski else
345*b1cdbd2cSJim Jagielski {
346*b1cdbd2cSJim Jagielski // Outline-Numerierung richtig behandeln !!!
347*b1cdbd2cSJim Jagielski SwTxtNode* pTNd = new SwTxtNode(
348*b1cdbd2cSJim Jagielski SwNodeIndex( *pSttNd->EndOfSectionNode() ),
349*b1cdbd2cSJim Jagielski (SwTxtFmtColl*)GetDoc()->GetDfltTxtFmtColl(),
350*b1cdbd2cSJim Jagielski pAutoAttr );
351*b1cdbd2cSJim Jagielski pTNd->ChgFmtColl( pTxtColl );
352*b1cdbd2cSJim Jagielski }
353*b1cdbd2cSJim Jagielski }
354*b1cdbd2cSJim Jagielski return sal_True;
355*b1cdbd2cSJim Jagielski }
356*b1cdbd2cSJim Jagielski
357*b1cdbd2cSJim Jagielski // --------------- einfuegen einer neuen Tabelle --------------
358*b1cdbd2cSJim Jagielski
InsertTable(const SwInsertTableOptions & rInsTblOpts,const SwPosition & rPos,sal_uInt16 nRows,sal_uInt16 nCols,sal_Int16 eAdjust,const SwTableAutoFmt * pTAFmt,const SvUShorts * pColArr,sal_Bool bCalledFromShell,sal_Bool bNewModel)359*b1cdbd2cSJim Jagielski const SwTable* SwDoc::InsertTable( const SwInsertTableOptions& rInsTblOpts,
360*b1cdbd2cSJim Jagielski const SwPosition& rPos, sal_uInt16 nRows,
361*b1cdbd2cSJim Jagielski sal_uInt16 nCols, sal_Int16 eAdjust,
362*b1cdbd2cSJim Jagielski const SwTableAutoFmt* pTAFmt,
363*b1cdbd2cSJim Jagielski const SvUShorts* pColArr,
364*b1cdbd2cSJim Jagielski sal_Bool bCalledFromShell,
365*b1cdbd2cSJim Jagielski sal_Bool bNewModel )
366*b1cdbd2cSJim Jagielski {
367*b1cdbd2cSJim Jagielski ASSERT( nRows, "Tabelle ohne Zeile?" );
368*b1cdbd2cSJim Jagielski ASSERT( nCols, "Tabelle ohne Spalten?" );
369*b1cdbd2cSJim Jagielski
370*b1cdbd2cSJim Jagielski {
371*b1cdbd2cSJim Jagielski // nicht in Fussnoten kopieren !!
372*b1cdbd2cSJim Jagielski if( rPos.nNode < GetNodes().GetEndOfInserts().GetIndex() &&
373*b1cdbd2cSJim Jagielski rPos.nNode >= GetNodes().GetEndOfInserts().StartOfSectionIndex() )
374*b1cdbd2cSJim Jagielski return 0;
375*b1cdbd2cSJim Jagielski
376*b1cdbd2cSJim Jagielski // sollte das ColumnArray die falsche Anzahl haben wird es ignoriert!
377*b1cdbd2cSJim Jagielski if( pColArr &&
378*b1cdbd2cSJim Jagielski (nCols + ( text::HoriOrientation::NONE == eAdjust ? 2 : 1 )) != pColArr->Count() )
379*b1cdbd2cSJim Jagielski pColArr = 0;
380*b1cdbd2cSJim Jagielski }
381*b1cdbd2cSJim Jagielski
382*b1cdbd2cSJim Jagielski String aTblName = GetUniqueTblName();
383*b1cdbd2cSJim Jagielski
384*b1cdbd2cSJim Jagielski if( GetIDocumentUndoRedo().DoesUndo() )
385*b1cdbd2cSJim Jagielski {
386*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().AppendUndo(
387*b1cdbd2cSJim Jagielski new SwUndoInsTbl( rPos, nCols, nRows, static_cast<sal_uInt16>(eAdjust),
388*b1cdbd2cSJim Jagielski rInsTblOpts, pTAFmt, pColArr,
389*b1cdbd2cSJim Jagielski aTblName));
390*b1cdbd2cSJim Jagielski }
391*b1cdbd2cSJim Jagielski
392*b1cdbd2cSJim Jagielski // fuege erstmal die Nodes ein
393*b1cdbd2cSJim Jagielski // hole das Auto-Format fuer die Tabelle
394*b1cdbd2cSJim Jagielski SwTxtFmtColl *pBodyColl = GetTxtCollFromPool( RES_POOLCOLL_TABLE ),
395*b1cdbd2cSJim Jagielski *pHeadColl = pBodyColl;
396*b1cdbd2cSJim Jagielski
397*b1cdbd2cSJim Jagielski sal_Bool bDfltBorders = 0 != ( rInsTblOpts.mnInsMode & tabopts::DEFAULT_BORDER );
398*b1cdbd2cSJim Jagielski
399*b1cdbd2cSJim Jagielski if( (rInsTblOpts.mnInsMode & tabopts::HEADLINE) && (1 != nRows || !bDfltBorders) )
400*b1cdbd2cSJim Jagielski pHeadColl = GetTxtCollFromPool( RES_POOLCOLL_TABLE_HDLN );
401*b1cdbd2cSJim Jagielski
402*b1cdbd2cSJim Jagielski const sal_uInt16 nRowsToRepeat =
403*b1cdbd2cSJim Jagielski tabopts::HEADLINE == (rInsTblOpts.mnInsMode & tabopts::HEADLINE) ?
404*b1cdbd2cSJim Jagielski rInsTblOpts.mnRowsToRepeat :
405*b1cdbd2cSJim Jagielski 0;
406*b1cdbd2cSJim Jagielski
407*b1cdbd2cSJim Jagielski /* #106283# Save content node to extract FRAMEDIR from. */
408*b1cdbd2cSJim Jagielski const SwCntntNode * pCntntNd = rPos.nNode.GetNode().GetCntntNode();
409*b1cdbd2cSJim Jagielski
410*b1cdbd2cSJim Jagielski /* #109161# If we are called from a shell pass the attrset from
411*b1cdbd2cSJim Jagielski pCntntNd (aka the node the table is inserted at) thus causing
412*b1cdbd2cSJim Jagielski SwNodes::InsertTable to propagate an adjust item if
413*b1cdbd2cSJim Jagielski necessary. */
414*b1cdbd2cSJim Jagielski SwTableNode *pTblNd = GetNodes().InsertTable(
415*b1cdbd2cSJim Jagielski rPos.nNode,
416*b1cdbd2cSJim Jagielski nCols,
417*b1cdbd2cSJim Jagielski pBodyColl,
418*b1cdbd2cSJim Jagielski nRows,
419*b1cdbd2cSJim Jagielski nRowsToRepeat,
420*b1cdbd2cSJim Jagielski pHeadColl,
421*b1cdbd2cSJim Jagielski bCalledFromShell ? &pCntntNd->GetSwAttrSet() : 0 );
422*b1cdbd2cSJim Jagielski
423*b1cdbd2cSJim Jagielski // dann erstelle die Box/Line/Table-Struktur
424*b1cdbd2cSJim Jagielski SwTableLineFmt* pLineFmt = MakeTableLineFmt();
425*b1cdbd2cSJim Jagielski SwTableFmt* pTableFmt = MakeTblFrmFmt( aTblName, GetDfltFrmFmt() );
426*b1cdbd2cSJim Jagielski
427*b1cdbd2cSJim Jagielski /* #106283# If the node to insert the table at is a context node and has a
428*b1cdbd2cSJim Jagielski non-default FRAMEDIR propagate it to the table. */
429*b1cdbd2cSJim Jagielski if (pCntntNd)
430*b1cdbd2cSJim Jagielski {
431*b1cdbd2cSJim Jagielski const SwAttrSet & aNdSet = pCntntNd->GetSwAttrSet();
432*b1cdbd2cSJim Jagielski const SfxPoolItem *pItem = NULL;
433*b1cdbd2cSJim Jagielski
434*b1cdbd2cSJim Jagielski if (SFX_ITEM_SET == aNdSet.GetItemState( RES_FRAMEDIR, sal_True, &pItem )
435*b1cdbd2cSJim Jagielski && pItem != NULL)
436*b1cdbd2cSJim Jagielski {
437*b1cdbd2cSJim Jagielski pTableFmt->SetFmtAttr( *pItem );
438*b1cdbd2cSJim Jagielski }
439*b1cdbd2cSJim Jagielski }
440*b1cdbd2cSJim Jagielski
441*b1cdbd2cSJim Jagielski //Orientation am Fmt der Table setzen
442*b1cdbd2cSJim Jagielski pTableFmt->SetFmtAttr( SwFmtHoriOrient( 0, eAdjust ) );
443*b1cdbd2cSJim Jagielski // alle Zeilen haben die Fill-Order von links nach rechts !
444*b1cdbd2cSJim Jagielski pLineFmt->SetFmtAttr( SwFmtFillOrder( ATT_LEFT_TO_RIGHT ));
445*b1cdbd2cSJim Jagielski
446*b1cdbd2cSJim Jagielski // die Tabelle bekommt USHRT_MAX als default SSize
447*b1cdbd2cSJim Jagielski SwTwips nWidth = USHRT_MAX;
448*b1cdbd2cSJim Jagielski if( pColArr )
449*b1cdbd2cSJim Jagielski {
450*b1cdbd2cSJim Jagielski sal_uInt16 nSttPos = (*pColArr)[ 0 ];
451*b1cdbd2cSJim Jagielski sal_uInt16 nLastPos = (*pColArr)[ sal_uInt16(pColArr->Count()-1)];
452*b1cdbd2cSJim Jagielski if( text::HoriOrientation::NONE == eAdjust )
453*b1cdbd2cSJim Jagielski {
454*b1cdbd2cSJim Jagielski sal_uInt16 nFrmWidth = nLastPos;
455*b1cdbd2cSJim Jagielski nLastPos = (*pColArr)[ sal_uInt16(pColArr->Count()-2)];
456*b1cdbd2cSJim Jagielski pTableFmt->SetFmtAttr( SvxLRSpaceItem( nSttPos, nFrmWidth - nLastPos, 0, 0, RES_LR_SPACE ) );
457*b1cdbd2cSJim Jagielski }
458*b1cdbd2cSJim Jagielski nWidth = nLastPos - nSttPos;
459*b1cdbd2cSJim Jagielski }
460*b1cdbd2cSJim Jagielski else if( nCols )
461*b1cdbd2cSJim Jagielski {
462*b1cdbd2cSJim Jagielski nWidth /= nCols;
463*b1cdbd2cSJim Jagielski nWidth *= nCols; // to avoid rounding problems
464*b1cdbd2cSJim Jagielski }
465*b1cdbd2cSJim Jagielski pTableFmt->SetFmtAttr( SwFmtFrmSize( ATT_VAR_SIZE, nWidth ));
466*b1cdbd2cSJim Jagielski if( !(rInsTblOpts.mnInsMode & tabopts::SPLIT_LAYOUT) )
467*b1cdbd2cSJim Jagielski pTableFmt->SetFmtAttr( SwFmtLayoutSplit( sal_False ));
468*b1cdbd2cSJim Jagielski
469*b1cdbd2cSJim Jagielski // verschiebe ggfs. die harten PageDesc/PageBreak Attribute:
470*b1cdbd2cSJim Jagielski SwCntntNode* pNextNd = GetNodes()[ pTblNd->EndOfSectionIndex()+1 ]
471*b1cdbd2cSJim Jagielski ->GetCntntNode();
472*b1cdbd2cSJim Jagielski if( pNextNd && pNextNd->HasSwAttrSet() )
473*b1cdbd2cSJim Jagielski {
474*b1cdbd2cSJim Jagielski const SfxItemSet* pNdSet = pNextNd->GetpSwAttrSet();
475*b1cdbd2cSJim Jagielski const SfxPoolItem *pItem;
476*b1cdbd2cSJim Jagielski if( SFX_ITEM_SET == pNdSet->GetItemState( RES_PAGEDESC, sal_False,
477*b1cdbd2cSJim Jagielski &pItem ) )
478*b1cdbd2cSJim Jagielski {
479*b1cdbd2cSJim Jagielski pTableFmt->SetFmtAttr( *pItem );
480*b1cdbd2cSJim Jagielski pNextNd->ResetAttr( RES_PAGEDESC );
481*b1cdbd2cSJim Jagielski pNdSet = pNextNd->GetpSwAttrSet();
482*b1cdbd2cSJim Jagielski }
483*b1cdbd2cSJim Jagielski if( pNdSet && SFX_ITEM_SET == pNdSet->GetItemState( RES_BREAK, sal_False,
484*b1cdbd2cSJim Jagielski &pItem ) )
485*b1cdbd2cSJim Jagielski {
486*b1cdbd2cSJim Jagielski pTableFmt->SetFmtAttr( *pItem );
487*b1cdbd2cSJim Jagielski pNextNd->ResetAttr( RES_BREAK );
488*b1cdbd2cSJim Jagielski }
489*b1cdbd2cSJim Jagielski }
490*b1cdbd2cSJim Jagielski
491*b1cdbd2cSJim Jagielski SwTable * pNdTbl = &pTblNd->GetTable();
492*b1cdbd2cSJim Jagielski pNdTbl->RegisterToFormat( *pTableFmt );
493*b1cdbd2cSJim Jagielski
494*b1cdbd2cSJim Jagielski pNdTbl->SetRowsToRepeat( nRowsToRepeat );
495*b1cdbd2cSJim Jagielski pNdTbl->SetTableModel( bNewModel );
496*b1cdbd2cSJim Jagielski
497*b1cdbd2cSJim Jagielski SvPtrarr aBoxFmtArr( 0, 16 );
498*b1cdbd2cSJim Jagielski SwTableBoxFmt* pBoxFmt = 0;
499*b1cdbd2cSJim Jagielski if( !bDfltBorders && !pTAFmt )
500*b1cdbd2cSJim Jagielski {
501*b1cdbd2cSJim Jagielski pBoxFmt = MakeTableBoxFmt();
502*b1cdbd2cSJim Jagielski pBoxFmt->SetFmtAttr( SwFmtFrmSize( ATT_VAR_SIZE, USHRT_MAX / nCols, 0 ));
503*b1cdbd2cSJim Jagielski }
504*b1cdbd2cSJim Jagielski else
505*b1cdbd2cSJim Jagielski {
506*b1cdbd2cSJim Jagielski const sal_uInt16 nBoxArrLen = pTAFmt ? 16 : 4;
507*b1cdbd2cSJim Jagielski for( sal_uInt16 i = 0; i < nBoxArrLen; ++i )
508*b1cdbd2cSJim Jagielski aBoxFmtArr.Insert( (void*)0, i );
509*b1cdbd2cSJim Jagielski }
510*b1cdbd2cSJim Jagielski // --> OD 2008-02-25 #refactorlists#
511*b1cdbd2cSJim Jagielski // SfxItemSet aCharSet( GetAttrPool(), RES_CHRATR_BEGIN, RES_PARATR_END-1 );
512*b1cdbd2cSJim Jagielski SfxItemSet aCharSet( GetAttrPool(), RES_CHRATR_BEGIN, RES_PARATR_LIST_END-1 );
513*b1cdbd2cSJim Jagielski // <--
514*b1cdbd2cSJim Jagielski
515*b1cdbd2cSJim Jagielski SwNodeIndex aNdIdx( *pTblNd, 1 ); // auf den ersten Box-StartNode
516*b1cdbd2cSJim Jagielski SwTableLines& rLines = pNdTbl->GetTabLines();
517*b1cdbd2cSJim Jagielski for( sal_uInt16 n = 0; n < nRows; ++n )
518*b1cdbd2cSJim Jagielski {
519*b1cdbd2cSJim Jagielski SwTableLine* pLine = new SwTableLine( pLineFmt, nCols, 0 );
520*b1cdbd2cSJim Jagielski rLines.C40_INSERT( SwTableLine, pLine, n );
521*b1cdbd2cSJim Jagielski SwTableBoxes& rBoxes = pLine->GetTabBoxes();
522*b1cdbd2cSJim Jagielski for( sal_uInt16 i = 0; i < nCols; ++i )
523*b1cdbd2cSJim Jagielski {
524*b1cdbd2cSJim Jagielski SwTableBoxFmt *pBoxF;
525*b1cdbd2cSJim Jagielski if( pTAFmt )
526*b1cdbd2cSJim Jagielski {
527*b1cdbd2cSJim Jagielski sal_uInt8 nId = static_cast<sal_uInt8>(!n ? 0 : (( n+1 == nRows )
528*b1cdbd2cSJim Jagielski ? 12 : (4 * (1 + ((n-1) & 1 )))));
529*b1cdbd2cSJim Jagielski nId = nId + static_cast<sal_uInt8>( !i ? 0 :
530*b1cdbd2cSJim Jagielski ( i+1 == nCols ? 3 : (1 + ((i-1) & 1))));
531*b1cdbd2cSJim Jagielski pBoxF = ::lcl_CreateAFmtBoxFmt( *this, aBoxFmtArr, *pTAFmt,
532*b1cdbd2cSJim Jagielski nCols, nId );
533*b1cdbd2cSJim Jagielski
534*b1cdbd2cSJim Jagielski // ggfs. noch die Absatz/ZeichenAttribute setzen
535*b1cdbd2cSJim Jagielski if( pTAFmt->IsFont() || pTAFmt->IsJustify() )
536*b1cdbd2cSJim Jagielski {
537*b1cdbd2cSJim Jagielski aCharSet.ClearItem();
538*b1cdbd2cSJim Jagielski pTAFmt->UpdateToSet( nId, aCharSet,
539*b1cdbd2cSJim Jagielski SwTableAutoFmt::UPDATE_CHAR, 0 );
540*b1cdbd2cSJim Jagielski if( aCharSet.Count() )
541*b1cdbd2cSJim Jagielski GetNodes()[ aNdIdx.GetIndex()+1 ]->GetCntntNode()->
542*b1cdbd2cSJim Jagielski SetAttr( aCharSet );
543*b1cdbd2cSJim Jagielski }
544*b1cdbd2cSJim Jagielski }
545*b1cdbd2cSJim Jagielski else if( bDfltBorders )
546*b1cdbd2cSJim Jagielski {
547*b1cdbd2cSJim Jagielski sal_uInt8 nBoxId = (i < nCols - 1 ? 0 : 1) + (n ? 2 : 0 );
548*b1cdbd2cSJim Jagielski pBoxF = ::lcl_CreateDfltBoxFmt( *this, aBoxFmtArr, nCols, nBoxId);
549*b1cdbd2cSJim Jagielski }
550*b1cdbd2cSJim Jagielski else
551*b1cdbd2cSJim Jagielski pBoxF = pBoxFmt;
552*b1cdbd2cSJim Jagielski
553*b1cdbd2cSJim Jagielski // fuer AutoFormat bei der Eingabe: beim Einfuegen der Tabelle
554*b1cdbd2cSJim Jagielski // werden gleich die Spalten gesetzt. Im Array stehen die
555*b1cdbd2cSJim Jagielski // Positionen der Spalten!! (nicht deren Breite!)
556*b1cdbd2cSJim Jagielski if( pColArr )
557*b1cdbd2cSJim Jagielski {
558*b1cdbd2cSJim Jagielski nWidth = (*pColArr)[ sal_uInt16(i + 1) ] - (*pColArr)[ i ];
559*b1cdbd2cSJim Jagielski if( pBoxF->GetFrmSize().GetWidth() != nWidth )
560*b1cdbd2cSJim Jagielski {
561*b1cdbd2cSJim Jagielski if( pBoxF->GetDepends() ) // neues Format erzeugen!
562*b1cdbd2cSJim Jagielski {
563*b1cdbd2cSJim Jagielski SwTableBoxFmt *pNewFmt = MakeTableBoxFmt();
564*b1cdbd2cSJim Jagielski *pNewFmt = *pBoxF;
565*b1cdbd2cSJim Jagielski pBoxF = pNewFmt;
566*b1cdbd2cSJim Jagielski }
567*b1cdbd2cSJim Jagielski pBoxF->SetFmtAttr( SwFmtFrmSize( ATT_VAR_SIZE, nWidth ));
568*b1cdbd2cSJim Jagielski }
569*b1cdbd2cSJim Jagielski }
570*b1cdbd2cSJim Jagielski
571*b1cdbd2cSJim Jagielski SwTableBox *pBox = new SwTableBox( pBoxF, aNdIdx, pLine);
572*b1cdbd2cSJim Jagielski rBoxes.C40_INSERT( SwTableBox, pBox, i );
573*b1cdbd2cSJim Jagielski aNdIdx += 3; // StartNode, TextNode, EndNode == 3 Nodes
574*b1cdbd2cSJim Jagielski }
575*b1cdbd2cSJim Jagielski }
576*b1cdbd2cSJim Jagielski // und Frms einfuegen.
577*b1cdbd2cSJim Jagielski GetNodes().GoNext( &aNdIdx ); // zum naechsten ContentNode
578*b1cdbd2cSJim Jagielski pTblNd->MakeFrms( &aNdIdx );
579*b1cdbd2cSJim Jagielski
580*b1cdbd2cSJim Jagielski if( IsRedlineOn() || (!IsIgnoreRedline() && pRedlineTbl->Count() ))
581*b1cdbd2cSJim Jagielski {
582*b1cdbd2cSJim Jagielski SwPaM aPam( *pTblNd->EndOfSectionNode(), *pTblNd, 1 );
583*b1cdbd2cSJim Jagielski if( IsRedlineOn() )
584*b1cdbd2cSJim Jagielski AppendRedline( new SwRedline( nsRedlineType_t::REDLINE_INSERT, aPam ), true);
585*b1cdbd2cSJim Jagielski else
586*b1cdbd2cSJim Jagielski SplitRedline( aPam );
587*b1cdbd2cSJim Jagielski }
588*b1cdbd2cSJim Jagielski
589*b1cdbd2cSJim Jagielski SetModified();
590*b1cdbd2cSJim Jagielski CHECK_TABLE( *pNdTbl );
591*b1cdbd2cSJim Jagielski return pNdTbl;
592*b1cdbd2cSJim Jagielski }
593*b1cdbd2cSJim Jagielski
InsertTable(const SwNodeIndex & rNdIdx,sal_uInt16 nBoxes,SwTxtFmtColl * pCntntTxtColl,sal_uInt16 nLines,sal_uInt16 nRepeat,SwTxtFmtColl * pHeadlineTxtColl,const SwAttrSet * pAttrSet)594*b1cdbd2cSJim Jagielski SwTableNode* SwNodes::InsertTable( const SwNodeIndex& rNdIdx,
595*b1cdbd2cSJim Jagielski sal_uInt16 nBoxes,
596*b1cdbd2cSJim Jagielski SwTxtFmtColl* pCntntTxtColl,
597*b1cdbd2cSJim Jagielski sal_uInt16 nLines,
598*b1cdbd2cSJim Jagielski sal_uInt16 nRepeat,
599*b1cdbd2cSJim Jagielski SwTxtFmtColl* pHeadlineTxtColl,
600*b1cdbd2cSJim Jagielski const SwAttrSet * pAttrSet)
601*b1cdbd2cSJim Jagielski {
602*b1cdbd2cSJim Jagielski if( !nBoxes )
603*b1cdbd2cSJim Jagielski return 0;
604*b1cdbd2cSJim Jagielski
605*b1cdbd2cSJim Jagielski // wenn Lines angegeben, erzeuge die Matrix aus Lines & Boxen
606*b1cdbd2cSJim Jagielski if( !pHeadlineTxtColl || !nLines )
607*b1cdbd2cSJim Jagielski pHeadlineTxtColl = pCntntTxtColl;
608*b1cdbd2cSJim Jagielski
609*b1cdbd2cSJim Jagielski SwTableNode * pTblNd = new SwTableNode( rNdIdx );
610*b1cdbd2cSJim Jagielski SwEndNode* pEndNd = new SwEndNode( rNdIdx, *pTblNd );
611*b1cdbd2cSJim Jagielski
612*b1cdbd2cSJim Jagielski if( !nLines ) // fuer die FOR-Schleife
613*b1cdbd2cSJim Jagielski ++nLines;
614*b1cdbd2cSJim Jagielski
615*b1cdbd2cSJim Jagielski SwNodeIndex aIdx( *pEndNd );
616*b1cdbd2cSJim Jagielski SwTxtFmtColl* pTxtColl = pHeadlineTxtColl;
617*b1cdbd2cSJim Jagielski for( sal_uInt16 nL = 0; nL < nLines; ++nL )
618*b1cdbd2cSJim Jagielski {
619*b1cdbd2cSJim Jagielski for( sal_uInt16 nB = 0; nB < nBoxes; ++nB )
620*b1cdbd2cSJim Jagielski {
621*b1cdbd2cSJim Jagielski SwStartNode* pSttNd = new SwStartNode( aIdx, ND_STARTNODE,
622*b1cdbd2cSJim Jagielski SwTableBoxStartNode );
623*b1cdbd2cSJim Jagielski pSttNd->pStartOfSection = pTblNd;
624*b1cdbd2cSJim Jagielski
625*b1cdbd2cSJim Jagielski SwTxtNode * pTmpNd = new SwTxtNode( aIdx, pTxtColl );
626*b1cdbd2cSJim Jagielski
627*b1cdbd2cSJim Jagielski // --> FME 2006-04-13 #i60422# Propagate some more attributes.
628*b1cdbd2cSJim Jagielski // Adjustment was done for #109161#
629*b1cdbd2cSJim Jagielski const SfxPoolItem* pItem = NULL;
630*b1cdbd2cSJim Jagielski if ( NULL != pAttrSet )
631*b1cdbd2cSJim Jagielski {
632*b1cdbd2cSJim Jagielski static const sal_uInt16 aPropagateItems[] = {
633*b1cdbd2cSJim Jagielski RES_PARATR_ADJUST,
634*b1cdbd2cSJim Jagielski RES_CHRATR_FONT, RES_CHRATR_FONTSIZE,
635*b1cdbd2cSJim Jagielski RES_CHRATR_CJK_FONT, RES_CHRATR_CJK_FONTSIZE,
636*b1cdbd2cSJim Jagielski RES_CHRATR_CTL_FONT, RES_CHRATR_CTL_FONTSIZE, 0 };
637*b1cdbd2cSJim Jagielski
638*b1cdbd2cSJim Jagielski const sal_uInt16* pIdx = aPropagateItems;
639*b1cdbd2cSJim Jagielski while ( *pIdx != 0 )
640*b1cdbd2cSJim Jagielski {
641*b1cdbd2cSJim Jagielski if ( SFX_ITEM_SET != pTmpNd->GetSwAttrSet().GetItemState( *pIdx ) &&
642*b1cdbd2cSJim Jagielski SFX_ITEM_SET == pAttrSet->GetItemState( *pIdx, sal_True, &pItem ) )
643*b1cdbd2cSJim Jagielski static_cast<SwCntntNode *>(pTmpNd)->SetAttr(*pItem);
644*b1cdbd2cSJim Jagielski ++pIdx;
645*b1cdbd2cSJim Jagielski }
646*b1cdbd2cSJim Jagielski }
647*b1cdbd2cSJim Jagielski // <--
648*b1cdbd2cSJim Jagielski
649*b1cdbd2cSJim Jagielski new SwEndNode( aIdx, *pSttNd );
650*b1cdbd2cSJim Jagielski }
651*b1cdbd2cSJim Jagielski if ( nL + 1 >= nRepeat )
652*b1cdbd2cSJim Jagielski pTxtColl = pCntntTxtColl;
653*b1cdbd2cSJim Jagielski }
654*b1cdbd2cSJim Jagielski return pTblNd;
655*b1cdbd2cSJim Jagielski }
656*b1cdbd2cSJim Jagielski
657*b1cdbd2cSJim Jagielski
658*b1cdbd2cSJim Jagielski //---------------- Text -> Tabelle -----------------------
659*b1cdbd2cSJim Jagielski
TextToTable(const SwInsertTableOptions & rInsTblOpts,const SwPaM & rRange,sal_Unicode cCh,sal_Int16 eAdjust,const SwTableAutoFmt * pTAFmt)660*b1cdbd2cSJim Jagielski const SwTable* SwDoc::TextToTable( const SwInsertTableOptions& rInsTblOpts,
661*b1cdbd2cSJim Jagielski const SwPaM& rRange, sal_Unicode cCh,
662*b1cdbd2cSJim Jagielski sal_Int16 eAdjust,
663*b1cdbd2cSJim Jagielski const SwTableAutoFmt* pTAFmt )
664*b1cdbd2cSJim Jagielski {
665*b1cdbd2cSJim Jagielski // pruefe ob in der Selection eine Tabelle liegt
666*b1cdbd2cSJim Jagielski const SwPosition *pStt = rRange.Start(), *pEnd = rRange.End();
667*b1cdbd2cSJim Jagielski {
668*b1cdbd2cSJim Jagielski sal_uLong nCnt = pStt->nNode.GetIndex();
669*b1cdbd2cSJim Jagielski for( ; nCnt <= pEnd->nNode.GetIndex(); ++nCnt )
670*b1cdbd2cSJim Jagielski if( !GetNodes()[ nCnt ]->IsTxtNode() )
671*b1cdbd2cSJim Jagielski return 0;
672*b1cdbd2cSJim Jagielski }
673*b1cdbd2cSJim Jagielski
674*b1cdbd2cSJim Jagielski /* #106283# Save first node in the selection if it is a context node. */
675*b1cdbd2cSJim Jagielski SwCntntNode * pSttCntntNd = pStt->nNode.GetNode().GetCntntNode();
676*b1cdbd2cSJim Jagielski
677*b1cdbd2cSJim Jagielski SwPaM aOriginal( *pStt, *pEnd );
678*b1cdbd2cSJim Jagielski pStt = aOriginal.GetMark();
679*b1cdbd2cSJim Jagielski pEnd = aOriginal.GetPoint();
680*b1cdbd2cSJim Jagielski
681*b1cdbd2cSJim Jagielski #ifdef DEL_TABLE_REDLINES
682*b1cdbd2cSJim Jagielski lcl_DelRedlines aDelRedl( aOriginal );
683*b1cdbd2cSJim Jagielski #endif
684*b1cdbd2cSJim Jagielski
685*b1cdbd2cSJim Jagielski SwUndoTxtToTbl* pUndo = 0;
686*b1cdbd2cSJim Jagielski if( GetIDocumentUndoRedo().DoesUndo() )
687*b1cdbd2cSJim Jagielski {
688*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().StartUndo( UNDO_TEXTTOTABLE, NULL );
689*b1cdbd2cSJim Jagielski pUndo = new SwUndoTxtToTbl( aOriginal, rInsTblOpts, cCh,
690*b1cdbd2cSJim Jagielski static_cast<sal_uInt16>(eAdjust), pTAFmt );
691*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().AppendUndo( pUndo );
692*b1cdbd2cSJim Jagielski
693*b1cdbd2cSJim Jagielski // das Splitten vom TextNode nicht in die Undohistory aufnehmen
694*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().DoUndo( false );
695*b1cdbd2cSJim Jagielski }
696*b1cdbd2cSJim Jagielski
697*b1cdbd2cSJim Jagielski ::PaMCorrAbs( aOriginal, *pEnd );
698*b1cdbd2cSJim Jagielski
699*b1cdbd2cSJim Jagielski // sorge dafuer, das der Bereich auf Node-Grenzen liegt
700*b1cdbd2cSJim Jagielski SwNodeRange aRg( pStt->nNode, pEnd->nNode );
701*b1cdbd2cSJim Jagielski if( pStt->nContent.GetIndex() )
702*b1cdbd2cSJim Jagielski SplitNode( *pStt, false );
703*b1cdbd2cSJim Jagielski
704*b1cdbd2cSJim Jagielski sal_Bool bEndCntnt = 0 != pEnd->nContent.GetIndex();
705*b1cdbd2cSJim Jagielski // nicht splitten am Ende der Zeile (aber am Ende vom Doc!!)
706*b1cdbd2cSJim Jagielski if( bEndCntnt )
707*b1cdbd2cSJim Jagielski {
708*b1cdbd2cSJim Jagielski if( pEnd->nNode.GetNode().GetCntntNode()->Len() != pEnd->nContent.GetIndex()
709*b1cdbd2cSJim Jagielski || pEnd->nNode.GetIndex() >= GetNodes().GetEndOfContent().GetIndex()-1 )
710*b1cdbd2cSJim Jagielski {
711*b1cdbd2cSJim Jagielski SplitNode( *pEnd, false );
712*b1cdbd2cSJim Jagielski ((SwNodeIndex&)pEnd->nNode)--;
713*b1cdbd2cSJim Jagielski ((SwIndex&)pEnd->nContent).Assign(
714*b1cdbd2cSJim Jagielski pEnd->nNode.GetNode().GetCntntNode(), 0 );
715*b1cdbd2cSJim Jagielski // ein Node und am Ende ??
716*b1cdbd2cSJim Jagielski if( pStt->nNode.GetIndex() >= pEnd->nNode.GetIndex() )
717*b1cdbd2cSJim Jagielski aRg.aStart--;
718*b1cdbd2cSJim Jagielski }
719*b1cdbd2cSJim Jagielski else
720*b1cdbd2cSJim Jagielski aRg.aEnd++;
721*b1cdbd2cSJim Jagielski }
722*b1cdbd2cSJim Jagielski
723*b1cdbd2cSJim Jagielski
724*b1cdbd2cSJim Jagielski if( aRg.aEnd.GetIndex() == aRg.aStart.GetIndex() )
725*b1cdbd2cSJim Jagielski {
726*b1cdbd2cSJim Jagielski ASSERT( sal_False, "Kein Bereich" );
727*b1cdbd2cSJim Jagielski aRg.aEnd++;
728*b1cdbd2cSJim Jagielski }
729*b1cdbd2cSJim Jagielski
730*b1cdbd2cSJim Jagielski // Wir gehen jetzt immer ueber die Upper, um die Tabelle einzufuegen:
731*b1cdbd2cSJim Jagielski SwNode2Layout aNode2Layout( aRg.aStart.GetNode() );
732*b1cdbd2cSJim Jagielski
733*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().DoUndo( 0 != pUndo );
734*b1cdbd2cSJim Jagielski
735*b1cdbd2cSJim Jagielski // dann erstelle die Box/Line/Table-Struktur
736*b1cdbd2cSJim Jagielski SwTableBoxFmt* pBoxFmt = MakeTableBoxFmt();
737*b1cdbd2cSJim Jagielski SwTableLineFmt* pLineFmt = MakeTableLineFmt();
738*b1cdbd2cSJim Jagielski SwTableFmt* pTableFmt = MakeTblFrmFmt( GetUniqueTblName(), GetDfltFrmFmt() );
739*b1cdbd2cSJim Jagielski
740*b1cdbd2cSJim Jagielski // alle Zeilen haben die Fill-Order von links nach rechts !
741*b1cdbd2cSJim Jagielski pLineFmt->SetFmtAttr( SwFmtFillOrder( ATT_LEFT_TO_RIGHT ));
742*b1cdbd2cSJim Jagielski // die Tabelle bekommt USHRT_MAX als default SSize
743*b1cdbd2cSJim Jagielski pTableFmt->SetFmtAttr( SwFmtFrmSize( ATT_VAR_SIZE, USHRT_MAX ));
744*b1cdbd2cSJim Jagielski if( !(rInsTblOpts.mnInsMode & tabopts::SPLIT_LAYOUT) )
745*b1cdbd2cSJim Jagielski pTableFmt->SetFmtAttr( SwFmtLayoutSplit( sal_False ));
746*b1cdbd2cSJim Jagielski
747*b1cdbd2cSJim Jagielski /* #106283# If the first node in the selection is a context node and if it
748*b1cdbd2cSJim Jagielski has an item FRAMEDIR set (no default) propagate the item to the
749*b1cdbd2cSJim Jagielski replacing table. */
750*b1cdbd2cSJim Jagielski if (pSttCntntNd)
751*b1cdbd2cSJim Jagielski {
752*b1cdbd2cSJim Jagielski const SwAttrSet & aNdSet = pSttCntntNd->GetSwAttrSet();
753*b1cdbd2cSJim Jagielski const SfxPoolItem *pItem = NULL;
754*b1cdbd2cSJim Jagielski
755*b1cdbd2cSJim Jagielski if (SFX_ITEM_SET == aNdSet.GetItemState( RES_FRAMEDIR, sal_True, &pItem )
756*b1cdbd2cSJim Jagielski && pItem != NULL)
757*b1cdbd2cSJim Jagielski {
758*b1cdbd2cSJim Jagielski pTableFmt->SetFmtAttr( *pItem );
759*b1cdbd2cSJim Jagielski }
760*b1cdbd2cSJim Jagielski }
761*b1cdbd2cSJim Jagielski
762*b1cdbd2cSJim Jagielski SwTableNode* pTblNd = GetNodes().TextToTable(
763*b1cdbd2cSJim Jagielski aRg, cCh, pTableFmt, pLineFmt, pBoxFmt,
764*b1cdbd2cSJim Jagielski GetTxtCollFromPool( RES_POOLCOLL_STANDARD ), pUndo );
765*b1cdbd2cSJim Jagielski
766*b1cdbd2cSJim Jagielski SwTable * pNdTbl = &pTblNd->GetTable();
767*b1cdbd2cSJim Jagielski ASSERT( pNdTbl, "kein Tabellen-Node angelegt." )
768*b1cdbd2cSJim Jagielski
769*b1cdbd2cSJim Jagielski const sal_uInt16 nRowsToRepeat =
770*b1cdbd2cSJim Jagielski tabopts::HEADLINE == (rInsTblOpts.mnInsMode & tabopts::HEADLINE) ?
771*b1cdbd2cSJim Jagielski rInsTblOpts.mnRowsToRepeat :
772*b1cdbd2cSJim Jagielski 0;
773*b1cdbd2cSJim Jagielski pNdTbl->SetRowsToRepeat( nRowsToRepeat );
774*b1cdbd2cSJim Jagielski
775*b1cdbd2cSJim Jagielski sal_Bool bUseBoxFmt = sal_False;
776*b1cdbd2cSJim Jagielski if( !pBoxFmt->GetDepends() )
777*b1cdbd2cSJim Jagielski {
778*b1cdbd2cSJim Jagielski // die Formate an den Boxen haben schon die richtige Size, es darf
779*b1cdbd2cSJim Jagielski // also nur noch die richtige Umrandung/AutoFmt gesetzt werden.
780*b1cdbd2cSJim Jagielski bUseBoxFmt = sal_True;
781*b1cdbd2cSJim Jagielski pTableFmt->SetFmtAttr( pBoxFmt->GetFrmSize() );
782*b1cdbd2cSJim Jagielski delete pBoxFmt;
783*b1cdbd2cSJim Jagielski eAdjust = text::HoriOrientation::NONE;
784*b1cdbd2cSJim Jagielski }
785*b1cdbd2cSJim Jagielski
786*b1cdbd2cSJim Jagielski //Orientation am Fmt der Table setzen
787*b1cdbd2cSJim Jagielski pTableFmt->SetFmtAttr( SwFmtHoriOrient( 0, eAdjust ) );
788*b1cdbd2cSJim Jagielski pNdTbl->RegisterToFormat( *pTableFmt );
789*b1cdbd2cSJim Jagielski
790*b1cdbd2cSJim Jagielski if( pTAFmt || ( rInsTblOpts.mnInsMode & tabopts::DEFAULT_BORDER) )
791*b1cdbd2cSJim Jagielski {
792*b1cdbd2cSJim Jagielski sal_uInt8 nBoxArrLen = pTAFmt ? 16 : 4;
793*b1cdbd2cSJim Jagielski SvPtrarr aBoxFmtArr( nBoxArrLen, 0 );
794*b1cdbd2cSJim Jagielski {
795*b1cdbd2cSJim Jagielski for( sal_uInt8 i = 0; i < nBoxArrLen; ++i )
796*b1cdbd2cSJim Jagielski aBoxFmtArr.Insert( (void*)0, i );
797*b1cdbd2cSJim Jagielski }
798*b1cdbd2cSJim Jagielski
799*b1cdbd2cSJim Jagielski // --> OD 2008-02-25 #refactorlists#
800*b1cdbd2cSJim Jagielski // SfxItemSet aCharSet( GetAttrPool(), RES_CHRATR_BEGIN, RES_PARATR_END-1 );
801*b1cdbd2cSJim Jagielski SfxItemSet aCharSet( GetAttrPool(), RES_CHRATR_BEGIN, RES_PARATR_LIST_END-1 );
802*b1cdbd2cSJim Jagielski // <--
803*b1cdbd2cSJim Jagielski SwHistory* pHistory = pUndo ? &pUndo->GetHistory() : 0;
804*b1cdbd2cSJim Jagielski
805*b1cdbd2cSJim Jagielski SwTableBoxFmt *pBoxF = 0;
806*b1cdbd2cSJim Jagielski SwTableLines& rLines = pNdTbl->GetTabLines();
807*b1cdbd2cSJim Jagielski sal_uInt16 nRows = rLines.Count();
808*b1cdbd2cSJim Jagielski for( sal_uInt16 n = 0; n < nRows; ++n )
809*b1cdbd2cSJim Jagielski {
810*b1cdbd2cSJim Jagielski SwTableBoxes& rBoxes = rLines[ n ]->GetTabBoxes();
811*b1cdbd2cSJim Jagielski sal_uInt16 nCols = rBoxes.Count();
812*b1cdbd2cSJim Jagielski for( sal_uInt16 i = 0; i < nCols; ++i )
813*b1cdbd2cSJim Jagielski {
814*b1cdbd2cSJim Jagielski SwTableBox* pBox = rBoxes[ i ];
815*b1cdbd2cSJim Jagielski sal_Bool bChgSz = sal_False;
816*b1cdbd2cSJim Jagielski
817*b1cdbd2cSJim Jagielski if( pTAFmt )
818*b1cdbd2cSJim Jagielski {
819*b1cdbd2cSJim Jagielski sal_uInt8 nId = static_cast<sal_uInt8>(!n ? 0 : (( n+1 == nRows )
820*b1cdbd2cSJim Jagielski ? 12 : (4 * (1 + ((n-1) & 1 )))));
821*b1cdbd2cSJim Jagielski nId = nId + static_cast<sal_uInt8>(!i ? 0 :
822*b1cdbd2cSJim Jagielski ( i+1 == nCols ? 3 : (1 + ((i-1) & 1))));
823*b1cdbd2cSJim Jagielski if( bUseBoxFmt )
824*b1cdbd2cSJim Jagielski ::lcl_SetDfltBoxAttr( *pBox, aBoxFmtArr, nId, pTAFmt );
825*b1cdbd2cSJim Jagielski else
826*b1cdbd2cSJim Jagielski {
827*b1cdbd2cSJim Jagielski bChgSz = 0 == aBoxFmtArr[ nId ];
828*b1cdbd2cSJim Jagielski pBoxF = ::lcl_CreateAFmtBoxFmt( *this, aBoxFmtArr,
829*b1cdbd2cSJim Jagielski *pTAFmt, USHRT_MAX, nId );
830*b1cdbd2cSJim Jagielski }
831*b1cdbd2cSJim Jagielski
832*b1cdbd2cSJim Jagielski // ggfs. noch die Absatz/ZeichenAttribute setzen
833*b1cdbd2cSJim Jagielski if( pTAFmt->IsFont() || pTAFmt->IsJustify() )
834*b1cdbd2cSJim Jagielski {
835*b1cdbd2cSJim Jagielski aCharSet.ClearItem();
836*b1cdbd2cSJim Jagielski pTAFmt->UpdateToSet( nId, aCharSet,
837*b1cdbd2cSJim Jagielski SwTableAutoFmt::UPDATE_CHAR, 0 );
838*b1cdbd2cSJim Jagielski if( aCharSet.Count() )
839*b1cdbd2cSJim Jagielski {
840*b1cdbd2cSJim Jagielski sal_uLong nSttNd = pBox->GetSttIdx()+1;
841*b1cdbd2cSJim Jagielski sal_uLong nEndNd = pBox->GetSttNd()->EndOfSectionIndex();
842*b1cdbd2cSJim Jagielski for( ; nSttNd < nEndNd; ++nSttNd )
843*b1cdbd2cSJim Jagielski {
844*b1cdbd2cSJim Jagielski SwCntntNode* pNd = GetNodes()[ nSttNd ]->GetCntntNode();
845*b1cdbd2cSJim Jagielski if( pNd )
846*b1cdbd2cSJim Jagielski {
847*b1cdbd2cSJim Jagielski if( pHistory )
848*b1cdbd2cSJim Jagielski {
849*b1cdbd2cSJim Jagielski SwRegHistory aReg( pNd, *pNd, pHistory );
850*b1cdbd2cSJim Jagielski pNd->SetAttr( aCharSet );
851*b1cdbd2cSJim Jagielski }
852*b1cdbd2cSJim Jagielski else
853*b1cdbd2cSJim Jagielski pNd->SetAttr( aCharSet );
854*b1cdbd2cSJim Jagielski }
855*b1cdbd2cSJim Jagielski }
856*b1cdbd2cSJim Jagielski }
857*b1cdbd2cSJim Jagielski }
858*b1cdbd2cSJim Jagielski }
859*b1cdbd2cSJim Jagielski else
860*b1cdbd2cSJim Jagielski {
861*b1cdbd2cSJim Jagielski sal_uInt8 nId = (i < nCols - 1 ? 0 : 1) + (n ? 2 : 0 );
862*b1cdbd2cSJim Jagielski if( bUseBoxFmt )
863*b1cdbd2cSJim Jagielski ::lcl_SetDfltBoxAttr( *pBox, aBoxFmtArr, nId );
864*b1cdbd2cSJim Jagielski else
865*b1cdbd2cSJim Jagielski {
866*b1cdbd2cSJim Jagielski bChgSz = 0 == aBoxFmtArr[ nId ];
867*b1cdbd2cSJim Jagielski pBoxF = ::lcl_CreateDfltBoxFmt( *this, aBoxFmtArr,
868*b1cdbd2cSJim Jagielski USHRT_MAX, nId );
869*b1cdbd2cSJim Jagielski }
870*b1cdbd2cSJim Jagielski }
871*b1cdbd2cSJim Jagielski
872*b1cdbd2cSJim Jagielski if( !bUseBoxFmt )
873*b1cdbd2cSJim Jagielski {
874*b1cdbd2cSJim Jagielski if( bChgSz )
875*b1cdbd2cSJim Jagielski pBoxF->SetFmtAttr( pBox->GetFrmFmt()->GetFrmSize() );
876*b1cdbd2cSJim Jagielski pBox->ChgFrmFmt( pBoxF );
877*b1cdbd2cSJim Jagielski }
878*b1cdbd2cSJim Jagielski }
879*b1cdbd2cSJim Jagielski }
880*b1cdbd2cSJim Jagielski
881*b1cdbd2cSJim Jagielski if( bUseBoxFmt )
882*b1cdbd2cSJim Jagielski {
883*b1cdbd2cSJim Jagielski for( sal_uInt8 i = 0; i < nBoxArrLen; ++i )
884*b1cdbd2cSJim Jagielski {
885*b1cdbd2cSJim Jagielski SvPtrarr* pArr = (SvPtrarr*)aBoxFmtArr[ i ];
886*b1cdbd2cSJim Jagielski delete pArr;
887*b1cdbd2cSJim Jagielski }
888*b1cdbd2cSJim Jagielski }
889*b1cdbd2cSJim Jagielski }
890*b1cdbd2cSJim Jagielski
891*b1cdbd2cSJim Jagielski // JP 03.04.97: Inhalt der Boxen auf Zahlen abpruefen
892*b1cdbd2cSJim Jagielski if( IsInsTblFormatNum() )
893*b1cdbd2cSJim Jagielski {
894*b1cdbd2cSJim Jagielski for( sal_uInt16 nBoxes = pNdTbl->GetTabSortBoxes().Count(); nBoxes; )
895*b1cdbd2cSJim Jagielski ChkBoxNumFmt( *pNdTbl->GetTabSortBoxes()[ --nBoxes ], sal_False );
896*b1cdbd2cSJim Jagielski }
897*b1cdbd2cSJim Jagielski
898*b1cdbd2cSJim Jagielski sal_uLong nIdx = pTblNd->GetIndex();
899*b1cdbd2cSJim Jagielski aNode2Layout.RestoreUpperFrms( GetNodes(), nIdx, nIdx + 1 );
900*b1cdbd2cSJim Jagielski
901*b1cdbd2cSJim Jagielski {
902*b1cdbd2cSJim Jagielski SwPaM& rTmp = (SwPaM&)rRange; // Point immer an den Anfang
903*b1cdbd2cSJim Jagielski rTmp.DeleteMark();
904*b1cdbd2cSJim Jagielski rTmp.GetPoint()->nNode = *pTblNd;
905*b1cdbd2cSJim Jagielski SwCntntNode* pCNd = GetNodes().GoNext( &rTmp.GetPoint()->nNode );
906*b1cdbd2cSJim Jagielski rTmp.GetPoint()->nContent.Assign( pCNd, 0 );
907*b1cdbd2cSJim Jagielski }
908*b1cdbd2cSJim Jagielski
909*b1cdbd2cSJim Jagielski if( pUndo )
910*b1cdbd2cSJim Jagielski {
911*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().EndUndo( UNDO_TEXTTOTABLE, NULL );
912*b1cdbd2cSJim Jagielski }
913*b1cdbd2cSJim Jagielski
914*b1cdbd2cSJim Jagielski SetModified();
915*b1cdbd2cSJim Jagielski SetFieldsDirty(true, NULL, 0);
916*b1cdbd2cSJim Jagielski return pNdTbl;
917*b1cdbd2cSJim Jagielski }
918*b1cdbd2cSJim Jagielski
TextToTable(const SwNodeRange & rRange,sal_Unicode cCh,SwTableFmt * pTblFmt,SwTableLineFmt * pLineFmt,SwTableBoxFmt * pBoxFmt,SwTxtFmtColl * pTxtColl,SwUndoTxtToTbl * pUndo)919*b1cdbd2cSJim Jagielski SwTableNode* SwNodes::TextToTable( const SwNodeRange& rRange, sal_Unicode cCh,
920*b1cdbd2cSJim Jagielski SwTableFmt* pTblFmt,
921*b1cdbd2cSJim Jagielski SwTableLineFmt* pLineFmt,
922*b1cdbd2cSJim Jagielski SwTableBoxFmt* pBoxFmt,
923*b1cdbd2cSJim Jagielski SwTxtFmtColl* pTxtColl,
924*b1cdbd2cSJim Jagielski SwUndoTxtToTbl* pUndo )
925*b1cdbd2cSJim Jagielski {
926*b1cdbd2cSJim Jagielski if( rRange.aStart >= rRange.aEnd )
927*b1cdbd2cSJim Jagielski return 0;
928*b1cdbd2cSJim Jagielski
929*b1cdbd2cSJim Jagielski SwTableNode * pTblNd = new SwTableNode( rRange.aStart );
930*b1cdbd2cSJim Jagielski new SwEndNode( rRange.aEnd, *pTblNd );
931*b1cdbd2cSJim Jagielski
932*b1cdbd2cSJim Jagielski SwDoc* pDoc = GetDoc();
933*b1cdbd2cSJim Jagielski SvUShorts aPosArr( 0, 16 );
934*b1cdbd2cSJim Jagielski SwTable * pTable = &pTblNd->GetTable();
935*b1cdbd2cSJim Jagielski SwTableLine* pLine;
936*b1cdbd2cSJim Jagielski SwTableBox* pBox;
937*b1cdbd2cSJim Jagielski sal_uInt16 nBoxes, nLines, nMaxBoxes = 0;
938*b1cdbd2cSJim Jagielski
939*b1cdbd2cSJim Jagielski SwNodeIndex aSttIdx( *pTblNd, 1 );
940*b1cdbd2cSJim Jagielski SwNodeIndex aEndIdx( rRange.aEnd, -1 );
941*b1cdbd2cSJim Jagielski for( nLines = 0, nBoxes = 0;
942*b1cdbd2cSJim Jagielski aSttIdx.GetIndex() < aEndIdx.GetIndex();
943*b1cdbd2cSJim Jagielski aSttIdx += 2, nLines++, nBoxes = 0 )
944*b1cdbd2cSJim Jagielski {
945*b1cdbd2cSJim Jagielski SwTxtNode* pTxtNd = aSttIdx.GetNode().GetTxtNode();
946*b1cdbd2cSJim Jagielski ASSERT( pTxtNd, "nur TextNodes in der Tabelle aufnehmen" );
947*b1cdbd2cSJim Jagielski
948*b1cdbd2cSJim Jagielski if( !nLines && 0x0b == cCh )
949*b1cdbd2cSJim Jagielski {
950*b1cdbd2cSJim Jagielski cCh = 0x09;
951*b1cdbd2cSJim Jagielski
952*b1cdbd2cSJim Jagielski // JP 28.10.96: vom 1. Node die Positionen des Trenners besorgen,
953*b1cdbd2cSJim Jagielski // damit die Boxen entsprechend eingestellt werden
954*b1cdbd2cSJim Jagielski SwTxtFrmInfo aFInfo( (SwTxtFrm*)pTxtNd->getLayoutFrm( pTxtNd->GetDoc()->GetCurrentLayout() ) );
955*b1cdbd2cSJim Jagielski if( aFInfo.IsOneLine() ) // nur dann sinnvoll!
956*b1cdbd2cSJim Jagielski {
957*b1cdbd2cSJim Jagielski const sal_Unicode* pTxt = pTxtNd->GetTxt().GetBuffer();
958*b1cdbd2cSJim Jagielski for( xub_StrLen nChPos = 0; *pTxt; ++nChPos, ++pTxt )
959*b1cdbd2cSJim Jagielski {
960*b1cdbd2cSJim Jagielski if( *pTxt == cCh )
961*b1cdbd2cSJim Jagielski {
962*b1cdbd2cSJim Jagielski aPosArr.Insert( static_cast<sal_uInt16>(
963*b1cdbd2cSJim Jagielski aFInfo.GetCharPos( nChPos+1, sal_False )),
964*b1cdbd2cSJim Jagielski aPosArr.Count() );
965*b1cdbd2cSJim Jagielski }
966*b1cdbd2cSJim Jagielski }
967*b1cdbd2cSJim Jagielski
968*b1cdbd2cSJim Jagielski aPosArr.Insert( /*aFInfo.GetFrm()->Frm().Left() +*/
969*b1cdbd2cSJim Jagielski static_cast<sal_uInt16>(aFInfo.GetFrm()->IsVertical() ?
970*b1cdbd2cSJim Jagielski aFInfo.GetFrm()->Prt().Bottom() :
971*b1cdbd2cSJim Jagielski aFInfo.GetFrm()->Prt().Right()),
972*b1cdbd2cSJim Jagielski aPosArr.Count() );
973*b1cdbd2cSJim Jagielski }
974*b1cdbd2cSJim Jagielski }
975*b1cdbd2cSJim Jagielski
976*b1cdbd2cSJim Jagielski // die alten Frames loeschen, es werden neue erzeugt
977*b1cdbd2cSJim Jagielski pTxtNd->DelFrms();
978*b1cdbd2cSJim Jagielski
979*b1cdbd2cSJim Jagielski // PageBreaks/PageDesc/ColBreak rausschmeissen.
980*b1cdbd2cSJim Jagielski const SfxItemSet* pSet = pTxtNd->GetpSwAttrSet();
981*b1cdbd2cSJim Jagielski if( pSet )
982*b1cdbd2cSJim Jagielski {
983*b1cdbd2cSJim Jagielski // das entfernen der PageBreaks erst nach dem erzeugen der Tabelle
984*b1cdbd2cSJim Jagielski // erfolgen, denn sonst stehen sie falsch in der History !!!
985*b1cdbd2cSJim Jagielski // SwRegHistory aRegH( pTxtNd, *pTxtNd, pHistory );
986*b1cdbd2cSJim Jagielski const SfxPoolItem* pItem;
987*b1cdbd2cSJim Jagielski if( SFX_ITEM_SET == pSet->GetItemState( RES_BREAK, sal_False, &pItem ) )
988*b1cdbd2cSJim Jagielski {
989*b1cdbd2cSJim Jagielski if( !nLines )
990*b1cdbd2cSJim Jagielski pTblFmt->SetFmtAttr( *pItem );
991*b1cdbd2cSJim Jagielski pTxtNd->ResetAttr( RES_BREAK );
992*b1cdbd2cSJim Jagielski pSet = pTxtNd->GetpSwAttrSet();
993*b1cdbd2cSJim Jagielski }
994*b1cdbd2cSJim Jagielski
995*b1cdbd2cSJim Jagielski if( pSet && SFX_ITEM_SET == pSet->GetItemState(
996*b1cdbd2cSJim Jagielski RES_PAGEDESC, sal_False, &pItem ) &&
997*b1cdbd2cSJim Jagielski ((SwFmtPageDesc*)pItem)->GetPageDesc() )
998*b1cdbd2cSJim Jagielski {
999*b1cdbd2cSJim Jagielski if( !nLines )
1000*b1cdbd2cSJim Jagielski pTblFmt->SetFmtAttr( *pItem );
1001*b1cdbd2cSJim Jagielski pTxtNd->ResetAttr( RES_PAGEDESC );
1002*b1cdbd2cSJim Jagielski }
1003*b1cdbd2cSJim Jagielski }
1004*b1cdbd2cSJim Jagielski
1005*b1cdbd2cSJim Jagielski // setze den bei allen TextNode in der Tabelle den TableNode
1006*b1cdbd2cSJim Jagielski // als StartNode
1007*b1cdbd2cSJim Jagielski pTxtNd->pStartOfSection = pTblNd;
1008*b1cdbd2cSJim Jagielski
1009*b1cdbd2cSJim Jagielski pLine = new SwTableLine( pLineFmt, 1, 0 );
1010*b1cdbd2cSJim Jagielski pTable->GetTabLines().C40_INSERT( SwTableLine, pLine, nLines );
1011*b1cdbd2cSJim Jagielski
1012*b1cdbd2cSJim Jagielski SwStartNode* pSttNd;
1013*b1cdbd2cSJim Jagielski SwPosition aCntPos( aSttIdx, SwIndex( pTxtNd ));
1014*b1cdbd2cSJim Jagielski
1015*b1cdbd2cSJim Jagielski SvULongs aBkmkArr( 15, 15 );
1016*b1cdbd2cSJim Jagielski _SaveCntntIdx( pDoc, aSttIdx.GetIndex(), pTxtNd->GetTxt().Len(), aBkmkArr );
1017*b1cdbd2cSJim Jagielski
1018*b1cdbd2cSJim Jagielski const sal_Unicode* pTxt = pTxtNd->GetTxt().GetBuffer();
1019*b1cdbd2cSJim Jagielski
1020*b1cdbd2cSJim Jagielski if( T2T_PARA != cCh )
1021*b1cdbd2cSJim Jagielski for( xub_StrLen nChPos = 0; *pTxt; ++nChPos, ++pTxt )
1022*b1cdbd2cSJim Jagielski if( *pTxt == cCh )
1023*b1cdbd2cSJim Jagielski {
1024*b1cdbd2cSJim Jagielski aCntPos.nContent = nChPos;
1025*b1cdbd2cSJim Jagielski SwCntntNode* pNewNd = pTxtNd->SplitCntntNode( aCntPos );
1026*b1cdbd2cSJim Jagielski
1027*b1cdbd2cSJim Jagielski if( aBkmkArr.Count() )
1028*b1cdbd2cSJim Jagielski _RestoreCntntIdx( aBkmkArr, *pNewNd, nChPos,
1029*b1cdbd2cSJim Jagielski nChPos + 1 );
1030*b1cdbd2cSJim Jagielski
1031*b1cdbd2cSJim Jagielski // Trennzeichen loeschen und SuchString korrigieren
1032*b1cdbd2cSJim Jagielski pTxtNd->EraseText( aCntPos.nContent, 1 );
1033*b1cdbd2cSJim Jagielski pTxt = pTxtNd->GetTxt().GetBuffer();
1034*b1cdbd2cSJim Jagielski nChPos = 0;
1035*b1cdbd2cSJim Jagielski --nChPos, --pTxt; // for the ++ in the for loop !!!
1036*b1cdbd2cSJim Jagielski
1037*b1cdbd2cSJim Jagielski // setze bei allen TextNodes in der Tabelle den TableNode
1038*b1cdbd2cSJim Jagielski // als StartNode
1039*b1cdbd2cSJim Jagielski const SwNodeIndex aTmpIdx( aCntPos.nNode, -1 );
1040*b1cdbd2cSJim Jagielski pSttNd = new SwStartNode( aTmpIdx, ND_STARTNODE,
1041*b1cdbd2cSJim Jagielski SwTableBoxStartNode );
1042*b1cdbd2cSJim Jagielski new SwEndNode( aCntPos.nNode, *pSttNd );
1043*b1cdbd2cSJim Jagielski pNewNd->pStartOfSection = pSttNd;
1044*b1cdbd2cSJim Jagielski
1045*b1cdbd2cSJim Jagielski // Section der Box zuweisen
1046*b1cdbd2cSJim Jagielski pBox = new SwTableBox( pBoxFmt, *pSttNd, pLine );
1047*b1cdbd2cSJim Jagielski pLine->GetTabBoxes().C40_INSERT( SwTableBox, pBox, nBoxes++ );
1048*b1cdbd2cSJim Jagielski }
1049*b1cdbd2cSJim Jagielski
1050*b1cdbd2cSJim Jagielski // und jetzt den letzten Teil-String
1051*b1cdbd2cSJim Jagielski if( aBkmkArr.Count() )
1052*b1cdbd2cSJim Jagielski _RestoreCntntIdx( aBkmkArr, *pTxtNd, pTxtNd->GetTxt().Len(),
1053*b1cdbd2cSJim Jagielski pTxtNd->GetTxt().Len()+1 );
1054*b1cdbd2cSJim Jagielski
1055*b1cdbd2cSJim Jagielski pSttNd = new SwStartNode( aCntPos.nNode, ND_STARTNODE, SwTableBoxStartNode );
1056*b1cdbd2cSJim Jagielski const SwNodeIndex aTmpIdx( aCntPos.nNode, 1 );
1057*b1cdbd2cSJim Jagielski new SwEndNode( aTmpIdx, *pSttNd );
1058*b1cdbd2cSJim Jagielski pTxtNd->pStartOfSection = pSttNd;
1059*b1cdbd2cSJim Jagielski
1060*b1cdbd2cSJim Jagielski pBox = new SwTableBox( pBoxFmt, *pSttNd, pLine );
1061*b1cdbd2cSJim Jagielski pLine->GetTabBoxes().C40_INSERT( SwTableBox, pBox, nBoxes++ );
1062*b1cdbd2cSJim Jagielski if( nMaxBoxes < nBoxes )
1063*b1cdbd2cSJim Jagielski nMaxBoxes = nBoxes;
1064*b1cdbd2cSJim Jagielski }
1065*b1cdbd2cSJim Jagielski
1066*b1cdbd2cSJim Jagielski // die Tabelle ausgleichen, leere Sections einfuegen
1067*b1cdbd2cSJim Jagielski sal_uInt16 n;
1068*b1cdbd2cSJim Jagielski
1069*b1cdbd2cSJim Jagielski for( n = 0; n < pTable->GetTabLines().Count(); ++n )
1070*b1cdbd2cSJim Jagielski {
1071*b1cdbd2cSJim Jagielski SwTableLine* pCurrLine = pTable->GetTabLines()[ n ];
1072*b1cdbd2cSJim Jagielski if( nMaxBoxes != ( nBoxes = pCurrLine->GetTabBoxes().Count() ))
1073*b1cdbd2cSJim Jagielski {
1074*b1cdbd2cSJim Jagielski InsBoxen( pTblNd, pCurrLine, pBoxFmt, pTxtColl, 0,
1075*b1cdbd2cSJim Jagielski nBoxes, nMaxBoxes - nBoxes );
1076*b1cdbd2cSJim Jagielski
1077*b1cdbd2cSJim Jagielski if( pUndo )
1078*b1cdbd2cSJim Jagielski for( sal_uInt16 i = nBoxes; i < nMaxBoxes; ++i )
1079*b1cdbd2cSJim Jagielski pUndo->AddFillBox( *pCurrLine->GetTabBoxes()[ i ] );
1080*b1cdbd2cSJim Jagielski
1081*b1cdbd2cSJim Jagielski // fehlen der 1. Line Boxen, dann kann man das Breiten Array
1082*b1cdbd2cSJim Jagielski // vergessen!
1083*b1cdbd2cSJim Jagielski if( !n )
1084*b1cdbd2cSJim Jagielski aPosArr.Remove( 0, aPosArr.Count() );
1085*b1cdbd2cSJim Jagielski }
1086*b1cdbd2cSJim Jagielski }
1087*b1cdbd2cSJim Jagielski
1088*b1cdbd2cSJim Jagielski if( aPosArr.Count() )
1089*b1cdbd2cSJim Jagielski {
1090*b1cdbd2cSJim Jagielski SwTableLines& rLns = pTable->GetTabLines();
1091*b1cdbd2cSJim Jagielski sal_uInt16 nLastPos = 0;
1092*b1cdbd2cSJim Jagielski for( n = 0; n < aPosArr.Count(); ++n )
1093*b1cdbd2cSJim Jagielski {
1094*b1cdbd2cSJim Jagielski SwTableBoxFmt *pNewFmt = pDoc->MakeTableBoxFmt();
1095*b1cdbd2cSJim Jagielski pNewFmt->SetFmtAttr( SwFmtFrmSize( ATT_VAR_SIZE,
1096*b1cdbd2cSJim Jagielski aPosArr[ n ] - nLastPos ));
1097*b1cdbd2cSJim Jagielski for( sal_uInt16 nTmpLine = 0; nTmpLine < rLns.Count(); ++nTmpLine )
1098*b1cdbd2cSJim Jagielski //JP 24.06.98: hier muss ein Add erfolgen, da das BoxFormat
1099*b1cdbd2cSJim Jagielski // von der rufenden Methode noch gebraucht wird!
1100*b1cdbd2cSJim Jagielski pNewFmt->Add( rLns[ nTmpLine ]->GetTabBoxes()[ n ] );
1101*b1cdbd2cSJim Jagielski
1102*b1cdbd2cSJim Jagielski nLastPos = aPosArr[ n ];
1103*b1cdbd2cSJim Jagielski }
1104*b1cdbd2cSJim Jagielski
1105*b1cdbd2cSJim Jagielski // damit die Tabelle die richtige Groesse bekommt, im BoxFormat die
1106*b1cdbd2cSJim Jagielski // Groesse nach "oben" transportieren.
1107*b1cdbd2cSJim Jagielski ASSERT( !pBoxFmt->GetDepends(), "wer ist in dem Format noch angemeldet" );
1108*b1cdbd2cSJim Jagielski pBoxFmt->SetFmtAttr( SwFmtFrmSize( ATT_VAR_SIZE, nLastPos ));
1109*b1cdbd2cSJim Jagielski }
1110*b1cdbd2cSJim Jagielski else
1111*b1cdbd2cSJim Jagielski pBoxFmt->SetFmtAttr( SwFmtFrmSize( ATT_VAR_SIZE, USHRT_MAX / nMaxBoxes ));
1112*b1cdbd2cSJim Jagielski
1113*b1cdbd2cSJim Jagielski // das wars doch wohl ??
1114*b1cdbd2cSJim Jagielski return pTblNd;
1115*b1cdbd2cSJim Jagielski }
1116*b1cdbd2cSJim Jagielski /*-- 18.05.2006 10:30:29---------------------------------------------------
1117*b1cdbd2cSJim Jagielski
1118*b1cdbd2cSJim Jagielski -----------------------------------------------------------------------*/
TextToTable(const std::vector<std::vector<SwNodeRange>> & rTableNodes)1119*b1cdbd2cSJim Jagielski const SwTable* SwDoc::TextToTable( const std::vector< std::vector<SwNodeRange> >& rTableNodes )
1120*b1cdbd2cSJim Jagielski {
1121*b1cdbd2cSJim Jagielski /* #106283# Save first node in the selection if it is a content node. */
1122*b1cdbd2cSJim Jagielski SwCntntNode * pSttCntntNd = rTableNodes.begin()->begin()->aStart.GetNode().GetCntntNode();
1123*b1cdbd2cSJim Jagielski
1124*b1cdbd2cSJim Jagielski /**debug**/
1125*b1cdbd2cSJim Jagielski #if OSL_DEBUG_LEVEL > 1
1126*b1cdbd2cSJim Jagielski const SwNodeRange& rStartRange = *rTableNodes.begin()->begin();
1127*b1cdbd2cSJim Jagielski const SwNodeRange& rEndRange = *rTableNodes.rbegin()->rbegin();
1128*b1cdbd2cSJim Jagielski (void) rStartRange;
1129*b1cdbd2cSJim Jagielski (void) rEndRange;
1130*b1cdbd2cSJim Jagielski #endif
1131*b1cdbd2cSJim Jagielski /**debug**/
1132*b1cdbd2cSJim Jagielski
1133*b1cdbd2cSJim Jagielski //!!! not necessarily TextNodes !!!
1134*b1cdbd2cSJim Jagielski SwPaM aOriginal( rTableNodes.begin()->begin()->aStart, rTableNodes.rbegin()->rbegin()->aEnd );
1135*b1cdbd2cSJim Jagielski const SwPosition *pStt = aOriginal.GetMark();
1136*b1cdbd2cSJim Jagielski const SwPosition *pEnd = aOriginal.GetPoint();
1137*b1cdbd2cSJim Jagielski
1138*b1cdbd2cSJim Jagielski #ifdef DEL_TABLE_REDLINES
1139*b1cdbd2cSJim Jagielski lcl_DelRedlines aDelRedl( aOriginal );
1140*b1cdbd2cSJim Jagielski #endif
1141*b1cdbd2cSJim Jagielski
1142*b1cdbd2cSJim Jagielski // SwUndoTxtToTbl* pUndo = 0;
1143*b1cdbd2cSJim Jagielski bool const bUndo(GetIDocumentUndoRedo().DoesUndo());
1144*b1cdbd2cSJim Jagielski if (bUndo)
1145*b1cdbd2cSJim Jagielski {
1146*b1cdbd2cSJim Jagielski // das Splitten vom TextNode nicht in die Undohistory aufnehmen
1147*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().DoUndo(false);
1148*b1cdbd2cSJim Jagielski }
1149*b1cdbd2cSJim Jagielski
1150*b1cdbd2cSJim Jagielski ::PaMCorrAbs( aOriginal, *pEnd );
1151*b1cdbd2cSJim Jagielski
1152*b1cdbd2cSJim Jagielski // sorge dafuer, das der Bereich auf Node-Grenzen liegt
1153*b1cdbd2cSJim Jagielski SwNodeRange aRg( pStt->nNode, pEnd->nNode );
1154*b1cdbd2cSJim Jagielski if( pStt->nContent.GetIndex() )
1155*b1cdbd2cSJim Jagielski SplitNode( *pStt, false );
1156*b1cdbd2cSJim Jagielski
1157*b1cdbd2cSJim Jagielski sal_Bool bEndCntnt = 0 != pEnd->nContent.GetIndex();
1158*b1cdbd2cSJim Jagielski // nicht splitten am Ende der Zeile (aber am Ende vom Doc!!)
1159*b1cdbd2cSJim Jagielski if( bEndCntnt )
1160*b1cdbd2cSJim Jagielski {
1161*b1cdbd2cSJim Jagielski if( pEnd->nNode.GetNode().GetCntntNode()->Len() != pEnd->nContent.GetIndex()
1162*b1cdbd2cSJim Jagielski || pEnd->nNode.GetIndex() >= GetNodes().GetEndOfContent().GetIndex()-1 )
1163*b1cdbd2cSJim Jagielski {
1164*b1cdbd2cSJim Jagielski SplitNode( *pEnd, false );
1165*b1cdbd2cSJim Jagielski ((SwNodeIndex&)pEnd->nNode)--;
1166*b1cdbd2cSJim Jagielski ((SwIndex&)pEnd->nContent).Assign(
1167*b1cdbd2cSJim Jagielski pEnd->nNode.GetNode().GetCntntNode(), 0 );
1168*b1cdbd2cSJim Jagielski // ein Node und am Ende ??
1169*b1cdbd2cSJim Jagielski if( pStt->nNode.GetIndex() >= pEnd->nNode.GetIndex() )
1170*b1cdbd2cSJim Jagielski aRg.aStart--;
1171*b1cdbd2cSJim Jagielski }
1172*b1cdbd2cSJim Jagielski else
1173*b1cdbd2cSJim Jagielski aRg.aEnd++;
1174*b1cdbd2cSJim Jagielski }
1175*b1cdbd2cSJim Jagielski
1176*b1cdbd2cSJim Jagielski
1177*b1cdbd2cSJim Jagielski if( aRg.aEnd.GetIndex() == aRg.aStart.GetIndex() )
1178*b1cdbd2cSJim Jagielski {
1179*b1cdbd2cSJim Jagielski ASSERT( sal_False, "Kein Bereich" );
1180*b1cdbd2cSJim Jagielski aRg.aEnd++;
1181*b1cdbd2cSJim Jagielski }
1182*b1cdbd2cSJim Jagielski
1183*b1cdbd2cSJim Jagielski // Wir gehen jetzt immer ueber die Upper, um die Tabelle einzufuegen:
1184*b1cdbd2cSJim Jagielski SwNode2Layout aNode2Layout( aRg.aStart.GetNode() );
1185*b1cdbd2cSJim Jagielski
1186*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().DoUndo(bUndo);
1187*b1cdbd2cSJim Jagielski
1188*b1cdbd2cSJim Jagielski // dann erstelle die Box/Line/Table-Struktur
1189*b1cdbd2cSJim Jagielski SwTableBoxFmt* pBoxFmt = MakeTableBoxFmt();
1190*b1cdbd2cSJim Jagielski SwTableLineFmt* pLineFmt = MakeTableLineFmt();
1191*b1cdbd2cSJim Jagielski SwTableFmt* pTableFmt = MakeTblFrmFmt( GetUniqueTblName(), GetDfltFrmFmt() );
1192*b1cdbd2cSJim Jagielski
1193*b1cdbd2cSJim Jagielski // alle Zeilen haben die Fill-Order von links nach rechts !
1194*b1cdbd2cSJim Jagielski pLineFmt->SetFmtAttr( SwFmtFillOrder( ATT_LEFT_TO_RIGHT ));
1195*b1cdbd2cSJim Jagielski // die Tabelle bekommt USHRT_MAX als default SSize
1196*b1cdbd2cSJim Jagielski pTableFmt->SetFmtAttr( SwFmtFrmSize( ATT_VAR_SIZE, USHRT_MAX ));
1197*b1cdbd2cSJim Jagielski
1198*b1cdbd2cSJim Jagielski /* #106283# If the first node in the selection is a context node and if it
1199*b1cdbd2cSJim Jagielski has an item FRAMEDIR set (no default) propagate the item to the
1200*b1cdbd2cSJim Jagielski replacing table. */
1201*b1cdbd2cSJim Jagielski if (pSttCntntNd)
1202*b1cdbd2cSJim Jagielski {
1203*b1cdbd2cSJim Jagielski const SwAttrSet & aNdSet = pSttCntntNd->GetSwAttrSet();
1204*b1cdbd2cSJim Jagielski const SfxPoolItem *pItem = NULL;
1205*b1cdbd2cSJim Jagielski
1206*b1cdbd2cSJim Jagielski if (SFX_ITEM_SET == aNdSet.GetItemState( RES_FRAMEDIR, sal_True, &pItem )
1207*b1cdbd2cSJim Jagielski && pItem != NULL)
1208*b1cdbd2cSJim Jagielski {
1209*b1cdbd2cSJim Jagielski pTableFmt->SetFmtAttr( *pItem );
1210*b1cdbd2cSJim Jagielski }
1211*b1cdbd2cSJim Jagielski }
1212*b1cdbd2cSJim Jagielski
1213*b1cdbd2cSJim Jagielski SwTableNode* pTblNd = GetNodes().TextToTable(
1214*b1cdbd2cSJim Jagielski rTableNodes, pTableFmt, pLineFmt, pBoxFmt,
1215*b1cdbd2cSJim Jagielski GetTxtCollFromPool( RES_POOLCOLL_STANDARD )/*, pUndo*/ );
1216*b1cdbd2cSJim Jagielski
1217*b1cdbd2cSJim Jagielski SwTable * pNdTbl = &pTblNd->GetTable();
1218*b1cdbd2cSJim Jagielski ASSERT( pNdTbl, "kein Tabellen-Node angelegt." )
1219*b1cdbd2cSJim Jagielski pNdTbl->RegisterToFormat( *pTableFmt );
1220*b1cdbd2cSJim Jagielski
1221*b1cdbd2cSJim Jagielski sal_Bool bUseBoxFmt = sal_False;
1222*b1cdbd2cSJim Jagielski if( !pBoxFmt->GetDepends() )
1223*b1cdbd2cSJim Jagielski {
1224*b1cdbd2cSJim Jagielski // die Formate an den Boxen haben schon die richtige Size, es darf
1225*b1cdbd2cSJim Jagielski // also nur noch die richtige Umrandung/AutoFmt gesetzt werden.
1226*b1cdbd2cSJim Jagielski bUseBoxFmt = sal_True;
1227*b1cdbd2cSJim Jagielski pTableFmt->SetFmtAttr( pBoxFmt->GetFrmSize() );
1228*b1cdbd2cSJim Jagielski delete pBoxFmt;
1229*b1cdbd2cSJim Jagielski }
1230*b1cdbd2cSJim Jagielski
1231*b1cdbd2cSJim Jagielski sal_uLong nIdx = pTblNd->GetIndex();
1232*b1cdbd2cSJim Jagielski aNode2Layout.RestoreUpperFrms( GetNodes(), nIdx, nIdx + 1 );
1233*b1cdbd2cSJim Jagielski
1234*b1cdbd2cSJim Jagielski SetModified();
1235*b1cdbd2cSJim Jagielski SetFieldsDirty( true, NULL, 0 );
1236*b1cdbd2cSJim Jagielski return pNdTbl;
1237*b1cdbd2cSJim Jagielski }
1238*b1cdbd2cSJim Jagielski
ExpandRangeForTableBox(const SwNodeRange & rRange)1239*b1cdbd2cSJim Jagielski SwNodeRange * SwNodes::ExpandRangeForTableBox(const SwNodeRange & rRange)
1240*b1cdbd2cSJim Jagielski {
1241*b1cdbd2cSJim Jagielski SwNodeRange * pResult = NULL;
1242*b1cdbd2cSJim Jagielski bool bChanged = false;
1243*b1cdbd2cSJim Jagielski
1244*b1cdbd2cSJim Jagielski SwNodeIndex aNewStart = rRange.aStart;
1245*b1cdbd2cSJim Jagielski SwNodeIndex aNewEnd = rRange.aEnd;
1246*b1cdbd2cSJim Jagielski
1247*b1cdbd2cSJim Jagielski SwNodeIndex aEndIndex = rRange.aEnd;
1248*b1cdbd2cSJim Jagielski SwNodeIndex aIndex = rRange.aStart;
1249*b1cdbd2cSJim Jagielski
1250*b1cdbd2cSJim Jagielski while (aIndex < aEndIndex)
1251*b1cdbd2cSJim Jagielski {
1252*b1cdbd2cSJim Jagielski SwNode& rNode = aIndex.GetNode();
1253*b1cdbd2cSJim Jagielski
1254*b1cdbd2cSJim Jagielski if (rNode.IsStartNode())
1255*b1cdbd2cSJim Jagielski {
1256*b1cdbd2cSJim Jagielski // advance aIndex to the end node of this start node
1257*b1cdbd2cSJim Jagielski SwNode * pEndNode = rNode.EndOfSectionNode();
1258*b1cdbd2cSJim Jagielski aIndex = *pEndNode;
1259*b1cdbd2cSJim Jagielski
1260*b1cdbd2cSJim Jagielski if (aIndex > aNewEnd)
1261*b1cdbd2cSJim Jagielski {
1262*b1cdbd2cSJim Jagielski aNewEnd = aIndex;
1263*b1cdbd2cSJim Jagielski bChanged = true;
1264*b1cdbd2cSJim Jagielski }
1265*b1cdbd2cSJim Jagielski }
1266*b1cdbd2cSJim Jagielski else if (rNode.IsEndNode())
1267*b1cdbd2cSJim Jagielski {
1268*b1cdbd2cSJim Jagielski SwNode * pStartNode = rNode.StartOfSectionNode();
1269*b1cdbd2cSJim Jagielski SwNodeIndex aStartIndex = *pStartNode;
1270*b1cdbd2cSJim Jagielski
1271*b1cdbd2cSJim Jagielski if (aStartIndex < aNewStart)
1272*b1cdbd2cSJim Jagielski {
1273*b1cdbd2cSJim Jagielski aNewStart = aStartIndex;
1274*b1cdbd2cSJim Jagielski bChanged = true;
1275*b1cdbd2cSJim Jagielski }
1276*b1cdbd2cSJim Jagielski }
1277*b1cdbd2cSJim Jagielski
1278*b1cdbd2cSJim Jagielski if (aIndex < aEndIndex)
1279*b1cdbd2cSJim Jagielski ++aIndex;
1280*b1cdbd2cSJim Jagielski }
1281*b1cdbd2cSJim Jagielski
1282*b1cdbd2cSJim Jagielski SwNode * pNode = &aIndex.GetNode();
1283*b1cdbd2cSJim Jagielski while (pNode->IsEndNode())
1284*b1cdbd2cSJim Jagielski {
1285*b1cdbd2cSJim Jagielski SwNode * pStartNode = pNode->StartOfSectionNode();
1286*b1cdbd2cSJim Jagielski SwNodeIndex aStartIndex(*pStartNode);
1287*b1cdbd2cSJim Jagielski aNewStart = aStartIndex;
1288*b1cdbd2cSJim Jagielski aNewEnd = aIndex;
1289*b1cdbd2cSJim Jagielski bChanged = true;
1290*b1cdbd2cSJim Jagielski
1291*b1cdbd2cSJim Jagielski ++aIndex;
1292*b1cdbd2cSJim Jagielski pNode = &aIndex.GetNode();
1293*b1cdbd2cSJim Jagielski }
1294*b1cdbd2cSJim Jagielski
1295*b1cdbd2cSJim Jagielski if (bChanged)
1296*b1cdbd2cSJim Jagielski pResult = new SwNodeRange(aNewStart, aNewEnd);
1297*b1cdbd2cSJim Jagielski
1298*b1cdbd2cSJim Jagielski return pResult;
1299*b1cdbd2cSJim Jagielski }
1300*b1cdbd2cSJim Jagielski
1301*b1cdbd2cSJim Jagielski /*-- 18.05.2006 08:23:28---------------------------------------------------
1302*b1cdbd2cSJim Jagielski
1303*b1cdbd2cSJim Jagielski -----------------------------------------------------------------------*/
TextToTable(const SwNodes::TableRanges_t & rTableNodes,SwTableFmt * pTblFmt,SwTableLineFmt * pLineFmt,SwTableBoxFmt * pBoxFmt,SwTxtFmtColl *)1304*b1cdbd2cSJim Jagielski SwTableNode* SwNodes::TextToTable( const SwNodes::TableRanges_t & rTableNodes,
1305*b1cdbd2cSJim Jagielski SwTableFmt* pTblFmt,
1306*b1cdbd2cSJim Jagielski SwTableLineFmt* pLineFmt,
1307*b1cdbd2cSJim Jagielski SwTableBoxFmt* pBoxFmt,
1308*b1cdbd2cSJim Jagielski SwTxtFmtColl* /*pTxtColl*/ /*, SwUndo... pUndo*/ )
1309*b1cdbd2cSJim Jagielski {
1310*b1cdbd2cSJim Jagielski if( !rTableNodes.size() )
1311*b1cdbd2cSJim Jagielski return 0;
1312*b1cdbd2cSJim Jagielski
1313*b1cdbd2cSJim Jagielski SwTableNode * pTblNd = new SwTableNode( rTableNodes.begin()->begin()->aStart );
1314*b1cdbd2cSJim Jagielski //insert the end node after the last text node
1315*b1cdbd2cSJim Jagielski SwNodeIndex aInsertIndex( rTableNodes.rbegin()->rbegin()->aEnd );
1316*b1cdbd2cSJim Jagielski ++aInsertIndex;
1317*b1cdbd2cSJim Jagielski
1318*b1cdbd2cSJim Jagielski //!! owner ship will be transferred in c-tor to SwNodes array.
1319*b1cdbd2cSJim Jagielski //!! Thus no real problem here...
1320*b1cdbd2cSJim Jagielski new SwEndNode( aInsertIndex, *pTblNd );
1321*b1cdbd2cSJim Jagielski
1322*b1cdbd2cSJim Jagielski #if OSL_DEBUG_LEVEL > 1
1323*b1cdbd2cSJim Jagielski /**debug**/
1324*b1cdbd2cSJim Jagielski const SwNodeRange& rStartRange = *rTableNodes.begin()->begin();
1325*b1cdbd2cSJim Jagielski const SwNodeRange& rEndRange = *rTableNodes.rbegin()->rbegin();
1326*b1cdbd2cSJim Jagielski (void) rStartRange;
1327*b1cdbd2cSJim Jagielski (void) rEndRange;
1328*b1cdbd2cSJim Jagielski /**debug**/
1329*b1cdbd2cSJim Jagielski #endif
1330*b1cdbd2cSJim Jagielski
1331*b1cdbd2cSJim Jagielski SwDoc* pDoc = GetDoc();
1332*b1cdbd2cSJim Jagielski SvUShorts aPosArr( 0, 16 );
1333*b1cdbd2cSJim Jagielski SwTable * pTable = &pTblNd->GetTable();
1334*b1cdbd2cSJim Jagielski SwTableLine* pLine;
1335*b1cdbd2cSJim Jagielski SwTableBox* pBox;
1336*b1cdbd2cSJim Jagielski sal_uInt16 nBoxes, nLines, nMaxBoxes = 0;
1337*b1cdbd2cSJim Jagielski
1338*b1cdbd2cSJim Jagielski // SwHistory* pHistory = pUndo ? &pUndo->GetHistory() : 0;
1339*b1cdbd2cSJim Jagielski
1340*b1cdbd2cSJim Jagielski
1341*b1cdbd2cSJim Jagielski SwNodeIndex aNodeIndex = rTableNodes.begin()->begin()->aStart;
1342*b1cdbd2cSJim Jagielski // delete frames of all contained content nodes
1343*b1cdbd2cSJim Jagielski for( nLines = 0; aNodeIndex <= rTableNodes.rbegin()->rbegin()->aEnd; ++aNodeIndex,++nLines )
1344*b1cdbd2cSJim Jagielski {
1345*b1cdbd2cSJim Jagielski SwNode& rNode = aNodeIndex.GetNode();
1346*b1cdbd2cSJim Jagielski if( rNode.IsCntntNode() )
1347*b1cdbd2cSJim Jagielski {
1348*b1cdbd2cSJim Jagielski static_cast<SwCntntNode&>(rNode).DelFrms();
1349*b1cdbd2cSJim Jagielski if(rNode.IsTxtNode())
1350*b1cdbd2cSJim Jagielski {
1351*b1cdbd2cSJim Jagielski SwTxtNode& rTxtNode = static_cast<SwTxtNode&>(rNode);
1352*b1cdbd2cSJim Jagielski // setze den bei allen TextNode in der Tabelle den TableNode
1353*b1cdbd2cSJim Jagielski // als StartNode
1354*b1cdbd2cSJim Jagielski // FIXME: this is setting wrong node StartOfSections in nested tables.
1355*b1cdbd2cSJim Jagielski // rTxtNode.pStartOfSection = pTblNd;
1356*b1cdbd2cSJim Jagielski // remove PageBreaks/PageDesc/ColBreak
1357*b1cdbd2cSJim Jagielski const SwAttrSet* pSet = rTxtNode.GetpSwAttrSet();
1358*b1cdbd2cSJim Jagielski if( pSet )
1359*b1cdbd2cSJim Jagielski {
1360*b1cdbd2cSJim Jagielski // das entfernen der PageBreaks erst nach dem erzeugen der Tabelle
1361*b1cdbd2cSJim Jagielski // erfolgen, denn sonst stehen sie falsch in der History !!!
1362*b1cdbd2cSJim Jagielski // SwRegHistory aRegH( pTxtNd, *pTxtNd, pHistory );
1363*b1cdbd2cSJim Jagielski const SfxPoolItem* pItem;
1364*b1cdbd2cSJim Jagielski if( SFX_ITEM_SET == pSet->GetItemState( RES_BREAK, sal_False, &pItem ) )
1365*b1cdbd2cSJim Jagielski {
1366*b1cdbd2cSJim Jagielski if( !nLines )
1367*b1cdbd2cSJim Jagielski pTblFmt->SetFmtAttr( *pItem );
1368*b1cdbd2cSJim Jagielski rTxtNode.ResetAttr( RES_BREAK );
1369*b1cdbd2cSJim Jagielski pSet = rTxtNode.GetpSwAttrSet();
1370*b1cdbd2cSJim Jagielski }
1371*b1cdbd2cSJim Jagielski
1372*b1cdbd2cSJim Jagielski if( pSet && SFX_ITEM_SET == pSet->GetItemState(
1373*b1cdbd2cSJim Jagielski RES_PAGEDESC, sal_False, &pItem ) &&
1374*b1cdbd2cSJim Jagielski ((SwFmtPageDesc*)pItem)->GetPageDesc() )
1375*b1cdbd2cSJim Jagielski {
1376*b1cdbd2cSJim Jagielski if( !nLines )
1377*b1cdbd2cSJim Jagielski pTblFmt->SetFmtAttr( *pItem );
1378*b1cdbd2cSJim Jagielski rTxtNode.ResetAttr( RES_PAGEDESC );
1379*b1cdbd2cSJim Jagielski }
1380*b1cdbd2cSJim Jagielski }
1381*b1cdbd2cSJim Jagielski }
1382*b1cdbd2cSJim Jagielski }
1383*b1cdbd2cSJim Jagielski }
1384*b1cdbd2cSJim Jagielski
1385*b1cdbd2cSJim Jagielski // SwNodeIndex aSttIdx( *pTblNd, 1 );
1386*b1cdbd2cSJim Jagielski // SwNodeIndex aEndIdx( rlNodes.rbegin()->aEnd, -1 );
1387*b1cdbd2cSJim Jagielski std::vector<std::vector < SwNodeRange > >::const_iterator aRowIter = rTableNodes.begin();
1388*b1cdbd2cSJim Jagielski for( nLines = 0, nBoxes = 0;
1389*b1cdbd2cSJim Jagielski aRowIter != rTableNodes.end();
1390*b1cdbd2cSJim Jagielski ++aRowIter, /*aSttIdx += 2, */nLines++, nBoxes = 0 )
1391*b1cdbd2cSJim Jagielski {
1392*b1cdbd2cSJim Jagielski // SwTxtNode* pTxtNd = aSttIdx.GetNode().GetTxtNode();
1393*b1cdbd2cSJim Jagielski // ASSERT( pTxtNd, "nur TextNodes in der Tabelle aufnehmen" );
1394*b1cdbd2cSJim Jagielski
1395*b1cdbd2cSJim Jagielski pLine = new SwTableLine( pLineFmt, 1, 0 );
1396*b1cdbd2cSJim Jagielski pTable->GetTabLines().C40_INSERT( SwTableLine, pLine, nLines );
1397*b1cdbd2cSJim Jagielski
1398*b1cdbd2cSJim Jagielski // SwStartNode* pSttNd;
1399*b1cdbd2cSJim Jagielski // SwPosition aCntPos( aSttIdx, SwIndex( pTxtNd ));
1400*b1cdbd2cSJim Jagielski
1401*b1cdbd2cSJim Jagielski std::vector< SwNodeRange >::const_iterator aCellIter = aRowIter->begin();
1402*b1cdbd2cSJim Jagielski // SvULongs aBkmkArr( 15, 15 );
1403*b1cdbd2cSJim Jagielski // _SaveCntntIdx( pDoc, aCellIter->aStart.GetIndex(), pTxtNd->GetTxt().Len(), aBkmkArr );
1404*b1cdbd2cSJim Jagielski // const sal_Unicode* pTxt = pTxtNd->GetTxt().GetBuffer();
1405*b1cdbd2cSJim Jagielski
1406*b1cdbd2cSJim Jagielski for( ; aCellIter != aRowIter->end(); ++aCellIter )
1407*b1cdbd2cSJim Jagielski {
1408*b1cdbd2cSJim Jagielski // aCellIter->aStart aCellIter->aEnd
1409*b1cdbd2cSJim Jagielski // aCntPos.nContent = nChPos;
1410*b1cdbd2cSJim Jagielski // SwCntntNode* pNewNd = pTxtNd->SplitNode( aCntPos );
1411*b1cdbd2cSJim Jagielski
1412*b1cdbd2cSJim Jagielski // auch f?rs undo?
1413*b1cdbd2cSJim Jagielski // if( aBkmkArr.Count() )
1414*b1cdbd2cSJim Jagielski // _RestoreCntntIdx( aBkmkArr, *pNewNd, nChPos,
1415*b1cdbd2cSJim Jagielski // nChPos + 1 );
1416*b1cdbd2cSJim Jagielski
1417*b1cdbd2cSJim Jagielski const SwNodeIndex aTmpIdx( aCellIter->aStart, 0 );
1418*b1cdbd2cSJim Jagielski
1419*b1cdbd2cSJim Jagielski SwNodeIndex aCellEndIdx(aCellIter->aEnd);
1420*b1cdbd2cSJim Jagielski ++aCellEndIdx;
1421*b1cdbd2cSJim Jagielski SwStartNode* pSttNd = new SwStartNode( aTmpIdx, ND_STARTNODE,
1422*b1cdbd2cSJim Jagielski SwTableBoxStartNode );
1423*b1cdbd2cSJim Jagielski new SwEndNode( aCellEndIdx, *pSttNd );
1424*b1cdbd2cSJim Jagielski //set the start node on all node of the current cell
1425*b1cdbd2cSJim Jagielski SwNodeIndex aCellNodeIdx = aCellIter->aStart;
1426*b1cdbd2cSJim Jagielski for(;aCellNodeIdx <= aCellIter->aEnd; ++aCellNodeIdx )
1427*b1cdbd2cSJim Jagielski {
1428*b1cdbd2cSJim Jagielski aCellNodeIdx.GetNode().pStartOfSection = pSttNd;
1429*b1cdbd2cSJim Jagielski //skip start/end node pairs
1430*b1cdbd2cSJim Jagielski if( aCellNodeIdx.GetNode().IsStartNode() )
1431*b1cdbd2cSJim Jagielski aCellNodeIdx = SwNodeIndex( *aCellNodeIdx.GetNode().EndOfSectionNode() );
1432*b1cdbd2cSJim Jagielski }
1433*b1cdbd2cSJim Jagielski
1434*b1cdbd2cSJim Jagielski // Section der Box zuweisen
1435*b1cdbd2cSJim Jagielski pBox = new SwTableBox( pBoxFmt, *pSttNd, pLine );
1436*b1cdbd2cSJim Jagielski pLine->GetTabBoxes().C40_INSERT( SwTableBox, pBox, nBoxes++ );
1437*b1cdbd2cSJim Jagielski }
1438*b1cdbd2cSJim Jagielski if( nMaxBoxes < nBoxes )
1439*b1cdbd2cSJim Jagielski nMaxBoxes = nBoxes;
1440*b1cdbd2cSJim Jagielski }
1441*b1cdbd2cSJim Jagielski
1442*b1cdbd2cSJim Jagielski // die Tabelle ausgleichen, leere Sections einfuegen
1443*b1cdbd2cSJim Jagielski sal_uInt16 n;
1444*b1cdbd2cSJim Jagielski
1445*b1cdbd2cSJim Jagielski if( aPosArr.Count() )
1446*b1cdbd2cSJim Jagielski {
1447*b1cdbd2cSJim Jagielski SwTableLines& rLns = pTable->GetTabLines();
1448*b1cdbd2cSJim Jagielski sal_uInt16 nLastPos = 0;
1449*b1cdbd2cSJim Jagielski for( n = 0; n < aPosArr.Count(); ++n )
1450*b1cdbd2cSJim Jagielski {
1451*b1cdbd2cSJim Jagielski SwTableBoxFmt *pNewFmt = pDoc->MakeTableBoxFmt();
1452*b1cdbd2cSJim Jagielski pNewFmt->SetFmtAttr( SwFmtFrmSize( ATT_VAR_SIZE,
1453*b1cdbd2cSJim Jagielski aPosArr[ n ] - nLastPos ));
1454*b1cdbd2cSJim Jagielski for( sal_uInt16 nLines2 = 0; nLines2 < rLns.Count(); ++nLines2 )
1455*b1cdbd2cSJim Jagielski //JP 24.06.98: hier muss ein Add erfolgen, da das BoxFormat
1456*b1cdbd2cSJim Jagielski // von der rufenden Methode noch gebraucht wird!
1457*b1cdbd2cSJim Jagielski pNewFmt->Add( rLns[ nLines2 ]->GetTabBoxes()[ n ] );
1458*b1cdbd2cSJim Jagielski
1459*b1cdbd2cSJim Jagielski nLastPos = aPosArr[ n ];
1460*b1cdbd2cSJim Jagielski }
1461*b1cdbd2cSJim Jagielski
1462*b1cdbd2cSJim Jagielski // damit die Tabelle die richtige Groesse bekommt, im BoxFormat die
1463*b1cdbd2cSJim Jagielski // Groesse nach "oben" transportieren.
1464*b1cdbd2cSJim Jagielski ASSERT( !pBoxFmt->GetDepends(), "wer ist in dem Format noch angemeldet" );
1465*b1cdbd2cSJim Jagielski pBoxFmt->SetFmtAttr( SwFmtFrmSize( ATT_VAR_SIZE, nLastPos ));
1466*b1cdbd2cSJim Jagielski }
1467*b1cdbd2cSJim Jagielski else
1468*b1cdbd2cSJim Jagielski pBoxFmt->SetFmtAttr( SwFmtFrmSize( ATT_VAR_SIZE, USHRT_MAX / nMaxBoxes ));
1469*b1cdbd2cSJim Jagielski
1470*b1cdbd2cSJim Jagielski // das wars doch wohl ??
1471*b1cdbd2cSJim Jagielski return pTblNd;
1472*b1cdbd2cSJim Jagielski }
1473*b1cdbd2cSJim Jagielski
1474*b1cdbd2cSJim Jagielski
1475*b1cdbd2cSJim Jagielski //---------------- Tabelle -> Text -----------------------
1476*b1cdbd2cSJim Jagielski
1477*b1cdbd2cSJim Jagielski
TableToText(const SwTableNode * pTblNd,sal_Unicode cCh)1478*b1cdbd2cSJim Jagielski sal_Bool SwDoc::TableToText( const SwTableNode* pTblNd, sal_Unicode cCh )
1479*b1cdbd2cSJim Jagielski {
1480*b1cdbd2cSJim Jagielski if( !pTblNd )
1481*b1cdbd2cSJim Jagielski return sal_False;
1482*b1cdbd2cSJim Jagielski
1483*b1cdbd2cSJim Jagielski // --> FME 2004-09-28 #i34471#
1484*b1cdbd2cSJim Jagielski // If this is trigged by SwUndoTblToTxt::Repeat() nobody ever deleted
1485*b1cdbd2cSJim Jagielski // the table cursor.
1486*b1cdbd2cSJim Jagielski SwEditShell* pESh = GetEditShell();
1487*b1cdbd2cSJim Jagielski if( pESh && pESh->IsTableMode() )
1488*b1cdbd2cSJim Jagielski pESh->ClearMark();
1489*b1cdbd2cSJim Jagielski // <--
1490*b1cdbd2cSJim Jagielski
1491*b1cdbd2cSJim Jagielski #ifdef DEL_TABLE_REDLINES
1492*b1cdbd2cSJim Jagielski lcl_DelRedlines aDelRedl( *pTblNd, sal_False );
1493*b1cdbd2cSJim Jagielski #endif
1494*b1cdbd2cSJim Jagielski
1495*b1cdbd2cSJim Jagielski SwNodeRange aRg( *pTblNd, 0, *pTblNd->EndOfSectionNode() );
1496*b1cdbd2cSJim Jagielski SwUndoTblToTxt* pUndo = 0;
1497*b1cdbd2cSJim Jagielski SwNodeRange* pUndoRg = 0;
1498*b1cdbd2cSJim Jagielski if (GetIDocumentUndoRedo().DoesUndo())
1499*b1cdbd2cSJim Jagielski {
1500*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().ClearRedo();
1501*b1cdbd2cSJim Jagielski pUndoRg = new SwNodeRange( aRg.aStart, -1, aRg.aEnd, +1 );
1502*b1cdbd2cSJim Jagielski pUndo = new SwUndoTblToTxt( pTblNd->GetTable(), cCh );
1503*b1cdbd2cSJim Jagielski }
1504*b1cdbd2cSJim Jagielski
1505*b1cdbd2cSJim Jagielski SwTableFmlUpdate aMsgHnt( &pTblNd->GetTable() );
1506*b1cdbd2cSJim Jagielski aMsgHnt.eFlags = TBL_BOXNAME;
1507*b1cdbd2cSJim Jagielski UpdateTblFlds( &aMsgHnt );
1508*b1cdbd2cSJim Jagielski
1509*b1cdbd2cSJim Jagielski sal_Bool bRet = GetNodes().TableToText( aRg, cCh, pUndo );
1510*b1cdbd2cSJim Jagielski if( pUndoRg )
1511*b1cdbd2cSJim Jagielski {
1512*b1cdbd2cSJim Jagielski pUndoRg->aStart++;
1513*b1cdbd2cSJim Jagielski pUndoRg->aEnd--;
1514*b1cdbd2cSJim Jagielski pUndo->SetRange( *pUndoRg );
1515*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().AppendUndo(pUndo);
1516*b1cdbd2cSJim Jagielski delete pUndoRg;
1517*b1cdbd2cSJim Jagielski }
1518*b1cdbd2cSJim Jagielski
1519*b1cdbd2cSJim Jagielski if( bRet )
1520*b1cdbd2cSJim Jagielski SetModified();
1521*b1cdbd2cSJim Jagielski
1522*b1cdbd2cSJim Jagielski return bRet;
1523*b1cdbd2cSJim Jagielski }
1524*b1cdbd2cSJim Jagielski
1525*b1cdbd2cSJim Jagielski // -- benutze die ForEach Methode vom PtrArray um aus einer Tabelle wieder
1526*b1cdbd2cSJim Jagielski // Text zuerzeugen. (Die Boxen koennen auch noch Lines enthalten !!)
1527*b1cdbd2cSJim Jagielski struct _DelTabPara
1528*b1cdbd2cSJim Jagielski {
1529*b1cdbd2cSJim Jagielski SwTxtNode* pLastNd;
1530*b1cdbd2cSJim Jagielski SwNodes& rNds;
1531*b1cdbd2cSJim Jagielski SwUndoTblToTxt* pUndo;
1532*b1cdbd2cSJim Jagielski sal_Unicode cCh;
1533*b1cdbd2cSJim Jagielski
_DelTabPara_DelTabPara1534*b1cdbd2cSJim Jagielski _DelTabPara( SwNodes& rNodes, sal_Unicode cChar, SwUndoTblToTxt* pU ) :
1535*b1cdbd2cSJim Jagielski pLastNd(0), rNds( rNodes ), pUndo( pU ), cCh( cChar ) {}
_DelTabPara_DelTabPara1536*b1cdbd2cSJim Jagielski _DelTabPara( const _DelTabPara& rPara ) :
1537*b1cdbd2cSJim Jagielski pLastNd(rPara.pLastNd), rNds( rPara.rNds ),
1538*b1cdbd2cSJim Jagielski pUndo( rPara.pUndo ), cCh( rPara.cCh ) {}
1539*b1cdbd2cSJim Jagielski };
1540*b1cdbd2cSJim Jagielski
1541*b1cdbd2cSJim Jagielski // forward deklarieren damit sich die Lines und Boxen rekursiv aufrufen
1542*b1cdbd2cSJim Jagielski // koennen.
1543*b1cdbd2cSJim Jagielski sal_Bool lcl_DelBox( const SwTableBox*&, void *pPara );
1544*b1cdbd2cSJim Jagielski
lcl_DelLine(const SwTableLine * & rpLine,void * pPara)1545*b1cdbd2cSJim Jagielski sal_Bool lcl_DelLine( const SwTableLine*& rpLine, void* pPara )
1546*b1cdbd2cSJim Jagielski {
1547*b1cdbd2cSJim Jagielski ASSERT( pPara, "die Parameter fehlen" );
1548*b1cdbd2cSJim Jagielski _DelTabPara aPara( *(_DelTabPara*)pPara );
1549*b1cdbd2cSJim Jagielski ((SwTableLine*&)rpLine)->GetTabBoxes().ForEach( &lcl_DelBox, &aPara );
1550*b1cdbd2cSJim Jagielski if( rpLine->GetUpper() ) // gibt es noch eine uebergeordnete Box ??
1551*b1cdbd2cSJim Jagielski // dann gebe den letzten TextNode zurueck
1552*b1cdbd2cSJim Jagielski ((_DelTabPara*)pPara)->pLastNd = aPara.pLastNd;
1553*b1cdbd2cSJim Jagielski return sal_True;
1554*b1cdbd2cSJim Jagielski }
1555*b1cdbd2cSJim Jagielski
1556*b1cdbd2cSJim Jagielski
lcl_DelBox(const SwTableBox * & rpBox,void * pPara)1557*b1cdbd2cSJim Jagielski sal_Bool lcl_DelBox( const SwTableBox*& rpBox, void* pPara )
1558*b1cdbd2cSJim Jagielski {
1559*b1cdbd2cSJim Jagielski ASSERT( pPara, "die Parameter fehlen" );
1560*b1cdbd2cSJim Jagielski
1561*b1cdbd2cSJim Jagielski // loesche erstmal die Lines der Box
1562*b1cdbd2cSJim Jagielski _DelTabPara* pDelPara = (_DelTabPara*)pPara;
1563*b1cdbd2cSJim Jagielski if( rpBox->GetTabLines().Count() )
1564*b1cdbd2cSJim Jagielski ((SwTableBox*&)rpBox)->GetTabLines().ForEach( &lcl_DelLine, pDelPara );
1565*b1cdbd2cSJim Jagielski else
1566*b1cdbd2cSJim Jagielski {
1567*b1cdbd2cSJim Jagielski SwDoc* pDoc = pDelPara->rNds.GetDoc();
1568*b1cdbd2cSJim Jagielski SwNodeRange aDelRg( *rpBox->GetSttNd(), 0,
1569*b1cdbd2cSJim Jagielski *rpBox->GetSttNd()->EndOfSectionNode() );
1570*b1cdbd2cSJim Jagielski // loesche die Section
1571*b1cdbd2cSJim Jagielski pDelPara->rNds.SectionUp( &aDelRg );
1572*b1cdbd2cSJim Jagielski const SwTxtNode* pCurTxtNd;
1573*b1cdbd2cSJim Jagielski if( T2T_PARA != pDelPara->cCh && pDelPara->pLastNd &&
1574*b1cdbd2cSJim Jagielski 0 != ( pCurTxtNd = aDelRg.aStart.GetNode().GetTxtNode() ))
1575*b1cdbd2cSJim Jagielski {
1576*b1cdbd2cSJim Jagielski // Join the current text node with the last from the previous box if possible
1577*b1cdbd2cSJim Jagielski sal_uLong nNdIdx = aDelRg.aStart.GetIndex();
1578*b1cdbd2cSJim Jagielski aDelRg.aStart--;
1579*b1cdbd2cSJim Jagielski if( pDelPara->pLastNd == &aDelRg.aStart.GetNode() )
1580*b1cdbd2cSJim Jagielski {
1581*b1cdbd2cSJim Jagielski // Inserting the seperator
1582*b1cdbd2cSJim Jagielski SwIndex aCntIdx( pDelPara->pLastNd, pDelPara->pLastNd->GetTxt().Len());
1583*b1cdbd2cSJim Jagielski pDelPara->pLastNd->InsertText( pDelPara->cCh, aCntIdx,
1584*b1cdbd2cSJim Jagielski IDocumentContentOperations::INS_EMPTYEXPAND );
1585*b1cdbd2cSJim Jagielski if( pDelPara->pUndo )
1586*b1cdbd2cSJim Jagielski pDelPara->pUndo->AddBoxPos( *pDoc, nNdIdx, aDelRg.aEnd.GetIndex(),
1587*b1cdbd2cSJim Jagielski aCntIdx.GetIndex() );
1588*b1cdbd2cSJim Jagielski
1589*b1cdbd2cSJim Jagielski SvULongs aBkmkArr( 4, 4 );
1590*b1cdbd2cSJim Jagielski xub_StrLen nOldTxtLen = aCntIdx.GetIndex();
1591*b1cdbd2cSJim Jagielski _SaveCntntIdx( pDoc, nNdIdx, pCurTxtNd->GetTxt().Len(),
1592*b1cdbd2cSJim Jagielski aBkmkArr );
1593*b1cdbd2cSJim Jagielski
1594*b1cdbd2cSJim Jagielski pDelPara->pLastNd->JoinNext();
1595*b1cdbd2cSJim Jagielski
1596*b1cdbd2cSJim Jagielski if( aBkmkArr.Count() )
1597*b1cdbd2cSJim Jagielski _RestoreCntntIdx( pDoc, aBkmkArr,
1598*b1cdbd2cSJim Jagielski pDelPara->pLastNd->GetIndex(),
1599*b1cdbd2cSJim Jagielski nOldTxtLen );
1600*b1cdbd2cSJim Jagielski }
1601*b1cdbd2cSJim Jagielski else if( pDelPara->pUndo )
1602*b1cdbd2cSJim Jagielski {
1603*b1cdbd2cSJim Jagielski aDelRg.aStart++;
1604*b1cdbd2cSJim Jagielski pDelPara->pUndo->AddBoxPos( *pDoc, nNdIdx, aDelRg.aEnd.GetIndex() );
1605*b1cdbd2cSJim Jagielski }
1606*b1cdbd2cSJim Jagielski }
1607*b1cdbd2cSJim Jagielski else if( pDelPara->pUndo )
1608*b1cdbd2cSJim Jagielski pDelPara->pUndo->AddBoxPos( *pDoc, aDelRg.aStart.GetIndex(), aDelRg.aEnd.GetIndex() );
1609*b1cdbd2cSJim Jagielski aDelRg.aEnd--;
1610*b1cdbd2cSJim Jagielski pDelPara->pLastNd = aDelRg.aEnd.GetNode().GetTxtNode();
1611*b1cdbd2cSJim Jagielski
1612*b1cdbd2cSJim Jagielski //JP 03.04.97: die Ausrichtung der ZahlenFormatierung auf
1613*b1cdbd2cSJim Jagielski // keinen Fall uebernehmen
1614*b1cdbd2cSJim Jagielski if( pDelPara->pLastNd && pDelPara->pLastNd->HasSwAttrSet() )
1615*b1cdbd2cSJim Jagielski pDelPara->pLastNd->ResetAttr( RES_PARATR_ADJUST );
1616*b1cdbd2cSJim Jagielski }
1617*b1cdbd2cSJim Jagielski return sal_True;
1618*b1cdbd2cSJim Jagielski }
1619*b1cdbd2cSJim Jagielski
1620*b1cdbd2cSJim Jagielski
TableToText(const SwNodeRange & rRange,sal_Unicode cCh,SwUndoTblToTxt * pUndo)1621*b1cdbd2cSJim Jagielski sal_Bool SwNodes::TableToText( const SwNodeRange& rRange, sal_Unicode cCh,
1622*b1cdbd2cSJim Jagielski SwUndoTblToTxt* pUndo )
1623*b1cdbd2cSJim Jagielski {
1624*b1cdbd2cSJim Jagielski // ist eine Tabelle selektiert ?
1625*b1cdbd2cSJim Jagielski SwTableNode* pTblNd;
1626*b1cdbd2cSJim Jagielski if( rRange.aStart.GetIndex() >= rRange.aEnd.GetIndex() ||
1627*b1cdbd2cSJim Jagielski 0 == ( pTblNd = rRange.aStart.GetNode().GetTableNode()) ||
1628*b1cdbd2cSJim Jagielski &rRange.aEnd.GetNode() != pTblNd->EndOfSectionNode() )
1629*b1cdbd2cSJim Jagielski return sal_False;
1630*b1cdbd2cSJim Jagielski
1631*b1cdbd2cSJim Jagielski // stand die Tabelle ganz alleine in einer Section ?
1632*b1cdbd2cSJim Jagielski // dann ueber den Upper der Tabelle die Frames anlegen
1633*b1cdbd2cSJim Jagielski SwNode2Layout* pNode2Layout = 0;
1634*b1cdbd2cSJim Jagielski SwNodeIndex aFrmIdx( rRange.aStart );
1635*b1cdbd2cSJim Jagielski SwNode* pFrmNd = FindPrvNxtFrmNode( aFrmIdx, &rRange.aEnd.GetNode() );
1636*b1cdbd2cSJim Jagielski if( !pFrmNd )
1637*b1cdbd2cSJim Jagielski // dann sammel mal alle Uppers ein
1638*b1cdbd2cSJim Jagielski pNode2Layout = new SwNode2Layout( *pTblNd );
1639*b1cdbd2cSJim Jagielski
1640*b1cdbd2cSJim Jagielski // loesche schon mal die Frames
1641*b1cdbd2cSJim Jagielski pTblNd->DelFrms();
1642*b1cdbd2cSJim Jagielski
1643*b1cdbd2cSJim Jagielski // dann "loeschen" die Tabellen und fasse alle Lines/Boxen zusammen
1644*b1cdbd2cSJim Jagielski _DelTabPara aDelPara( *this, cCh, pUndo );
1645*b1cdbd2cSJim Jagielski pTblNd->pTable->GetTabLines().ForEach( &lcl_DelLine, &aDelPara );
1646*b1cdbd2cSJim Jagielski
1647*b1cdbd2cSJim Jagielski // jetzt ist aus jeder TableLine ein TextNode mit dem entsprechenden
1648*b1cdbd2cSJim Jagielski // Trenner erzeugt worden. Es braucht nur noch die Table-Section
1649*b1cdbd2cSJim Jagielski // geloescht und fuer die neuen TextNode die Frames erzeugt werden.
1650*b1cdbd2cSJim Jagielski SwNodeRange aDelRg( rRange.aStart, rRange.aEnd );
1651*b1cdbd2cSJim Jagielski
1652*b1cdbd2cSJim Jagielski // JP 14.01.97: hat die Tabelle PageDesc-/Break-Attribute? Dann in den
1653*b1cdbd2cSJim Jagielski // ersten TextNode uebernehmen
1654*b1cdbd2cSJim Jagielski {
1655*b1cdbd2cSJim Jagielski // was ist mit UNDO???
1656*b1cdbd2cSJim Jagielski const SfxItemSet& rTblSet = pTblNd->pTable->GetFrmFmt()->GetAttrSet();
1657*b1cdbd2cSJim Jagielski const SfxPoolItem *pBreak, *pDesc;
1658*b1cdbd2cSJim Jagielski if( SFX_ITEM_SET != rTblSet.GetItemState( RES_PAGEDESC, sal_False, &pDesc ))
1659*b1cdbd2cSJim Jagielski pDesc = 0;
1660*b1cdbd2cSJim Jagielski if( SFX_ITEM_SET != rTblSet.GetItemState( RES_BREAK, sal_False, &pBreak ))
1661*b1cdbd2cSJim Jagielski pBreak = 0;
1662*b1cdbd2cSJim Jagielski
1663*b1cdbd2cSJim Jagielski if( pBreak || pDesc )
1664*b1cdbd2cSJim Jagielski {
1665*b1cdbd2cSJim Jagielski SwNodeIndex aIdx( *pTblNd );
1666*b1cdbd2cSJim Jagielski SwCntntNode* pCNd = GoNext( &aIdx );
1667*b1cdbd2cSJim Jagielski if( pBreak )
1668*b1cdbd2cSJim Jagielski pCNd->SetAttr( *pBreak );
1669*b1cdbd2cSJim Jagielski if( pDesc )
1670*b1cdbd2cSJim Jagielski pCNd->SetAttr( *pDesc );
1671*b1cdbd2cSJim Jagielski }
1672*b1cdbd2cSJim Jagielski }
1673*b1cdbd2cSJim Jagielski
1674*b1cdbd2cSJim Jagielski SectionUp( &aDelRg ); // loesche die Section und damit die Tabelle
1675*b1cdbd2cSJim Jagielski // #i28006#
1676*b1cdbd2cSJim Jagielski sal_uLong nStt = aDelRg.aStart.GetIndex(), nEnd = aDelRg.aEnd.GetIndex();
1677*b1cdbd2cSJim Jagielski if( !pFrmNd )
1678*b1cdbd2cSJim Jagielski {
1679*b1cdbd2cSJim Jagielski pNode2Layout->RestoreUpperFrms( *this,
1680*b1cdbd2cSJim Jagielski aDelRg.aStart.GetIndex(), aDelRg.aEnd.GetIndex() );
1681*b1cdbd2cSJim Jagielski delete pNode2Layout;
1682*b1cdbd2cSJim Jagielski }
1683*b1cdbd2cSJim Jagielski else
1684*b1cdbd2cSJim Jagielski {
1685*b1cdbd2cSJim Jagielski SwCntntNode *pCNd;
1686*b1cdbd2cSJim Jagielski SwSectionNode *pSNd;
1687*b1cdbd2cSJim Jagielski while( aDelRg.aStart.GetIndex() < nEnd )
1688*b1cdbd2cSJim Jagielski {
1689*b1cdbd2cSJim Jagielski if( 0 != ( pCNd = aDelRg.aStart.GetNode().GetCntntNode()))
1690*b1cdbd2cSJim Jagielski {
1691*b1cdbd2cSJim Jagielski if( pFrmNd->IsCntntNode() )
1692*b1cdbd2cSJim Jagielski ((SwCntntNode*)pFrmNd)->MakeFrms( *pCNd );
1693*b1cdbd2cSJim Jagielski else if( pFrmNd->IsTableNode() )
1694*b1cdbd2cSJim Jagielski ((SwTableNode*)pFrmNd)->MakeFrms( aDelRg.aStart );
1695*b1cdbd2cSJim Jagielski else if( pFrmNd->IsSectionNode() )
1696*b1cdbd2cSJim Jagielski ((SwSectionNode*)pFrmNd)->MakeFrms( aDelRg.aStart );
1697*b1cdbd2cSJim Jagielski pFrmNd = pCNd;
1698*b1cdbd2cSJim Jagielski }
1699*b1cdbd2cSJim Jagielski else if( 0 != ( pSNd = aDelRg.aStart.GetNode().GetSectionNode()))
1700*b1cdbd2cSJim Jagielski {
1701*b1cdbd2cSJim Jagielski if( !pSNd->GetSection().IsHidden() && !pSNd->IsCntntHidden() )
1702*b1cdbd2cSJim Jagielski {
1703*b1cdbd2cSJim Jagielski pSNd->MakeFrms( &aFrmIdx, &aDelRg.aEnd );
1704*b1cdbd2cSJim Jagielski pFrmNd = pSNd;
1705*b1cdbd2cSJim Jagielski break;
1706*b1cdbd2cSJim Jagielski }
1707*b1cdbd2cSJim Jagielski aDelRg.aStart = *pSNd->EndOfSectionNode();
1708*b1cdbd2cSJim Jagielski }
1709*b1cdbd2cSJim Jagielski aDelRg.aStart++;
1710*b1cdbd2cSJim Jagielski }
1711*b1cdbd2cSJim Jagielski }
1712*b1cdbd2cSJim Jagielski
1713*b1cdbd2cSJim Jagielski // #i28006# Fly frames have to be restored even if the table was
1714*b1cdbd2cSJim Jagielski // #alone in the section
1715*b1cdbd2cSJim Jagielski const SwSpzFrmFmts& rFlyArr = *GetDoc()->GetSpzFrmFmts();
1716*b1cdbd2cSJim Jagielski for( sal_uInt16 n = 0; n < rFlyArr.Count(); ++n )
1717*b1cdbd2cSJim Jagielski {
1718*b1cdbd2cSJim Jagielski SwFrmFmt *const pFmt = (SwFrmFmt*)rFlyArr[n];
1719*b1cdbd2cSJim Jagielski const SwFmtAnchor& rAnchor = pFmt->GetAnchor();
1720*b1cdbd2cSJim Jagielski SwPosition const*const pAPos = rAnchor.GetCntntAnchor();
1721*b1cdbd2cSJim Jagielski if (pAPos &&
1722*b1cdbd2cSJim Jagielski ((FLY_AT_PARA == rAnchor.GetAnchorId()) ||
1723*b1cdbd2cSJim Jagielski (FLY_AT_CHAR == rAnchor.GetAnchorId())) &&
1724*b1cdbd2cSJim Jagielski nStt <= pAPos->nNode.GetIndex() &&
1725*b1cdbd2cSJim Jagielski pAPos->nNode.GetIndex() < nEnd )
1726*b1cdbd2cSJim Jagielski {
1727*b1cdbd2cSJim Jagielski pFmt->MakeFrms();
1728*b1cdbd2cSJim Jagielski }
1729*b1cdbd2cSJim Jagielski }
1730*b1cdbd2cSJim Jagielski
1731*b1cdbd2cSJim Jagielski return sal_True;
1732*b1cdbd2cSJim Jagielski }
1733*b1cdbd2cSJim Jagielski
1734*b1cdbd2cSJim Jagielski
1735*b1cdbd2cSJim Jagielski // ----- einfuegen von Spalten/Zeilen ------------------------
1736*b1cdbd2cSJim Jagielski
InsertCol(const SwCursor & rCursor,sal_uInt16 nCnt,sal_Bool bBehind)1737*b1cdbd2cSJim Jagielski sal_Bool SwDoc::InsertCol( const SwCursor& rCursor, sal_uInt16 nCnt, sal_Bool bBehind )
1738*b1cdbd2cSJim Jagielski {
1739*b1cdbd2cSJim Jagielski if( !::CheckSplitCells( rCursor, nCnt + 1, nsSwTblSearchType::TBLSEARCH_COL ) )
1740*b1cdbd2cSJim Jagielski return sal_False;
1741*b1cdbd2cSJim Jagielski
1742*b1cdbd2cSJim Jagielski // lasse ueber das Layout die Boxen suchen
1743*b1cdbd2cSJim Jagielski SwSelBoxes aBoxes;
1744*b1cdbd2cSJim Jagielski ::GetTblSel( rCursor, aBoxes, nsSwTblSearchType::TBLSEARCH_COL );
1745*b1cdbd2cSJim Jagielski
1746*b1cdbd2cSJim Jagielski sal_Bool bRet = sal_False;
1747*b1cdbd2cSJim Jagielski if( aBoxes.Count() )
1748*b1cdbd2cSJim Jagielski bRet = InsertCol( aBoxes, nCnt, bBehind );
1749*b1cdbd2cSJim Jagielski return bRet;
1750*b1cdbd2cSJim Jagielski }
1751*b1cdbd2cSJim Jagielski
InsertCol(const SwSelBoxes & rBoxes,sal_uInt16 nCnt,sal_Bool bBehind)1752*b1cdbd2cSJim Jagielski sal_Bool SwDoc::InsertCol( const SwSelBoxes& rBoxes, sal_uInt16 nCnt, sal_Bool bBehind )
1753*b1cdbd2cSJim Jagielski {
1754*b1cdbd2cSJim Jagielski // uebers SwDoc fuer Undo !!
1755*b1cdbd2cSJim Jagielski ASSERT( rBoxes.Count(), "keine gueltige Box-Liste" );
1756*b1cdbd2cSJim Jagielski SwTableNode* pTblNd = (SwTableNode*)rBoxes[0]->GetSttNd()->FindTableNode();
1757*b1cdbd2cSJim Jagielski if( !pTblNd )
1758*b1cdbd2cSJim Jagielski return sal_False;
1759*b1cdbd2cSJim Jagielski
1760*b1cdbd2cSJim Jagielski SwTable& rTbl = pTblNd->GetTable();
1761*b1cdbd2cSJim Jagielski if( rTbl.ISA( SwDDETable ))
1762*b1cdbd2cSJim Jagielski return sal_False;
1763*b1cdbd2cSJim Jagielski
1764*b1cdbd2cSJim Jagielski #ifdef DEL_TABLE_REDLINES
1765*b1cdbd2cSJim Jagielski lcl_DelRedlines aDelRedl( *pTblNd, sal_True );
1766*b1cdbd2cSJim Jagielski #endif
1767*b1cdbd2cSJim Jagielski
1768*b1cdbd2cSJim Jagielski SwTableSortBoxes aTmpLst( 0, 5 );
1769*b1cdbd2cSJim Jagielski SwUndoTblNdsChg* pUndo = 0;
1770*b1cdbd2cSJim Jagielski if (GetIDocumentUndoRedo().DoesUndo())
1771*b1cdbd2cSJim Jagielski {
1772*b1cdbd2cSJim Jagielski pUndo = new SwUndoTblNdsChg( UNDO_TABLE_INSCOL, rBoxes, *pTblNd,
1773*b1cdbd2cSJim Jagielski 0, 0, nCnt, bBehind, sal_False );
1774*b1cdbd2cSJim Jagielski aTmpLst.Insert( &rTbl.GetTabSortBoxes(), 0, rTbl.GetTabSortBoxes().Count() );
1775*b1cdbd2cSJim Jagielski }
1776*b1cdbd2cSJim Jagielski
1777*b1cdbd2cSJim Jagielski bool bRet(false);
1778*b1cdbd2cSJim Jagielski {
1779*b1cdbd2cSJim Jagielski ::sw::UndoGuard const undoGuard(GetIDocumentUndoRedo());
1780*b1cdbd2cSJim Jagielski
1781*b1cdbd2cSJim Jagielski SwTableFmlUpdate aMsgHnt( &rTbl );
1782*b1cdbd2cSJim Jagielski aMsgHnt.eFlags = TBL_BOXPTR;
1783*b1cdbd2cSJim Jagielski UpdateTblFlds( &aMsgHnt );
1784*b1cdbd2cSJim Jagielski
1785*b1cdbd2cSJim Jagielski bRet = rTbl.InsertCol( this, rBoxes, nCnt, bBehind );
1786*b1cdbd2cSJim Jagielski if (bRet)
1787*b1cdbd2cSJim Jagielski {
1788*b1cdbd2cSJim Jagielski SetModified();
1789*b1cdbd2cSJim Jagielski ::ClearFEShellTabCols();
1790*b1cdbd2cSJim Jagielski SetFieldsDirty( true, NULL, 0 );
1791*b1cdbd2cSJim Jagielski }
1792*b1cdbd2cSJim Jagielski }
1793*b1cdbd2cSJim Jagielski
1794*b1cdbd2cSJim Jagielski if( pUndo )
1795*b1cdbd2cSJim Jagielski {
1796*b1cdbd2cSJim Jagielski if( bRet )
1797*b1cdbd2cSJim Jagielski {
1798*b1cdbd2cSJim Jagielski pUndo->SaveNewBoxes( *pTblNd, aTmpLst );
1799*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().AppendUndo( pUndo );
1800*b1cdbd2cSJim Jagielski }
1801*b1cdbd2cSJim Jagielski else
1802*b1cdbd2cSJim Jagielski delete pUndo;
1803*b1cdbd2cSJim Jagielski }
1804*b1cdbd2cSJim Jagielski return bRet;
1805*b1cdbd2cSJim Jagielski }
1806*b1cdbd2cSJim Jagielski
InsertRow(const SwCursor & rCursor,sal_uInt16 nCnt,sal_Bool bBehind)1807*b1cdbd2cSJim Jagielski sal_Bool SwDoc::InsertRow( const SwCursor& rCursor, sal_uInt16 nCnt, sal_Bool bBehind )
1808*b1cdbd2cSJim Jagielski {
1809*b1cdbd2cSJim Jagielski // lasse ueber das Layout die Boxen suchen
1810*b1cdbd2cSJim Jagielski SwSelBoxes aBoxes;
1811*b1cdbd2cSJim Jagielski GetTblSel( rCursor, aBoxes, nsSwTblSearchType::TBLSEARCH_ROW );
1812*b1cdbd2cSJim Jagielski
1813*b1cdbd2cSJim Jagielski sal_Bool bRet = sal_False;
1814*b1cdbd2cSJim Jagielski if( aBoxes.Count() )
1815*b1cdbd2cSJim Jagielski bRet = InsertRow( aBoxes, nCnt, bBehind );
1816*b1cdbd2cSJim Jagielski return bRet;
1817*b1cdbd2cSJim Jagielski }
1818*b1cdbd2cSJim Jagielski
InsertRow(const SwSelBoxes & rBoxes,sal_uInt16 nCnt,sal_Bool bBehind)1819*b1cdbd2cSJim Jagielski sal_Bool SwDoc::InsertRow( const SwSelBoxes& rBoxes, sal_uInt16 nCnt, sal_Bool bBehind )
1820*b1cdbd2cSJim Jagielski {
1821*b1cdbd2cSJim Jagielski // uebers SwDoc fuer Undo !!
1822*b1cdbd2cSJim Jagielski ASSERT( rBoxes.Count(), "keine gueltige Box-Liste" );
1823*b1cdbd2cSJim Jagielski SwTableNode* pTblNd = (SwTableNode*)rBoxes[0]->GetSttNd()->FindTableNode();
1824*b1cdbd2cSJim Jagielski if( !pTblNd )
1825*b1cdbd2cSJim Jagielski return sal_False;
1826*b1cdbd2cSJim Jagielski
1827*b1cdbd2cSJim Jagielski SwTable& rTbl = pTblNd->GetTable();
1828*b1cdbd2cSJim Jagielski if( rTbl.ISA( SwDDETable ))
1829*b1cdbd2cSJim Jagielski return sal_False;
1830*b1cdbd2cSJim Jagielski
1831*b1cdbd2cSJim Jagielski #ifdef DEL_TABLE_REDLINES
1832*b1cdbd2cSJim Jagielski lcl_DelRedlines aDelRedl( *pTblNd, sal_True );
1833*b1cdbd2cSJim Jagielski #endif
1834*b1cdbd2cSJim Jagielski
1835*b1cdbd2cSJim Jagielski SwTableSortBoxes aTmpLst( 0, 5 );
1836*b1cdbd2cSJim Jagielski SwUndoTblNdsChg* pUndo = 0;
1837*b1cdbd2cSJim Jagielski if (GetIDocumentUndoRedo().DoesUndo())
1838*b1cdbd2cSJim Jagielski {
1839*b1cdbd2cSJim Jagielski pUndo = new SwUndoTblNdsChg( UNDO_TABLE_INSROW,rBoxes, *pTblNd,
1840*b1cdbd2cSJim Jagielski 0, 0, nCnt, bBehind, sal_False );
1841*b1cdbd2cSJim Jagielski aTmpLst.Insert( &rTbl.GetTabSortBoxes(), 0, rTbl.GetTabSortBoxes().Count() );
1842*b1cdbd2cSJim Jagielski }
1843*b1cdbd2cSJim Jagielski
1844*b1cdbd2cSJim Jagielski bool bRet(false);
1845*b1cdbd2cSJim Jagielski {
1846*b1cdbd2cSJim Jagielski ::sw::UndoGuard const undoGuard(GetIDocumentUndoRedo());
1847*b1cdbd2cSJim Jagielski
1848*b1cdbd2cSJim Jagielski SwTableFmlUpdate aMsgHnt( &rTbl );
1849*b1cdbd2cSJim Jagielski aMsgHnt.eFlags = TBL_BOXPTR;
1850*b1cdbd2cSJim Jagielski UpdateTblFlds( &aMsgHnt );
1851*b1cdbd2cSJim Jagielski
1852*b1cdbd2cSJim Jagielski bRet = rTbl.InsertRow( this, rBoxes, nCnt, bBehind );
1853*b1cdbd2cSJim Jagielski if (bRet)
1854*b1cdbd2cSJim Jagielski {
1855*b1cdbd2cSJim Jagielski SetModified();
1856*b1cdbd2cSJim Jagielski ::ClearFEShellTabCols();
1857*b1cdbd2cSJim Jagielski SetFieldsDirty( true, NULL, 0 );
1858*b1cdbd2cSJim Jagielski }
1859*b1cdbd2cSJim Jagielski }
1860*b1cdbd2cSJim Jagielski
1861*b1cdbd2cSJim Jagielski if( pUndo )
1862*b1cdbd2cSJim Jagielski {
1863*b1cdbd2cSJim Jagielski if( bRet )
1864*b1cdbd2cSJim Jagielski {
1865*b1cdbd2cSJim Jagielski pUndo->SaveNewBoxes( *pTblNd, aTmpLst );
1866*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().AppendUndo( pUndo );
1867*b1cdbd2cSJim Jagielski }
1868*b1cdbd2cSJim Jagielski else
1869*b1cdbd2cSJim Jagielski delete pUndo;
1870*b1cdbd2cSJim Jagielski }
1871*b1cdbd2cSJim Jagielski return bRet;
1872*b1cdbd2cSJim Jagielski
1873*b1cdbd2cSJim Jagielski }
1874*b1cdbd2cSJim Jagielski
1875*b1cdbd2cSJim Jagielski // ----- loeschen von Spalten/Zeilen ------------------------
1876*b1cdbd2cSJim Jagielski
DeleteRow(const SwCursor & rCursor)1877*b1cdbd2cSJim Jagielski sal_Bool SwDoc::DeleteRow( const SwCursor& rCursor )
1878*b1cdbd2cSJim Jagielski {
1879*b1cdbd2cSJim Jagielski // lasse ueber das Layout die Boxen suchen
1880*b1cdbd2cSJim Jagielski SwSelBoxes aBoxes;
1881*b1cdbd2cSJim Jagielski GetTblSel( rCursor, aBoxes, nsSwTblSearchType::TBLSEARCH_ROW );
1882*b1cdbd2cSJim Jagielski if( ::HasProtectedCells( aBoxes ))
1883*b1cdbd2cSJim Jagielski return sal_False;
1884*b1cdbd2cSJim Jagielski
1885*b1cdbd2cSJim Jagielski // die Crsr aus dem Loeschbereich entfernen.
1886*b1cdbd2cSJim Jagielski // Der Cursor steht danach:
1887*b1cdbd2cSJim Jagielski // - es folgt noch eine Zeile, in dieser
1888*b1cdbd2cSJim Jagielski // - vorher steht noch eine Zeile, in dieser
1889*b1cdbd2cSJim Jagielski // - sonst immer dahinter
1890*b1cdbd2cSJim Jagielski {
1891*b1cdbd2cSJim Jagielski SwTableNode* pTblNd = rCursor.GetNode()->FindTableNode();
1892*b1cdbd2cSJim Jagielski
1893*b1cdbd2cSJim Jagielski if( pTblNd->GetTable().ISA( SwDDETable ))
1894*b1cdbd2cSJim Jagielski return sal_False;
1895*b1cdbd2cSJim Jagielski
1896*b1cdbd2cSJim Jagielski // suche alle Boxen / Lines
1897*b1cdbd2cSJim Jagielski _FndBox aFndBox( 0, 0 );
1898*b1cdbd2cSJim Jagielski {
1899*b1cdbd2cSJim Jagielski _FndPara aPara( aBoxes, &aFndBox );
1900*b1cdbd2cSJim Jagielski pTblNd->GetTable().GetTabLines().ForEach( &_FndLineCopyCol, &aPara );
1901*b1cdbd2cSJim Jagielski }
1902*b1cdbd2cSJim Jagielski
1903*b1cdbd2cSJim Jagielski if( !aFndBox.GetLines().Count() )
1904*b1cdbd2cSJim Jagielski return sal_False;
1905*b1cdbd2cSJim Jagielski
1906*b1cdbd2cSJim Jagielski SwEditShell* pESh = GetEditShell();
1907*b1cdbd2cSJim Jagielski if( pESh )
1908*b1cdbd2cSJim Jagielski {
1909*b1cdbd2cSJim Jagielski pESh->KillPams();
1910*b1cdbd2cSJim Jagielski // JP: eigentlich sollte man ueber alle Shells iterieren!!
1911*b1cdbd2cSJim Jagielski }
1912*b1cdbd2cSJim Jagielski
1913*b1cdbd2cSJim Jagielski _FndBox* pFndBox = &aFndBox;
1914*b1cdbd2cSJim Jagielski while( 1 == pFndBox->GetLines().Count() &&
1915*b1cdbd2cSJim Jagielski 1 == pFndBox->GetLines()[0]->GetBoxes().Count() )
1916*b1cdbd2cSJim Jagielski {
1917*b1cdbd2cSJim Jagielski _FndBox* pTmp = pFndBox->GetLines()[0]->GetBoxes()[0];
1918*b1cdbd2cSJim Jagielski if( pTmp->GetBox()->GetSttNd() )
1919*b1cdbd2cSJim Jagielski break; // das ist sonst zu weit
1920*b1cdbd2cSJim Jagielski pFndBox = pTmp;
1921*b1cdbd2cSJim Jagielski }
1922*b1cdbd2cSJim Jagielski
1923*b1cdbd2cSJim Jagielski SwTableLine* pDelLine = pFndBox->GetLines()[
1924*b1cdbd2cSJim Jagielski pFndBox->GetLines().Count()-1 ]->GetLine();
1925*b1cdbd2cSJim Jagielski SwTableBox* pDelBox = pDelLine->GetTabBoxes()[
1926*b1cdbd2cSJim Jagielski pDelLine->GetTabBoxes().Count() - 1 ];
1927*b1cdbd2cSJim Jagielski while( !pDelBox->GetSttNd() )
1928*b1cdbd2cSJim Jagielski {
1929*b1cdbd2cSJim Jagielski SwTableLine* pLn = pDelBox->GetTabLines()[
1930*b1cdbd2cSJim Jagielski pDelBox->GetTabLines().Count()-1 ];
1931*b1cdbd2cSJim Jagielski pDelBox = pLn->GetTabBoxes()[ pLn->GetTabBoxes().Count() - 1 ];
1932*b1cdbd2cSJim Jagielski }
1933*b1cdbd2cSJim Jagielski SwTableBox* pNextBox = pDelLine->FindNextBox( pTblNd->GetTable(),
1934*b1cdbd2cSJim Jagielski pDelBox, sal_True );
1935*b1cdbd2cSJim Jagielski while( pNextBox &&
1936*b1cdbd2cSJim Jagielski pNextBox->GetFrmFmt()->GetProtect().IsCntntProtected() )
1937*b1cdbd2cSJim Jagielski pNextBox = pNextBox->FindNextBox( pTblNd->GetTable(), pNextBox );
1938*b1cdbd2cSJim Jagielski
1939*b1cdbd2cSJim Jagielski if( !pNextBox ) // keine nachfolgende? dann die vorhergehende
1940*b1cdbd2cSJim Jagielski {
1941*b1cdbd2cSJim Jagielski pDelLine = pFndBox->GetLines()[ 0 ]->GetLine();
1942*b1cdbd2cSJim Jagielski pDelBox = pDelLine->GetTabBoxes()[ 0 ];
1943*b1cdbd2cSJim Jagielski while( !pDelBox->GetSttNd() )
1944*b1cdbd2cSJim Jagielski pDelBox = pDelBox->GetTabLines()[0]->GetTabBoxes()[0];
1945*b1cdbd2cSJim Jagielski pNextBox = pDelLine->FindPreviousBox( pTblNd->GetTable(),
1946*b1cdbd2cSJim Jagielski pDelBox, sal_True );
1947*b1cdbd2cSJim Jagielski while( pNextBox &&
1948*b1cdbd2cSJim Jagielski pNextBox->GetFrmFmt()->GetProtect().IsCntntProtected() )
1949*b1cdbd2cSJim Jagielski pNextBox = pNextBox->FindPreviousBox( pTblNd->GetTable(), pNextBox );
1950*b1cdbd2cSJim Jagielski }
1951*b1cdbd2cSJim Jagielski
1952*b1cdbd2cSJim Jagielski sal_uLong nIdx;
1953*b1cdbd2cSJim Jagielski if( pNextBox ) // dann den Cursor hier hinein
1954*b1cdbd2cSJim Jagielski nIdx = pNextBox->GetSttIdx() + 1;
1955*b1cdbd2cSJim Jagielski else // ansonsten hinter die Tabelle
1956*b1cdbd2cSJim Jagielski nIdx = pTblNd->EndOfSectionIndex() + 1;
1957*b1cdbd2cSJim Jagielski
1958*b1cdbd2cSJim Jagielski SwNodeIndex aIdx( GetNodes(), nIdx );
1959*b1cdbd2cSJim Jagielski SwCntntNode* pCNd = aIdx.GetNode().GetCntntNode();
1960*b1cdbd2cSJim Jagielski if( !pCNd )
1961*b1cdbd2cSJim Jagielski pCNd = GetNodes().GoNext( &aIdx );
1962*b1cdbd2cSJim Jagielski
1963*b1cdbd2cSJim Jagielski if( pCNd )
1964*b1cdbd2cSJim Jagielski {
1965*b1cdbd2cSJim Jagielski // die Cursor von der Shell oder den uebergebenen Cursor aendern?
1966*b1cdbd2cSJim Jagielski SwPaM* pPam = (SwPaM*)&rCursor;
1967*b1cdbd2cSJim Jagielski pPam->GetPoint()->nNode = aIdx;
1968*b1cdbd2cSJim Jagielski pPam->GetPoint()->nContent.Assign( pCNd, 0 );
1969*b1cdbd2cSJim Jagielski pPam->SetMark(); // beide wollen etwas davon haben
1970*b1cdbd2cSJim Jagielski pPam->DeleteMark();
1971*b1cdbd2cSJim Jagielski }
1972*b1cdbd2cSJim Jagielski }
1973*b1cdbd2cSJim Jagielski
1974*b1cdbd2cSJim Jagielski // dann loesche doch die Zeilen
1975*b1cdbd2cSJim Jagielski
1976*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().StartUndo(UNDO_ROW_DELETE, NULL);
1977*b1cdbd2cSJim Jagielski sal_Bool bResult = DeleteRowCol( aBoxes );
1978*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().EndUndo(UNDO_ROW_DELETE, NULL);
1979*b1cdbd2cSJim Jagielski
1980*b1cdbd2cSJim Jagielski return bResult;
1981*b1cdbd2cSJim Jagielski }
1982*b1cdbd2cSJim Jagielski
DeleteCol(const SwCursor & rCursor)1983*b1cdbd2cSJim Jagielski sal_Bool SwDoc::DeleteCol( const SwCursor& rCursor )
1984*b1cdbd2cSJim Jagielski {
1985*b1cdbd2cSJim Jagielski // lasse ueber das Layout die Boxen suchen
1986*b1cdbd2cSJim Jagielski SwSelBoxes aBoxes;
1987*b1cdbd2cSJim Jagielski GetTblSel( rCursor, aBoxes, nsSwTblSearchType::TBLSEARCH_COL );
1988*b1cdbd2cSJim Jagielski if( ::HasProtectedCells( aBoxes ))
1989*b1cdbd2cSJim Jagielski return sal_False;
1990*b1cdbd2cSJim Jagielski
1991*b1cdbd2cSJim Jagielski // die Crsr muessen noch aus dem Loesch Bereich entfernt
1992*b1cdbd2cSJim Jagielski // werden. Setze sie immer hinter/auf die Tabelle; ueber die
1993*b1cdbd2cSJim Jagielski // Dokument-Position werden sie dann immer an die alte Position gesetzt.
1994*b1cdbd2cSJim Jagielski SwEditShell* pESh = GetEditShell();
1995*b1cdbd2cSJim Jagielski if( pESh )
1996*b1cdbd2cSJim Jagielski {
1997*b1cdbd2cSJim Jagielski const SwNode* pNd = rCursor.GetNode()->FindTableBoxStartNode();
1998*b1cdbd2cSJim Jagielski pESh->ParkCrsr( SwNodeIndex( *pNd ) );
1999*b1cdbd2cSJim Jagielski }
2000*b1cdbd2cSJim Jagielski
2001*b1cdbd2cSJim Jagielski // dann loesche doch die Spalten
2002*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().StartUndo(UNDO_COL_DELETE, NULL);
2003*b1cdbd2cSJim Jagielski sal_Bool bResult = DeleteRowCol( aBoxes, true );
2004*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().EndUndo(UNDO_COL_DELETE, NULL);
2005*b1cdbd2cSJim Jagielski
2006*b1cdbd2cSJim Jagielski return bResult;
2007*b1cdbd2cSJim Jagielski }
2008*b1cdbd2cSJim Jagielski
DeleteRowCol(const SwSelBoxes & rBoxes,bool bColumn)2009*b1cdbd2cSJim Jagielski sal_Bool SwDoc::DeleteRowCol( const SwSelBoxes& rBoxes, bool bColumn )
2010*b1cdbd2cSJim Jagielski {
2011*b1cdbd2cSJim Jagielski if( ::HasProtectedCells( rBoxes ))
2012*b1cdbd2cSJim Jagielski return sal_False;
2013*b1cdbd2cSJim Jagielski
2014*b1cdbd2cSJim Jagielski // uebers SwDoc fuer Undo !!
2015*b1cdbd2cSJim Jagielski ASSERT( rBoxes.Count(), "keine gueltige Box-Liste" );
2016*b1cdbd2cSJim Jagielski SwTableNode* pTblNd = (SwTableNode*)rBoxes[0]->GetSttNd()->FindTableNode();
2017*b1cdbd2cSJim Jagielski if( !pTblNd )
2018*b1cdbd2cSJim Jagielski return sal_False;
2019*b1cdbd2cSJim Jagielski
2020*b1cdbd2cSJim Jagielski if( pTblNd->GetTable().ISA( SwDDETable ))
2021*b1cdbd2cSJim Jagielski return sal_False;
2022*b1cdbd2cSJim Jagielski
2023*b1cdbd2cSJim Jagielski ::ClearFEShellTabCols();
2024*b1cdbd2cSJim Jagielski SwSelBoxes aSelBoxes;
2025*b1cdbd2cSJim Jagielski aSelBoxes.Insert(rBoxes.GetData(), rBoxes.Count());
2026*b1cdbd2cSJim Jagielski SwTable &rTable = pTblNd->GetTable();
2027*b1cdbd2cSJim Jagielski long nMin = 0;
2028*b1cdbd2cSJim Jagielski long nMax = 0;
2029*b1cdbd2cSJim Jagielski if( rTable.IsNewModel() )
2030*b1cdbd2cSJim Jagielski {
2031*b1cdbd2cSJim Jagielski if( bColumn )
2032*b1cdbd2cSJim Jagielski rTable.ExpandColumnSelection( aSelBoxes, nMin, nMax );
2033*b1cdbd2cSJim Jagielski else
2034*b1cdbd2cSJim Jagielski rTable.FindSuperfluousRows( aSelBoxes );
2035*b1cdbd2cSJim Jagielski }
2036*b1cdbd2cSJim Jagielski
2037*b1cdbd2cSJim Jagielski #ifdef DEL_TABLE_REDLINES
2038*b1cdbd2cSJim Jagielski lcl_DelRedlines aDelRedl( *pTblNd, sal_True );
2039*b1cdbd2cSJim Jagielski #endif
2040*b1cdbd2cSJim Jagielski
2041*b1cdbd2cSJim Jagielski // soll die gesamte Tabelle geloescht werden ??
2042*b1cdbd2cSJim Jagielski const sal_uLong nTmpIdx1 = pTblNd->GetIndex();
2043*b1cdbd2cSJim Jagielski const sal_uLong nTmpIdx2 = aSelBoxes[ aSelBoxes.Count()-1 ]->GetSttNd()->
2044*b1cdbd2cSJim Jagielski EndOfSectionIndex()+1;
2045*b1cdbd2cSJim Jagielski if( pTblNd->GetTable().GetTabSortBoxes().Count() == aSelBoxes.Count() &&
2046*b1cdbd2cSJim Jagielski aSelBoxes[0]->GetSttIdx()-1 == nTmpIdx1 &&
2047*b1cdbd2cSJim Jagielski nTmpIdx2 == pTblNd->EndOfSectionIndex() )
2048*b1cdbd2cSJim Jagielski {
2049*b1cdbd2cSJim Jagielski sal_Bool bNewTxtNd = sal_False;
2050*b1cdbd2cSJim Jagielski // steht diese auch noch alleine in einem FlyFrame ?
2051*b1cdbd2cSJim Jagielski SwNodeIndex aIdx( *pTblNd, -1 );
2052*b1cdbd2cSJim Jagielski const SwStartNode* pSttNd = aIdx.GetNode().GetStartNode();
2053*b1cdbd2cSJim Jagielski if( pSttNd )
2054*b1cdbd2cSJim Jagielski {
2055*b1cdbd2cSJim Jagielski const sal_uLong nTblEnd = pTblNd->EndOfSectionIndex() + 1;
2056*b1cdbd2cSJim Jagielski const sal_uLong nSectEnd = pSttNd->EndOfSectionIndex();
2057*b1cdbd2cSJim Jagielski if( nTblEnd == nSectEnd )
2058*b1cdbd2cSJim Jagielski {
2059*b1cdbd2cSJim Jagielski if( SwFlyStartNode == pSttNd->GetStartNodeType() )
2060*b1cdbd2cSJim Jagielski {
2061*b1cdbd2cSJim Jagielski SwFrmFmt* pFmt = pSttNd->GetFlyFmt();
2062*b1cdbd2cSJim Jagielski if( pFmt )
2063*b1cdbd2cSJim Jagielski {
2064*b1cdbd2cSJim Jagielski // Ok, das ist das gesuchte FlyFormat
2065*b1cdbd2cSJim Jagielski DelLayoutFmt( pFmt );
2066*b1cdbd2cSJim Jagielski return sal_True;
2067*b1cdbd2cSJim Jagielski }
2068*b1cdbd2cSJim Jagielski }
2069*b1cdbd2cSJim Jagielski // kein Fly ?? also Kopf- oder Fusszeile: dann immer einen
2070*b1cdbd2cSJim Jagielski // TextNode ueberig lassen.
2071*b1cdbd2cSJim Jagielski // Undo koennen wir dann vergessen !!
2072*b1cdbd2cSJim Jagielski bNewTxtNd = sal_True;
2073*b1cdbd2cSJim Jagielski }
2074*b1cdbd2cSJim Jagielski }
2075*b1cdbd2cSJim Jagielski
2076*b1cdbd2cSJim Jagielski // kein Fly ?? also Kopf- oder Fusszeile: dann immer einen
2077*b1cdbd2cSJim Jagielski // TextNode ueberig lassen.
2078*b1cdbd2cSJim Jagielski aIdx++;
2079*b1cdbd2cSJim Jagielski if (GetIDocumentUndoRedo().DoesUndo())
2080*b1cdbd2cSJim Jagielski {
2081*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().ClearRedo();
2082*b1cdbd2cSJim Jagielski SwPaM aPaM( *pTblNd->EndOfSectionNode(), aIdx.GetNode() );
2083*b1cdbd2cSJim Jagielski
2084*b1cdbd2cSJim Jagielski if( bNewTxtNd )
2085*b1cdbd2cSJim Jagielski {
2086*b1cdbd2cSJim Jagielski const SwNodeIndex aTmpIdx( *pTblNd->EndOfSectionNode(), 1 );
2087*b1cdbd2cSJim Jagielski GetNodes().MakeTxtNode( aTmpIdx,
2088*b1cdbd2cSJim Jagielski GetTxtCollFromPool( RES_POOLCOLL_STANDARD ) );
2089*b1cdbd2cSJim Jagielski }
2090*b1cdbd2cSJim Jagielski
2091*b1cdbd2cSJim Jagielski // save the cursors (UNO and otherwise)
2092*b1cdbd2cSJim Jagielski SwPaM aSavePaM( SwNodeIndex( *pTblNd->EndOfSectionNode() ) );
2093*b1cdbd2cSJim Jagielski if( ! aSavePaM.Move( fnMoveForward, fnGoNode ) )
2094*b1cdbd2cSJim Jagielski {
2095*b1cdbd2cSJim Jagielski *aSavePaM.GetMark() = SwPosition( *pTblNd );
2096*b1cdbd2cSJim Jagielski aSavePaM.Move( fnMoveBackward, fnGoNode );
2097*b1cdbd2cSJim Jagielski }
2098*b1cdbd2cSJim Jagielski {
2099*b1cdbd2cSJim Jagielski SwPaM const tmpPaM(*pTblNd, *pTblNd->EndOfSectionNode());
2100*b1cdbd2cSJim Jagielski ::PaMCorrAbs(tmpPaM, *aSavePaM.GetMark());
2101*b1cdbd2cSJim Jagielski }
2102*b1cdbd2cSJim Jagielski
2103*b1cdbd2cSJim Jagielski // harte SeitenUmbrueche am nachfolgenden Node verschieben
2104*b1cdbd2cSJim Jagielski sal_Bool bSavePageBreak = sal_False, bSavePageDesc = sal_False;
2105*b1cdbd2cSJim Jagielski sal_uLong nNextNd = pTblNd->EndOfSectionIndex()+1;
2106*b1cdbd2cSJim Jagielski SwCntntNode* pNextNd = GetNodes()[ nNextNd ]->GetCntntNode();
2107*b1cdbd2cSJim Jagielski if( pNextNd )
2108*b1cdbd2cSJim Jagielski {
2109*b1cdbd2cSJim Jagielski //JP 24.08.98: will man wirklich den PageDesc/Break vom
2110*b1cdbd2cSJim Jagielski // nachfolgen Absatz ueberbuegeln?
2111*b1cdbd2cSJim Jagielski // const SwAttrSet& rAttrSet = pNextNd->GetSwAttrSet();
2112*b1cdbd2cSJim Jagielski // if( SFX_ITEM_SET != rAttrSet.GetItemState( RES_PAGEDESC ) &&
2113*b1cdbd2cSJim Jagielski // SFX_ITEM_SET != rAttrSet.GetItemState( RES_BREAK ))
2114*b1cdbd2cSJim Jagielski {
2115*b1cdbd2cSJim Jagielski SwFrmFmt* pTableFmt = pTblNd->GetTable().GetFrmFmt();
2116*b1cdbd2cSJim Jagielski const SfxPoolItem *pItem;
2117*b1cdbd2cSJim Jagielski if( SFX_ITEM_SET == pTableFmt->GetItemState( RES_PAGEDESC,
2118*b1cdbd2cSJim Jagielski sal_False, &pItem ) )
2119*b1cdbd2cSJim Jagielski {
2120*b1cdbd2cSJim Jagielski pNextNd->SetAttr( *pItem );
2121*b1cdbd2cSJim Jagielski bSavePageDesc = sal_True;
2122*b1cdbd2cSJim Jagielski }
2123*b1cdbd2cSJim Jagielski
2124*b1cdbd2cSJim Jagielski if( SFX_ITEM_SET == pTableFmt->GetItemState( RES_BREAK,
2125*b1cdbd2cSJim Jagielski sal_False, &pItem ) )
2126*b1cdbd2cSJim Jagielski {
2127*b1cdbd2cSJim Jagielski pNextNd->SetAttr( *pItem );
2128*b1cdbd2cSJim Jagielski bSavePageBreak = sal_True;
2129*b1cdbd2cSJim Jagielski }
2130*b1cdbd2cSJim Jagielski }
2131*b1cdbd2cSJim Jagielski }
2132*b1cdbd2cSJim Jagielski SwUndoDelete* pUndo = new SwUndoDelete( aPaM );
2133*b1cdbd2cSJim Jagielski if( bNewTxtNd )
2134*b1cdbd2cSJim Jagielski pUndo->SetTblDelLastNd();
2135*b1cdbd2cSJim Jagielski pUndo->SetPgBrkFlags( bSavePageBreak, bSavePageDesc );
2136*b1cdbd2cSJim Jagielski pUndo->SetTableName(pTblNd->GetTable().GetFrmFmt()->GetName());
2137*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().AppendUndo( pUndo );
2138*b1cdbd2cSJim Jagielski }
2139*b1cdbd2cSJim Jagielski else
2140*b1cdbd2cSJim Jagielski {
2141*b1cdbd2cSJim Jagielski if( bNewTxtNd )
2142*b1cdbd2cSJim Jagielski {
2143*b1cdbd2cSJim Jagielski const SwNodeIndex aTmpIdx( *pTblNd->EndOfSectionNode(), 1 );
2144*b1cdbd2cSJim Jagielski GetNodes().MakeTxtNode( aTmpIdx,
2145*b1cdbd2cSJim Jagielski GetTxtCollFromPool( RES_POOLCOLL_STANDARD ) );
2146*b1cdbd2cSJim Jagielski }
2147*b1cdbd2cSJim Jagielski
2148*b1cdbd2cSJim Jagielski // save the cursors (UNO and otherwise)
2149*b1cdbd2cSJim Jagielski SwPaM aSavePaM( SwNodeIndex( *pTblNd->EndOfSectionNode() ) );
2150*b1cdbd2cSJim Jagielski if( ! aSavePaM.Move( fnMoveForward, fnGoNode ) )
2151*b1cdbd2cSJim Jagielski {
2152*b1cdbd2cSJim Jagielski *aSavePaM.GetMark() = SwPosition( *pTblNd );
2153*b1cdbd2cSJim Jagielski aSavePaM.Move( fnMoveBackward, fnGoNode );
2154*b1cdbd2cSJim Jagielski }
2155*b1cdbd2cSJim Jagielski {
2156*b1cdbd2cSJim Jagielski SwPaM const tmpPaM(*pTblNd, *pTblNd->EndOfSectionNode());
2157*b1cdbd2cSJim Jagielski ::PaMCorrAbs(tmpPaM, *aSavePaM.GetMark());
2158*b1cdbd2cSJim Jagielski }
2159*b1cdbd2cSJim Jagielski
2160*b1cdbd2cSJim Jagielski // harte SeitenUmbrueche am nachfolgenden Node verschieben
2161*b1cdbd2cSJim Jagielski SwCntntNode* pNextNd = GetNodes()[ pTblNd->EndOfSectionIndex()+1 ]->GetCntntNode();
2162*b1cdbd2cSJim Jagielski if( pNextNd )
2163*b1cdbd2cSJim Jagielski {
2164*b1cdbd2cSJim Jagielski SwFrmFmt* pTableFmt = pTblNd->GetTable().GetFrmFmt();
2165*b1cdbd2cSJim Jagielski const SfxPoolItem *pItem;
2166*b1cdbd2cSJim Jagielski if( SFX_ITEM_SET == pTableFmt->GetItemState( RES_PAGEDESC,
2167*b1cdbd2cSJim Jagielski sal_False, &pItem ) )
2168*b1cdbd2cSJim Jagielski pNextNd->SetAttr( *pItem );
2169*b1cdbd2cSJim Jagielski
2170*b1cdbd2cSJim Jagielski if( SFX_ITEM_SET == pTableFmt->GetItemState( RES_BREAK,
2171*b1cdbd2cSJim Jagielski sal_False, &pItem ) )
2172*b1cdbd2cSJim Jagielski pNextNd->SetAttr( *pItem );
2173*b1cdbd2cSJim Jagielski }
2174*b1cdbd2cSJim Jagielski
2175*b1cdbd2cSJim Jagielski pTblNd->DelFrms();
2176*b1cdbd2cSJim Jagielski DeleteSection( pTblNd );
2177*b1cdbd2cSJim Jagielski }
2178*b1cdbd2cSJim Jagielski SetModified();
2179*b1cdbd2cSJim Jagielski SetFieldsDirty( true, NULL, 0 );
2180*b1cdbd2cSJim Jagielski return sal_True;
2181*b1cdbd2cSJim Jagielski }
2182*b1cdbd2cSJim Jagielski
2183*b1cdbd2cSJim Jagielski SwUndoTblNdsChg* pUndo = 0;
2184*b1cdbd2cSJim Jagielski if (GetIDocumentUndoRedo().DoesUndo())
2185*b1cdbd2cSJim Jagielski {
2186*b1cdbd2cSJim Jagielski pUndo = new SwUndoTblNdsChg( UNDO_TABLE_DELBOX, aSelBoxes, *pTblNd,
2187*b1cdbd2cSJim Jagielski nMin, nMax, 0, sal_False, sal_False );
2188*b1cdbd2cSJim Jagielski }
2189*b1cdbd2cSJim Jagielski
2190*b1cdbd2cSJim Jagielski bool bRet(false);
2191*b1cdbd2cSJim Jagielski {
2192*b1cdbd2cSJim Jagielski ::sw::UndoGuard const undoGuard(GetIDocumentUndoRedo());
2193*b1cdbd2cSJim Jagielski
2194*b1cdbd2cSJim Jagielski SwTableFmlUpdate aMsgHnt( &pTblNd->GetTable() );
2195*b1cdbd2cSJim Jagielski aMsgHnt.eFlags = TBL_BOXPTR;
2196*b1cdbd2cSJim Jagielski UpdateTblFlds( &aMsgHnt );
2197*b1cdbd2cSJim Jagielski
2198*b1cdbd2cSJim Jagielski if (rTable.IsNewModel())
2199*b1cdbd2cSJim Jagielski {
2200*b1cdbd2cSJim Jagielski if (bColumn)
2201*b1cdbd2cSJim Jagielski rTable.PrepareDeleteCol( nMin, nMax );
2202*b1cdbd2cSJim Jagielski rTable.FindSuperfluousRows( aSelBoxes );
2203*b1cdbd2cSJim Jagielski if (pUndo)
2204*b1cdbd2cSJim Jagielski pUndo->ReNewBoxes( aSelBoxes );
2205*b1cdbd2cSJim Jagielski }
2206*b1cdbd2cSJim Jagielski bRet = rTable.DeleteSel( this, aSelBoxes, 0, pUndo, sal_True, sal_True );
2207*b1cdbd2cSJim Jagielski if (bRet)
2208*b1cdbd2cSJim Jagielski {
2209*b1cdbd2cSJim Jagielski SetModified();
2210*b1cdbd2cSJim Jagielski SetFieldsDirty( true, NULL, 0 );
2211*b1cdbd2cSJim Jagielski }
2212*b1cdbd2cSJim Jagielski }
2213*b1cdbd2cSJim Jagielski
2214*b1cdbd2cSJim Jagielski if( pUndo )
2215*b1cdbd2cSJim Jagielski {
2216*b1cdbd2cSJim Jagielski if( bRet )
2217*b1cdbd2cSJim Jagielski {
2218*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().AppendUndo( pUndo );
2219*b1cdbd2cSJim Jagielski }
2220*b1cdbd2cSJim Jagielski else
2221*b1cdbd2cSJim Jagielski delete pUndo;
2222*b1cdbd2cSJim Jagielski }
2223*b1cdbd2cSJim Jagielski
2224*b1cdbd2cSJim Jagielski return bRet;
2225*b1cdbd2cSJim Jagielski }
2226*b1cdbd2cSJim Jagielski
2227*b1cdbd2cSJim Jagielski
2228*b1cdbd2cSJim Jagielski // ---------- teilen / zusammenfassen von Boxen in der Tabelle --------
2229*b1cdbd2cSJim Jagielski
SplitTbl(const SwSelBoxes & rBoxes,sal_Bool bVert,sal_uInt16 nCnt,sal_Bool bSameHeight)2230*b1cdbd2cSJim Jagielski sal_Bool SwDoc::SplitTbl( const SwSelBoxes& rBoxes, sal_Bool bVert, sal_uInt16 nCnt,
2231*b1cdbd2cSJim Jagielski sal_Bool bSameHeight )
2232*b1cdbd2cSJim Jagielski {
2233*b1cdbd2cSJim Jagielski // uebers SwDoc fuer Undo !!
2234*b1cdbd2cSJim Jagielski ASSERT( rBoxes.Count() && nCnt, "keine gueltige Box-Liste" );
2235*b1cdbd2cSJim Jagielski SwTableNode* pTblNd = (SwTableNode*)rBoxes[0]->GetSttNd()->FindTableNode();
2236*b1cdbd2cSJim Jagielski if( !pTblNd )
2237*b1cdbd2cSJim Jagielski return sal_False;
2238*b1cdbd2cSJim Jagielski
2239*b1cdbd2cSJim Jagielski SwTable& rTbl = pTblNd->GetTable();
2240*b1cdbd2cSJim Jagielski if( rTbl.ISA( SwDDETable ))
2241*b1cdbd2cSJim Jagielski return sal_False;
2242*b1cdbd2cSJim Jagielski
2243*b1cdbd2cSJim Jagielski #ifdef DEL_TABLE_REDLINES
2244*b1cdbd2cSJim Jagielski lcl_DelRedlines aDelRedl( *pTblNd, sal_True );
2245*b1cdbd2cSJim Jagielski #endif
2246*b1cdbd2cSJim Jagielski
2247*b1cdbd2cSJim Jagielski SvULongs aNdsCnts;
2248*b1cdbd2cSJim Jagielski SwTableSortBoxes aTmpLst( 0, 5 );
2249*b1cdbd2cSJim Jagielski SwUndoTblNdsChg* pUndo = 0;
2250*b1cdbd2cSJim Jagielski if (GetIDocumentUndoRedo().DoesUndo())
2251*b1cdbd2cSJim Jagielski {
2252*b1cdbd2cSJim Jagielski pUndo = new SwUndoTblNdsChg( UNDO_TABLE_SPLIT, rBoxes, *pTblNd, 0, 0,
2253*b1cdbd2cSJim Jagielski nCnt, bVert, bSameHeight );
2254*b1cdbd2cSJim Jagielski
2255*b1cdbd2cSJim Jagielski aTmpLst.Insert( &rTbl.GetTabSortBoxes(), 0, rTbl.GetTabSortBoxes().Count() );
2256*b1cdbd2cSJim Jagielski if( !bVert )
2257*b1cdbd2cSJim Jagielski {
2258*b1cdbd2cSJim Jagielski for( sal_uInt16 n = 0; n < rBoxes.Count(); ++n )
2259*b1cdbd2cSJim Jagielski {
2260*b1cdbd2cSJim Jagielski const SwStartNode* pSttNd = rBoxes[ n ]->GetSttNd();
2261*b1cdbd2cSJim Jagielski aNdsCnts.Insert( pSttNd->EndOfSectionIndex() -
2262*b1cdbd2cSJim Jagielski pSttNd->GetIndex(), n );
2263*b1cdbd2cSJim Jagielski }
2264*b1cdbd2cSJim Jagielski }
2265*b1cdbd2cSJim Jagielski }
2266*b1cdbd2cSJim Jagielski
2267*b1cdbd2cSJim Jagielski bool bRet(false);
2268*b1cdbd2cSJim Jagielski {
2269*b1cdbd2cSJim Jagielski ::sw::UndoGuard const undoGuard(GetIDocumentUndoRedo());
2270*b1cdbd2cSJim Jagielski
2271*b1cdbd2cSJim Jagielski SwTableFmlUpdate aMsgHnt( &rTbl );
2272*b1cdbd2cSJim Jagielski aMsgHnt.eFlags = TBL_BOXPTR;
2273*b1cdbd2cSJim Jagielski UpdateTblFlds( &aMsgHnt );
2274*b1cdbd2cSJim Jagielski
2275*b1cdbd2cSJim Jagielski if (bVert)
2276*b1cdbd2cSJim Jagielski bRet = rTbl.SplitCol( this, rBoxes, nCnt );
2277*b1cdbd2cSJim Jagielski else
2278*b1cdbd2cSJim Jagielski bRet = rTbl.SplitRow( this, rBoxes, nCnt, bSameHeight );
2279*b1cdbd2cSJim Jagielski
2280*b1cdbd2cSJim Jagielski if (bRet)
2281*b1cdbd2cSJim Jagielski {
2282*b1cdbd2cSJim Jagielski SetModified();
2283*b1cdbd2cSJim Jagielski SetFieldsDirty( true, NULL, 0 );
2284*b1cdbd2cSJim Jagielski }
2285*b1cdbd2cSJim Jagielski }
2286*b1cdbd2cSJim Jagielski
2287*b1cdbd2cSJim Jagielski if( pUndo )
2288*b1cdbd2cSJim Jagielski {
2289*b1cdbd2cSJim Jagielski if( bRet )
2290*b1cdbd2cSJim Jagielski {
2291*b1cdbd2cSJim Jagielski if( bVert )
2292*b1cdbd2cSJim Jagielski pUndo->SaveNewBoxes( *pTblNd, aTmpLst );
2293*b1cdbd2cSJim Jagielski else
2294*b1cdbd2cSJim Jagielski pUndo->SaveNewBoxes( *pTblNd, aTmpLst, rBoxes, aNdsCnts );
2295*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().AppendUndo( pUndo );
2296*b1cdbd2cSJim Jagielski }
2297*b1cdbd2cSJim Jagielski else
2298*b1cdbd2cSJim Jagielski delete pUndo;
2299*b1cdbd2cSJim Jagielski }
2300*b1cdbd2cSJim Jagielski
2301*b1cdbd2cSJim Jagielski return bRet;
2302*b1cdbd2cSJim Jagielski }
2303*b1cdbd2cSJim Jagielski
2304*b1cdbd2cSJim Jagielski
MergeTbl(SwPaM & rPam)2305*b1cdbd2cSJim Jagielski sal_uInt16 SwDoc::MergeTbl( SwPaM& rPam )
2306*b1cdbd2cSJim Jagielski {
2307*b1cdbd2cSJim Jagielski // pruefe ob vom aktuellen Crsr der SPoint/Mark in einer Tabelle stehen
2308*b1cdbd2cSJim Jagielski SwTableNode* pTblNd = rPam.GetNode()->FindTableNode();
2309*b1cdbd2cSJim Jagielski if( !pTblNd )
2310*b1cdbd2cSJim Jagielski return TBLMERGE_NOSELECTION;
2311*b1cdbd2cSJim Jagielski SwTable& rTable = pTblNd->GetTable();
2312*b1cdbd2cSJim Jagielski if( rTable.ISA(SwDDETable) )
2313*b1cdbd2cSJim Jagielski return TBLMERGE_NOSELECTION;
2314*b1cdbd2cSJim Jagielski sal_uInt16 nRet = TBLMERGE_NOSELECTION;
2315*b1cdbd2cSJim Jagielski if( !rTable.IsNewModel() )
2316*b1cdbd2cSJim Jagielski {
2317*b1cdbd2cSJim Jagielski nRet =::CheckMergeSel( rPam );
2318*b1cdbd2cSJim Jagielski if( TBLMERGE_OK != nRet )
2319*b1cdbd2cSJim Jagielski return nRet;
2320*b1cdbd2cSJim Jagielski nRet = TBLMERGE_NOSELECTION;
2321*b1cdbd2cSJim Jagielski }
2322*b1cdbd2cSJim Jagielski
2323*b1cdbd2cSJim Jagielski // --> FME 2004-10-08 #i33394#
2324*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().StartUndo( UNDO_TABLE_MERGE, NULL );
2325*b1cdbd2cSJim Jagielski // <--
2326*b1cdbd2cSJim Jagielski
2327*b1cdbd2cSJim Jagielski #ifdef DEL_TABLE_REDLINES
2328*b1cdbd2cSJim Jagielski if( !IsIgnoreRedline() && GetRedlineTbl().Count() )
2329*b1cdbd2cSJim Jagielski DeleteRedline( *pTblNd, true, USHRT_MAX );
2330*b1cdbd2cSJim Jagielski #endif
2331*b1cdbd2cSJim Jagielski RedlineMode_t eOld = GetRedlineMode();
2332*b1cdbd2cSJim Jagielski SetRedlineMode_intern((RedlineMode_t)(eOld | nsRedlineMode_t::REDLINE_IGNORE));
2333*b1cdbd2cSJim Jagielski
2334*b1cdbd2cSJim Jagielski SwUndoTblMerge *const pUndo( (GetIDocumentUndoRedo().DoesUndo())
2335*b1cdbd2cSJim Jagielski ? new SwUndoTblMerge( rPam )
2336*b1cdbd2cSJim Jagielski : 0 );
2337*b1cdbd2cSJim Jagielski
2338*b1cdbd2cSJim Jagielski // lasse ueber das Layout die Boxen suchen
2339*b1cdbd2cSJim Jagielski SwSelBoxes aBoxes;
2340*b1cdbd2cSJim Jagielski SwSelBoxes aMerged;
2341*b1cdbd2cSJim Jagielski SwTableBox* pMergeBox;
2342*b1cdbd2cSJim Jagielski
2343*b1cdbd2cSJim Jagielski if( !rTable.PrepareMerge( rPam, aBoxes, aMerged, &pMergeBox, pUndo ) )
2344*b1cdbd2cSJim Jagielski { // no cells found to merge
2345*b1cdbd2cSJim Jagielski SetRedlineMode_intern( eOld );
2346*b1cdbd2cSJim Jagielski if( pUndo )
2347*b1cdbd2cSJim Jagielski {
2348*b1cdbd2cSJim Jagielski delete pUndo;
2349*b1cdbd2cSJim Jagielski SwUndoId nLastUndoId(UNDO_EMPTY);
2350*b1cdbd2cSJim Jagielski if (GetIDocumentUndoRedo().GetLastUndoInfo(0, & nLastUndoId)
2351*b1cdbd2cSJim Jagielski && (UNDO_REDLINE == nLastUndoId))
2352*b1cdbd2cSJim Jagielski {
2353*b1cdbd2cSJim Jagielski // FIXME: why is this horrible cleanup necessary?
2354*b1cdbd2cSJim Jagielski SwUndoRedline *const pU = dynamic_cast<SwUndoRedline*>(
2355*b1cdbd2cSJim Jagielski GetUndoManager().RemoveLastUndo());
2356*b1cdbd2cSJim Jagielski if( pU->GetRedlSaveCount() )
2357*b1cdbd2cSJim Jagielski {
2358*b1cdbd2cSJim Jagielski SwEditShell *const pEditShell(GetEditShell(0));
2359*b1cdbd2cSJim Jagielski OSL_ASSERT(pEditShell);
2360*b1cdbd2cSJim Jagielski ::sw::UndoRedoContext context(*this, *pEditShell);
2361*b1cdbd2cSJim Jagielski static_cast<SfxUndoAction *>(pU)->UndoWithContext(context);
2362*b1cdbd2cSJim Jagielski }
2363*b1cdbd2cSJim Jagielski delete pU;
2364*b1cdbd2cSJim Jagielski }
2365*b1cdbd2cSJim Jagielski }
2366*b1cdbd2cSJim Jagielski }
2367*b1cdbd2cSJim Jagielski else
2368*b1cdbd2cSJim Jagielski {
2369*b1cdbd2cSJim Jagielski // die PaMs muessen noch aus dem Loesch Bereich entfernt
2370*b1cdbd2cSJim Jagielski // werden. Setze sie immer hinter/auf die Tabelle; ueber die
2371*b1cdbd2cSJim Jagielski // Dokument-Position werden sie dann immer an die alte Position gesetzt.
2372*b1cdbd2cSJim Jagielski // Erstmal einen Index auf die Parkposition merken, denn nach GetMergeSel
2373*b1cdbd2cSJim Jagielski // komme ich nicht mehr dran.
2374*b1cdbd2cSJim Jagielski {
2375*b1cdbd2cSJim Jagielski rPam.DeleteMark();
2376*b1cdbd2cSJim Jagielski rPam.GetPoint()->nNode = *pMergeBox->GetSttNd();
2377*b1cdbd2cSJim Jagielski rPam.GetPoint()->nContent.Assign( 0, 0 );
2378*b1cdbd2cSJim Jagielski rPam.SetMark();
2379*b1cdbd2cSJim Jagielski rPam.DeleteMark();
2380*b1cdbd2cSJim Jagielski
2381*b1cdbd2cSJim Jagielski SwPaM* pTmp = &rPam;
2382*b1cdbd2cSJim Jagielski while( &rPam != ( pTmp = (SwPaM*)pTmp->GetNext() ))
2383*b1cdbd2cSJim Jagielski for( int i = 0; i < 2; ++i )
2384*b1cdbd2cSJim Jagielski pTmp->GetBound( (sal_Bool)i ) = *rPam.GetPoint();
2385*b1cdbd2cSJim Jagielski }
2386*b1cdbd2cSJim Jagielski
2387*b1cdbd2cSJim Jagielski // dann fuege sie zusammen
2388*b1cdbd2cSJim Jagielski SwTableFmlUpdate aMsgHnt( &pTblNd->GetTable() );
2389*b1cdbd2cSJim Jagielski aMsgHnt.eFlags = TBL_BOXPTR;
2390*b1cdbd2cSJim Jagielski UpdateTblFlds( &aMsgHnt );
2391*b1cdbd2cSJim Jagielski
2392*b1cdbd2cSJim Jagielski if( pTblNd->GetTable().Merge( this, aBoxes, aMerged, pMergeBox, pUndo ))
2393*b1cdbd2cSJim Jagielski {
2394*b1cdbd2cSJim Jagielski nRet = TBLMERGE_OK;
2395*b1cdbd2cSJim Jagielski SetModified();
2396*b1cdbd2cSJim Jagielski SetFieldsDirty( true, NULL, 0 );
2397*b1cdbd2cSJim Jagielski if( pUndo )
2398*b1cdbd2cSJim Jagielski {
2399*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().AppendUndo( pUndo );
2400*b1cdbd2cSJim Jagielski }
2401*b1cdbd2cSJim Jagielski }
2402*b1cdbd2cSJim Jagielski else if( pUndo )
2403*b1cdbd2cSJim Jagielski delete pUndo;
2404*b1cdbd2cSJim Jagielski
2405*b1cdbd2cSJim Jagielski rPam.GetPoint()->nNode = *pMergeBox->GetSttNd();
2406*b1cdbd2cSJim Jagielski rPam.Move();
2407*b1cdbd2cSJim Jagielski
2408*b1cdbd2cSJim Jagielski ::ClearFEShellTabCols();
2409*b1cdbd2cSJim Jagielski SetRedlineMode_intern( eOld );
2410*b1cdbd2cSJim Jagielski }
2411*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().EndUndo( UNDO_TABLE_MERGE, NULL );
2412*b1cdbd2cSJim Jagielski return nRet;
2413*b1cdbd2cSJim Jagielski }
2414*b1cdbd2cSJim Jagielski
2415*b1cdbd2cSJim Jagielski
2416*b1cdbd2cSJim Jagielski
2417*b1cdbd2cSJim Jagielski // -------------------------------------------------------
2418*b1cdbd2cSJim Jagielski
2419*b1cdbd2cSJim Jagielski //---------
2420*b1cdbd2cSJim Jagielski // SwTableNode
2421*b1cdbd2cSJim Jagielski //---------
2422*b1cdbd2cSJim Jagielski
SwTableNode(const SwNodeIndex & rIdx)2423*b1cdbd2cSJim Jagielski SwTableNode::SwTableNode( const SwNodeIndex& rIdx )
2424*b1cdbd2cSJim Jagielski : SwStartNode( rIdx, ND_TABLENODE )
2425*b1cdbd2cSJim Jagielski {
2426*b1cdbd2cSJim Jagielski pTable = new SwTable( 0 );
2427*b1cdbd2cSJim Jagielski }
2428*b1cdbd2cSJim Jagielski
~SwTableNode()2429*b1cdbd2cSJim Jagielski SwTableNode::~SwTableNode()
2430*b1cdbd2cSJim Jagielski {
2431*b1cdbd2cSJim Jagielski //don't forget to notify uno wrappers
2432*b1cdbd2cSJim Jagielski SwFrmFmt* pTblFmt = GetTable().GetFrmFmt();
2433*b1cdbd2cSJim Jagielski SwPtrMsgPoolItem aMsgHint( RES_REMOVE_UNO_OBJECT,
2434*b1cdbd2cSJim Jagielski pTblFmt );
2435*b1cdbd2cSJim Jagielski pTblFmt->ModifyNotification( &aMsgHint, &aMsgHint );
2436*b1cdbd2cSJim Jagielski DelFrms();
2437*b1cdbd2cSJim Jagielski delete pTable;
2438*b1cdbd2cSJim Jagielski }
2439*b1cdbd2cSJim Jagielski
MakeFrm(SwFrm * pSib)2440*b1cdbd2cSJim Jagielski SwTabFrm *SwTableNode::MakeFrm( SwFrm* pSib )
2441*b1cdbd2cSJim Jagielski {
2442*b1cdbd2cSJim Jagielski return new SwTabFrm( *pTable, pSib );
2443*b1cdbd2cSJim Jagielski }
2444*b1cdbd2cSJim Jagielski
2445*b1cdbd2cSJim Jagielski //Methode erzeugt fuer den vorhergehenden Node alle Ansichten vom
2446*b1cdbd2cSJim Jagielski //Dokument. Die erzeugten Contentframes werden in das entsprechende
2447*b1cdbd2cSJim Jagielski //Layout gehaengt.
MakeFrms(const SwNodeIndex & rIdx)2448*b1cdbd2cSJim Jagielski void SwTableNode::MakeFrms(const SwNodeIndex & rIdx )
2449*b1cdbd2cSJim Jagielski {
2450*b1cdbd2cSJim Jagielski if( !GetTable().GetFrmFmt()->GetDepends())//gibt es ueberhaupt Frames ??
2451*b1cdbd2cSJim Jagielski return;
2452*b1cdbd2cSJim Jagielski
2453*b1cdbd2cSJim Jagielski SwFrm *pFrm, *pNew;
2454*b1cdbd2cSJim Jagielski SwCntntNode * pNode = rIdx.GetNode().GetCntntNode();
2455*b1cdbd2cSJim Jagielski
2456*b1cdbd2cSJim Jagielski ASSERT( pNode, "Kein Contentnode oder Copy-Node und neuer Node identisch.");
2457*b1cdbd2cSJim Jagielski
2458*b1cdbd2cSJim Jagielski sal_Bool bBefore = rIdx < GetIndex();
2459*b1cdbd2cSJim Jagielski
2460*b1cdbd2cSJim Jagielski SwNode2Layout aNode2Layout( *this, rIdx.GetIndex() );
2461*b1cdbd2cSJim Jagielski
2462*b1cdbd2cSJim Jagielski while( 0 != (pFrm = aNode2Layout.NextFrm()) )
2463*b1cdbd2cSJim Jagielski {
2464*b1cdbd2cSJim Jagielski pNew = pNode->MakeFrm( pFrm );
2465*b1cdbd2cSJim Jagielski // wird ein Node vorher oder nachher mit Frames versehen
2466*b1cdbd2cSJim Jagielski if ( bBefore )
2467*b1cdbd2cSJim Jagielski // der neue liegt vor mir
2468*b1cdbd2cSJim Jagielski pNew->Paste( pFrm->GetUpper(), pFrm );
2469*b1cdbd2cSJim Jagielski else
2470*b1cdbd2cSJim Jagielski // der neue liegt hinter mir
2471*b1cdbd2cSJim Jagielski pNew->Paste( pFrm->GetUpper(), pFrm->GetNext() );
2472*b1cdbd2cSJim Jagielski }
2473*b1cdbd2cSJim Jagielski }
2474*b1cdbd2cSJim Jagielski
2475*b1cdbd2cSJim Jagielski //Fuer jede Shell einen TblFrm anlegen und vor den entsprechenden
2476*b1cdbd2cSJim Jagielski //CntntFrm pasten.
2477*b1cdbd2cSJim Jagielski
MakeFrms(SwNodeIndex * pIdxBehind)2478*b1cdbd2cSJim Jagielski void SwTableNode::MakeFrms( SwNodeIndex* pIdxBehind )
2479*b1cdbd2cSJim Jagielski {
2480*b1cdbd2cSJim Jagielski ASSERT( pIdxBehind, "kein Index" );
2481*b1cdbd2cSJim Jagielski *pIdxBehind = *this;
2482*b1cdbd2cSJim Jagielski SwNode *pNd = GetNodes().FindPrvNxtFrmNode( *pIdxBehind, EndOfSectionNode() );
2483*b1cdbd2cSJim Jagielski if( !pNd )
2484*b1cdbd2cSJim Jagielski return ;
2485*b1cdbd2cSJim Jagielski
2486*b1cdbd2cSJim Jagielski SwFrm *pFrm( 0L );
2487*b1cdbd2cSJim Jagielski SwLayoutFrm *pUpper( 0L );
2488*b1cdbd2cSJim Jagielski SwNode2Layout aNode2Layout( *pNd, GetIndex() );
2489*b1cdbd2cSJim Jagielski while( 0 != (pUpper = aNode2Layout.UpperFrm( pFrm, *this )) )
2490*b1cdbd2cSJim Jagielski {
2491*b1cdbd2cSJim Jagielski SwTabFrm* pNew = MakeFrm( pUpper );
2492*b1cdbd2cSJim Jagielski pNew->Paste( pUpper, pFrm );
2493*b1cdbd2cSJim Jagielski // --> OD 2005-12-01 #i27138#
2494*b1cdbd2cSJim Jagielski // notify accessibility paragraphs objects about changed
2495*b1cdbd2cSJim Jagielski // CONTENT_FLOWS_FROM/_TO relation.
2496*b1cdbd2cSJim Jagielski // Relation CONTENT_FLOWS_FROM for next paragraph will change
2497*b1cdbd2cSJim Jagielski // and relation CONTENT_FLOWS_TO for previous paragraph will change.
2498*b1cdbd2cSJim Jagielski {
2499*b1cdbd2cSJim Jagielski ViewShell* pViewShell( pNew->getRootFrm()->GetCurrShell() );
2500*b1cdbd2cSJim Jagielski if ( pViewShell && pViewShell->GetLayout() &&
2501*b1cdbd2cSJim Jagielski pViewShell->GetLayout()->IsAnyShellAccessible() )
2502*b1cdbd2cSJim Jagielski {
2503*b1cdbd2cSJim Jagielski pViewShell->InvalidateAccessibleParaFlowRelation(
2504*b1cdbd2cSJim Jagielski dynamic_cast<SwTxtFrm*>(pNew->FindNextCnt( true )),
2505*b1cdbd2cSJim Jagielski dynamic_cast<SwTxtFrm*>(pNew->FindPrevCnt( true )) );
2506*b1cdbd2cSJim Jagielski }
2507*b1cdbd2cSJim Jagielski }
2508*b1cdbd2cSJim Jagielski // <--
2509*b1cdbd2cSJim Jagielski ((SwTabFrm*)pNew)->RegistFlys();
2510*b1cdbd2cSJim Jagielski }
2511*b1cdbd2cSJim Jagielski }
2512*b1cdbd2cSJim Jagielski
DelFrms()2513*b1cdbd2cSJim Jagielski void SwTableNode::DelFrms()
2514*b1cdbd2cSJim Jagielski {
2515*b1cdbd2cSJim Jagielski //Erstmal die TabFrms ausschneiden und deleten, die Columns und Rows
2516*b1cdbd2cSJim Jagielski //nehmen sie mit in's Grab.
2517*b1cdbd2cSJim Jagielski //Die TabFrms haengen am FrmFmt des SwTable.
2518*b1cdbd2cSJim Jagielski //Sie muessen etwas umstaendlich zerstort werden, damit die Master
2519*b1cdbd2cSJim Jagielski //die Follows mit in's Grab nehmen.
2520*b1cdbd2cSJim Jagielski
2521*b1cdbd2cSJim Jagielski SwIterator<SwTabFrm,SwFmt> aIter( *(pTable->GetFrmFmt()) );
2522*b1cdbd2cSJim Jagielski SwTabFrm *pFrm = aIter.First();
2523*b1cdbd2cSJim Jagielski while ( pFrm )
2524*b1cdbd2cSJim Jagielski {
2525*b1cdbd2cSJim Jagielski sal_Bool bAgain = sal_False;
2526*b1cdbd2cSJim Jagielski {
2527*b1cdbd2cSJim Jagielski if ( !pFrm->IsFollow() )
2528*b1cdbd2cSJim Jagielski {
2529*b1cdbd2cSJim Jagielski while ( pFrm->HasFollow() )
2530*b1cdbd2cSJim Jagielski pFrm->JoinAndDelFollows();
2531*b1cdbd2cSJim Jagielski // --> OD 2005-12-01 #i27138#
2532*b1cdbd2cSJim Jagielski // notify accessibility paragraphs objects about changed
2533*b1cdbd2cSJim Jagielski // CONTENT_FLOWS_FROM/_TO relation.
2534*b1cdbd2cSJim Jagielski // Relation CONTENT_FLOWS_FROM for current next paragraph will change
2535*b1cdbd2cSJim Jagielski // and relation CONTENT_FLOWS_TO for current previous paragraph will change.
2536*b1cdbd2cSJim Jagielski {
2537*b1cdbd2cSJim Jagielski ViewShell* pViewShell( pFrm->getRootFrm()->GetCurrShell() );
2538*b1cdbd2cSJim Jagielski if ( pViewShell && pViewShell->GetLayout() &&
2539*b1cdbd2cSJim Jagielski pViewShell->GetLayout()->IsAnyShellAccessible() )
2540*b1cdbd2cSJim Jagielski {
2541*b1cdbd2cSJim Jagielski pViewShell->InvalidateAccessibleParaFlowRelation(
2542*b1cdbd2cSJim Jagielski dynamic_cast<SwTxtFrm*>(pFrm->FindNextCnt( true )),
2543*b1cdbd2cSJim Jagielski dynamic_cast<SwTxtFrm*>(pFrm->FindPrevCnt( true )) );
2544*b1cdbd2cSJim Jagielski }
2545*b1cdbd2cSJim Jagielski }
2546*b1cdbd2cSJim Jagielski // <--
2547*b1cdbd2cSJim Jagielski pFrm->Cut();
2548*b1cdbd2cSJim Jagielski delete pFrm;
2549*b1cdbd2cSJim Jagielski bAgain = sal_True;
2550*b1cdbd2cSJim Jagielski }
2551*b1cdbd2cSJim Jagielski }
2552*b1cdbd2cSJim Jagielski pFrm = bAgain ? aIter.First() : aIter.Next();
2553*b1cdbd2cSJim Jagielski }
2554*b1cdbd2cSJim Jagielski }
2555*b1cdbd2cSJim Jagielski
2556*b1cdbd2cSJim Jagielski
SetNewTable(SwTable * pNewTable,sal_Bool bNewFrames)2557*b1cdbd2cSJim Jagielski void SwTableNode::SetNewTable( SwTable* pNewTable, sal_Bool bNewFrames )
2558*b1cdbd2cSJim Jagielski {
2559*b1cdbd2cSJim Jagielski DelFrms();
2560*b1cdbd2cSJim Jagielski delete pTable;
2561*b1cdbd2cSJim Jagielski pTable = pNewTable;
2562*b1cdbd2cSJim Jagielski if( bNewFrames )
2563*b1cdbd2cSJim Jagielski {
2564*b1cdbd2cSJim Jagielski SwNodeIndex aIdx( *EndOfSectionNode());
2565*b1cdbd2cSJim Jagielski GetNodes().GoNext( &aIdx );
2566*b1cdbd2cSJim Jagielski MakeFrms( &aIdx );
2567*b1cdbd2cSJim Jagielski }
2568*b1cdbd2cSJim Jagielski }
2569*b1cdbd2cSJim Jagielski
GetTabCols(SwTabCols & rFill,const SwCursor * pCrsr,const SwCellFrm * pBoxFrm) const2570*b1cdbd2cSJim Jagielski void SwDoc::GetTabCols( SwTabCols &rFill, const SwCursor* pCrsr,
2571*b1cdbd2cSJim Jagielski const SwCellFrm* pBoxFrm ) const
2572*b1cdbd2cSJim Jagielski {
2573*b1cdbd2cSJim Jagielski const SwTableBox* pBox = 0;
2574*b1cdbd2cSJim Jagielski SwTabFrm *pTab = 0;
2575*b1cdbd2cSJim Jagielski
2576*b1cdbd2cSJim Jagielski if( pBoxFrm )
2577*b1cdbd2cSJim Jagielski {
2578*b1cdbd2cSJim Jagielski pTab = ((SwFrm*)pBoxFrm)->ImplFindTabFrm();
2579*b1cdbd2cSJim Jagielski pBox = pBoxFrm->GetTabBox();
2580*b1cdbd2cSJim Jagielski }
2581*b1cdbd2cSJim Jagielski else if( pCrsr )
2582*b1cdbd2cSJim Jagielski {
2583*b1cdbd2cSJim Jagielski const SwCntntNode* pCNd = pCrsr->GetCntntNode();
2584*b1cdbd2cSJim Jagielski if( !pCNd )
2585*b1cdbd2cSJim Jagielski return ;
2586*b1cdbd2cSJim Jagielski
2587*b1cdbd2cSJim Jagielski Point aPt;
2588*b1cdbd2cSJim Jagielski const SwShellCrsr *pShCrsr = dynamic_cast<const SwShellCrsr*>(pCrsr);
2589*b1cdbd2cSJim Jagielski if( pShCrsr )
2590*b1cdbd2cSJim Jagielski aPt = pShCrsr->GetPtPos();
2591*b1cdbd2cSJim Jagielski
2592*b1cdbd2cSJim Jagielski const SwFrm* pTmpFrm = pCNd->getLayoutFrm( pCNd->GetDoc()->GetCurrentLayout(), &aPt, 0, sal_False );
2593*b1cdbd2cSJim Jagielski do {
2594*b1cdbd2cSJim Jagielski pTmpFrm = pTmpFrm->GetUpper();
2595*b1cdbd2cSJim Jagielski } while ( !pTmpFrm->IsCellFrm() );
2596*b1cdbd2cSJim Jagielski
2597*b1cdbd2cSJim Jagielski pBoxFrm = (SwCellFrm*)pTmpFrm;
2598*b1cdbd2cSJim Jagielski pTab = ((SwFrm*)pBoxFrm)->ImplFindTabFrm();
2599*b1cdbd2cSJim Jagielski pBox = pBoxFrm->GetTabBox();
2600*b1cdbd2cSJim Jagielski }
2601*b1cdbd2cSJim Jagielski else if( !pCrsr && !pBoxFrm )
2602*b1cdbd2cSJim Jagielski {
2603*b1cdbd2cSJim Jagielski ASSERT( !this, "einer von beiden muss angegeben werden!" );
2604*b1cdbd2cSJim Jagielski return ;
2605*b1cdbd2cSJim Jagielski }
2606*b1cdbd2cSJim Jagielski
2607*b1cdbd2cSJim Jagielski //Fix-Punkte setzen, LeftMin in Dokumentkoordinaten die anderen relativ.
2608*b1cdbd2cSJim Jagielski SWRECTFN( pTab )
2609*b1cdbd2cSJim Jagielski const SwPageFrm* pPage = pTab->FindPageFrm();
2610*b1cdbd2cSJim Jagielski const sal_uLong nLeftMin = (pTab->Frm().*fnRect->fnGetLeft)() -
2611*b1cdbd2cSJim Jagielski (pPage->Frm().*fnRect->fnGetLeft)();
2612*b1cdbd2cSJim Jagielski const sal_uLong nRightMax = (pTab->Frm().*fnRect->fnGetRight)() -
2613*b1cdbd2cSJim Jagielski (pPage->Frm().*fnRect->fnGetLeft)();
2614*b1cdbd2cSJim Jagielski
2615*b1cdbd2cSJim Jagielski rFill.SetLeftMin ( nLeftMin );
2616*b1cdbd2cSJim Jagielski rFill.SetLeft ( (pTab->Prt().*fnRect->fnGetLeft)() );
2617*b1cdbd2cSJim Jagielski rFill.SetRight ( (pTab->Prt().*fnRect->fnGetRight)());
2618*b1cdbd2cSJim Jagielski rFill.SetRightMax( nRightMax - nLeftMin );
2619*b1cdbd2cSJim Jagielski
2620*b1cdbd2cSJim Jagielski pTab->GetTable()->GetTabCols( rFill, pBox );
2621*b1cdbd2cSJim Jagielski }
2622*b1cdbd2cSJim Jagielski
2623*b1cdbd2cSJim Jagielski //
2624*b1cdbd2cSJim Jagielski // Here are some little helpers used in SwDoc::GetTabRows
2625*b1cdbd2cSJim Jagielski //
2626*b1cdbd2cSJim Jagielski
2627*b1cdbd2cSJim Jagielski #define ROWFUZZY 25
2628*b1cdbd2cSJim Jagielski
2629*b1cdbd2cSJim Jagielski struct FuzzyCompare
2630*b1cdbd2cSJim Jagielski {
2631*b1cdbd2cSJim Jagielski bool operator() ( long s1, long s2 ) const;
2632*b1cdbd2cSJim Jagielski };
2633*b1cdbd2cSJim Jagielski
operator ()(long s1,long s2) const2634*b1cdbd2cSJim Jagielski bool FuzzyCompare::operator() ( long s1, long s2 ) const
2635*b1cdbd2cSJim Jagielski {
2636*b1cdbd2cSJim Jagielski return ( s1 < s2 && abs( s1 - s2 ) > ROWFUZZY );
2637*b1cdbd2cSJim Jagielski }
2638*b1cdbd2cSJim Jagielski
lcl_IsFrmInColumn(const SwCellFrm & rFrm,SwSelBoxes & rBoxes)2639*b1cdbd2cSJim Jagielski bool lcl_IsFrmInColumn( const SwCellFrm& rFrm, SwSelBoxes& rBoxes )
2640*b1cdbd2cSJim Jagielski {
2641*b1cdbd2cSJim Jagielski for( sal_uInt16 i = 0; i < rBoxes.Count(); ++i )
2642*b1cdbd2cSJim Jagielski {
2643*b1cdbd2cSJim Jagielski if ( rFrm.GetTabBox() == rBoxes[ i ] )
2644*b1cdbd2cSJim Jagielski return true;
2645*b1cdbd2cSJim Jagielski }
2646*b1cdbd2cSJim Jagielski
2647*b1cdbd2cSJim Jagielski return false;
2648*b1cdbd2cSJim Jagielski }
2649*b1cdbd2cSJim Jagielski
2650*b1cdbd2cSJim Jagielski //
2651*b1cdbd2cSJim Jagielski // SwDoc::GetTabRows()
2652*b1cdbd2cSJim Jagielski //
2653*b1cdbd2cSJim Jagielski
GetTabRows(SwTabCols & rFill,const SwCursor *,const SwCellFrm * pBoxFrm) const2654*b1cdbd2cSJim Jagielski void SwDoc::GetTabRows( SwTabCols &rFill, const SwCursor* ,
2655*b1cdbd2cSJim Jagielski const SwCellFrm* pBoxFrm ) const
2656*b1cdbd2cSJim Jagielski {
2657*b1cdbd2cSJim Jagielski ASSERT( pBoxFrm, "GetTabRows called without pBoxFrm" )
2658*b1cdbd2cSJim Jagielski
2659*b1cdbd2cSJim Jagielski // --> FME 2005-09-12 #121591# Make code robust:
2660*b1cdbd2cSJim Jagielski if ( !pBoxFrm )
2661*b1cdbd2cSJim Jagielski return;
2662*b1cdbd2cSJim Jagielski // <--
2663*b1cdbd2cSJim Jagielski
2664*b1cdbd2cSJim Jagielski // --> FME 2005-01-06 #i39552# Collection of the boxes of the current
2665*b1cdbd2cSJim Jagielski // column has to be done at the beginning of this function, because
2666*b1cdbd2cSJim Jagielski // the table may be formatted in ::GetTblSel.
2667*b1cdbd2cSJim Jagielski SwDeletionChecker aDelCheck( pBoxFrm );
2668*b1cdbd2cSJim Jagielski
2669*b1cdbd2cSJim Jagielski SwSelBoxes aBoxes;
2670*b1cdbd2cSJim Jagielski const SwCntntFrm* pCntnt = ::GetCellCntnt( *pBoxFrm );
2671*b1cdbd2cSJim Jagielski if ( pCntnt && pCntnt->IsTxtFrm() )
2672*b1cdbd2cSJim Jagielski {
2673*b1cdbd2cSJim Jagielski const SwPosition aPos( *((SwTxtFrm*)pCntnt)->GetTxtNode() );
2674*b1cdbd2cSJim Jagielski const SwCursor aTmpCrsr( aPos, 0, false );
2675*b1cdbd2cSJim Jagielski ::GetTblSel( aTmpCrsr, aBoxes, nsSwTblSearchType::TBLSEARCH_COL );
2676*b1cdbd2cSJim Jagielski }
2677*b1cdbd2cSJim Jagielski // <--
2678*b1cdbd2cSJim Jagielski
2679*b1cdbd2cSJim Jagielski // --> FME 2005-09-12 #121591# Make code robust:
2680*b1cdbd2cSJim Jagielski if ( aDelCheck.HasBeenDeleted() )
2681*b1cdbd2cSJim Jagielski {
2682*b1cdbd2cSJim Jagielski ASSERT( false, "Current box has been deleted during GetTabRows()" )
2683*b1cdbd2cSJim Jagielski return;
2684*b1cdbd2cSJim Jagielski }
2685*b1cdbd2cSJim Jagielski // <--
2686*b1cdbd2cSJim Jagielski
2687*b1cdbd2cSJim Jagielski // --> FME 2005-09-12 #121591# Make code robust:
2688*b1cdbd2cSJim Jagielski const SwTabFrm* pTab = pBoxFrm->FindTabFrm();
2689*b1cdbd2cSJim Jagielski ASSERT( pTab, "GetTabRows called without a table" )
2690*b1cdbd2cSJim Jagielski if ( !pTab )
2691*b1cdbd2cSJim Jagielski return;
2692*b1cdbd2cSJim Jagielski // <--
2693*b1cdbd2cSJim Jagielski
2694*b1cdbd2cSJim Jagielski const SwFrm* pFrm = pTab->GetNextLayoutLeaf();
2695*b1cdbd2cSJim Jagielski
2696*b1cdbd2cSJim Jagielski //Fix-Punkte setzen, LeftMin in Dokumentkoordinaten die anderen relativ.
2697*b1cdbd2cSJim Jagielski SWRECTFN( pTab )
2698*b1cdbd2cSJim Jagielski const SwPageFrm* pPage = pTab->FindPageFrm();
2699*b1cdbd2cSJim Jagielski const long nLeftMin = ( bVert ?
2700*b1cdbd2cSJim Jagielski pTab->GetPrtLeft() - pPage->Frm().Left() :
2701*b1cdbd2cSJim Jagielski pTab->GetPrtTop() - pPage->Frm().Top() );
2702*b1cdbd2cSJim Jagielski const long nLeft = bVert ? LONG_MAX : 0;
2703*b1cdbd2cSJim Jagielski const long nRight = (pTab->Prt().*fnRect->fnGetHeight)();
2704*b1cdbd2cSJim Jagielski const long nRightMax = bVert ? nRight : LONG_MAX;
2705*b1cdbd2cSJim Jagielski
2706*b1cdbd2cSJim Jagielski rFill.SetLeftMin( nLeftMin );
2707*b1cdbd2cSJim Jagielski rFill.SetLeft( nLeft );
2708*b1cdbd2cSJim Jagielski rFill.SetRight( nRight );
2709*b1cdbd2cSJim Jagielski rFill.SetRightMax( nRightMax );
2710*b1cdbd2cSJim Jagielski
2711*b1cdbd2cSJim Jagielski typedef std::map< long, std::pair< long, long >, FuzzyCompare > BoundaryMap;
2712*b1cdbd2cSJim Jagielski BoundaryMap aBoundaries;
2713*b1cdbd2cSJim Jagielski BoundaryMap::iterator aIter;
2714*b1cdbd2cSJim Jagielski std::pair< long, long > aPair;
2715*b1cdbd2cSJim Jagielski
2716*b1cdbd2cSJim Jagielski typedef std::map< long, bool > HiddenMap;
2717*b1cdbd2cSJim Jagielski HiddenMap aHidden;
2718*b1cdbd2cSJim Jagielski HiddenMap::iterator aHiddenIter;
2719*b1cdbd2cSJim Jagielski
2720*b1cdbd2cSJim Jagielski while ( pFrm && pTab->IsAnLower( pFrm ) )
2721*b1cdbd2cSJim Jagielski {
2722*b1cdbd2cSJim Jagielski if ( pFrm->IsCellFrm() && pFrm->FindTabFrm() == pTab )
2723*b1cdbd2cSJim Jagielski {
2724*b1cdbd2cSJim Jagielski // upper and lower borders of current cell frame:
2725*b1cdbd2cSJim Jagielski long nUpperBorder = (pFrm->Frm().*fnRect->fnGetTop)();
2726*b1cdbd2cSJim Jagielski long nLowerBorder = (pFrm->Frm().*fnRect->fnGetBottom)();
2727*b1cdbd2cSJim Jagielski
2728*b1cdbd2cSJim Jagielski // get boundaries for nUpperBorder:
2729*b1cdbd2cSJim Jagielski aIter = aBoundaries.find( nUpperBorder );
2730*b1cdbd2cSJim Jagielski if ( aIter == aBoundaries.end() )
2731*b1cdbd2cSJim Jagielski {
2732*b1cdbd2cSJim Jagielski aPair.first = nUpperBorder; aPair.second = LONG_MAX;
2733*b1cdbd2cSJim Jagielski aBoundaries[ nUpperBorder ] = aPair;
2734*b1cdbd2cSJim Jagielski }
2735*b1cdbd2cSJim Jagielski
2736*b1cdbd2cSJim Jagielski // get boundaries for nLowerBorder:
2737*b1cdbd2cSJim Jagielski aIter = aBoundaries.find( nLowerBorder );
2738*b1cdbd2cSJim Jagielski if ( aIter == aBoundaries.end() )
2739*b1cdbd2cSJim Jagielski {
2740*b1cdbd2cSJim Jagielski aPair.first = nUpperBorder; aPair.second = LONG_MAX;
2741*b1cdbd2cSJim Jagielski }
2742*b1cdbd2cSJim Jagielski else
2743*b1cdbd2cSJim Jagielski {
2744*b1cdbd2cSJim Jagielski nLowerBorder = (*aIter).first;
2745*b1cdbd2cSJim Jagielski long nNewLowerBorderUpperBoundary = Max( (*aIter).second.first, nUpperBorder );
2746*b1cdbd2cSJim Jagielski aPair.first = nNewLowerBorderUpperBoundary; aPair.second = LONG_MAX;
2747*b1cdbd2cSJim Jagielski }
2748*b1cdbd2cSJim Jagielski aBoundaries[ nLowerBorder ] = aPair;
2749*b1cdbd2cSJim Jagielski
2750*b1cdbd2cSJim Jagielski // calculate hidden flags for entry nUpperBorder/nLowerBorder:
2751*b1cdbd2cSJim Jagielski long nTmpVal = nUpperBorder;
2752*b1cdbd2cSJim Jagielski for ( sal_uInt8 i = 0; i < 2; ++i )
2753*b1cdbd2cSJim Jagielski {
2754*b1cdbd2cSJim Jagielski aHiddenIter = aHidden.find( nTmpVal );
2755*b1cdbd2cSJim Jagielski if ( aHiddenIter == aHidden.end() )
2756*b1cdbd2cSJim Jagielski aHidden[ nTmpVal ] = !lcl_IsFrmInColumn( *((SwCellFrm*)pFrm), aBoxes );
2757*b1cdbd2cSJim Jagielski else
2758*b1cdbd2cSJim Jagielski {
2759*b1cdbd2cSJim Jagielski if ( aHidden[ nTmpVal ] &&
2760*b1cdbd2cSJim Jagielski lcl_IsFrmInColumn( *((SwCellFrm*)pFrm), aBoxes ) )
2761*b1cdbd2cSJim Jagielski aHidden[ nTmpVal ] = false;
2762*b1cdbd2cSJim Jagielski }
2763*b1cdbd2cSJim Jagielski nTmpVal = nLowerBorder;
2764*b1cdbd2cSJim Jagielski }
2765*b1cdbd2cSJim Jagielski }
2766*b1cdbd2cSJim Jagielski
2767*b1cdbd2cSJim Jagielski pFrm = pFrm->GetNextLayoutLeaf();
2768*b1cdbd2cSJim Jagielski }
2769*b1cdbd2cSJim Jagielski
2770*b1cdbd2cSJim Jagielski // transfer calculated values from BoundaryMap and HiddenMap into rFill:
2771*b1cdbd2cSJim Jagielski sal_uInt16 nIdx = 0;
2772*b1cdbd2cSJim Jagielski for ( aIter = aBoundaries.begin(); aIter != aBoundaries.end(); ++aIter )
2773*b1cdbd2cSJim Jagielski {
2774*b1cdbd2cSJim Jagielski const long nTabTop = (pTab->*fnRect->fnGetPrtTop)();
2775*b1cdbd2cSJim Jagielski const long nKey = (*fnRect->fnYDiff)( (*aIter).first, nTabTop );
2776*b1cdbd2cSJim Jagielski const std::pair< long, long > aTmpPair = (*aIter).second;
2777*b1cdbd2cSJim Jagielski const long nFirst = (*fnRect->fnYDiff)( aTmpPair.first, nTabTop );
2778*b1cdbd2cSJim Jagielski const long nSecond = aTmpPair.second;
2779*b1cdbd2cSJim Jagielski
2780*b1cdbd2cSJim Jagielski aHiddenIter = aHidden.find( (*aIter).first );
2781*b1cdbd2cSJim Jagielski const bool bHidden = aHiddenIter != aHidden.end() && (*aHiddenIter).second;
2782*b1cdbd2cSJim Jagielski rFill.Insert( nKey, nFirst, nSecond, bHidden, nIdx++ );
2783*b1cdbd2cSJim Jagielski }
2784*b1cdbd2cSJim Jagielski
2785*b1cdbd2cSJim Jagielski // delete first and last entry
2786*b1cdbd2cSJim Jagielski ASSERT( rFill.Count(), "Deleting from empty vector. Fasten your seatbelts!" )
2787*b1cdbd2cSJim Jagielski // --> FME 2006-01-19 #i60818# There may be only one entry in rFill. Make
2788*b1cdbd2cSJim Jagielski // code robust by checking count of rFill.
2789*b1cdbd2cSJim Jagielski if ( rFill.Count() ) rFill.Remove( 0, 1 );
2790*b1cdbd2cSJim Jagielski if ( rFill.Count() ) rFill.Remove( rFill.Count() - 1 , 1 );
2791*b1cdbd2cSJim Jagielski // <--
2792*b1cdbd2cSJim Jagielski rFill.SetLastRowAllowedToChange( !pTab->HasFollowFlowLine() );
2793*b1cdbd2cSJim Jagielski }
2794*b1cdbd2cSJim Jagielski
SetTabCols(const SwTabCols & rNew,sal_Bool bCurRowOnly,const SwCursor * pCrsr,const SwCellFrm * pBoxFrm)2795*b1cdbd2cSJim Jagielski void SwDoc::SetTabCols( const SwTabCols &rNew, sal_Bool bCurRowOnly,
2796*b1cdbd2cSJim Jagielski const SwCursor* pCrsr, const SwCellFrm* pBoxFrm )
2797*b1cdbd2cSJim Jagielski {
2798*b1cdbd2cSJim Jagielski const SwTableBox* pBox = 0;
2799*b1cdbd2cSJim Jagielski SwTabFrm *pTab = 0;
2800*b1cdbd2cSJim Jagielski
2801*b1cdbd2cSJim Jagielski if( pBoxFrm )
2802*b1cdbd2cSJim Jagielski {
2803*b1cdbd2cSJim Jagielski pTab = ((SwFrm*)pBoxFrm)->ImplFindTabFrm();
2804*b1cdbd2cSJim Jagielski pBox = pBoxFrm->GetTabBox();
2805*b1cdbd2cSJim Jagielski }
2806*b1cdbd2cSJim Jagielski else if( pCrsr )
2807*b1cdbd2cSJim Jagielski {
2808*b1cdbd2cSJim Jagielski const SwCntntNode* pCNd = pCrsr->GetCntntNode();
2809*b1cdbd2cSJim Jagielski if( !pCNd )
2810*b1cdbd2cSJim Jagielski return ;
2811*b1cdbd2cSJim Jagielski
2812*b1cdbd2cSJim Jagielski Point aPt;
2813*b1cdbd2cSJim Jagielski const SwShellCrsr *pShCrsr = dynamic_cast<const SwShellCrsr*>(pCrsr);
2814*b1cdbd2cSJim Jagielski if( pShCrsr )
2815*b1cdbd2cSJim Jagielski aPt = pShCrsr->GetPtPos();
2816*b1cdbd2cSJim Jagielski
2817*b1cdbd2cSJim Jagielski const SwFrm* pTmpFrm = pCNd->getLayoutFrm( pCNd->GetDoc()->GetCurrentLayout(), &aPt, 0, sal_False );
2818*b1cdbd2cSJim Jagielski do {
2819*b1cdbd2cSJim Jagielski pTmpFrm = pTmpFrm->GetUpper();
2820*b1cdbd2cSJim Jagielski } while ( !pTmpFrm->IsCellFrm() );
2821*b1cdbd2cSJim Jagielski
2822*b1cdbd2cSJim Jagielski pBoxFrm = (SwCellFrm*)pTmpFrm;
2823*b1cdbd2cSJim Jagielski pTab = ((SwFrm*)pBoxFrm)->ImplFindTabFrm();
2824*b1cdbd2cSJim Jagielski pBox = pBoxFrm->GetTabBox();
2825*b1cdbd2cSJim Jagielski }
2826*b1cdbd2cSJim Jagielski else if( !pCrsr && !pBoxFrm )
2827*b1cdbd2cSJim Jagielski {
2828*b1cdbd2cSJim Jagielski ASSERT( !this, "einer von beiden muss angegeben werden!" );
2829*b1cdbd2cSJim Jagielski return ;
2830*b1cdbd2cSJim Jagielski }
2831*b1cdbd2cSJim Jagielski
2832*b1cdbd2cSJim Jagielski // sollte die Tabelle noch auf relativen Werten (USHRT_MAX) stehen
2833*b1cdbd2cSJim Jagielski // dann muss es jetzt auf absolute umgerechnet werden.
2834*b1cdbd2cSJim Jagielski SwTable& rTab = *pTab->GetTable();
2835*b1cdbd2cSJim Jagielski const SwFmtFrmSize& rTblFrmSz = rTab.GetFrmFmt()->GetFrmSize();
2836*b1cdbd2cSJim Jagielski SWRECTFN( pTab )
2837*b1cdbd2cSJim Jagielski // OD 06.08.2003 #i17174# - With fix for #i9040# the shadow size is taken
2838*b1cdbd2cSJim Jagielski // from the table width. Thus, add its left and right size to current table
2839*b1cdbd2cSJim Jagielski // printing area width in order to get the correct table size attribute.
2840*b1cdbd2cSJim Jagielski SwTwips nPrtWidth = (pTab->Prt().*fnRect->fnGetWidth)();
2841*b1cdbd2cSJim Jagielski {
2842*b1cdbd2cSJim Jagielski SvxShadowItem aShadow( rTab.GetFrmFmt()->GetShadow() );
2843*b1cdbd2cSJim Jagielski nPrtWidth += aShadow.CalcShadowSpace( SHADOW_LEFT ) +
2844*b1cdbd2cSJim Jagielski aShadow.CalcShadowSpace( SHADOW_RIGHT );
2845*b1cdbd2cSJim Jagielski }
2846*b1cdbd2cSJim Jagielski if( nPrtWidth != rTblFrmSz.GetWidth() )
2847*b1cdbd2cSJim Jagielski {
2848*b1cdbd2cSJim Jagielski SwFmtFrmSize aSz( rTblFrmSz );
2849*b1cdbd2cSJim Jagielski aSz.SetWidth( nPrtWidth );
2850*b1cdbd2cSJim Jagielski rTab.GetFrmFmt()->SetFmtAttr( aSz );
2851*b1cdbd2cSJim Jagielski }
2852*b1cdbd2cSJim Jagielski
2853*b1cdbd2cSJim Jagielski SwTabCols aOld( rNew.Count() );
2854*b1cdbd2cSJim Jagielski
2855*b1cdbd2cSJim Jagielski const SwPageFrm* pPage = pTab->FindPageFrm();
2856*b1cdbd2cSJim Jagielski const sal_uLong nLeftMin = (pTab->Frm().*fnRect->fnGetLeft)() -
2857*b1cdbd2cSJim Jagielski (pPage->Frm().*fnRect->fnGetLeft)();
2858*b1cdbd2cSJim Jagielski const sal_uLong nRightMax = (pTab->Frm().*fnRect->fnGetRight)() -
2859*b1cdbd2cSJim Jagielski (pPage->Frm().*fnRect->fnGetLeft)();
2860*b1cdbd2cSJim Jagielski
2861*b1cdbd2cSJim Jagielski //Fix-Punkte setzen, LeftMin in Dokumentkoordinaten die anderen relativ.
2862*b1cdbd2cSJim Jagielski aOld.SetLeftMin ( nLeftMin );
2863*b1cdbd2cSJim Jagielski aOld.SetLeft ( (pTab->Prt().*fnRect->fnGetLeft)() );
2864*b1cdbd2cSJim Jagielski aOld.SetRight ( (pTab->Prt().*fnRect->fnGetRight)());
2865*b1cdbd2cSJim Jagielski aOld.SetRightMax( nRightMax - nLeftMin );
2866*b1cdbd2cSJim Jagielski
2867*b1cdbd2cSJim Jagielski rTab.GetTabCols( aOld, pBox );
2868*b1cdbd2cSJim Jagielski SetTabCols(rTab, rNew, aOld, pBox, bCurRowOnly );
2869*b1cdbd2cSJim Jagielski }
2870*b1cdbd2cSJim Jagielski
SetTabRows(const SwTabCols & rNew,sal_Bool bCurColOnly,const SwCursor *,const SwCellFrm * pBoxFrm)2871*b1cdbd2cSJim Jagielski void SwDoc::SetTabRows( const SwTabCols &rNew, sal_Bool bCurColOnly, const SwCursor*,
2872*b1cdbd2cSJim Jagielski const SwCellFrm* pBoxFrm )
2873*b1cdbd2cSJim Jagielski {
2874*b1cdbd2cSJim Jagielski const SwTableBox* pBox;
2875*b1cdbd2cSJim Jagielski SwTabFrm *pTab;
2876*b1cdbd2cSJim Jagielski
2877*b1cdbd2cSJim Jagielski ASSERT( pBoxFrm, "SetTabRows called without pBoxFrm" )
2878*b1cdbd2cSJim Jagielski
2879*b1cdbd2cSJim Jagielski pTab = ((SwFrm*)pBoxFrm)->ImplFindTabFrm();
2880*b1cdbd2cSJim Jagielski pBox = pBoxFrm->GetTabBox();
2881*b1cdbd2cSJim Jagielski
2882*b1cdbd2cSJim Jagielski // sollte die Tabelle noch auf relativen Werten (USHRT_MAX) stehen
2883*b1cdbd2cSJim Jagielski // dann muss es jetzt auf absolute umgerechnet werden.
2884*b1cdbd2cSJim Jagielski SWRECTFN( pTab )
2885*b1cdbd2cSJim Jagielski SwTabCols aOld( rNew.Count() );
2886*b1cdbd2cSJim Jagielski
2887*b1cdbd2cSJim Jagielski //Fix-Punkte setzen, LeftMin in Dokumentkoordinaten die anderen relativ.
2888*b1cdbd2cSJim Jagielski const SwPageFrm* pPage = pTab->FindPageFrm();
2889*b1cdbd2cSJim Jagielski
2890*b1cdbd2cSJim Jagielski aOld.SetRight( (pTab->Prt().*fnRect->fnGetHeight)() );
2891*b1cdbd2cSJim Jagielski long nLeftMin;
2892*b1cdbd2cSJim Jagielski if ( bVert )
2893*b1cdbd2cSJim Jagielski {
2894*b1cdbd2cSJim Jagielski nLeftMin = pTab->GetPrtLeft() - pPage->Frm().Left();
2895*b1cdbd2cSJim Jagielski aOld.SetLeft ( LONG_MAX );
2896*b1cdbd2cSJim Jagielski aOld.SetRightMax( aOld.GetRight() );
2897*b1cdbd2cSJim Jagielski
2898*b1cdbd2cSJim Jagielski }
2899*b1cdbd2cSJim Jagielski else
2900*b1cdbd2cSJim Jagielski {
2901*b1cdbd2cSJim Jagielski nLeftMin = pTab->GetPrtTop() - pPage->Frm().Top();
2902*b1cdbd2cSJim Jagielski aOld.SetLeft ( 0 );
2903*b1cdbd2cSJim Jagielski aOld.SetRightMax( LONG_MAX );
2904*b1cdbd2cSJim Jagielski }
2905*b1cdbd2cSJim Jagielski aOld.SetLeftMin ( nLeftMin );
2906*b1cdbd2cSJim Jagielski
2907*b1cdbd2cSJim Jagielski GetTabRows( aOld, 0, pBoxFrm );
2908*b1cdbd2cSJim Jagielski
2909*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().StartUndo( UNDO_TABLE_ATTR, NULL );
2910*b1cdbd2cSJim Jagielski
2911*b1cdbd2cSJim Jagielski // check for differences between aOld and rNew:
2912*b1cdbd2cSJim Jagielski const sal_uInt16 nCount = rNew.Count();
2913*b1cdbd2cSJim Jagielski const SwTable* pTable = pTab->GetTable();
2914*b1cdbd2cSJim Jagielski ASSERT( pTable, "My colleague told me, this couldn't happen" );
2915*b1cdbd2cSJim Jagielski
2916*b1cdbd2cSJim Jagielski for ( sal_uInt16 i = 0; i <= nCount; ++i )
2917*b1cdbd2cSJim Jagielski {
2918*b1cdbd2cSJim Jagielski const sal_uInt16 nIdxStt = bVert ? nCount - i : i - 1;
2919*b1cdbd2cSJim Jagielski const sal_uInt16 nIdxEnd = bVert ? nCount - i - 1 : i;
2920*b1cdbd2cSJim Jagielski
2921*b1cdbd2cSJim Jagielski const long nOldRowStart = i == 0 ? 0 : aOld[ nIdxStt ];
2922*b1cdbd2cSJim Jagielski const long nOldRowEnd = i == nCount ? aOld.GetRight() : aOld[ nIdxEnd ];
2923*b1cdbd2cSJim Jagielski const long nOldRowHeight = nOldRowEnd - nOldRowStart;
2924*b1cdbd2cSJim Jagielski
2925*b1cdbd2cSJim Jagielski const long nNewRowStart = i == 0 ? 0 : rNew[ nIdxStt ];
2926*b1cdbd2cSJim Jagielski const long nNewRowEnd = i == nCount ? rNew.GetRight() : rNew[ nIdxEnd ];
2927*b1cdbd2cSJim Jagielski const long nNewRowHeight = nNewRowEnd - nNewRowStart;
2928*b1cdbd2cSJim Jagielski
2929*b1cdbd2cSJim Jagielski const long nDiff = nNewRowHeight - nOldRowHeight;
2930*b1cdbd2cSJim Jagielski if ( abs( nDiff ) >= ROWFUZZY )
2931*b1cdbd2cSJim Jagielski {
2932*b1cdbd2cSJim Jagielski // For the old table model pTxtFrm and pLine will be set for every box.
2933*b1cdbd2cSJim Jagielski // For the new table model pTxtFrm will be set if the box is not covered,
2934*b1cdbd2cSJim Jagielski // but the pLine will be set if the box is not an overlapping box
2935*b1cdbd2cSJim Jagielski // In the new table model the row height can be adjusted,
2936*b1cdbd2cSJim Jagielski // when both variables are set.
2937*b1cdbd2cSJim Jagielski SwTxtFrm* pTxtFrm = 0;
2938*b1cdbd2cSJim Jagielski const SwTableLine* pLine = 0;
2939*b1cdbd2cSJim Jagielski
2940*b1cdbd2cSJim Jagielski // Iterate over all SwCellFrms with Bottom = nOldPos
2941*b1cdbd2cSJim Jagielski const SwFrm* pFrm = pTab->GetNextLayoutLeaf();
2942*b1cdbd2cSJim Jagielski while ( pFrm && pTab->IsAnLower( pFrm ) )
2943*b1cdbd2cSJim Jagielski {
2944*b1cdbd2cSJim Jagielski if ( pFrm->IsCellFrm() && pFrm->FindTabFrm() == pTab )
2945*b1cdbd2cSJim Jagielski {
2946*b1cdbd2cSJim Jagielski const long nLowerBorder = (pFrm->Frm().*fnRect->fnGetBottom)();
2947*b1cdbd2cSJim Jagielski const sal_uLong nTabTop = (pTab->*fnRect->fnGetPrtTop)();
2948*b1cdbd2cSJim Jagielski if ( abs( (*fnRect->fnYInc)( nTabTop, nOldRowEnd ) - nLowerBorder ) <= ROWFUZZY )
2949*b1cdbd2cSJim Jagielski {
2950*b1cdbd2cSJim Jagielski if ( !bCurColOnly || pFrm == pBoxFrm )
2951*b1cdbd2cSJim Jagielski {
2952*b1cdbd2cSJim Jagielski const SwFrm* pCntnt = ::GetCellCntnt( static_cast<const SwCellFrm&>(*pFrm) );
2953*b1cdbd2cSJim Jagielski
2954*b1cdbd2cSJim Jagielski if ( pCntnt && pCntnt->IsTxtFrm() )
2955*b1cdbd2cSJim Jagielski {
2956*b1cdbd2cSJim Jagielski pBox = ((SwCellFrm*)pFrm)->GetTabBox();
2957*b1cdbd2cSJim Jagielski const long nRowSpan = pBox->getRowSpan();
2958*b1cdbd2cSJim Jagielski if( nRowSpan > 0 ) // Not overlapped
2959*b1cdbd2cSJim Jagielski pTxtFrm = (SwTxtFrm*)pCntnt;
2960*b1cdbd2cSJim Jagielski if( nRowSpan < 2 ) // Not overlapping for row height
2961*b1cdbd2cSJim Jagielski pLine = pBox->GetUpper();
2962*b1cdbd2cSJim Jagielski if( pLine && pTxtFrm ) // always for old table model
2963*b1cdbd2cSJim Jagielski {
2964*b1cdbd2cSJim Jagielski // The new row height must not to be calculated from a overlapping box
2965*b1cdbd2cSJim Jagielski SwFmtFrmSize aNew( pLine->GetFrmFmt()->GetFrmSize() );
2966*b1cdbd2cSJim Jagielski const long nNewSize = (pFrm->Frm().*fnRect->fnGetHeight)() + nDiff;
2967*b1cdbd2cSJim Jagielski if( nNewSize != aNew.GetHeight() )
2968*b1cdbd2cSJim Jagielski {
2969*b1cdbd2cSJim Jagielski aNew.SetHeight( nNewSize );
2970*b1cdbd2cSJim Jagielski if ( ATT_VAR_SIZE == aNew.GetHeightSizeType() )
2971*b1cdbd2cSJim Jagielski aNew.SetHeightSizeType( ATT_MIN_SIZE );
2972*b1cdbd2cSJim Jagielski // This position must not be in an overlapped box
2973*b1cdbd2cSJim Jagielski const SwPosition aPos( *((SwTxtFrm*)pCntnt)->GetTxtNode() );
2974*b1cdbd2cSJim Jagielski const SwCursor aTmpCrsr( aPos, 0, false );
2975*b1cdbd2cSJim Jagielski SetRowHeight( aTmpCrsr, aNew );
2976*b1cdbd2cSJim Jagielski // For the new table model we're done, for the old one
2977*b1cdbd2cSJim Jagielski // there might be another (sub)row to adjust...
2978*b1cdbd2cSJim Jagielski if( pTable->IsNewModel() )
2979*b1cdbd2cSJim Jagielski break;
2980*b1cdbd2cSJim Jagielski }
2981*b1cdbd2cSJim Jagielski pLine = 0;
2982*b1cdbd2cSJim Jagielski }
2983*b1cdbd2cSJim Jagielski }
2984*b1cdbd2cSJim Jagielski }
2985*b1cdbd2cSJim Jagielski }
2986*b1cdbd2cSJim Jagielski }
2987*b1cdbd2cSJim Jagielski pFrm = pFrm->GetNextLayoutLeaf();
2988*b1cdbd2cSJim Jagielski }
2989*b1cdbd2cSJim Jagielski }
2990*b1cdbd2cSJim Jagielski }
2991*b1cdbd2cSJim Jagielski
2992*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().EndUndo( UNDO_TABLE_ATTR, NULL );
2993*b1cdbd2cSJim Jagielski
2994*b1cdbd2cSJim Jagielski ::ClearFEShellTabCols();
2995*b1cdbd2cSJim Jagielski }
2996*b1cdbd2cSJim Jagielski
2997*b1cdbd2cSJim Jagielski /* -----------------18.07.98 11:45-------------------
2998*b1cdbd2cSJim Jagielski * Direktzugriff fuer UNO
2999*b1cdbd2cSJim Jagielski * --------------------------------------------------*/
SetTabCols(SwTable & rTab,const SwTabCols & rNew,const SwTabCols & rOld,const SwTableBox * pStart,sal_Bool bCurRowOnly)3000*b1cdbd2cSJim Jagielski void SwDoc::SetTabCols(SwTable& rTab, const SwTabCols &rNew, const SwTabCols &rOld,
3001*b1cdbd2cSJim Jagielski const SwTableBox *pStart, sal_Bool bCurRowOnly )
3002*b1cdbd2cSJim Jagielski {
3003*b1cdbd2cSJim Jagielski if (GetIDocumentUndoRedo().DoesUndo())
3004*b1cdbd2cSJim Jagielski {
3005*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().AppendUndo(
3006*b1cdbd2cSJim Jagielski new SwUndoAttrTbl( *rTab.GetTableNode(), sal_True ));
3007*b1cdbd2cSJim Jagielski }
3008*b1cdbd2cSJim Jagielski rTab.SetTabCols( rNew, rOld, pStart, bCurRowOnly );
3009*b1cdbd2cSJim Jagielski ::ClearFEShellTabCols();
3010*b1cdbd2cSJim Jagielski SetModified();
3011*b1cdbd2cSJim Jagielski }
3012*b1cdbd2cSJim Jagielski
SetRowsToRepeat(SwTable & rTable,sal_uInt16 nSet)3013*b1cdbd2cSJim Jagielski void SwDoc::SetRowsToRepeat( SwTable &rTable, sal_uInt16 nSet )
3014*b1cdbd2cSJim Jagielski {
3015*b1cdbd2cSJim Jagielski if( nSet == rTable.GetRowsToRepeat() )
3016*b1cdbd2cSJim Jagielski return;
3017*b1cdbd2cSJim Jagielski
3018*b1cdbd2cSJim Jagielski if (GetIDocumentUndoRedo().DoesUndo())
3019*b1cdbd2cSJim Jagielski {
3020*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().AppendUndo(
3021*b1cdbd2cSJim Jagielski new SwUndoTblHeadline(rTable, rTable.GetRowsToRepeat(), nSet) );
3022*b1cdbd2cSJim Jagielski }
3023*b1cdbd2cSJim Jagielski
3024*b1cdbd2cSJim Jagielski SwMsgPoolItem aChg( RES_TBLHEADLINECHG );
3025*b1cdbd2cSJim Jagielski rTable.SetRowsToRepeat( nSet );
3026*b1cdbd2cSJim Jagielski rTable.GetFrmFmt()->ModifyNotification( &aChg, &aChg );
3027*b1cdbd2cSJim Jagielski SetModified();
3028*b1cdbd2cSJim Jagielski }
3029*b1cdbd2cSJim Jagielski
3030*b1cdbd2cSJim Jagielski
3031*b1cdbd2cSJim Jagielski
3032*b1cdbd2cSJim Jagielski
3033*b1cdbd2cSJim Jagielski // Splittet eine Tabelle in der Grund-Zeile, in der der Index steht.
3034*b1cdbd2cSJim Jagielski // Alle GrundZeilen dahinter wandern in eine neue Tabelle/-Node.
3035*b1cdbd2cSJim Jagielski // Ist das Flag bCalcNewSize auf sal_True, wird fuer beide neuen Tabellen
3036*b1cdbd2cSJim Jagielski // die neue Size aus dem Max der Boxen errechnet; vorrausgesetzt,
3037*b1cdbd2cSJim Jagielski // die Size ist "absolut" gesetzt (USHRT_MAX)
3038*b1cdbd2cSJim Jagielski
AddToUndoHistory(const SwCntntNode & rNd)3039*b1cdbd2cSJim Jagielski void SwCollectTblLineBoxes::AddToUndoHistory( const SwCntntNode& rNd )
3040*b1cdbd2cSJim Jagielski {
3041*b1cdbd2cSJim Jagielski if( pHst )
3042*b1cdbd2cSJim Jagielski pHst->Add( rNd.GetFmtColl(), rNd.GetIndex(), ND_TEXTNODE );
3043*b1cdbd2cSJim Jagielski }
3044*b1cdbd2cSJim Jagielski
AddBox(const SwTableBox & rBox)3045*b1cdbd2cSJim Jagielski void SwCollectTblLineBoxes::AddBox( const SwTableBox& rBox )
3046*b1cdbd2cSJim Jagielski {
3047*b1cdbd2cSJim Jagielski aPosArr.Insert( nWidth, aPosArr.Count() );
3048*b1cdbd2cSJim Jagielski SwTableBox* p = (SwTableBox*)&rBox;
3049*b1cdbd2cSJim Jagielski aBoxes.Insert( p, aBoxes.Count() );
3050*b1cdbd2cSJim Jagielski nWidth = nWidth + (sal_uInt16)rBox.GetFrmFmt()->GetFrmSize().GetWidth();
3051*b1cdbd2cSJim Jagielski }
3052*b1cdbd2cSJim Jagielski
GetBoxOfPos(const SwTableBox & rBox)3053*b1cdbd2cSJim Jagielski const SwTableBox* SwCollectTblLineBoxes::GetBoxOfPos( const SwTableBox& rBox )
3054*b1cdbd2cSJim Jagielski {
3055*b1cdbd2cSJim Jagielski const SwTableBox* pRet = 0;
3056*b1cdbd2cSJim Jagielski sal_uInt16 n;
3057*b1cdbd2cSJim Jagielski
3058*b1cdbd2cSJim Jagielski if( aPosArr.Count() )
3059*b1cdbd2cSJim Jagielski {
3060*b1cdbd2cSJim Jagielski for( n = 0; n < aPosArr.Count(); ++n )
3061*b1cdbd2cSJim Jagielski if( aPosArr[ n ] == nWidth )
3062*b1cdbd2cSJim Jagielski break;
3063*b1cdbd2cSJim Jagielski else if( aPosArr[ n ] > nWidth )
3064*b1cdbd2cSJim Jagielski {
3065*b1cdbd2cSJim Jagielski if( n )
3066*b1cdbd2cSJim Jagielski --n;
3067*b1cdbd2cSJim Jagielski break;
3068*b1cdbd2cSJim Jagielski }
3069*b1cdbd2cSJim Jagielski
3070*b1cdbd2cSJim Jagielski if( n >= aPosArr.Count() )
3071*b1cdbd2cSJim Jagielski --n;
3072*b1cdbd2cSJim Jagielski
3073*b1cdbd2cSJim Jagielski nWidth = nWidth + (sal_uInt16)rBox.GetFrmFmt()->GetFrmSize().GetWidth();
3074*b1cdbd2cSJim Jagielski pRet = aBoxes[ n ];
3075*b1cdbd2cSJim Jagielski }
3076*b1cdbd2cSJim Jagielski return pRet;
3077*b1cdbd2cSJim Jagielski }
3078*b1cdbd2cSJim Jagielski
Resize(sal_uInt16 nOffset,sal_uInt16 nOldWidth)3079*b1cdbd2cSJim Jagielski sal_Bool SwCollectTblLineBoxes::Resize( sal_uInt16 nOffset, sal_uInt16 nOldWidth )
3080*b1cdbd2cSJim Jagielski {
3081*b1cdbd2cSJim Jagielski sal_uInt16 n;
3082*b1cdbd2cSJim Jagielski
3083*b1cdbd2cSJim Jagielski if( aPosArr.Count() )
3084*b1cdbd2cSJim Jagielski {
3085*b1cdbd2cSJim Jagielski for( n = 0; n < aPosArr.Count(); ++n )
3086*b1cdbd2cSJim Jagielski if( aPosArr[ n ] == nOffset )
3087*b1cdbd2cSJim Jagielski break;
3088*b1cdbd2cSJim Jagielski else if( aPosArr[ n ] > nOffset )
3089*b1cdbd2cSJim Jagielski {
3090*b1cdbd2cSJim Jagielski if( n )
3091*b1cdbd2cSJim Jagielski --n;
3092*b1cdbd2cSJim Jagielski break;
3093*b1cdbd2cSJim Jagielski }
3094*b1cdbd2cSJim Jagielski
3095*b1cdbd2cSJim Jagielski aPosArr.Remove( 0, n );
3096*b1cdbd2cSJim Jagielski aBoxes.Remove( 0, n );
3097*b1cdbd2cSJim Jagielski
3098*b1cdbd2cSJim Jagielski // dann die Positionen der neuen Size anpassen
3099*b1cdbd2cSJim Jagielski for( n = 0; n < aPosArr.Count(); ++n )
3100*b1cdbd2cSJim Jagielski {
3101*b1cdbd2cSJim Jagielski sal_uLong nSize = nWidth;
3102*b1cdbd2cSJim Jagielski nSize *= ( aPosArr[ n ] - nOffset );
3103*b1cdbd2cSJim Jagielski nSize /= nOldWidth;
3104*b1cdbd2cSJim Jagielski aPosArr[ n ] = sal_uInt16( nSize );
3105*b1cdbd2cSJim Jagielski }
3106*b1cdbd2cSJim Jagielski }
3107*b1cdbd2cSJim Jagielski return 0 != aPosArr.Count();
3108*b1cdbd2cSJim Jagielski }
3109*b1cdbd2cSJim Jagielski
lcl_Line_CollectBox(const SwTableLine * & rpLine,void * pPara)3110*b1cdbd2cSJim Jagielski sal_Bool lcl_Line_CollectBox( const SwTableLine*& rpLine, void* pPara )
3111*b1cdbd2cSJim Jagielski {
3112*b1cdbd2cSJim Jagielski SwCollectTblLineBoxes* pSplPara = (SwCollectTblLineBoxes*)pPara;
3113*b1cdbd2cSJim Jagielski if( pSplPara->IsGetValues() )
3114*b1cdbd2cSJim Jagielski ((SwTableLine*)rpLine)->GetTabBoxes().ForEach( &lcl_Box_CollectBox, pPara );
3115*b1cdbd2cSJim Jagielski else
3116*b1cdbd2cSJim Jagielski ((SwTableLine*)rpLine)->GetTabBoxes().ForEach( &lcl_BoxSetSplitBoxFmts, pPara );
3117*b1cdbd2cSJim Jagielski return sal_True;
3118*b1cdbd2cSJim Jagielski }
3119*b1cdbd2cSJim Jagielski
lcl_Box_CollectBox(const SwTableBox * & rpBox,void * pPara)3120*b1cdbd2cSJim Jagielski sal_Bool lcl_Box_CollectBox( const SwTableBox*& rpBox, void* pPara )
3121*b1cdbd2cSJim Jagielski {
3122*b1cdbd2cSJim Jagielski SwCollectTblLineBoxes* pSplPara = (SwCollectTblLineBoxes*)pPara;
3123*b1cdbd2cSJim Jagielski sal_uInt16 nLen = rpBox->GetTabLines().Count();
3124*b1cdbd2cSJim Jagielski if( nLen )
3125*b1cdbd2cSJim Jagielski {
3126*b1cdbd2cSJim Jagielski // dann mit der richtigen Line weitermachen
3127*b1cdbd2cSJim Jagielski if( pSplPara->IsGetFromTop() )
3128*b1cdbd2cSJim Jagielski nLen = 0;
3129*b1cdbd2cSJim Jagielski else
3130*b1cdbd2cSJim Jagielski --nLen;
3131*b1cdbd2cSJim Jagielski
3132*b1cdbd2cSJim Jagielski const SwTableLine* pLn = rpBox->GetTabLines()[ nLen ];
3133*b1cdbd2cSJim Jagielski lcl_Line_CollectBox( pLn, pPara );
3134*b1cdbd2cSJim Jagielski }
3135*b1cdbd2cSJim Jagielski else
3136*b1cdbd2cSJim Jagielski pSplPara->AddBox( *rpBox );
3137*b1cdbd2cSJim Jagielski return sal_True;
3138*b1cdbd2cSJim Jagielski }
3139*b1cdbd2cSJim Jagielski
lcl_BoxSetSplitBoxFmts(const SwTableBox * & rpBox,void * pPara)3140*b1cdbd2cSJim Jagielski sal_Bool lcl_BoxSetSplitBoxFmts( const SwTableBox*& rpBox, void* pPara )
3141*b1cdbd2cSJim Jagielski {
3142*b1cdbd2cSJim Jagielski SwCollectTblLineBoxes* pSplPara = (SwCollectTblLineBoxes*)pPara;
3143*b1cdbd2cSJim Jagielski sal_uInt16 nLen = rpBox->GetTabLines().Count();
3144*b1cdbd2cSJim Jagielski if( nLen )
3145*b1cdbd2cSJim Jagielski {
3146*b1cdbd2cSJim Jagielski // dann mit der richtigen Line weitermachen
3147*b1cdbd2cSJim Jagielski if( pSplPara->IsGetFromTop() )
3148*b1cdbd2cSJim Jagielski nLen = 0;
3149*b1cdbd2cSJim Jagielski else
3150*b1cdbd2cSJim Jagielski --nLen;
3151*b1cdbd2cSJim Jagielski
3152*b1cdbd2cSJim Jagielski const SwTableLine* pLn = rpBox->GetTabLines()[ nLen ];
3153*b1cdbd2cSJim Jagielski lcl_Line_CollectBox( pLn, pPara );
3154*b1cdbd2cSJim Jagielski }
3155*b1cdbd2cSJim Jagielski else
3156*b1cdbd2cSJim Jagielski {
3157*b1cdbd2cSJim Jagielski const SwTableBox* pSrcBox = pSplPara->GetBoxOfPos( *rpBox );
3158*b1cdbd2cSJim Jagielski SwFrmFmt* pFmt = pSrcBox->GetFrmFmt();
3159*b1cdbd2cSJim Jagielski SwTableBox* pBox = (SwTableBox*)rpBox;
3160*b1cdbd2cSJim Jagielski
3161*b1cdbd2cSJim Jagielski if( HEADLINE_BORDERCOPY == pSplPara->GetMode() )
3162*b1cdbd2cSJim Jagielski {
3163*b1cdbd2cSJim Jagielski const SvxBoxItem& rBoxItem = pBox->GetFrmFmt()->GetBox();
3164*b1cdbd2cSJim Jagielski if( !rBoxItem.GetTop() )
3165*b1cdbd2cSJim Jagielski {
3166*b1cdbd2cSJim Jagielski SvxBoxItem aNew( rBoxItem );
3167*b1cdbd2cSJim Jagielski aNew.SetLine( pFmt->GetBox().GetBottom(), BOX_LINE_TOP );
3168*b1cdbd2cSJim Jagielski if( aNew != rBoxItem )
3169*b1cdbd2cSJim Jagielski pBox->ClaimFrmFmt()->SetFmtAttr( aNew );
3170*b1cdbd2cSJim Jagielski }
3171*b1cdbd2cSJim Jagielski }
3172*b1cdbd2cSJim Jagielski else
3173*b1cdbd2cSJim Jagielski {
3174*b1cdbd2cSJim Jagielski sal_uInt16 __FAR_DATA aTableSplitBoxSetRange[] = {
3175*b1cdbd2cSJim Jagielski RES_LR_SPACE, RES_UL_SPACE,
3176*b1cdbd2cSJim Jagielski RES_BACKGROUND, RES_SHADOW,
3177*b1cdbd2cSJim Jagielski RES_PROTECT, RES_PROTECT,
3178*b1cdbd2cSJim Jagielski RES_VERT_ORIENT, RES_VERT_ORIENT,
3179*b1cdbd2cSJim Jagielski 0 };
3180*b1cdbd2cSJim Jagielski SfxItemSet aTmpSet( pFmt->GetDoc()->GetAttrPool(),
3181*b1cdbd2cSJim Jagielski aTableSplitBoxSetRange );
3182*b1cdbd2cSJim Jagielski aTmpSet.Put( pFmt->GetAttrSet() );
3183*b1cdbd2cSJim Jagielski if( aTmpSet.Count() )
3184*b1cdbd2cSJim Jagielski pBox->ClaimFrmFmt()->SetFmtAttr( aTmpSet );
3185*b1cdbd2cSJim Jagielski
3186*b1cdbd2cSJim Jagielski if( HEADLINE_BOXATRCOLLCOPY == pSplPara->GetMode() )
3187*b1cdbd2cSJim Jagielski {
3188*b1cdbd2cSJim Jagielski SwNodeIndex aIdx( *pSrcBox->GetSttNd(), 1 );
3189*b1cdbd2cSJim Jagielski SwCntntNode* pCNd = aIdx.GetNode().GetCntntNode();
3190*b1cdbd2cSJim Jagielski if( !pCNd )
3191*b1cdbd2cSJim Jagielski pCNd = aIdx.GetNodes().GoNext( &aIdx );
3192*b1cdbd2cSJim Jagielski aIdx = *pBox->GetSttNd();
3193*b1cdbd2cSJim Jagielski SwCntntNode* pDNd = aIdx.GetNodes().GoNext( &aIdx );
3194*b1cdbd2cSJim Jagielski
3195*b1cdbd2cSJim Jagielski // nur wenn der Node alleine in der Section steht
3196*b1cdbd2cSJim Jagielski if( 2 == pDNd->EndOfSectionIndex() -
3197*b1cdbd2cSJim Jagielski pDNd->StartOfSectionIndex() )
3198*b1cdbd2cSJim Jagielski {
3199*b1cdbd2cSJim Jagielski pSplPara->AddToUndoHistory( *pDNd );
3200*b1cdbd2cSJim Jagielski pDNd->ChgFmtColl( pCNd->GetFmtColl() );
3201*b1cdbd2cSJim Jagielski }
3202*b1cdbd2cSJim Jagielski }
3203*b1cdbd2cSJim Jagielski
3204*b1cdbd2cSJim Jagielski // bedingte Vorlage beachten
3205*b1cdbd2cSJim Jagielski pBox->GetSttNd()->CheckSectionCondColl();
3206*b1cdbd2cSJim Jagielski }
3207*b1cdbd2cSJim Jagielski }
3208*b1cdbd2cSJim Jagielski return sal_True;
3209*b1cdbd2cSJim Jagielski }
3210*b1cdbd2cSJim Jagielski
3211*b1cdbd2cSJim Jagielski
SplitTable(const SwPosition & rPos,sal_uInt16 eHdlnMode,sal_Bool bCalcNewSize)3212*b1cdbd2cSJim Jagielski sal_Bool SwDoc::SplitTable( const SwPosition& rPos, sal_uInt16 eHdlnMode,
3213*b1cdbd2cSJim Jagielski sal_Bool bCalcNewSize )
3214*b1cdbd2cSJim Jagielski {
3215*b1cdbd2cSJim Jagielski SwNode* pNd = &rPos.nNode.GetNode();
3216*b1cdbd2cSJim Jagielski SwTableNode* pTNd = pNd->FindTableNode();
3217*b1cdbd2cSJim Jagielski if( !pTNd || pNd->IsTableNode() )
3218*b1cdbd2cSJim Jagielski return 0;
3219*b1cdbd2cSJim Jagielski
3220*b1cdbd2cSJim Jagielski if( pTNd->GetTable().ISA( SwDDETable ))
3221*b1cdbd2cSJim Jagielski return sal_False;
3222*b1cdbd2cSJim Jagielski
3223*b1cdbd2cSJim Jagielski SwTable& rTbl = pTNd->GetTable();
3224*b1cdbd2cSJim Jagielski rTbl.SetHTMLTableLayout( 0 ); // MIB 9.7.97: HTML-Layout loeschen
3225*b1cdbd2cSJim Jagielski
3226*b1cdbd2cSJim Jagielski SwTableFmlUpdate aMsgHnt( &rTbl );
3227*b1cdbd2cSJim Jagielski
3228*b1cdbd2cSJim Jagielski SwHistory aHistory;
3229*b1cdbd2cSJim Jagielski if (GetIDocumentUndoRedo().DoesUndo())
3230*b1cdbd2cSJim Jagielski {
3231*b1cdbd2cSJim Jagielski aMsgHnt.pHistory = &aHistory;
3232*b1cdbd2cSJim Jagielski }
3233*b1cdbd2cSJim Jagielski
3234*b1cdbd2cSJim Jagielski {
3235*b1cdbd2cSJim Jagielski sal_uLong nSttIdx = pNd->FindTableBoxStartNode()->GetIndex();
3236*b1cdbd2cSJim Jagielski
3237*b1cdbd2cSJim Jagielski // Suche die Grund-Line dieser Box:
3238*b1cdbd2cSJim Jagielski SwTableBox* pBox = rTbl.GetTblBox( nSttIdx );
3239*b1cdbd2cSJim Jagielski if( pBox )
3240*b1cdbd2cSJim Jagielski {
3241*b1cdbd2cSJim Jagielski SwTableLine* pLine = pBox->GetUpper();
3242*b1cdbd2cSJim Jagielski while( pLine->GetUpper() )
3243*b1cdbd2cSJim Jagielski pLine = pLine->GetUpper()->GetUpper();
3244*b1cdbd2cSJim Jagielski
3245*b1cdbd2cSJim Jagielski // in pLine steht jetzt die GrundLine.
3246*b1cdbd2cSJim Jagielski aMsgHnt.nSplitLine = rTbl.GetTabLines().C40_GETPOS( SwTableLine, pLine );
3247*b1cdbd2cSJim Jagielski }
3248*b1cdbd2cSJim Jagielski
3249*b1cdbd2cSJim Jagielski String sNewTblNm( GetUniqueTblName() );
3250*b1cdbd2cSJim Jagielski aMsgHnt.DATA.pNewTblNm = &sNewTblNm;
3251*b1cdbd2cSJim Jagielski aMsgHnt.eFlags = TBL_SPLITTBL;
3252*b1cdbd2cSJim Jagielski UpdateTblFlds( &aMsgHnt );
3253*b1cdbd2cSJim Jagielski }
3254*b1cdbd2cSJim Jagielski
3255*b1cdbd2cSJim Jagielski //Lines fuer das Layout-Update heraussuchen.
3256*b1cdbd2cSJim Jagielski _FndBox aFndBox( 0, 0 );
3257*b1cdbd2cSJim Jagielski aFndBox.SetTableLines( rTbl );
3258*b1cdbd2cSJim Jagielski aFndBox.DelFrms( rTbl );
3259*b1cdbd2cSJim Jagielski
3260*b1cdbd2cSJim Jagielski // TL_CHART2: need to inform chart of probably changed cell names
3261*b1cdbd2cSJim Jagielski //pDoc->UpdateCharts( rTbl.GetFrmFmt()->GetName() );
3262*b1cdbd2cSJim Jagielski
3263*b1cdbd2cSJim Jagielski SwTableNode* pNew = GetNodes().SplitTable( rPos.nNode, sal_False, bCalcNewSize );
3264*b1cdbd2cSJim Jagielski
3265*b1cdbd2cSJim Jagielski if( pNew )
3266*b1cdbd2cSJim Jagielski {
3267*b1cdbd2cSJim Jagielski SwSaveRowSpan* pSaveRowSp = pNew->GetTable().CleanUpTopRowSpan( rTbl.GetTabLines().Count() );
3268*b1cdbd2cSJim Jagielski SwUndoSplitTbl* pUndo = 0;
3269*b1cdbd2cSJim Jagielski if (GetIDocumentUndoRedo().DoesUndo())
3270*b1cdbd2cSJim Jagielski {
3271*b1cdbd2cSJim Jagielski pUndo = new SwUndoSplitTbl(
3272*b1cdbd2cSJim Jagielski *pNew, pSaveRowSp, eHdlnMode, bCalcNewSize);
3273*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().AppendUndo(pUndo);
3274*b1cdbd2cSJim Jagielski if( aHistory.Count() )
3275*b1cdbd2cSJim Jagielski pUndo->SaveFormula( aHistory );
3276*b1cdbd2cSJim Jagielski }
3277*b1cdbd2cSJim Jagielski
3278*b1cdbd2cSJim Jagielski switch( eHdlnMode )
3279*b1cdbd2cSJim Jagielski {
3280*b1cdbd2cSJim Jagielski // setze die untere Border der vorherige Line,
3281*b1cdbd2cSJim Jagielski // an der aktuellen als obere
3282*b1cdbd2cSJim Jagielski case HEADLINE_BORDERCOPY:
3283*b1cdbd2cSJim Jagielski {
3284*b1cdbd2cSJim Jagielski SwCollectTblLineBoxes aPara( sal_False, eHdlnMode );
3285*b1cdbd2cSJim Jagielski SwTableLine* pLn = rTbl.GetTabLines()[
3286*b1cdbd2cSJim Jagielski rTbl.GetTabLines().Count() - 1 ];
3287*b1cdbd2cSJim Jagielski pLn->GetTabBoxes().ForEach( &lcl_Box_CollectBox, &aPara );
3288*b1cdbd2cSJim Jagielski
3289*b1cdbd2cSJim Jagielski aPara.SetValues( sal_True );
3290*b1cdbd2cSJim Jagielski pLn = pNew->GetTable().GetTabLines()[ 0 ];
3291*b1cdbd2cSJim Jagielski pLn->GetTabBoxes().ForEach( &lcl_BoxSetSplitBoxFmts, &aPara );
3292*b1cdbd2cSJim Jagielski
3293*b1cdbd2cSJim Jagielski // Kopfzeile wiederholen abschalten
3294*b1cdbd2cSJim Jagielski pNew->GetTable().SetRowsToRepeat( 0 );
3295*b1cdbd2cSJim Jagielski }
3296*b1cdbd2cSJim Jagielski break;
3297*b1cdbd2cSJim Jagielski
3298*b1cdbd2cSJim Jagielski // setze die Attributierung der ersten Line an der neuen ersten
3299*b1cdbd2cSJim Jagielski case HEADLINE_BOXATTRCOPY:
3300*b1cdbd2cSJim Jagielski case HEADLINE_BOXATRCOLLCOPY:
3301*b1cdbd2cSJim Jagielski {
3302*b1cdbd2cSJim Jagielski SwHistory* pHst = 0;
3303*b1cdbd2cSJim Jagielski if( HEADLINE_BOXATRCOLLCOPY == eHdlnMode && pUndo )
3304*b1cdbd2cSJim Jagielski pHst = pUndo->GetHistory();
3305*b1cdbd2cSJim Jagielski
3306*b1cdbd2cSJim Jagielski SwCollectTblLineBoxes aPara( sal_True, eHdlnMode, pHst );
3307*b1cdbd2cSJim Jagielski SwTableLine* pLn = rTbl.GetTabLines()[ 0 ];
3308*b1cdbd2cSJim Jagielski pLn->GetTabBoxes().ForEach( &lcl_Box_CollectBox, &aPara );
3309*b1cdbd2cSJim Jagielski
3310*b1cdbd2cSJim Jagielski aPara.SetValues( sal_True );
3311*b1cdbd2cSJim Jagielski pLn = pNew->GetTable().GetTabLines()[ 0 ];
3312*b1cdbd2cSJim Jagielski pLn->GetTabBoxes().ForEach( &lcl_BoxSetSplitBoxFmts, &aPara );
3313*b1cdbd2cSJim Jagielski }
3314*b1cdbd2cSJim Jagielski break;
3315*b1cdbd2cSJim Jagielski
3316*b1cdbd2cSJim Jagielski case HEADLINE_CNTNTCOPY:
3317*b1cdbd2cSJim Jagielski rTbl.CopyHeadlineIntoTable( *pNew );
3318*b1cdbd2cSJim Jagielski if( pUndo )
3319*b1cdbd2cSJim Jagielski pUndo->SetTblNodeOffset( pNew->GetIndex() );
3320*b1cdbd2cSJim Jagielski break;
3321*b1cdbd2cSJim Jagielski
3322*b1cdbd2cSJim Jagielski case HEADLINE_NONE:
3323*b1cdbd2cSJim Jagielski // Kopfzeile wiederholen abschalten
3324*b1cdbd2cSJim Jagielski pNew->GetTable().SetRowsToRepeat( 0 );
3325*b1cdbd2cSJim Jagielski break;
3326*b1cdbd2cSJim Jagielski }
3327*b1cdbd2cSJim Jagielski
3328*b1cdbd2cSJim Jagielski // und Frms einfuegen.
3329*b1cdbd2cSJim Jagielski SwNodeIndex aNdIdx( *pNew->EndOfSectionNode() );
3330*b1cdbd2cSJim Jagielski GetNodes().GoNext( &aNdIdx ); // zum naechsten ContentNode
3331*b1cdbd2cSJim Jagielski pNew->MakeFrms( &aNdIdx );
3332*b1cdbd2cSJim Jagielski
3333*b1cdbd2cSJim Jagielski //Zwischen die Tabellen wird ein Absatz geschoben
3334*b1cdbd2cSJim Jagielski GetNodes().MakeTxtNode( SwNodeIndex( *pNew ),
3335*b1cdbd2cSJim Jagielski GetTxtCollFromPool( RES_POOLCOLL_TEXT ) );
3336*b1cdbd2cSJim Jagielski }
3337*b1cdbd2cSJim Jagielski
3338*b1cdbd2cSJim Jagielski //Layout updaten
3339*b1cdbd2cSJim Jagielski aFndBox.MakeFrms( rTbl );
3340*b1cdbd2cSJim Jagielski
3341*b1cdbd2cSJim Jagielski // TL_CHART2: need to inform chart of probably changed cell names
3342*b1cdbd2cSJim Jagielski UpdateCharts( rTbl.GetFrmFmt()->GetName() );
3343*b1cdbd2cSJim Jagielski
3344*b1cdbd2cSJim Jagielski SetFieldsDirty( true, NULL, 0 );
3345*b1cdbd2cSJim Jagielski
3346*b1cdbd2cSJim Jagielski return 0 != pNew;
3347*b1cdbd2cSJim Jagielski }
3348*b1cdbd2cSJim Jagielski
lcl_ChgTblSize(SwTable & rTbl)3349*b1cdbd2cSJim Jagielski sal_Bool lcl_ChgTblSize( SwTable& rTbl )
3350*b1cdbd2cSJim Jagielski {
3351*b1cdbd2cSJim Jagielski // das Attribut darf nicht ueber das Modify an der
3352*b1cdbd2cSJim Jagielski // Tabelle gesetzt werden, denn sonst werden alle
3353*b1cdbd2cSJim Jagielski // Boxen wieder auf 0 zurueck gesetzt. Also locke das Format
3354*b1cdbd2cSJim Jagielski SwFrmFmt* pFmt = rTbl.GetFrmFmt();
3355*b1cdbd2cSJim Jagielski SwFmtFrmSize aTblMaxSz( pFmt->GetFrmSize() );
3356*b1cdbd2cSJim Jagielski
3357*b1cdbd2cSJim Jagielski if( USHRT_MAX == aTblMaxSz.GetWidth() )
3358*b1cdbd2cSJim Jagielski return sal_False;
3359*b1cdbd2cSJim Jagielski
3360*b1cdbd2cSJim Jagielski sal_Bool bLocked = pFmt->IsModifyLocked();
3361*b1cdbd2cSJim Jagielski pFmt->LockModify();
3362*b1cdbd2cSJim Jagielski
3363*b1cdbd2cSJim Jagielski aTblMaxSz.SetWidth( 0 );
3364*b1cdbd2cSJim Jagielski
3365*b1cdbd2cSJim Jagielski SwTableLines& rLns = rTbl.GetTabLines();
3366*b1cdbd2cSJim Jagielski for( sal_uInt16 nLns = 0; nLns < rLns.Count(); ++nLns )
3367*b1cdbd2cSJim Jagielski {
3368*b1cdbd2cSJim Jagielski SwTwips nMaxLnWidth = 0;
3369*b1cdbd2cSJim Jagielski SwTableBoxes& rBoxes = rLns[ nLns ]->GetTabBoxes();
3370*b1cdbd2cSJim Jagielski for( sal_uInt16 nBox = 0; nBox < rBoxes.Count(); ++nBox )
3371*b1cdbd2cSJim Jagielski nMaxLnWidth += rBoxes[nBox]->GetFrmFmt()->GetFrmSize().GetWidth();
3372*b1cdbd2cSJim Jagielski
3373*b1cdbd2cSJim Jagielski if( nMaxLnWidth > aTblMaxSz.GetWidth() )
3374*b1cdbd2cSJim Jagielski aTblMaxSz.SetWidth( nMaxLnWidth );
3375*b1cdbd2cSJim Jagielski }
3376*b1cdbd2cSJim Jagielski pFmt->SetFmtAttr( aTblMaxSz );
3377*b1cdbd2cSJim Jagielski if( !bLocked ) // und gegebenenfalls Lock wieder freigeben
3378*b1cdbd2cSJim Jagielski pFmt->UnlockModify();
3379*b1cdbd2cSJim Jagielski
3380*b1cdbd2cSJim Jagielski return sal_True;
3381*b1cdbd2cSJim Jagielski }
3382*b1cdbd2cSJim Jagielski
3383*b1cdbd2cSJim Jagielski class _SplitTable_Para
3384*b1cdbd2cSJim Jagielski {
3385*b1cdbd2cSJim Jagielski SvPtrarr aSrc, aDest;
3386*b1cdbd2cSJim Jagielski SwTableNode* pNewTblNd;
3387*b1cdbd2cSJim Jagielski SwTable& rOldTbl;
3388*b1cdbd2cSJim Jagielski
3389*b1cdbd2cSJim Jagielski public:
_SplitTable_Para(SwTableNode * pNew,SwTable & rOld)3390*b1cdbd2cSJim Jagielski _SplitTable_Para( SwTableNode* pNew, SwTable& rOld )
3391*b1cdbd2cSJim Jagielski : aSrc( 16, 16 ), aDest( 16, 16 ), pNewTblNd( pNew ), rOldTbl( rOld )
3392*b1cdbd2cSJim Jagielski {}
SrcFmt_GetPos(void * pFmt) const3393*b1cdbd2cSJim Jagielski sal_uInt16 SrcFmt_GetPos( void* pFmt ) const
3394*b1cdbd2cSJim Jagielski { return aSrc.GetPos( pFmt ); }
3395*b1cdbd2cSJim Jagielski
DestFmt_Insert(void * pFmt)3396*b1cdbd2cSJim Jagielski void DestFmt_Insert( void* pFmt )
3397*b1cdbd2cSJim Jagielski { aDest.Insert( pFmt, aDest.Count() ); }
3398*b1cdbd2cSJim Jagielski
SrcFmt_Insert(void * pFmt)3399*b1cdbd2cSJim Jagielski void SrcFmt_Insert( void* pFmt )
3400*b1cdbd2cSJim Jagielski { aSrc.Insert( pFmt, aSrc.Count() ); }
3401*b1cdbd2cSJim Jagielski
DestFmt_Get(sal_uInt16 nPos) const3402*b1cdbd2cSJim Jagielski SwFrmFmt* DestFmt_Get( sal_uInt16 nPos ) const
3403*b1cdbd2cSJim Jagielski { return (SwFrmFmt*)aDest[ nPos ]; }
3404*b1cdbd2cSJim Jagielski
ChgBox(SwTableBox * pBox)3405*b1cdbd2cSJim Jagielski void ChgBox( SwTableBox* pBox )
3406*b1cdbd2cSJim Jagielski {
3407*b1cdbd2cSJim Jagielski rOldTbl.GetTabSortBoxes().Remove( pBox );
3408*b1cdbd2cSJim Jagielski pNewTblNd->GetTable().GetTabSortBoxes().Insert( pBox );
3409*b1cdbd2cSJim Jagielski }
3410*b1cdbd2cSJim Jagielski };
3411*b1cdbd2cSJim Jagielski
3412*b1cdbd2cSJim Jagielski
3413*b1cdbd2cSJim Jagielski sal_Bool lcl_SplitTable_CpyBox( const SwTableBox*& rpBox, void* pPara );
3414*b1cdbd2cSJim Jagielski
lcl_SplitTable_CpyLine(const SwTableLine * & rpLine,void * pPara)3415*b1cdbd2cSJim Jagielski sal_Bool lcl_SplitTable_CpyLine( const SwTableLine*& rpLine, void* pPara )
3416*b1cdbd2cSJim Jagielski {
3417*b1cdbd2cSJim Jagielski SwTableLine* pLn = (SwTableLine*)rpLine;
3418*b1cdbd2cSJim Jagielski _SplitTable_Para& rPara = *(_SplitTable_Para*)pPara;
3419*b1cdbd2cSJim Jagielski
3420*b1cdbd2cSJim Jagielski SwFrmFmt *pSrcFmt = pLn->GetFrmFmt();
3421*b1cdbd2cSJim Jagielski sal_uInt16 nPos = rPara.SrcFmt_GetPos( pSrcFmt );
3422*b1cdbd2cSJim Jagielski if( USHRT_MAX == nPos )
3423*b1cdbd2cSJim Jagielski {
3424*b1cdbd2cSJim Jagielski rPara.DestFmt_Insert( pLn->ClaimFrmFmt() );
3425*b1cdbd2cSJim Jagielski rPara.SrcFmt_Insert( pSrcFmt );
3426*b1cdbd2cSJim Jagielski }
3427*b1cdbd2cSJim Jagielski else
3428*b1cdbd2cSJim Jagielski pLn->ChgFrmFmt( (SwTableLineFmt*)rPara.DestFmt_Get( nPos ) );
3429*b1cdbd2cSJim Jagielski
3430*b1cdbd2cSJim Jagielski pLn->GetTabBoxes().ForEach( &lcl_SplitTable_CpyBox, pPara );
3431*b1cdbd2cSJim Jagielski return sal_True;
3432*b1cdbd2cSJim Jagielski }
3433*b1cdbd2cSJim Jagielski
lcl_SplitTable_CpyBox(const SwTableBox * & rpBox,void * pPara)3434*b1cdbd2cSJim Jagielski sal_Bool lcl_SplitTable_CpyBox( const SwTableBox*& rpBox, void* pPara )
3435*b1cdbd2cSJim Jagielski {
3436*b1cdbd2cSJim Jagielski SwTableBox* pBox = (SwTableBox*)rpBox;
3437*b1cdbd2cSJim Jagielski _SplitTable_Para& rPara = *(_SplitTable_Para*)pPara;
3438*b1cdbd2cSJim Jagielski
3439*b1cdbd2cSJim Jagielski SwFrmFmt *pSrcFmt = pBox->GetFrmFmt();
3440*b1cdbd2cSJim Jagielski sal_uInt16 nPos = rPara.SrcFmt_GetPos( pSrcFmt );
3441*b1cdbd2cSJim Jagielski if( USHRT_MAX == nPos )
3442*b1cdbd2cSJim Jagielski {
3443*b1cdbd2cSJim Jagielski rPara.DestFmt_Insert( pBox->ClaimFrmFmt() );
3444*b1cdbd2cSJim Jagielski rPara.SrcFmt_Insert( pSrcFmt );
3445*b1cdbd2cSJim Jagielski }
3446*b1cdbd2cSJim Jagielski else
3447*b1cdbd2cSJim Jagielski pBox->ChgFrmFmt( (SwTableBoxFmt*)rPara.DestFmt_Get( nPos ) );
3448*b1cdbd2cSJim Jagielski
3449*b1cdbd2cSJim Jagielski if( pBox->GetSttNd() )
3450*b1cdbd2cSJim Jagielski rPara.ChgBox( pBox );
3451*b1cdbd2cSJim Jagielski else
3452*b1cdbd2cSJim Jagielski pBox->GetTabLines().ForEach( &lcl_SplitTable_CpyLine, pPara );
3453*b1cdbd2cSJim Jagielski return sal_True;
3454*b1cdbd2cSJim Jagielski }
3455*b1cdbd2cSJim Jagielski
SplitTable(const SwNodeIndex & rPos,sal_Bool bAfter,sal_Bool bCalcNewSize)3456*b1cdbd2cSJim Jagielski SwTableNode* SwNodes::SplitTable( const SwNodeIndex& rPos, sal_Bool bAfter,
3457*b1cdbd2cSJim Jagielski sal_Bool bCalcNewSize )
3458*b1cdbd2cSJim Jagielski {
3459*b1cdbd2cSJim Jagielski SwNode* pNd = &rPos.GetNode();
3460*b1cdbd2cSJim Jagielski SwTableNode* pTNd = pNd->FindTableNode();
3461*b1cdbd2cSJim Jagielski if( !pTNd || pNd->IsTableNode() )
3462*b1cdbd2cSJim Jagielski return 0;
3463*b1cdbd2cSJim Jagielski
3464*b1cdbd2cSJim Jagielski sal_uLong nSttIdx = pNd->FindTableBoxStartNode()->GetIndex();
3465*b1cdbd2cSJim Jagielski
3466*b1cdbd2cSJim Jagielski // Suche die Grund-Line dieser Box:
3467*b1cdbd2cSJim Jagielski SwTable& rTbl = pTNd->GetTable();
3468*b1cdbd2cSJim Jagielski SwTableBox* pBox = rTbl.GetTblBox( nSttIdx );
3469*b1cdbd2cSJim Jagielski if( !pBox )
3470*b1cdbd2cSJim Jagielski return 0;
3471*b1cdbd2cSJim Jagielski
3472*b1cdbd2cSJim Jagielski SwTableLine* pLine = pBox->GetUpper();
3473*b1cdbd2cSJim Jagielski while( pLine->GetUpper() )
3474*b1cdbd2cSJim Jagielski pLine = pLine->GetUpper()->GetUpper();
3475*b1cdbd2cSJim Jagielski
3476*b1cdbd2cSJim Jagielski // in pLine steht jetzt die GrundLine.
3477*b1cdbd2cSJim Jagielski sal_uInt16 nLinePos = rTbl.GetTabLines().C40_GETPOS( SwTableLine, pLine );
3478*b1cdbd2cSJim Jagielski if( USHRT_MAX == nLinePos ||
3479*b1cdbd2cSJim Jagielski ( bAfter ? ++nLinePos >= rTbl.GetTabLines().Count() : !nLinePos ))
3480*b1cdbd2cSJim Jagielski return 0; // nicht gefunden oder letze Line !!
3481*b1cdbd2cSJim Jagielski
3482*b1cdbd2cSJim Jagielski // Suche jetzt die 1. Box der nachfolgenden Line
3483*b1cdbd2cSJim Jagielski SwTableLine* pNextLine = rTbl.GetTabLines()[ nLinePos ];
3484*b1cdbd2cSJim Jagielski pBox = pNextLine->GetTabBoxes()[0];
3485*b1cdbd2cSJim Jagielski while( !pBox->GetSttNd() )
3486*b1cdbd2cSJim Jagielski pBox = pBox->GetTabLines()[0]->GetTabBoxes()[0];
3487*b1cdbd2cSJim Jagielski
3488*b1cdbd2cSJim Jagielski // dann fuege mal einen End- und TabelleNode ins Nodes-Array ein.
3489*b1cdbd2cSJim Jagielski SwTableNode * pNewTblNd;
3490*b1cdbd2cSJim Jagielski {
3491*b1cdbd2cSJim Jagielski SwEndNode* pOldTblEndNd = (SwEndNode*)pTNd->EndOfSectionNode()->GetEndNode();
3492*b1cdbd2cSJim Jagielski ASSERT( pOldTblEndNd, "wo ist der EndNode?" )
3493*b1cdbd2cSJim Jagielski
3494*b1cdbd2cSJim Jagielski SwNodeIndex aIdx( *pBox->GetSttNd() );
3495*b1cdbd2cSJim Jagielski new SwEndNode( aIdx, *pTNd );
3496*b1cdbd2cSJim Jagielski pNewTblNd = new SwTableNode( aIdx );
3497*b1cdbd2cSJim Jagielski pNewTblNd->GetTable().SetTableModel( rTbl.IsNewModel() );
3498*b1cdbd2cSJim Jagielski
3499*b1cdbd2cSJim Jagielski pOldTblEndNd->pStartOfSection = pNewTblNd;
3500*b1cdbd2cSJim Jagielski pNewTblNd->pEndOfSection = pOldTblEndNd;
3501*b1cdbd2cSJim Jagielski
3502*b1cdbd2cSJim Jagielski SwNode* pBoxNd = aIdx.GetNode().GetStartNode();
3503*b1cdbd2cSJim Jagielski do {
3504*b1cdbd2cSJim Jagielski ASSERT( pBoxNd->IsStartNode(), "das muss ein StartNode sein!" );
3505*b1cdbd2cSJim Jagielski pBoxNd->pStartOfSection = pNewTblNd;
3506*b1cdbd2cSJim Jagielski pBoxNd = (*this)[ pBoxNd->EndOfSectionIndex() + 1 ];
3507*b1cdbd2cSJim Jagielski } while( pBoxNd != pOldTblEndNd );
3508*b1cdbd2cSJim Jagielski }
3509*b1cdbd2cSJim Jagielski
3510*b1cdbd2cSJim Jagielski {
3511*b1cdbd2cSJim Jagielski // die Lines ruebermoven...
3512*b1cdbd2cSJim Jagielski SwTable& rNewTbl = pNewTblNd->GetTable();
3513*b1cdbd2cSJim Jagielski rNewTbl.GetTabLines().Insert( &rTbl.GetTabLines(), 0, nLinePos );
3514*b1cdbd2cSJim Jagielski //
3515*b1cdbd2cSJim Jagielski // von hinten (unten-rechts) nach vorn (oben-links) alle Boxen
3516*b1cdbd2cSJim Jagielski // beim chart data provider austragen (das modified event wird dann
3517*b1cdbd2cSJim Jagielski // in der aufrufenden Funktion getriggert.
3518*b1cdbd2cSJim Jagielski // TL_CHART2:
3519*b1cdbd2cSJim Jagielski SwChartDataProvider *pPCD = rTbl.GetFrmFmt()->getIDocumentChartDataProviderAccess()->GetChartDataProvider();
3520*b1cdbd2cSJim Jagielski if( pPCD )
3521*b1cdbd2cSJim Jagielski {
3522*b1cdbd2cSJim Jagielski for (sal_uInt16 k = nLinePos; k < rTbl.GetTabLines().Count(); ++k)
3523*b1cdbd2cSJim Jagielski {
3524*b1cdbd2cSJim Jagielski sal_uInt16 nLineIdx = (rTbl.GetTabLines().Count() - 1) - k + nLinePos;
3525*b1cdbd2cSJim Jagielski sal_uInt16 nBoxCnt = rTbl.GetTabLines()[ nLineIdx ]->GetTabBoxes().Count();
3526*b1cdbd2cSJim Jagielski for (sal_uInt16 j = 0; j < nBoxCnt; ++j)
3527*b1cdbd2cSJim Jagielski {
3528*b1cdbd2cSJim Jagielski sal_uInt16 nIdx = nBoxCnt - 1 - j;
3529*b1cdbd2cSJim Jagielski pPCD->DeleteBox( &rTbl, *rTbl.GetTabLines()[ nLineIdx ]->GetTabBoxes()[nIdx] );
3530*b1cdbd2cSJim Jagielski }
3531*b1cdbd2cSJim Jagielski }
3532*b1cdbd2cSJim Jagielski }
3533*b1cdbd2cSJim Jagielski //
3534*b1cdbd2cSJim Jagielski // ...und loeschen
3535*b1cdbd2cSJim Jagielski sal_uInt16 nDeleted = rTbl.GetTabLines().Count() - nLinePos;
3536*b1cdbd2cSJim Jagielski rTbl.GetTabLines().Remove( nLinePos, nDeleted );
3537*b1cdbd2cSJim Jagielski
3538*b1cdbd2cSJim Jagielski // und die betr. Boxen verschieben. Dabei die Formate eindeutig
3539*b1cdbd2cSJim Jagielski // machen und die StartNodes korrigieren
3540*b1cdbd2cSJim Jagielski _SplitTable_Para aPara( pNewTblNd, rTbl );
3541*b1cdbd2cSJim Jagielski rNewTbl.GetTabLines().ForEach( &lcl_SplitTable_CpyLine, &aPara );
3542*b1cdbd2cSJim Jagielski rTbl.CleanUpBottomRowSpan( nDeleted );
3543*b1cdbd2cSJim Jagielski }
3544*b1cdbd2cSJim Jagielski
3545*b1cdbd2cSJim Jagielski {
3546*b1cdbd2cSJim Jagielski // Das Tabellen-FrmFormat kopieren
3547*b1cdbd2cSJim Jagielski SwFrmFmt* pOldTblFmt = rTbl.GetFrmFmt();
3548*b1cdbd2cSJim Jagielski SwFrmFmt* pNewTblFmt = pOldTblFmt->GetDoc()->MakeTblFrmFmt(
3549*b1cdbd2cSJim Jagielski pOldTblFmt->GetDoc()->GetUniqueTblName(),
3550*b1cdbd2cSJim Jagielski pOldTblFmt->GetDoc()->GetDfltFrmFmt() );
3551*b1cdbd2cSJim Jagielski
3552*b1cdbd2cSJim Jagielski *pNewTblFmt = *pOldTblFmt;
3553*b1cdbd2cSJim Jagielski pNewTblNd->GetTable().RegisterToFormat( *pNewTblFmt );
3554*b1cdbd2cSJim Jagielski
3555*b1cdbd2cSJim Jagielski // neue Size errechnen ? (lcl_ChgTblSize nur das 2. aufrufen, wenn es
3556*b1cdbd2cSJim Jagielski // beim 1. schon geklappt hat; also absolute Groesse hat)
3557*b1cdbd2cSJim Jagielski if( bCalcNewSize && lcl_ChgTblSize( rTbl ) )
3558*b1cdbd2cSJim Jagielski lcl_ChgTblSize( pNewTblNd->GetTable() );
3559*b1cdbd2cSJim Jagielski }
3560*b1cdbd2cSJim Jagielski
3561*b1cdbd2cSJim Jagielski // TL_CHART2: need to inform chart of probably changed cell names
3562*b1cdbd2cSJim Jagielski rTbl.UpdateCharts();
3563*b1cdbd2cSJim Jagielski
3564*b1cdbd2cSJim Jagielski return pNewTblNd; // das wars
3565*b1cdbd2cSJim Jagielski }
3566*b1cdbd2cSJim Jagielski
3567*b1cdbd2cSJim Jagielski // und die Umkehrung davon. rPos muss in der Tabelle stehen, die bestehen
3568*b1cdbd2cSJim Jagielski // bleibt. Das Flag besagt ob die aktuelle mit der davor oder dahinter
3569*b1cdbd2cSJim Jagielski // stehenden vereint wird.
MergeTable(const SwPosition & rPos,sal_Bool bWithPrev,sal_uInt16 nMode)3570*b1cdbd2cSJim Jagielski sal_Bool SwDoc::MergeTable( const SwPosition& rPos, sal_Bool bWithPrev, sal_uInt16 nMode )
3571*b1cdbd2cSJim Jagielski {
3572*b1cdbd2cSJim Jagielski SwTableNode* pTblNd = rPos.nNode.GetNode().FindTableNode(), *pDelTblNd;
3573*b1cdbd2cSJim Jagielski if( !pTblNd )
3574*b1cdbd2cSJim Jagielski return sal_False;
3575*b1cdbd2cSJim Jagielski
3576*b1cdbd2cSJim Jagielski SwNodes& rNds = GetNodes();
3577*b1cdbd2cSJim Jagielski if( bWithPrev )
3578*b1cdbd2cSJim Jagielski pDelTblNd = rNds[ pTblNd->GetIndex() - 1 ]->FindTableNode();
3579*b1cdbd2cSJim Jagielski else
3580*b1cdbd2cSJim Jagielski pDelTblNd = rNds[ pTblNd->EndOfSectionIndex() + 1 ]->GetTableNode();
3581*b1cdbd2cSJim Jagielski if( !pDelTblNd )
3582*b1cdbd2cSJim Jagielski return sal_False;
3583*b1cdbd2cSJim Jagielski
3584*b1cdbd2cSJim Jagielski if( pTblNd->GetTable().ISA( SwDDETable ) ||
3585*b1cdbd2cSJim Jagielski pDelTblNd->GetTable().ISA( SwDDETable ))
3586*b1cdbd2cSJim Jagielski return sal_False;
3587*b1cdbd2cSJim Jagielski
3588*b1cdbd2cSJim Jagielski // MIB 9.7.97: HTML-Layout loeschen
3589*b1cdbd2cSJim Jagielski pTblNd->GetTable().SetHTMLTableLayout( 0 );
3590*b1cdbd2cSJim Jagielski pDelTblNd->GetTable().SetHTMLTableLayout( 0 );
3591*b1cdbd2cSJim Jagielski
3592*b1cdbd2cSJim Jagielski // beide Tabellen vorhanden, also kanns losgehen
3593*b1cdbd2cSJim Jagielski SwUndoMergeTbl* pUndo = 0;
3594*b1cdbd2cSJim Jagielski SwHistory* pHistory = 0;
3595*b1cdbd2cSJim Jagielski if (GetIDocumentUndoRedo().DoesUndo())
3596*b1cdbd2cSJim Jagielski {
3597*b1cdbd2cSJim Jagielski pUndo = new SwUndoMergeTbl( *pTblNd, *pDelTblNd, bWithPrev, nMode );
3598*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().AppendUndo(pUndo);
3599*b1cdbd2cSJim Jagielski pHistory = new SwHistory;
3600*b1cdbd2cSJim Jagielski }
3601*b1cdbd2cSJim Jagielski
3602*b1cdbd2cSJim Jagielski // alle "Tabellenformeln" anpassen
3603*b1cdbd2cSJim Jagielski SwTableFmlUpdate aMsgHnt( &pTblNd->GetTable() );
3604*b1cdbd2cSJim Jagielski aMsgHnt.DATA.pDelTbl = &pDelTblNd->GetTable();
3605*b1cdbd2cSJim Jagielski aMsgHnt.eFlags = TBL_MERGETBL;
3606*b1cdbd2cSJim Jagielski aMsgHnt.pHistory = pHistory;
3607*b1cdbd2cSJim Jagielski UpdateTblFlds( &aMsgHnt );
3608*b1cdbd2cSJim Jagielski
3609*b1cdbd2cSJim Jagielski // das eigentliche Mergen
3610*b1cdbd2cSJim Jagielski SwNodeIndex aIdx( bWithPrev ? *pTblNd : *pDelTblNd );
3611*b1cdbd2cSJim Jagielski sal_Bool bRet = rNds.MergeTable( aIdx, !bWithPrev, nMode, pHistory );
3612*b1cdbd2cSJim Jagielski
3613*b1cdbd2cSJim Jagielski if( pHistory )
3614*b1cdbd2cSJim Jagielski {
3615*b1cdbd2cSJim Jagielski if( pHistory->Count() )
3616*b1cdbd2cSJim Jagielski pUndo->SaveFormula( *pHistory );
3617*b1cdbd2cSJim Jagielski delete pHistory;
3618*b1cdbd2cSJim Jagielski }
3619*b1cdbd2cSJim Jagielski if( bRet )
3620*b1cdbd2cSJim Jagielski {
3621*b1cdbd2cSJim Jagielski SetModified();
3622*b1cdbd2cSJim Jagielski SetFieldsDirty( true, NULL, 0 );
3623*b1cdbd2cSJim Jagielski }
3624*b1cdbd2cSJim Jagielski return bRet;
3625*b1cdbd2cSJim Jagielski }
3626*b1cdbd2cSJim Jagielski
MergeTable(const SwNodeIndex & rPos,sal_Bool bWithPrev,sal_uInt16 nMode,SwHistory *)3627*b1cdbd2cSJim Jagielski sal_Bool SwNodes::MergeTable( const SwNodeIndex& rPos, sal_Bool bWithPrev,
3628*b1cdbd2cSJim Jagielski sal_uInt16 nMode, SwHistory* )
3629*b1cdbd2cSJim Jagielski {
3630*b1cdbd2cSJim Jagielski SwTableNode* pDelTblNd = rPos.GetNode().GetTableNode();
3631*b1cdbd2cSJim Jagielski ASSERT( pDelTblNd, "wo ist der TableNode geblieben?" );
3632*b1cdbd2cSJim Jagielski
3633*b1cdbd2cSJim Jagielski SwTableNode* pTblNd = (*this)[ rPos.GetIndex() - 1]->FindTableNode();
3634*b1cdbd2cSJim Jagielski ASSERT( pTblNd, "wo ist der TableNode geblieben?" );
3635*b1cdbd2cSJim Jagielski
3636*b1cdbd2cSJim Jagielski if( !pDelTblNd || !pTblNd )
3637*b1cdbd2cSJim Jagielski return sal_False;
3638*b1cdbd2cSJim Jagielski
3639*b1cdbd2cSJim Jagielski pDelTblNd->DelFrms();
3640*b1cdbd2cSJim Jagielski
3641*b1cdbd2cSJim Jagielski SwTable& rDelTbl = pDelTblNd->GetTable();
3642*b1cdbd2cSJim Jagielski SwTable& rTbl = pTblNd->GetTable();
3643*b1cdbd2cSJim Jagielski
3644*b1cdbd2cSJim Jagielski //Lines fuer das Layout-Update herausuchen.
3645*b1cdbd2cSJim Jagielski _FndBox aFndBox( 0, 0 );
3646*b1cdbd2cSJim Jagielski aFndBox.SetTableLines( rTbl );
3647*b1cdbd2cSJim Jagielski aFndBox.DelFrms( rTbl );
3648*b1cdbd2cSJim Jagielski
3649*b1cdbd2cSJim Jagielski // TL_CHART2: since chart currently does not want to get informed about
3650*b1cdbd2cSJim Jagielski // additional rows/cols there is no need for a modified event in the
3651*b1cdbd2cSJim Jagielski // remaining first table. Also, if it is required it should be done
3652*b1cdbd2cSJim Jagielski // after the merging and not here...
3653*b1cdbd2cSJim Jagielski // pDoc->UpdateCharts( rTbl.GetFrmFmt()->GetName() );
3654*b1cdbd2cSJim Jagielski
3655*b1cdbd2cSJim Jagielski
3656*b1cdbd2cSJim Jagielski // TL_CHART2:
3657*b1cdbd2cSJim Jagielski // tell the charts about the table to be deleted and have them use their own data
3658*b1cdbd2cSJim Jagielski GetDoc()->CreateChartInternalDataProviders( &rDelTbl );
3659*b1cdbd2cSJim Jagielski
3660*b1cdbd2cSJim Jagielski // die Breite der TabellenFormate abgleichen:
3661*b1cdbd2cSJim Jagielski {
3662*b1cdbd2cSJim Jagielski const SwFmtFrmSize& rTblSz = rTbl.GetFrmFmt()->GetFrmSize();
3663*b1cdbd2cSJim Jagielski const SwFmtFrmSize& rDelTblSz = rDelTbl.GetFrmFmt()->GetFrmSize();
3664*b1cdbd2cSJim Jagielski if( rTblSz != rDelTblSz )
3665*b1cdbd2cSJim Jagielski {
3666*b1cdbd2cSJim Jagielski // dann sollten die mal schleunigst korrigiert werden
3667*b1cdbd2cSJim Jagielski if( bWithPrev )
3668*b1cdbd2cSJim Jagielski rDelTbl.GetFrmFmt()->SetFmtAttr( rTblSz );
3669*b1cdbd2cSJim Jagielski else
3670*b1cdbd2cSJim Jagielski rTbl.GetFrmFmt()->SetFmtAttr( rDelTblSz );
3671*b1cdbd2cSJim Jagielski }
3672*b1cdbd2cSJim Jagielski }
3673*b1cdbd2cSJim Jagielski
3674*b1cdbd2cSJim Jagielski if( !bWithPrev )
3675*b1cdbd2cSJim Jagielski {
3676*b1cdbd2cSJim Jagielski // dann mussen alle Attruibute der hinteren Tabelle auf die
3677*b1cdbd2cSJim Jagielski // vordere uebertragen werden, weil die hintere ueber das loeschen
3678*b1cdbd2cSJim Jagielski // des Node geloescht wird.
3679*b1cdbd2cSJim Jagielski rTbl.SetRowsToRepeat( rDelTbl.GetRowsToRepeat() );
3680*b1cdbd2cSJim Jagielski rTbl.SetTblChgMode( rDelTbl.GetTblChgMode() );
3681*b1cdbd2cSJim Jagielski
3682*b1cdbd2cSJim Jagielski rTbl.GetFrmFmt()->LockModify();
3683*b1cdbd2cSJim Jagielski *rTbl.GetFrmFmt() = *rDelTbl.GetFrmFmt();
3684*b1cdbd2cSJim Jagielski // auch den Namen umsetzen!
3685*b1cdbd2cSJim Jagielski rTbl.GetFrmFmt()->SetName( rDelTbl.GetFrmFmt()->GetName() );
3686*b1cdbd2cSJim Jagielski rTbl.GetFrmFmt()->UnlockModify();
3687*b1cdbd2cSJim Jagielski }
3688*b1cdbd2cSJim Jagielski
3689*b1cdbd2cSJim Jagielski // die Lines und Boxen ruebermoven
3690*b1cdbd2cSJim Jagielski sal_uInt16 nOldSize = rTbl.GetTabLines().Count();
3691*b1cdbd2cSJim Jagielski rTbl.GetTabLines().Insert( &rDelTbl.GetTabLines(), nOldSize );
3692*b1cdbd2cSJim Jagielski rDelTbl.GetTabLines().Remove( 0, rDelTbl.GetTabLines().Count() );
3693*b1cdbd2cSJim Jagielski
3694*b1cdbd2cSJim Jagielski rTbl.GetTabSortBoxes().Insert( &rDelTbl.GetTabSortBoxes() );
3695*b1cdbd2cSJim Jagielski rDelTbl.GetTabSortBoxes().Remove( (sal_uInt16)0, rDelTbl.GetTabSortBoxes().Count() );
3696*b1cdbd2cSJim Jagielski
3697*b1cdbd2cSJim Jagielski // die vordere Tabelle bleibt immer stehen, die hintere wird geloescht
3698*b1cdbd2cSJim Jagielski SwEndNode* pTblEndNd = pDelTblNd->EndOfSectionNode();
3699*b1cdbd2cSJim Jagielski pTblNd->pEndOfSection = pTblEndNd;
3700*b1cdbd2cSJim Jagielski
3701*b1cdbd2cSJim Jagielski SwNodeIndex aIdx( *pDelTblNd, 1 );
3702*b1cdbd2cSJim Jagielski
3703*b1cdbd2cSJim Jagielski SwNode* pBoxNd = aIdx.GetNode().GetStartNode();
3704*b1cdbd2cSJim Jagielski do {
3705*b1cdbd2cSJim Jagielski ASSERT( pBoxNd->IsStartNode(), "das muss ein StartNode sein!" );
3706*b1cdbd2cSJim Jagielski pBoxNd->pStartOfSection = pTblNd;
3707*b1cdbd2cSJim Jagielski pBoxNd = (*this)[ pBoxNd->EndOfSectionIndex() + 1 ];
3708*b1cdbd2cSJim Jagielski } while( pBoxNd != pTblEndNd );
3709*b1cdbd2cSJim Jagielski pBoxNd->pStartOfSection = pTblNd;
3710*b1cdbd2cSJim Jagielski
3711*b1cdbd2cSJim Jagielski aIdx -= 2;
3712*b1cdbd2cSJim Jagielski DelNodes( aIdx, 2 );
3713*b1cdbd2cSJim Jagielski
3714*b1cdbd2cSJim Jagielski // jetzt an der 1. eingefuegten Line die bedingten Vorlagen umschubsen
3715*b1cdbd2cSJim Jagielski const SwTableLine* pFirstLn = rTbl.GetTabLines()[ nOldSize ];
3716*b1cdbd2cSJim Jagielski if( 1 == nMode ) //
3717*b1cdbd2cSJim Jagielski {
3718*b1cdbd2cSJim Jagielski // Header-Vorlagen in der Zeile setzen
3719*b1cdbd2cSJim Jagielski // und ggfs. in der History speichern fuers Undo!!!
3720*b1cdbd2cSJim Jagielski }
3721*b1cdbd2cSJim Jagielski lcl_LineSetHeadCondColl( pFirstLn, 0 );
3722*b1cdbd2cSJim Jagielski
3723*b1cdbd2cSJim Jagielski // und die Borders "aufrauemen"
3724*b1cdbd2cSJim Jagielski if( nOldSize )
3725*b1cdbd2cSJim Jagielski {
3726*b1cdbd2cSJim Jagielski _SwGCLineBorder aPara( rTbl );
3727*b1cdbd2cSJim Jagielski aPara.nLinePos = --nOldSize;
3728*b1cdbd2cSJim Jagielski pFirstLn = rTbl.GetTabLines()[ nOldSize ];
3729*b1cdbd2cSJim Jagielski lcl_GC_Line_Border( pFirstLn, &aPara );
3730*b1cdbd2cSJim Jagielski }
3731*b1cdbd2cSJim Jagielski
3732*b1cdbd2cSJim Jagielski //Layout updaten
3733*b1cdbd2cSJim Jagielski aFndBox.MakeFrms( rTbl );
3734*b1cdbd2cSJim Jagielski
3735*b1cdbd2cSJim Jagielski return sal_True;
3736*b1cdbd2cSJim Jagielski }
3737*b1cdbd2cSJim Jagielski
3738*b1cdbd2cSJim Jagielski // -------------------------------------------------------------------
3739*b1cdbd2cSJim Jagielski
3740*b1cdbd2cSJim Jagielski
3741*b1cdbd2cSJim Jagielski // -- benutze die ForEach Methode vom PtrArray
3742*b1cdbd2cSJim Jagielski struct _SetAFmtTabPara
3743*b1cdbd2cSJim Jagielski {
3744*b1cdbd2cSJim Jagielski SwTableAutoFmt& rTblFmt;
3745*b1cdbd2cSJim Jagielski SwUndoTblAutoFmt* pUndo;
3746*b1cdbd2cSJim Jagielski sal_uInt16 nEndBox, nCurBox;
3747*b1cdbd2cSJim Jagielski sal_uInt8 nAFmtLine, nAFmtBox;
3748*b1cdbd2cSJim Jagielski
_SetAFmtTabPara_SetAFmtTabPara3749*b1cdbd2cSJim Jagielski _SetAFmtTabPara( const SwTableAutoFmt& rNew )
3750*b1cdbd2cSJim Jagielski : rTblFmt( (SwTableAutoFmt&)rNew ), pUndo( 0 ),
3751*b1cdbd2cSJim Jagielski nEndBox( 0 ), nCurBox( 0 ), nAFmtLine( 0 ), nAFmtBox( 0 )
3752*b1cdbd2cSJim Jagielski {}
3753*b1cdbd2cSJim Jagielski };
3754*b1cdbd2cSJim Jagielski
3755*b1cdbd2cSJim Jagielski // forward deklarieren damit sich die Lines und Boxen rekursiv aufrufen
3756*b1cdbd2cSJim Jagielski // koennen.
3757*b1cdbd2cSJim Jagielski sal_Bool lcl_SetAFmtBox( const _FndBox*&, void *pPara );
3758*b1cdbd2cSJim Jagielski sal_Bool lcl_SetAFmtLine( const _FndLine*&, void *pPara );
3759*b1cdbd2cSJim Jagielski
lcl_SetAFmtLine(const _FndLine * & rpLine,void * pPara)3760*b1cdbd2cSJim Jagielski sal_Bool lcl_SetAFmtLine( const _FndLine*& rpLine, void *pPara )
3761*b1cdbd2cSJim Jagielski {
3762*b1cdbd2cSJim Jagielski ((_FndLine*&)rpLine)->GetBoxes().ForEach( &lcl_SetAFmtBox, pPara );
3763*b1cdbd2cSJim Jagielski return sal_True;
3764*b1cdbd2cSJim Jagielski }
3765*b1cdbd2cSJim Jagielski
lcl_SetAFmtBox(const _FndBox * & rpBox,void * pPara)3766*b1cdbd2cSJim Jagielski sal_Bool lcl_SetAFmtBox( const _FndBox*& rpBox, void *pPara )
3767*b1cdbd2cSJim Jagielski {
3768*b1cdbd2cSJim Jagielski _SetAFmtTabPara* pSetPara = (_SetAFmtTabPara*)pPara;
3769*b1cdbd2cSJim Jagielski
3770*b1cdbd2cSJim Jagielski if( !rpBox->GetUpper()->GetUpper() ) // Box auf 1. Ebene ?
3771*b1cdbd2cSJim Jagielski {
3772*b1cdbd2cSJim Jagielski if( !pSetPara->nCurBox )
3773*b1cdbd2cSJim Jagielski pSetPara->nAFmtBox = 0;
3774*b1cdbd2cSJim Jagielski else if( pSetPara->nCurBox == pSetPara->nEndBox )
3775*b1cdbd2cSJim Jagielski pSetPara->nAFmtBox = 3;
3776*b1cdbd2cSJim Jagielski else
3777*b1cdbd2cSJim Jagielski pSetPara->nAFmtBox = (sal_uInt8)(1 + ((pSetPara->nCurBox-1) & 1));
3778*b1cdbd2cSJim Jagielski }
3779*b1cdbd2cSJim Jagielski
3780*b1cdbd2cSJim Jagielski if( rpBox->GetBox()->GetSttNd() )
3781*b1cdbd2cSJim Jagielski {
3782*b1cdbd2cSJim Jagielski SwTableBox* pSetBox = (SwTableBox*)rpBox->GetBox();
3783*b1cdbd2cSJim Jagielski SwDoc* pDoc = pSetBox->GetFrmFmt()->GetDoc();
3784*b1cdbd2cSJim Jagielski // --> OD 2008-02-25 #refactorlists#
3785*b1cdbd2cSJim Jagielski // SfxItemSet aCharSet( pDoc->GetAttrPool(), RES_CHRATR_BEGIN, RES_PARATR_END-1 );
3786*b1cdbd2cSJim Jagielski SfxItemSet aCharSet( pDoc->GetAttrPool(), RES_CHRATR_BEGIN, RES_PARATR_LIST_END-1 );
3787*b1cdbd2cSJim Jagielski // <--
3788*b1cdbd2cSJim Jagielski SfxItemSet aBoxSet( pDoc->GetAttrPool(), aTableBoxSetRange );
3789*b1cdbd2cSJim Jagielski sal_uInt8 nPos = pSetPara->nAFmtLine * 4 + pSetPara->nAFmtBox;
3790*b1cdbd2cSJim Jagielski pSetPara->rTblFmt.UpdateToSet( nPos, aCharSet,
3791*b1cdbd2cSJim Jagielski SwTableAutoFmt::UPDATE_CHAR, 0 );
3792*b1cdbd2cSJim Jagielski pSetPara->rTblFmt.UpdateToSet( nPos, aBoxSet,
3793*b1cdbd2cSJim Jagielski SwTableAutoFmt::UPDATE_BOX,
3794*b1cdbd2cSJim Jagielski pDoc->GetNumberFormatter( sal_True ) );
3795*b1cdbd2cSJim Jagielski if( aCharSet.Count() )
3796*b1cdbd2cSJim Jagielski {
3797*b1cdbd2cSJim Jagielski sal_uLong nSttNd = pSetBox->GetSttIdx()+1;
3798*b1cdbd2cSJim Jagielski sal_uLong nEndNd = pSetBox->GetSttNd()->EndOfSectionIndex();
3799*b1cdbd2cSJim Jagielski for( ; nSttNd < nEndNd; ++nSttNd )
3800*b1cdbd2cSJim Jagielski {
3801*b1cdbd2cSJim Jagielski SwCntntNode* pNd = pDoc->GetNodes()[ nSttNd ]->GetCntntNode();
3802*b1cdbd2cSJim Jagielski if( pNd )
3803*b1cdbd2cSJim Jagielski pNd->SetAttr( aCharSet );
3804*b1cdbd2cSJim Jagielski }
3805*b1cdbd2cSJim Jagielski }
3806*b1cdbd2cSJim Jagielski
3807*b1cdbd2cSJim Jagielski if( aBoxSet.Count() )
3808*b1cdbd2cSJim Jagielski {
3809*b1cdbd2cSJim Jagielski if( pSetPara->pUndo &&
3810*b1cdbd2cSJim Jagielski SFX_ITEM_SET == aBoxSet.GetItemState( RES_BOXATR_FORMAT ))
3811*b1cdbd2cSJim Jagielski pSetPara->pUndo->SaveBoxCntnt( *pSetBox );
3812*b1cdbd2cSJim Jagielski
3813*b1cdbd2cSJim Jagielski pSetBox->ClaimFrmFmt()->SetFmtAttr( aBoxSet );
3814*b1cdbd2cSJim Jagielski }
3815*b1cdbd2cSJim Jagielski }
3816*b1cdbd2cSJim Jagielski else
3817*b1cdbd2cSJim Jagielski ((_FndBox*&)rpBox)->GetLines().ForEach( &lcl_SetAFmtLine, pPara );
3818*b1cdbd2cSJim Jagielski
3819*b1cdbd2cSJim Jagielski if( !rpBox->GetUpper()->GetUpper() ) // eine BaseLine
3820*b1cdbd2cSJim Jagielski ++pSetPara->nCurBox;
3821*b1cdbd2cSJim Jagielski return sal_True;
3822*b1cdbd2cSJim Jagielski }
3823*b1cdbd2cSJim Jagielski
3824*b1cdbd2cSJim Jagielski
3825*b1cdbd2cSJim Jagielski // AutoFormat fuer die Tabelle/TabellenSelection
SetTableAutoFmt(const SwSelBoxes & rBoxes,const SwTableAutoFmt & rNew)3826*b1cdbd2cSJim Jagielski sal_Bool SwDoc::SetTableAutoFmt( const SwSelBoxes& rBoxes, const SwTableAutoFmt& rNew )
3827*b1cdbd2cSJim Jagielski {
3828*b1cdbd2cSJim Jagielski ASSERT( rBoxes.Count(), "keine gueltige Box-Liste" );
3829*b1cdbd2cSJim Jagielski SwTableNode* pTblNd = (SwTableNode*)rBoxes[0]->GetSttNd()->FindTableNode();
3830*b1cdbd2cSJim Jagielski if( !pTblNd )
3831*b1cdbd2cSJim Jagielski return sal_False;
3832*b1cdbd2cSJim Jagielski
3833*b1cdbd2cSJim Jagielski // suche alle Boxen / Lines
3834*b1cdbd2cSJim Jagielski _FndBox aFndBox( 0, 0 );
3835*b1cdbd2cSJim Jagielski {
3836*b1cdbd2cSJim Jagielski _FndPara aPara( rBoxes, &aFndBox );
3837*b1cdbd2cSJim Jagielski pTblNd->GetTable().GetTabLines().ForEach( &_FndLineCopyCol, &aPara );
3838*b1cdbd2cSJim Jagielski }
3839*b1cdbd2cSJim Jagielski if( !aFndBox.GetLines().Count() )
3840*b1cdbd2cSJim Jagielski return sal_False;
3841*b1cdbd2cSJim Jagielski
3842*b1cdbd2cSJim Jagielski pTblNd->GetTable().SetHTMLTableLayout( 0 );
3843*b1cdbd2cSJim Jagielski
3844*b1cdbd2cSJim Jagielski _FndBox* pFndBox = &aFndBox;
3845*b1cdbd2cSJim Jagielski while( 1 == pFndBox->GetLines().Count() &&
3846*b1cdbd2cSJim Jagielski 1 == pFndBox->GetLines()[0]->GetBoxes().Count() )
3847*b1cdbd2cSJim Jagielski pFndBox = pFndBox->GetLines()[0]->GetBoxes()[0];
3848*b1cdbd2cSJim Jagielski
3849*b1cdbd2cSJim Jagielski if( !pFndBox->GetLines().Count() ) // eine zu weit? (nur 1 sel.Box)
3850*b1cdbd2cSJim Jagielski pFndBox = pFndBox->GetUpper()->GetUpper();
3851*b1cdbd2cSJim Jagielski
3852*b1cdbd2cSJim Jagielski
3853*b1cdbd2cSJim Jagielski // Undo abschalten, Attribute werden sich vorher gemerkt
3854*b1cdbd2cSJim Jagielski SwUndoTblAutoFmt* pUndo = 0;
3855*b1cdbd2cSJim Jagielski bool const bUndo(GetIDocumentUndoRedo().DoesUndo());
3856*b1cdbd2cSJim Jagielski if (bUndo)
3857*b1cdbd2cSJim Jagielski {
3858*b1cdbd2cSJim Jagielski pUndo = new SwUndoTblAutoFmt( *pTblNd, rNew );
3859*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().AppendUndo(pUndo);
3860*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().DoUndo(false);
3861*b1cdbd2cSJim Jagielski }
3862*b1cdbd2cSJim Jagielski
3863*b1cdbd2cSJim Jagielski _SetAFmtTabPara aPara( rNew );
3864*b1cdbd2cSJim Jagielski _FndLines& rFLns = pFndBox->GetLines();
3865*b1cdbd2cSJim Jagielski _FndLine* pLine;
3866*b1cdbd2cSJim Jagielski
3867*b1cdbd2cSJim Jagielski for( sal_uInt16 n = 0; n < rFLns.Count(); ++n )
3868*b1cdbd2cSJim Jagielski {
3869*b1cdbd2cSJim Jagielski pLine = rFLns[n];
3870*b1cdbd2cSJim Jagielski
3871*b1cdbd2cSJim Jagielski // Upper auf 0 setzen (Base-Line simulieren!)
3872*b1cdbd2cSJim Jagielski _FndBox* pSaveBox = pLine->GetUpper();
3873*b1cdbd2cSJim Jagielski pLine->SetUpper( 0 );
3874*b1cdbd2cSJim Jagielski
3875*b1cdbd2cSJim Jagielski if( !n )
3876*b1cdbd2cSJim Jagielski aPara.nAFmtLine = 0;
3877*b1cdbd2cSJim Jagielski else if( n+1 == rFLns.Count() )
3878*b1cdbd2cSJim Jagielski aPara.nAFmtLine = 3;
3879*b1cdbd2cSJim Jagielski else
3880*b1cdbd2cSJim Jagielski aPara.nAFmtLine = (sal_uInt8)(1 + ((n-1) & 1 ));
3881*b1cdbd2cSJim Jagielski
3882*b1cdbd2cSJim Jagielski aPara.nAFmtBox = 0;
3883*b1cdbd2cSJim Jagielski aPara.nCurBox = 0;
3884*b1cdbd2cSJim Jagielski aPara.nEndBox = pLine->GetBoxes().Count()-1;
3885*b1cdbd2cSJim Jagielski aPara.pUndo = pUndo;
3886*b1cdbd2cSJim Jagielski pLine->GetBoxes().ForEach( &lcl_SetAFmtBox, &aPara );
3887*b1cdbd2cSJim Jagielski
3888*b1cdbd2cSJim Jagielski pLine->SetUpper( pSaveBox );
3889*b1cdbd2cSJim Jagielski }
3890*b1cdbd2cSJim Jagielski
3891*b1cdbd2cSJim Jagielski if( pUndo )
3892*b1cdbd2cSJim Jagielski {
3893*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().DoUndo(bUndo);
3894*b1cdbd2cSJim Jagielski }
3895*b1cdbd2cSJim Jagielski
3896*b1cdbd2cSJim Jagielski SetModified();
3897*b1cdbd2cSJim Jagielski SetFieldsDirty( true, NULL, 0 );
3898*b1cdbd2cSJim Jagielski
3899*b1cdbd2cSJim Jagielski return sal_True;
3900*b1cdbd2cSJim Jagielski }
3901*b1cdbd2cSJim Jagielski
3902*b1cdbd2cSJim Jagielski
3903*b1cdbd2cSJim Jagielski // Erfrage wie attributiert ist
GetTableAutoFmt(const SwSelBoxes & rBoxes,SwTableAutoFmt & rGet)3904*b1cdbd2cSJim Jagielski sal_Bool SwDoc::GetTableAutoFmt( const SwSelBoxes& rBoxes, SwTableAutoFmt& rGet )
3905*b1cdbd2cSJim Jagielski {
3906*b1cdbd2cSJim Jagielski ASSERT( rBoxes.Count(), "keine gueltige Box-Liste" );
3907*b1cdbd2cSJim Jagielski SwTableNode* pTblNd = (SwTableNode*)rBoxes[0]->GetSttNd()->FindTableNode();
3908*b1cdbd2cSJim Jagielski if( !pTblNd )
3909*b1cdbd2cSJim Jagielski return sal_False;
3910*b1cdbd2cSJim Jagielski
3911*b1cdbd2cSJim Jagielski // suche alle Boxen / Lines
3912*b1cdbd2cSJim Jagielski _FndBox aFndBox( 0, 0 );
3913*b1cdbd2cSJim Jagielski {
3914*b1cdbd2cSJim Jagielski _FndPara aPara( rBoxes, &aFndBox );
3915*b1cdbd2cSJim Jagielski pTblNd->GetTable().GetTabLines().ForEach( &_FndLineCopyCol, &aPara );
3916*b1cdbd2cSJim Jagielski }
3917*b1cdbd2cSJim Jagielski if( !aFndBox.GetLines().Count() )
3918*b1cdbd2cSJim Jagielski return sal_False;
3919*b1cdbd2cSJim Jagielski
3920*b1cdbd2cSJim Jagielski _FndBox* pFndBox = &aFndBox;
3921*b1cdbd2cSJim Jagielski while( 1 == pFndBox->GetLines().Count() &&
3922*b1cdbd2cSJim Jagielski 1 == pFndBox->GetLines()[0]->GetBoxes().Count() )
3923*b1cdbd2cSJim Jagielski pFndBox = pFndBox->GetLines()[0]->GetBoxes()[0];
3924*b1cdbd2cSJim Jagielski
3925*b1cdbd2cSJim Jagielski if( !pFndBox->GetLines().Count() ) // eine zu weit? (nur 1 sel.Box)
3926*b1cdbd2cSJim Jagielski pFndBox = pFndBox->GetUpper()->GetUpper();
3927*b1cdbd2cSJim Jagielski
3928*b1cdbd2cSJim Jagielski _FndLines& rFLns = pFndBox->GetLines();
3929*b1cdbd2cSJim Jagielski
3930*b1cdbd2cSJim Jagielski sal_uInt16 aLnArr[4];
3931*b1cdbd2cSJim Jagielski aLnArr[0] = 0;
3932*b1cdbd2cSJim Jagielski aLnArr[1] = 1 < rFLns.Count() ? 1 : 0;
3933*b1cdbd2cSJim Jagielski aLnArr[2] = 2 < rFLns.Count() ? 2 : aLnArr[1];
3934*b1cdbd2cSJim Jagielski aLnArr[3] = rFLns.Count() - 1;
3935*b1cdbd2cSJim Jagielski
3936*b1cdbd2cSJim Jagielski for( sal_uInt8 nLine = 0; nLine < 4; ++nLine )
3937*b1cdbd2cSJim Jagielski {
3938*b1cdbd2cSJim Jagielski _FndLine& rLine = *rFLns[ aLnArr[ nLine ] ];
3939*b1cdbd2cSJim Jagielski
3940*b1cdbd2cSJim Jagielski sal_uInt16 aBoxArr[4];
3941*b1cdbd2cSJim Jagielski aBoxArr[0] = 0;
3942*b1cdbd2cSJim Jagielski aBoxArr[1] = 1 < rLine.GetBoxes().Count() ? 1 : 0;
3943*b1cdbd2cSJim Jagielski aBoxArr[2] = 2 < rLine.GetBoxes().Count() ? 2 : aBoxArr[1];
3944*b1cdbd2cSJim Jagielski aBoxArr[3] = rLine.GetBoxes().Count() - 1;
3945*b1cdbd2cSJim Jagielski
3946*b1cdbd2cSJim Jagielski for( sal_uInt8 nBox = 0; nBox < 4; ++nBox )
3947*b1cdbd2cSJim Jagielski {
3948*b1cdbd2cSJim Jagielski SwTableBox* pFBox = rLine.GetBoxes()[ aBoxArr[ nBox ] ]->GetBox();
3949*b1cdbd2cSJim Jagielski // immer auf die 1. runterfallen
3950*b1cdbd2cSJim Jagielski while( !pFBox->GetSttNd() )
3951*b1cdbd2cSJim Jagielski pFBox = pFBox->GetTabLines()[0]->GetTabBoxes()[0];
3952*b1cdbd2cSJim Jagielski
3953*b1cdbd2cSJim Jagielski sal_uInt8 nPos = nLine * 4 + nBox;
3954*b1cdbd2cSJim Jagielski SwNodeIndex aIdx( *pFBox->GetSttNd(), 1 );
3955*b1cdbd2cSJim Jagielski SwCntntNode* pCNd = aIdx.GetNode().GetCntntNode();
3956*b1cdbd2cSJim Jagielski if( !pCNd )
3957*b1cdbd2cSJim Jagielski pCNd = GetNodes().GoNext( &aIdx );
3958*b1cdbd2cSJim Jagielski
3959*b1cdbd2cSJim Jagielski if( pCNd )
3960*b1cdbd2cSJim Jagielski rGet.UpdateFromSet( nPos, pCNd->GetSwAttrSet(),
3961*b1cdbd2cSJim Jagielski SwTableAutoFmt::UPDATE_CHAR, 0 );
3962*b1cdbd2cSJim Jagielski rGet.UpdateFromSet( nPos, pFBox->GetFrmFmt()->GetAttrSet(),
3963*b1cdbd2cSJim Jagielski SwTableAutoFmt::UPDATE_BOX,
3964*b1cdbd2cSJim Jagielski GetNumberFormatter( sal_True ) );
3965*b1cdbd2cSJim Jagielski }
3966*b1cdbd2cSJim Jagielski }
3967*b1cdbd2cSJim Jagielski
3968*b1cdbd2cSJim Jagielski return sal_True;
3969*b1cdbd2cSJim Jagielski }
3970*b1cdbd2cSJim Jagielski
GetUniqueTblName() const3971*b1cdbd2cSJim Jagielski String SwDoc::GetUniqueTblName() const
3972*b1cdbd2cSJim Jagielski {
3973*b1cdbd2cSJim Jagielski ResId aId( STR_TABLE_DEFNAME, *pSwResMgr );
3974*b1cdbd2cSJim Jagielski String aName( aId );
3975*b1cdbd2cSJim Jagielski xub_StrLen nNmLen = aName.Len();
3976*b1cdbd2cSJim Jagielski
3977*b1cdbd2cSJim Jagielski sal_uInt16 nNum, nTmp, nFlagSize = ( pTblFrmFmtTbl->Count() / 8 ) +2;
3978*b1cdbd2cSJim Jagielski sal_uInt16 n;
3979*b1cdbd2cSJim Jagielski
3980*b1cdbd2cSJim Jagielski sal_uInt8* pSetFlags = new sal_uInt8[ nFlagSize ];
3981*b1cdbd2cSJim Jagielski memset( pSetFlags, 0, nFlagSize );
3982*b1cdbd2cSJim Jagielski
3983*b1cdbd2cSJim Jagielski for( n = 0; n < pTblFrmFmtTbl->Count(); ++n )
3984*b1cdbd2cSJim Jagielski {
3985*b1cdbd2cSJim Jagielski const SwFrmFmt* pFmt = (*pTblFrmFmtTbl)[ n ];
3986*b1cdbd2cSJim Jagielski if( !pFmt->IsDefault() && IsUsed( *pFmt ) &&
3987*b1cdbd2cSJim Jagielski pFmt->GetName().Match( aName ) == nNmLen )
3988*b1cdbd2cSJim Jagielski {
3989*b1cdbd2cSJim Jagielski // Nummer bestimmen und das Flag setzen
3990*b1cdbd2cSJim Jagielski nNum = static_cast<sal_uInt16>(pFmt->GetName().Copy( nNmLen ).ToInt32());
3991*b1cdbd2cSJim Jagielski if( nNum-- && nNum < pTblFrmFmtTbl->Count() )
3992*b1cdbd2cSJim Jagielski pSetFlags[ nNum / 8 ] |= (0x01 << ( nNum & 0x07 ));
3993*b1cdbd2cSJim Jagielski }
3994*b1cdbd2cSJim Jagielski }
3995*b1cdbd2cSJim Jagielski
3996*b1cdbd2cSJim Jagielski // alle Nummern entsprechend geflag, also bestimme die richtige Nummer
3997*b1cdbd2cSJim Jagielski nNum = pTblFrmFmtTbl->Count();
3998*b1cdbd2cSJim Jagielski for( n = 0; n < nFlagSize; ++n )
3999*b1cdbd2cSJim Jagielski if( 0xff != ( nTmp = pSetFlags[ n ] ))
4000*b1cdbd2cSJim Jagielski {
4001*b1cdbd2cSJim Jagielski // also die Nummer bestimmen
4002*b1cdbd2cSJim Jagielski nNum = n * 8;
4003*b1cdbd2cSJim Jagielski while( nTmp & 1 )
4004*b1cdbd2cSJim Jagielski ++nNum, nTmp >>= 1;
4005*b1cdbd2cSJim Jagielski break;
4006*b1cdbd2cSJim Jagielski }
4007*b1cdbd2cSJim Jagielski
4008*b1cdbd2cSJim Jagielski delete [] pSetFlags;
4009*b1cdbd2cSJim Jagielski return aName += String::CreateFromInt32( ++nNum );
4010*b1cdbd2cSJim Jagielski }
4011*b1cdbd2cSJim Jagielski
FindTblFmtByName(const String & rName,sal_Bool bAll) const4012*b1cdbd2cSJim Jagielski SwTableFmt* SwDoc::FindTblFmtByName( const String& rName, sal_Bool bAll ) const
4013*b1cdbd2cSJim Jagielski {
4014*b1cdbd2cSJim Jagielski const SwFmt* pRet = 0;
4015*b1cdbd2cSJim Jagielski if( bAll )
4016*b1cdbd2cSJim Jagielski pRet = FindFmtByName( (SvPtrarr&)*pTblFrmFmtTbl, rName );
4017*b1cdbd2cSJim Jagielski else
4018*b1cdbd2cSJim Jagielski {
4019*b1cdbd2cSJim Jagielski // dann nur die, die im Doc gesetzt sind
4020*b1cdbd2cSJim Jagielski for( sal_uInt16 n = 0; n < pTblFrmFmtTbl->Count(); ++n )
4021*b1cdbd2cSJim Jagielski {
4022*b1cdbd2cSJim Jagielski const SwFrmFmt* pFmt = (*pTblFrmFmtTbl)[ n ];
4023*b1cdbd2cSJim Jagielski if( !pFmt->IsDefault() && IsUsed( *pFmt ) &&
4024*b1cdbd2cSJim Jagielski pFmt->GetName() == rName )
4025*b1cdbd2cSJim Jagielski {
4026*b1cdbd2cSJim Jagielski pRet = pFmt;
4027*b1cdbd2cSJim Jagielski break;
4028*b1cdbd2cSJim Jagielski }
4029*b1cdbd2cSJim Jagielski }
4030*b1cdbd2cSJim Jagielski }
4031*b1cdbd2cSJim Jagielski return (SwTableFmt*)pRet;
4032*b1cdbd2cSJim Jagielski }
4033*b1cdbd2cSJim Jagielski
SetColRowWidthHeight(SwTableBox & rAktBox,sal_uInt16 eType,SwTwips nAbsDiff,SwTwips nRelDiff)4034*b1cdbd2cSJim Jagielski sal_Bool SwDoc::SetColRowWidthHeight( SwTableBox& rAktBox, sal_uInt16 eType,
4035*b1cdbd2cSJim Jagielski SwTwips nAbsDiff, SwTwips nRelDiff )
4036*b1cdbd2cSJim Jagielski {
4037*b1cdbd2cSJim Jagielski SwTableNode* pTblNd = (SwTableNode*)rAktBox.GetSttNd()->FindTableNode();
4038*b1cdbd2cSJim Jagielski SwUndo* pUndo = 0;
4039*b1cdbd2cSJim Jagielski
4040*b1cdbd2cSJim Jagielski if( nsTblChgWidthHeightType::WH_FLAG_INSDEL & eType && pTblNd->GetTable().ISA( SwDDETable ))
4041*b1cdbd2cSJim Jagielski return sal_False;
4042*b1cdbd2cSJim Jagielski
4043*b1cdbd2cSJim Jagielski SwTableFmlUpdate aMsgHnt( &pTblNd->GetTable() );
4044*b1cdbd2cSJim Jagielski aMsgHnt.eFlags = TBL_BOXPTR;
4045*b1cdbd2cSJim Jagielski UpdateTblFlds( &aMsgHnt );
4046*b1cdbd2cSJim Jagielski
4047*b1cdbd2cSJim Jagielski bool const bUndo(GetIDocumentUndoRedo().DoesUndo());
4048*b1cdbd2cSJim Jagielski sal_Bool bRet = sal_False;
4049*b1cdbd2cSJim Jagielski switch( eType & 0xff )
4050*b1cdbd2cSJim Jagielski {
4051*b1cdbd2cSJim Jagielski case nsTblChgWidthHeightType::WH_COL_LEFT:
4052*b1cdbd2cSJim Jagielski case nsTblChgWidthHeightType::WH_COL_RIGHT:
4053*b1cdbd2cSJim Jagielski case nsTblChgWidthHeightType::WH_CELL_LEFT:
4054*b1cdbd2cSJim Jagielski case nsTblChgWidthHeightType::WH_CELL_RIGHT:
4055*b1cdbd2cSJim Jagielski {
4056*b1cdbd2cSJim Jagielski bRet = pTblNd->GetTable().SetColWidth( rAktBox,
4057*b1cdbd2cSJim Jagielski eType, nAbsDiff, nRelDiff,
4058*b1cdbd2cSJim Jagielski (bUndo) ? &pUndo : 0 );
4059*b1cdbd2cSJim Jagielski }
4060*b1cdbd2cSJim Jagielski break;
4061*b1cdbd2cSJim Jagielski case nsTblChgWidthHeightType::WH_ROW_TOP:
4062*b1cdbd2cSJim Jagielski case nsTblChgWidthHeightType::WH_ROW_BOTTOM:
4063*b1cdbd2cSJim Jagielski case nsTblChgWidthHeightType::WH_CELL_TOP:
4064*b1cdbd2cSJim Jagielski case nsTblChgWidthHeightType::WH_CELL_BOTTOM:
4065*b1cdbd2cSJim Jagielski bRet = pTblNd->GetTable().SetRowHeight( rAktBox,
4066*b1cdbd2cSJim Jagielski eType, nAbsDiff, nRelDiff,
4067*b1cdbd2cSJim Jagielski (bUndo) ? &pUndo : 0 );
4068*b1cdbd2cSJim Jagielski break;
4069*b1cdbd2cSJim Jagielski }
4070*b1cdbd2cSJim Jagielski
4071*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().DoUndo(bUndo); // SetColWidth can turn it off
4072*b1cdbd2cSJim Jagielski if( pUndo )
4073*b1cdbd2cSJim Jagielski {
4074*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().AppendUndo( pUndo );
4075*b1cdbd2cSJim Jagielski }
4076*b1cdbd2cSJim Jagielski
4077*b1cdbd2cSJim Jagielski if( bRet )
4078*b1cdbd2cSJim Jagielski {
4079*b1cdbd2cSJim Jagielski SetModified();
4080*b1cdbd2cSJim Jagielski if( nsTblChgWidthHeightType::WH_FLAG_INSDEL & eType )
4081*b1cdbd2cSJim Jagielski SetFieldsDirty( true, NULL, 0 );
4082*b1cdbd2cSJim Jagielski }
4083*b1cdbd2cSJim Jagielski return bRet;
4084*b1cdbd2cSJim Jagielski }
4085*b1cdbd2cSJim Jagielski
4086*b1cdbd2cSJim Jagielski
ChkBoxNumFmt(SwTableBox & rBox,sal_Bool bCallUpdate)4087*b1cdbd2cSJim Jagielski void SwDoc::ChkBoxNumFmt( SwTableBox& rBox, sal_Bool bCallUpdate )
4088*b1cdbd2cSJim Jagielski {
4089*b1cdbd2cSJim Jagielski //JP 09.07.97: Optimierung: wenn die Box schon sagt, das es Text
4090*b1cdbd2cSJim Jagielski // sein soll, dann bleibt das auch Text!
4091*b1cdbd2cSJim Jagielski const SfxPoolItem* pNumFmtItem = 0;
4092*b1cdbd2cSJim Jagielski if( SFX_ITEM_SET == rBox.GetFrmFmt()->GetItemState( RES_BOXATR_FORMAT,
4093*b1cdbd2cSJim Jagielski sal_False, &pNumFmtItem ) && GetNumberFormatter()->IsTextFormat(
4094*b1cdbd2cSJim Jagielski ((SwTblBoxNumFormat*)pNumFmtItem)->GetValue() ))
4095*b1cdbd2cSJim Jagielski return ;
4096*b1cdbd2cSJim Jagielski
4097*b1cdbd2cSJim Jagielski SwUndoTblNumFmt* pUndo = 0;
4098*b1cdbd2cSJim Jagielski
4099*b1cdbd2cSJim Jagielski sal_Bool bIsEmptyTxtNd, bChgd = sal_True;
4100*b1cdbd2cSJim Jagielski sal_uInt32 nFmtIdx;
4101*b1cdbd2cSJim Jagielski double fNumber;
4102*b1cdbd2cSJim Jagielski if( rBox.HasNumCntnt( fNumber, nFmtIdx, bIsEmptyTxtNd ) )
4103*b1cdbd2cSJim Jagielski {
4104*b1cdbd2cSJim Jagielski if( !rBox.IsNumberChanged() )
4105*b1cdbd2cSJim Jagielski bChgd = sal_False;
4106*b1cdbd2cSJim Jagielski else
4107*b1cdbd2cSJim Jagielski {
4108*b1cdbd2cSJim Jagielski if (GetIDocumentUndoRedo().DoesUndo())
4109*b1cdbd2cSJim Jagielski {
4110*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().StartUndo( UNDO_TABLE_AUTOFMT, NULL );
4111*b1cdbd2cSJim Jagielski pUndo = new SwUndoTblNumFmt( rBox );
4112*b1cdbd2cSJim Jagielski pUndo->SetNumFmt( nFmtIdx, fNumber );
4113*b1cdbd2cSJim Jagielski }
4114*b1cdbd2cSJim Jagielski
4115*b1cdbd2cSJim Jagielski SwTableBoxFmt* pBoxFmt = (SwTableBoxFmt*)rBox.GetFrmFmt();
4116*b1cdbd2cSJim Jagielski SfxItemSet aBoxSet( GetAttrPool(), RES_BOXATR_FORMAT, RES_BOXATR_VALUE );
4117*b1cdbd2cSJim Jagielski
4118*b1cdbd2cSJim Jagielski sal_Bool bSetNumFmt = IsInsTblFormatNum(), bLockModify = sal_True;
4119*b1cdbd2cSJim Jagielski if( bSetNumFmt )
4120*b1cdbd2cSJim Jagielski {
4121*b1cdbd2cSJim Jagielski if( !IsInsTblChangeNumFormat() )
4122*b1cdbd2cSJim Jagielski {
4123*b1cdbd2cSJim Jagielski if( !pNumFmtItem )
4124*b1cdbd2cSJim Jagielski bSetNumFmt = sal_False;
4125*b1cdbd2cSJim Jagielski else
4126*b1cdbd2cSJim Jagielski {
4127*b1cdbd2cSJim Jagielski sal_uLong nOldNumFmt = ((SwTblBoxNumFormat*)pNumFmtItem)->
4128*b1cdbd2cSJim Jagielski GetValue();
4129*b1cdbd2cSJim Jagielski SvNumberFormatter* pNumFmtr = GetNumberFormatter();
4130*b1cdbd2cSJim Jagielski
4131*b1cdbd2cSJim Jagielski short nFmtType = pNumFmtr->GetType( nFmtIdx );
4132*b1cdbd2cSJim Jagielski if( nFmtType == pNumFmtr->GetType( nOldNumFmt ) ||
4133*b1cdbd2cSJim Jagielski NUMBERFORMAT_NUMBER == nFmtType )
4134*b1cdbd2cSJim Jagielski // eingstelltes und vorgegebenes NumFormat
4135*b1cdbd2cSJim Jagielski // stimmen ueberein -> altes Format beibehalten
4136*b1cdbd2cSJim Jagielski nFmtIdx = nOldNumFmt;
4137*b1cdbd2cSJim Jagielski else
4138*b1cdbd2cSJim Jagielski // eingstelltes und vorgegebenes NumFormat
4139*b1cdbd2cSJim Jagielski // stimmen nicht ueberein -> als Text einfuegen
4140*b1cdbd2cSJim Jagielski bLockModify = bSetNumFmt = sal_False;
4141*b1cdbd2cSJim Jagielski }
4142*b1cdbd2cSJim Jagielski }
4143*b1cdbd2cSJim Jagielski
4144*b1cdbd2cSJim Jagielski if( bSetNumFmt )
4145*b1cdbd2cSJim Jagielski {
4146*b1cdbd2cSJim Jagielski pBoxFmt = (SwTableBoxFmt*)rBox.ClaimFrmFmt();
4147*b1cdbd2cSJim Jagielski
4148*b1cdbd2cSJim Jagielski aBoxSet.Put( SwTblBoxValue( fNumber ));
4149*b1cdbd2cSJim Jagielski aBoxSet.Put( SwTblBoxNumFormat( nFmtIdx ));
4150*b1cdbd2cSJim Jagielski }
4151*b1cdbd2cSJim Jagielski }
4152*b1cdbd2cSJim Jagielski
4153*b1cdbd2cSJim Jagielski // JP 28.04.98: Nur Formel zuruecksetzen reicht nicht.
4154*b1cdbd2cSJim Jagielski // Sorge dafuer, das der Text auch entsprechend
4155*b1cdbd2cSJim Jagielski // formatiert wird!
4156*b1cdbd2cSJim Jagielski
4157*b1cdbd2cSJim Jagielski if( !bSetNumFmt && !bIsEmptyTxtNd && pNumFmtItem )
4158*b1cdbd2cSJim Jagielski {
4159*b1cdbd2cSJim Jagielski // JP 15.01.99: Nur Attribute zuruecksetzen reicht nicht.
4160*b1cdbd2cSJim Jagielski // Sorge dafuer, das der Text auch entsprechend
4161*b1cdbd2cSJim Jagielski // formatiert wird!
4162*b1cdbd2cSJim Jagielski pBoxFmt->SetFmtAttr( *GetDfltAttr( RES_BOXATR_FORMAT ));
4163*b1cdbd2cSJim Jagielski }
4164*b1cdbd2cSJim Jagielski
4165*b1cdbd2cSJim Jagielski if( bLockModify ) pBoxFmt->LockModify();
4166*b1cdbd2cSJim Jagielski pBoxFmt->ResetFmtAttr( RES_BOXATR_FORMAT, RES_BOXATR_VALUE );
4167*b1cdbd2cSJim Jagielski if( bLockModify ) pBoxFmt->UnlockModify();
4168*b1cdbd2cSJim Jagielski
4169*b1cdbd2cSJim Jagielski if( bSetNumFmt )
4170*b1cdbd2cSJim Jagielski pBoxFmt->SetFmtAttr( aBoxSet );
4171*b1cdbd2cSJim Jagielski }
4172*b1cdbd2cSJim Jagielski }
4173*b1cdbd2cSJim Jagielski else
4174*b1cdbd2cSJim Jagielski {
4175*b1cdbd2cSJim Jagielski // es ist keine Zahl
4176*b1cdbd2cSJim Jagielski const SfxPoolItem* pValueItem = 0, *pFmtItem = 0;
4177*b1cdbd2cSJim Jagielski SwTableBoxFmt* pBoxFmt = (SwTableBoxFmt*)rBox.GetFrmFmt();
4178*b1cdbd2cSJim Jagielski if( SFX_ITEM_SET == pBoxFmt->GetItemState( RES_BOXATR_FORMAT,
4179*b1cdbd2cSJim Jagielski sal_False, &pFmtItem ) ||
4180*b1cdbd2cSJim Jagielski SFX_ITEM_SET == pBoxFmt->GetItemState( RES_BOXATR_VALUE,
4181*b1cdbd2cSJim Jagielski sal_False, &pValueItem ))
4182*b1cdbd2cSJim Jagielski {
4183*b1cdbd2cSJim Jagielski if (GetIDocumentUndoRedo().DoesUndo())
4184*b1cdbd2cSJim Jagielski {
4185*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().StartUndo( UNDO_TABLE_AUTOFMT, NULL );
4186*b1cdbd2cSJim Jagielski pUndo = new SwUndoTblNumFmt( rBox );
4187*b1cdbd2cSJim Jagielski }
4188*b1cdbd2cSJim Jagielski
4189*b1cdbd2cSJim Jagielski pBoxFmt = (SwTableBoxFmt*)rBox.ClaimFrmFmt();
4190*b1cdbd2cSJim Jagielski
4191*b1cdbd2cSJim Jagielski // alle Zahlenformate entfernen
4192*b1cdbd2cSJim Jagielski sal_uInt16 nWhich1 = RES_BOXATR_FORMULA;
4193*b1cdbd2cSJim Jagielski if( !bIsEmptyTxtNd )
4194*b1cdbd2cSJim Jagielski //JP 15.01.99: dieser Teil wurde doch schon oben abgeprueft!
4195*b1cdbd2cSJim Jagielski /* && pFmtItem && !GetNumberFormatter()->
4196*b1cdbd2cSJim Jagielski IsTextFormat( ((SwTblBoxNumFormat*)pFmtItem)->GetValue() ) )*/
4197*b1cdbd2cSJim Jagielski {
4198*b1cdbd2cSJim Jagielski nWhich1 = RES_BOXATR_FORMAT;
4199*b1cdbd2cSJim Jagielski
4200*b1cdbd2cSJim Jagielski // JP 15.01.99: Nur Attribute zuruecksetzen reicht nicht.
4201*b1cdbd2cSJim Jagielski // Sorge dafuer, das der Text auch entsprechend
4202*b1cdbd2cSJim Jagielski // formatiert wird!
4203*b1cdbd2cSJim Jagielski pBoxFmt->SetFmtAttr( *GetDfltAttr( nWhich1 ));
4204*b1cdbd2cSJim Jagielski }
4205*b1cdbd2cSJim Jagielski pBoxFmt->ResetFmtAttr( nWhich1, RES_BOXATR_VALUE );
4206*b1cdbd2cSJim Jagielski }
4207*b1cdbd2cSJim Jagielski else
4208*b1cdbd2cSJim Jagielski bChgd = sal_False;
4209*b1cdbd2cSJim Jagielski }
4210*b1cdbd2cSJim Jagielski
4211*b1cdbd2cSJim Jagielski if( bChgd )
4212*b1cdbd2cSJim Jagielski {
4213*b1cdbd2cSJim Jagielski if( pUndo )
4214*b1cdbd2cSJim Jagielski {
4215*b1cdbd2cSJim Jagielski pUndo->SetBox( rBox );
4216*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().AppendUndo(pUndo);
4217*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().EndUndo( UNDO_END, NULL );
4218*b1cdbd2cSJim Jagielski }
4219*b1cdbd2cSJim Jagielski
4220*b1cdbd2cSJim Jagielski const SwTableNode* pTblNd = rBox.GetSttNd()->FindTableNode();
4221*b1cdbd2cSJim Jagielski if( bCallUpdate )
4222*b1cdbd2cSJim Jagielski {
4223*b1cdbd2cSJim Jagielski SwTableFmlUpdate aTblUpdate( &pTblNd->GetTable() );
4224*b1cdbd2cSJim Jagielski UpdateTblFlds( &aTblUpdate );
4225*b1cdbd2cSJim Jagielski
4226*b1cdbd2cSJim Jagielski // TL_CHART2: update charts (when cursor leaves cell and
4227*b1cdbd2cSJim Jagielski // automatic update is enabled)
4228*b1cdbd2cSJim Jagielski if (AUTOUPD_FIELD_AND_CHARTS == getFieldUpdateFlags(true))
4229*b1cdbd2cSJim Jagielski pTblNd->GetTable().UpdateCharts();
4230*b1cdbd2cSJim Jagielski }
4231*b1cdbd2cSJim Jagielski SetModified();
4232*b1cdbd2cSJim Jagielski }
4233*b1cdbd2cSJim Jagielski }
4234*b1cdbd2cSJim Jagielski
SetTblBoxFormulaAttrs(SwTableBox & rBox,const SfxItemSet & rSet)4235*b1cdbd2cSJim Jagielski void SwDoc::SetTblBoxFormulaAttrs( SwTableBox& rBox, const SfxItemSet& rSet )
4236*b1cdbd2cSJim Jagielski {
4237*b1cdbd2cSJim Jagielski if (GetIDocumentUndoRedo().DoesUndo())
4238*b1cdbd2cSJim Jagielski {
4239*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().AppendUndo( new SwUndoTblNumFmt(rBox, &rSet) );
4240*b1cdbd2cSJim Jagielski }
4241*b1cdbd2cSJim Jagielski
4242*b1cdbd2cSJim Jagielski SwFrmFmt* pBoxFmt = rBox.ClaimFrmFmt();
4243*b1cdbd2cSJim Jagielski if( SFX_ITEM_SET == rSet.GetItemState( RES_BOXATR_FORMULA ))
4244*b1cdbd2cSJim Jagielski {
4245*b1cdbd2cSJim Jagielski pBoxFmt->LockModify();
4246*b1cdbd2cSJim Jagielski pBoxFmt->ResetFmtAttr( RES_BOXATR_VALUE );
4247*b1cdbd2cSJim Jagielski pBoxFmt->UnlockModify();
4248*b1cdbd2cSJim Jagielski }
4249*b1cdbd2cSJim Jagielski else if( SFX_ITEM_SET == rSet.GetItemState( RES_BOXATR_VALUE ))
4250*b1cdbd2cSJim Jagielski {
4251*b1cdbd2cSJim Jagielski pBoxFmt->LockModify();
4252*b1cdbd2cSJim Jagielski pBoxFmt->ResetFmtAttr( RES_BOXATR_FORMULA );
4253*b1cdbd2cSJim Jagielski pBoxFmt->UnlockModify();
4254*b1cdbd2cSJim Jagielski }
4255*b1cdbd2cSJim Jagielski pBoxFmt->SetFmtAttr( rSet );
4256*b1cdbd2cSJim Jagielski SetModified();
4257*b1cdbd2cSJim Jagielski }
4258*b1cdbd2cSJim Jagielski
ClearBoxNumAttrs(const SwNodeIndex & rNode)4259*b1cdbd2cSJim Jagielski void SwDoc::ClearBoxNumAttrs( const SwNodeIndex& rNode )
4260*b1cdbd2cSJim Jagielski {
4261*b1cdbd2cSJim Jagielski SwStartNode* pSttNd;
4262*b1cdbd2cSJim Jagielski if( 0 != ( pSttNd = rNode.GetNode().
4263*b1cdbd2cSJim Jagielski FindSttNodeByType( SwTableBoxStartNode )) &&
4264*b1cdbd2cSJim Jagielski 2 == pSttNd->EndOfSectionIndex() - pSttNd->GetIndex() )
4265*b1cdbd2cSJim Jagielski {
4266*b1cdbd2cSJim Jagielski SwTableBox* pBox = pSttNd->FindTableNode()->GetTable().
4267*b1cdbd2cSJim Jagielski GetTblBox( pSttNd->GetIndex() );
4268*b1cdbd2cSJim Jagielski
4269*b1cdbd2cSJim Jagielski const SfxPoolItem* pFmtItem = 0;
4270*b1cdbd2cSJim Jagielski const SfxItemSet& rSet = pBox->GetFrmFmt()->GetAttrSet();
4271*b1cdbd2cSJim Jagielski if( SFX_ITEM_SET == rSet.GetItemState( RES_BOXATR_FORMAT, sal_False, &pFmtItem ) ||
4272*b1cdbd2cSJim Jagielski SFX_ITEM_SET == rSet.GetItemState( RES_BOXATR_FORMULA, sal_False ) ||
4273*b1cdbd2cSJim Jagielski SFX_ITEM_SET == rSet.GetItemState( RES_BOXATR_VALUE, sal_False ))
4274*b1cdbd2cSJim Jagielski {
4275*b1cdbd2cSJim Jagielski if (GetIDocumentUndoRedo().DoesUndo())
4276*b1cdbd2cSJim Jagielski {
4277*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().AppendUndo(new SwUndoTblNumFmt(*pBox));
4278*b1cdbd2cSJim Jagielski }
4279*b1cdbd2cSJim Jagielski
4280*b1cdbd2cSJim Jagielski SwFrmFmt* pBoxFmt = pBox->ClaimFrmFmt();
4281*b1cdbd2cSJim Jagielski
4282*b1cdbd2cSJim Jagielski //JP 01.09.97: TextFormate bleiben erhalten!
4283*b1cdbd2cSJim Jagielski sal_uInt16 nWhich1 = RES_BOXATR_FORMAT;
4284*b1cdbd2cSJim Jagielski if( pFmtItem && GetNumberFormatter()->IsTextFormat(
4285*b1cdbd2cSJim Jagielski ((SwTblBoxNumFormat*)pFmtItem)->GetValue() ))
4286*b1cdbd2cSJim Jagielski nWhich1 = RES_BOXATR_FORMULA;
4287*b1cdbd2cSJim Jagielski else
4288*b1cdbd2cSJim Jagielski // JP 15.01.99: Nur Attribute zuruecksetzen reicht nicht.
4289*b1cdbd2cSJim Jagielski // Sorge dafuer, das der Text auch entsprechend
4290*b1cdbd2cSJim Jagielski // formatiert wird!
4291*b1cdbd2cSJim Jagielski pBoxFmt->SetFmtAttr( *GetDfltAttr( RES_BOXATR_FORMAT ));
4292*b1cdbd2cSJim Jagielski
4293*b1cdbd2cSJim Jagielski pBoxFmt->ResetFmtAttr( nWhich1, RES_BOXATR_VALUE );
4294*b1cdbd2cSJim Jagielski SetModified();
4295*b1cdbd2cSJim Jagielski }
4296*b1cdbd2cSJim Jagielski }
4297*b1cdbd2cSJim Jagielski }
4298*b1cdbd2cSJim Jagielski
4299*b1cdbd2cSJim Jagielski // kopiert eine Tabelle aus dem selben oder einem anderen Doc in sich
4300*b1cdbd2cSJim Jagielski // selbst. Dabei wird eine neue Tabelle angelegt oder eine bestehende
4301*b1cdbd2cSJim Jagielski // mit dem Inhalt gefuellt; wobei entweder der Inhalt ab einer Box oder
4302*b1cdbd2cSJim Jagielski // in eine bestehende TblSelektion gefuellt wird.
4303*b1cdbd2cSJim Jagielski // Gerufen wird es von: edglss.cxx/fecopy.cxx
4304*b1cdbd2cSJim Jagielski
InsCopyOfTbl(SwPosition & rInsPos,const SwSelBoxes & rBoxes,const SwTable * pCpyTbl,sal_Bool bCpyName,sal_Bool bCorrPos)4305*b1cdbd2cSJim Jagielski sal_Bool SwDoc::InsCopyOfTbl( SwPosition& rInsPos, const SwSelBoxes& rBoxes,
4306*b1cdbd2cSJim Jagielski const SwTable* pCpyTbl, sal_Bool bCpyName, sal_Bool bCorrPos )
4307*b1cdbd2cSJim Jagielski {
4308*b1cdbd2cSJim Jagielski sal_Bool bRet;
4309*b1cdbd2cSJim Jagielski
4310*b1cdbd2cSJim Jagielski const SwTableNode* pSrcTblNd = pCpyTbl
4311*b1cdbd2cSJim Jagielski ? pCpyTbl->GetTableNode()
4312*b1cdbd2cSJim Jagielski : rBoxes[ 0 ]->GetSttNd()->FindTableNode();
4313*b1cdbd2cSJim Jagielski
4314*b1cdbd2cSJim Jagielski SwTableNode * pInsTblNd = rInsPos.nNode.GetNode().FindTableNode();
4315*b1cdbd2cSJim Jagielski
4316*b1cdbd2cSJim Jagielski bool const bUndo( GetIDocumentUndoRedo().DoesUndo() );
4317*b1cdbd2cSJim Jagielski if( !pCpyTbl && !pInsTblNd )
4318*b1cdbd2cSJim Jagielski {
4319*b1cdbd2cSJim Jagielski SwUndoCpyTbl* pUndo = 0;
4320*b1cdbd2cSJim Jagielski if (bUndo)
4321*b1cdbd2cSJim Jagielski {
4322*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().ClearRedo();
4323*b1cdbd2cSJim Jagielski pUndo = new SwUndoCpyTbl;
4324*b1cdbd2cSJim Jagielski }
4325*b1cdbd2cSJim Jagielski
4326*b1cdbd2cSJim Jagielski {
4327*b1cdbd2cSJim Jagielski ::sw::UndoGuard const undoGuard(GetIDocumentUndoRedo());
4328*b1cdbd2cSJim Jagielski bRet = pSrcTblNd->GetTable().MakeCopy( this, rInsPos, rBoxes,
4329*b1cdbd2cSJim Jagielski sal_True, bCpyName );
4330*b1cdbd2cSJim Jagielski }
4331*b1cdbd2cSJim Jagielski
4332*b1cdbd2cSJim Jagielski if( pUndo )
4333*b1cdbd2cSJim Jagielski {
4334*b1cdbd2cSJim Jagielski if( !bRet )
4335*b1cdbd2cSJim Jagielski {
4336*b1cdbd2cSJim Jagielski delete pUndo;
4337*b1cdbd2cSJim Jagielski pUndo = 0;
4338*b1cdbd2cSJim Jagielski }
4339*b1cdbd2cSJim Jagielski else
4340*b1cdbd2cSJim Jagielski {
4341*b1cdbd2cSJim Jagielski pInsTblNd = GetNodes()[ rInsPos.nNode.GetIndex() - 1 ]->FindTableNode();
4342*b1cdbd2cSJim Jagielski
4343*b1cdbd2cSJim Jagielski pUndo->SetTableSttIdx( pInsTblNd->GetIndex() );
4344*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().AppendUndo( pUndo );
4345*b1cdbd2cSJim Jagielski }
4346*b1cdbd2cSJim Jagielski }
4347*b1cdbd2cSJim Jagielski }
4348*b1cdbd2cSJim Jagielski else
4349*b1cdbd2cSJim Jagielski {
4350*b1cdbd2cSJim Jagielski RedlineMode_t eOld = GetRedlineMode();
4351*b1cdbd2cSJim Jagielski if( IsRedlineOn() )
4352*b1cdbd2cSJim Jagielski SetRedlineMode( (RedlineMode_t)(nsRedlineMode_t::REDLINE_ON |
4353*b1cdbd2cSJim Jagielski nsRedlineMode_t::REDLINE_SHOW_INSERT |
4354*b1cdbd2cSJim Jagielski nsRedlineMode_t::REDLINE_SHOW_DELETE));
4355*b1cdbd2cSJim Jagielski
4356*b1cdbd2cSJim Jagielski SwUndoTblCpyTbl* pUndo = 0;
4357*b1cdbd2cSJim Jagielski if (bUndo)
4358*b1cdbd2cSJim Jagielski {
4359*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().ClearRedo();
4360*b1cdbd2cSJim Jagielski pUndo = new SwUndoTblCpyTbl;
4361*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().DoUndo(false);
4362*b1cdbd2cSJim Jagielski }
4363*b1cdbd2cSJim Jagielski
4364*b1cdbd2cSJim Jagielski SwDoc* pCpyDoc = (SwDoc*)pSrcTblNd->GetDoc();
4365*b1cdbd2cSJim Jagielski sal_Bool bDelCpyDoc = pCpyDoc == this;
4366*b1cdbd2cSJim Jagielski
4367*b1cdbd2cSJim Jagielski if( bDelCpyDoc )
4368*b1cdbd2cSJim Jagielski {
4369*b1cdbd2cSJim Jagielski // kopiere die Tabelle erstmal in ein temp. Doc
4370*b1cdbd2cSJim Jagielski pCpyDoc = new SwDoc;
4371*b1cdbd2cSJim Jagielski pCpyDoc->acquire();
4372*b1cdbd2cSJim Jagielski
4373*b1cdbd2cSJim Jagielski SwPosition aPos( SwNodeIndex( pCpyDoc->GetNodes().GetEndOfContent() ));
4374*b1cdbd2cSJim Jagielski if( !pSrcTblNd->GetTable().MakeCopy( pCpyDoc, aPos, rBoxes, sal_True, sal_True ))
4375*b1cdbd2cSJim Jagielski {
4376*b1cdbd2cSJim Jagielski if( pCpyDoc->release() == 0 )
4377*b1cdbd2cSJim Jagielski delete pCpyDoc;
4378*b1cdbd2cSJim Jagielski
4379*b1cdbd2cSJim Jagielski if( pUndo )
4380*b1cdbd2cSJim Jagielski {
4381*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().DoUndo(bUndo);
4382*b1cdbd2cSJim Jagielski delete pUndo;
4383*b1cdbd2cSJim Jagielski pUndo = 0;
4384*b1cdbd2cSJim Jagielski }
4385*b1cdbd2cSJim Jagielski return sal_False;
4386*b1cdbd2cSJim Jagielski }
4387*b1cdbd2cSJim Jagielski aPos.nNode -= 1; // auf den EndNode der Tabelle
4388*b1cdbd2cSJim Jagielski pSrcTblNd = aPos.nNode.GetNode().FindTableNode();
4389*b1cdbd2cSJim Jagielski }
4390*b1cdbd2cSJim Jagielski
4391*b1cdbd2cSJim Jagielski const SwStartNode* pSttNd = rInsPos.nNode.GetNode().FindTableBoxStartNode();
4392*b1cdbd2cSJim Jagielski
4393*b1cdbd2cSJim Jagielski rInsPos.nContent.Assign( 0, 0 );
4394*b1cdbd2cSJim Jagielski
4395*b1cdbd2cSJim Jagielski // no complex into complex, but copy into or from new model is welcome
4396*b1cdbd2cSJim Jagielski if( ( !pSrcTblNd->GetTable().IsTblComplex() || pInsTblNd->GetTable().IsNewModel() )
4397*b1cdbd2cSJim Jagielski && ( bDelCpyDoc || rBoxes.Count() ) )
4398*b1cdbd2cSJim Jagielski {
4399*b1cdbd2cSJim Jagielski // dann die Tabelle "relativ" kopieren
4400*b1cdbd2cSJim Jagielski const SwSelBoxes* pBoxes;
4401*b1cdbd2cSJim Jagielski SwSelBoxes aBoxes;
4402*b1cdbd2cSJim Jagielski
4403*b1cdbd2cSJim Jagielski if( bDelCpyDoc )
4404*b1cdbd2cSJim Jagielski {
4405*b1cdbd2cSJim Jagielski SwTableBox* pBox = pInsTblNd->GetTable().GetTblBox(
4406*b1cdbd2cSJim Jagielski pSttNd->GetIndex() );
4407*b1cdbd2cSJim Jagielski ASSERT( pBox, "Box steht nicht in dieser Tabelle" );
4408*b1cdbd2cSJim Jagielski aBoxes.Insert( pBox );
4409*b1cdbd2cSJim Jagielski pBoxes = &aBoxes;
4410*b1cdbd2cSJim Jagielski }
4411*b1cdbd2cSJim Jagielski else
4412*b1cdbd2cSJim Jagielski pBoxes = &rBoxes;
4413*b1cdbd2cSJim Jagielski
4414*b1cdbd2cSJim Jagielski // kopiere die Tabelle in die selktierten Zellen.
4415*b1cdbd2cSJim Jagielski bRet = pInsTblNd->GetTable().InsTable( pSrcTblNd->GetTable(),
4416*b1cdbd2cSJim Jagielski *pBoxes, pUndo );
4417*b1cdbd2cSJim Jagielski }
4418*b1cdbd2cSJim Jagielski else
4419*b1cdbd2cSJim Jagielski {
4420*b1cdbd2cSJim Jagielski SwNodeIndex aNdIdx( *pSttNd, 1 );
4421*b1cdbd2cSJim Jagielski bRet = pInsTblNd->GetTable().InsTable( pSrcTblNd->GetTable(),
4422*b1cdbd2cSJim Jagielski aNdIdx, pUndo );
4423*b1cdbd2cSJim Jagielski }
4424*b1cdbd2cSJim Jagielski
4425*b1cdbd2cSJim Jagielski if( bDelCpyDoc )
4426*b1cdbd2cSJim Jagielski {
4427*b1cdbd2cSJim Jagielski if( pCpyDoc->release() == 0 )
4428*b1cdbd2cSJim Jagielski delete pCpyDoc;
4429*b1cdbd2cSJim Jagielski }
4430*b1cdbd2cSJim Jagielski
4431*b1cdbd2cSJim Jagielski if( pUndo )
4432*b1cdbd2cSJim Jagielski {
4433*b1cdbd2cSJim Jagielski // falls die Tabelle nicht kopiert werden konnte, das Undo-Object
4434*b1cdbd2cSJim Jagielski // wieder loeschen
4435*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().DoUndo(bUndo);
4436*b1cdbd2cSJim Jagielski if( !bRet && pUndo->IsEmpty() )
4437*b1cdbd2cSJim Jagielski delete pUndo;
4438*b1cdbd2cSJim Jagielski else
4439*b1cdbd2cSJim Jagielski {
4440*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().AppendUndo(pUndo);
4441*b1cdbd2cSJim Jagielski }
4442*b1cdbd2cSJim Jagielski }
4443*b1cdbd2cSJim Jagielski
4444*b1cdbd2cSJim Jagielski if( bCorrPos )
4445*b1cdbd2cSJim Jagielski {
4446*b1cdbd2cSJim Jagielski rInsPos.nNode = *pSttNd;
4447*b1cdbd2cSJim Jagielski rInsPos.nContent.Assign( GetNodes().GoNext( &rInsPos.nNode ), 0 );
4448*b1cdbd2cSJim Jagielski }
4449*b1cdbd2cSJim Jagielski SetRedlineMode( eOld );
4450*b1cdbd2cSJim Jagielski }
4451*b1cdbd2cSJim Jagielski
4452*b1cdbd2cSJim Jagielski if( bRet )
4453*b1cdbd2cSJim Jagielski {
4454*b1cdbd2cSJim Jagielski SetModified();
4455*b1cdbd2cSJim Jagielski SetFieldsDirty( true, NULL, 0 );
4456*b1cdbd2cSJim Jagielski }
4457*b1cdbd2cSJim Jagielski return bRet;
4458*b1cdbd2cSJim Jagielski }
4459*b1cdbd2cSJim Jagielski
4460*b1cdbd2cSJim Jagielski
4461*b1cdbd2cSJim Jagielski
_UnProtectTblCells(SwTable & rTbl)4462*b1cdbd2cSJim Jagielski sal_Bool SwDoc::_UnProtectTblCells( SwTable& rTbl )
4463*b1cdbd2cSJim Jagielski {
4464*b1cdbd2cSJim Jagielski sal_Bool bChgd = sal_False;
4465*b1cdbd2cSJim Jagielski SwUndoAttrTbl *const pUndo = (GetIDocumentUndoRedo().DoesUndo())
4466*b1cdbd2cSJim Jagielski ? new SwUndoAttrTbl( *rTbl.GetTableNode() )
4467*b1cdbd2cSJim Jagielski : 0;
4468*b1cdbd2cSJim Jagielski
4469*b1cdbd2cSJim Jagielski SwTableSortBoxes& rSrtBox = rTbl.GetTabSortBoxes();
4470*b1cdbd2cSJim Jagielski for( sal_uInt16 i = rSrtBox.Count(); i; )
4471*b1cdbd2cSJim Jagielski {
4472*b1cdbd2cSJim Jagielski SwFrmFmt *pBoxFmt = rSrtBox[ --i ]->GetFrmFmt();
4473*b1cdbd2cSJim Jagielski if( pBoxFmt->GetProtect().IsCntntProtected() )
4474*b1cdbd2cSJim Jagielski {
4475*b1cdbd2cSJim Jagielski pBoxFmt->ResetFmtAttr( RES_PROTECT );
4476*b1cdbd2cSJim Jagielski bChgd = sal_True;
4477*b1cdbd2cSJim Jagielski }
4478*b1cdbd2cSJim Jagielski }
4479*b1cdbd2cSJim Jagielski
4480*b1cdbd2cSJim Jagielski if( pUndo )
4481*b1cdbd2cSJim Jagielski {
4482*b1cdbd2cSJim Jagielski if( bChgd )
4483*b1cdbd2cSJim Jagielski {
4484*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().AppendUndo( pUndo );
4485*b1cdbd2cSJim Jagielski }
4486*b1cdbd2cSJim Jagielski else
4487*b1cdbd2cSJim Jagielski delete pUndo;
4488*b1cdbd2cSJim Jagielski }
4489*b1cdbd2cSJim Jagielski return bChgd;
4490*b1cdbd2cSJim Jagielski }
4491*b1cdbd2cSJim Jagielski
4492*b1cdbd2cSJim Jagielski
UnProtectCells(const String & rName)4493*b1cdbd2cSJim Jagielski sal_Bool SwDoc::UnProtectCells( const String& rName )
4494*b1cdbd2cSJim Jagielski {
4495*b1cdbd2cSJim Jagielski sal_Bool bChgd = sal_False;
4496*b1cdbd2cSJim Jagielski SwTableFmt* pFmt = FindTblFmtByName( rName );
4497*b1cdbd2cSJim Jagielski if( pFmt )
4498*b1cdbd2cSJim Jagielski {
4499*b1cdbd2cSJim Jagielski bChgd = _UnProtectTblCells( *SwTable::FindTable( pFmt ) );
4500*b1cdbd2cSJim Jagielski if( bChgd )
4501*b1cdbd2cSJim Jagielski SetModified();
4502*b1cdbd2cSJim Jagielski }
4503*b1cdbd2cSJim Jagielski
4504*b1cdbd2cSJim Jagielski return bChgd;
4505*b1cdbd2cSJim Jagielski }
4506*b1cdbd2cSJim Jagielski
UnProtectCells(const SwSelBoxes & rBoxes)4507*b1cdbd2cSJim Jagielski sal_Bool SwDoc::UnProtectCells( const SwSelBoxes& rBoxes )
4508*b1cdbd2cSJim Jagielski {
4509*b1cdbd2cSJim Jagielski sal_Bool bChgd = sal_False;
4510*b1cdbd2cSJim Jagielski if( rBoxes.Count() )
4511*b1cdbd2cSJim Jagielski {
4512*b1cdbd2cSJim Jagielski SwUndoAttrTbl *const pUndo = (GetIDocumentUndoRedo().DoesUndo())
4513*b1cdbd2cSJim Jagielski ? new SwUndoAttrTbl( *rBoxes[0]->GetSttNd()->FindTableNode() )
4514*b1cdbd2cSJim Jagielski : 0;
4515*b1cdbd2cSJim Jagielski
4516*b1cdbd2cSJim Jagielski SvPtrarr aFmts( 16 ), aNewFmts( 16 );
4517*b1cdbd2cSJim Jagielski for( sal_uInt16 i = rBoxes.Count(); i; )
4518*b1cdbd2cSJim Jagielski {
4519*b1cdbd2cSJim Jagielski SwTableBox* pBox = rBoxes[ --i ];
4520*b1cdbd2cSJim Jagielski SwFrmFmt* pBoxFmt = pBox->GetFrmFmt();
4521*b1cdbd2cSJim Jagielski if( pBoxFmt->GetProtect().IsCntntProtected() )
4522*b1cdbd2cSJim Jagielski {
4523*b1cdbd2cSJim Jagielski sal_uInt16 nFnd = aFmts.GetPos( pBoxFmt );
4524*b1cdbd2cSJim Jagielski if( USHRT_MAX != nFnd )
4525*b1cdbd2cSJim Jagielski pBox->ChgFrmFmt( (SwTableBoxFmt*)aNewFmts[ nFnd ] );
4526*b1cdbd2cSJim Jagielski else
4527*b1cdbd2cSJim Jagielski {
4528*b1cdbd2cSJim Jagielski aFmts.Insert( pBoxFmt, aFmts.Count() );
4529*b1cdbd2cSJim Jagielski pBoxFmt = pBox->ClaimFrmFmt();
4530*b1cdbd2cSJim Jagielski pBoxFmt->ResetFmtAttr( RES_PROTECT );
4531*b1cdbd2cSJim Jagielski aNewFmts.Insert( pBoxFmt, aNewFmts.Count() );
4532*b1cdbd2cSJim Jagielski }
4533*b1cdbd2cSJim Jagielski bChgd = sal_True;
4534*b1cdbd2cSJim Jagielski }
4535*b1cdbd2cSJim Jagielski }
4536*b1cdbd2cSJim Jagielski
4537*b1cdbd2cSJim Jagielski if( pUndo )
4538*b1cdbd2cSJim Jagielski {
4539*b1cdbd2cSJim Jagielski if( bChgd )
4540*b1cdbd2cSJim Jagielski {
4541*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().AppendUndo( pUndo );
4542*b1cdbd2cSJim Jagielski }
4543*b1cdbd2cSJim Jagielski else
4544*b1cdbd2cSJim Jagielski delete pUndo;
4545*b1cdbd2cSJim Jagielski }
4546*b1cdbd2cSJim Jagielski }
4547*b1cdbd2cSJim Jagielski return bChgd;
4548*b1cdbd2cSJim Jagielski }
4549*b1cdbd2cSJim Jagielski
UnProtectTbls(const SwPaM & rPam)4550*b1cdbd2cSJim Jagielski sal_Bool SwDoc::UnProtectTbls( const SwPaM& rPam )
4551*b1cdbd2cSJim Jagielski {
4552*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().StartUndo(UNDO_EMPTY, NULL);
4553*b1cdbd2cSJim Jagielski
4554*b1cdbd2cSJim Jagielski sal_Bool bChgd = sal_False, bHasSel = rPam.HasMark() ||
4555*b1cdbd2cSJim Jagielski rPam.GetNext() != (SwPaM*)&rPam;
4556*b1cdbd2cSJim Jagielski SwFrmFmts& rFmts = *GetTblFrmFmts();
4557*b1cdbd2cSJim Jagielski SwTable* pTbl;
4558*b1cdbd2cSJim Jagielski const SwTableNode* pTblNd;
4559*b1cdbd2cSJim Jagielski for( sal_uInt16 n = rFmts.Count(); n ; )
4560*b1cdbd2cSJim Jagielski if( 0 != (pTbl = SwTable::FindTable( rFmts[ --n ] )) &&
4561*b1cdbd2cSJim Jagielski 0 != (pTblNd = pTbl->GetTableNode() ) &&
4562*b1cdbd2cSJim Jagielski pTblNd->GetNodes().IsDocNodes() )
4563*b1cdbd2cSJim Jagielski {
4564*b1cdbd2cSJim Jagielski sal_uLong nTblIdx = pTblNd->GetIndex();
4565*b1cdbd2cSJim Jagielski
4566*b1cdbd2cSJim Jagielski // dann ueberpruefe ob Tabelle in der Selection liegt
4567*b1cdbd2cSJim Jagielski if( bHasSel )
4568*b1cdbd2cSJim Jagielski {
4569*b1cdbd2cSJim Jagielski int bFound = sal_False;
4570*b1cdbd2cSJim Jagielski SwPaM* pTmp = (SwPaM*)&rPam;
4571*b1cdbd2cSJim Jagielski do {
4572*b1cdbd2cSJim Jagielski const SwPosition *pStt = pTmp->Start(),
4573*b1cdbd2cSJim Jagielski *pEnd = pTmp->End();
4574*b1cdbd2cSJim Jagielski bFound = pStt->nNode.GetIndex() < nTblIdx &&
4575*b1cdbd2cSJim Jagielski nTblIdx < pEnd->nNode.GetIndex();
4576*b1cdbd2cSJim Jagielski
4577*b1cdbd2cSJim Jagielski } while( !bFound && &rPam != ( pTmp = (SwPaM*)pTmp->GetNext() ) );
4578*b1cdbd2cSJim Jagielski if( !bFound )
4579*b1cdbd2cSJim Jagielski continue; // weitersuchen
4580*b1cdbd2cSJim Jagielski }
4581*b1cdbd2cSJim Jagielski
4582*b1cdbd2cSJim Jagielski // dann mal den Schutz aufheben
4583*b1cdbd2cSJim Jagielski bChgd |= _UnProtectTblCells( *pTbl );
4584*b1cdbd2cSJim Jagielski }
4585*b1cdbd2cSJim Jagielski
4586*b1cdbd2cSJim Jagielski GetIDocumentUndoRedo().EndUndo(UNDO_EMPTY, NULL);
4587*b1cdbd2cSJim Jagielski if( bChgd )
4588*b1cdbd2cSJim Jagielski SetModified();
4589*b1cdbd2cSJim Jagielski
4590*b1cdbd2cSJim Jagielski return bChgd;
4591*b1cdbd2cSJim Jagielski }
4592*b1cdbd2cSJim Jagielski
HasTblAnyProtection(const SwPosition * pPos,const String * pTblName,sal_Bool * pFullTblProtection)4593*b1cdbd2cSJim Jagielski sal_Bool SwDoc::HasTblAnyProtection( const SwPosition* pPos,
4594*b1cdbd2cSJim Jagielski const String* pTblName,
4595*b1cdbd2cSJim Jagielski sal_Bool* pFullTblProtection )
4596*b1cdbd2cSJim Jagielski {
4597*b1cdbd2cSJim Jagielski sal_Bool bHasProtection = sal_False;
4598*b1cdbd2cSJim Jagielski SwTable* pTbl = 0;
4599*b1cdbd2cSJim Jagielski if( pTblName )
4600*b1cdbd2cSJim Jagielski pTbl = SwTable::FindTable( FindTblFmtByName( *pTblName ) );
4601*b1cdbd2cSJim Jagielski else if( pPos )
4602*b1cdbd2cSJim Jagielski {
4603*b1cdbd2cSJim Jagielski SwTableNode* pTblNd = pPos->nNode.GetNode().FindTableNode();
4604*b1cdbd2cSJim Jagielski if( pTblNd )
4605*b1cdbd2cSJim Jagielski pTbl = &pTblNd->GetTable();
4606*b1cdbd2cSJim Jagielski }
4607*b1cdbd2cSJim Jagielski
4608*b1cdbd2cSJim Jagielski if( pTbl )
4609*b1cdbd2cSJim Jagielski {
4610*b1cdbd2cSJim Jagielski SwTableSortBoxes& rSrtBox = pTbl->GetTabSortBoxes();
4611*b1cdbd2cSJim Jagielski for( sal_uInt16 i = rSrtBox.Count(); i; )
4612*b1cdbd2cSJim Jagielski {
4613*b1cdbd2cSJim Jagielski SwFrmFmt *pBoxFmt = rSrtBox[ --i ]->GetFrmFmt();
4614*b1cdbd2cSJim Jagielski if( pBoxFmt->GetProtect().IsCntntProtected() )
4615*b1cdbd2cSJim Jagielski {
4616*b1cdbd2cSJim Jagielski if( !bHasProtection )
4617*b1cdbd2cSJim Jagielski {
4618*b1cdbd2cSJim Jagielski bHasProtection = sal_True;
4619*b1cdbd2cSJim Jagielski if( !pFullTblProtection )
4620*b1cdbd2cSJim Jagielski break;
4621*b1cdbd2cSJim Jagielski *pFullTblProtection = sal_True;
4622*b1cdbd2cSJim Jagielski }
4623*b1cdbd2cSJim Jagielski }
4624*b1cdbd2cSJim Jagielski else if( bHasProtection && pFullTblProtection )
4625*b1cdbd2cSJim Jagielski {
4626*b1cdbd2cSJim Jagielski *pFullTblProtection = sal_False;
4627*b1cdbd2cSJim Jagielski break;
4628*b1cdbd2cSJim Jagielski }
4629*b1cdbd2cSJim Jagielski }
4630*b1cdbd2cSJim Jagielski }
4631*b1cdbd2cSJim Jagielski return bHasProtection;
4632*b1cdbd2cSJim Jagielski }
4633*b1cdbd2cSJim Jagielski
4634*b1cdbd2cSJim Jagielski #ifdef DEL_TABLE_REDLINES
lcl_DelRedlines(const SwTableNode & rNd,sal_Bool bCheckForOwnRedline)4635*b1cdbd2cSJim Jagielski lcl_DelRedlines::lcl_DelRedlines( const SwTableNode& rNd,
4636*b1cdbd2cSJim Jagielski sal_Bool bCheckForOwnRedline )
4637*b1cdbd2cSJim Jagielski : pDoc( (SwDoc*)rNd.GetNodes().GetDoc() )
4638*b1cdbd2cSJim Jagielski {
4639*b1cdbd2cSJim Jagielski pDoc->StartUndo(UNDO_EMPTY, NULL);
4640*b1cdbd2cSJim Jagielski const SwRedlineTbl& rTbl = pDoc->GetRedlineTbl();
4641*b1cdbd2cSJim Jagielski if( !pDoc->IsIgnoreRedline() && rTbl.Count() )
4642*b1cdbd2cSJim Jagielski {
4643*b1cdbd2cSJim Jagielski sal_Bool bDelete = sal_True;
4644*b1cdbd2cSJim Jagielski if( bCheckForOwnRedline )
4645*b1cdbd2cSJim Jagielski {
4646*b1cdbd2cSJim Jagielski sal_uInt16 nRedlPos = pDoc->GetRedlinePos( rNd, USHRT_MAX );
4647*b1cdbd2cSJim Jagielski sal_uInt32 nSttNd = rNd.GetIndex(),
4648*b1cdbd2cSJim Jagielski nEndNd = rNd.EndOfSectionIndex();
4649*b1cdbd2cSJim Jagielski
4650*b1cdbd2cSJim Jagielski for ( ; nRedlPos < rTbl.Count(); ++nRedlPos )
4651*b1cdbd2cSJim Jagielski {
4652*b1cdbd2cSJim Jagielski const SwRedline* pRedline = rTbl[ nRedlPos ];
4653*b1cdbd2cSJim Jagielski const SwPosition* pStt = pRedline->Start(),
4654*b1cdbd2cSJim Jagielski * pEnd = pStt == pRedline->GetPoint()
4655*b1cdbd2cSJim Jagielski ? pRedline->GetMark()
4656*b1cdbd2cSJim Jagielski : pRedline->GetPoint();
4657*b1cdbd2cSJim Jagielski if( pStt->nNode <= nSttNd )
4658*b1cdbd2cSJim Jagielski {
4659*b1cdbd2cSJim Jagielski if( pEnd->nNode >= nEndNd &&
4660*b1cdbd2cSJim Jagielski pRedline->GetAuthor() == pDoc->GetRedlineAuthor() )
4661*b1cdbd2cSJim Jagielski {
4662*b1cdbd2cSJim Jagielski bDelete = sal_False;
4663*b1cdbd2cSJim Jagielski break;
4664*b1cdbd2cSJim Jagielski }
4665*b1cdbd2cSJim Jagielski }
4666*b1cdbd2cSJim Jagielski else
4667*b1cdbd2cSJim Jagielski break;
4668*b1cdbd2cSJim Jagielski }
4669*b1cdbd2cSJim Jagielski }
4670*b1cdbd2cSJim Jagielski if( bDelete )
4671*b1cdbd2cSJim Jagielski {
4672*b1cdbd2cSJim Jagielski SwPaM aPam(*rNd.EndOfSectionNode(), rNd);
4673*b1cdbd2cSJim Jagielski pDoc->AcceptRedline( aPam, true );
4674*b1cdbd2cSJim Jagielski }
4675*b1cdbd2cSJim Jagielski }
4676*b1cdbd2cSJim Jagielski }
4677*b1cdbd2cSJim Jagielski #endif
4678*b1cdbd2cSJim Jagielski
4679*b1cdbd2cSJim Jagielski
4680