LibreOffice Module sw (master)  1
ndcopy.cxx
Go to the documentation of this file.
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3  * This file is part of the LibreOffice project.
4  *
5  * This Source Code Form is subject to the terms of the Mozilla Public
6  * License, v. 2.0. If a copy of the MPL was not distributed with this
7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8  *
9  * This file incorporates work covered by the following license notice:
10  *
11  * Licensed to the Apache Software Foundation (ASF) under one or more
12  * contributor license agreements. See the NOTICE file distributed
13  * with this work for additional information regarding copyright
14  * ownership. The ASF licenses this file to you under the Apache
15  * License, Version 2.0 (the "License"); you may not use this file
16  * except in compliance with the License. You may obtain a copy of
17  * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18  */
19 #include <doc.hxx>
21 #include <node.hxx>
22 #include <frmfmt.hxx>
23 #include <swtable.hxx>
24 #include <ndtxt.hxx>
25 #include <swtblfmt.hxx>
26 #include <cellatr.hxx>
27 #include <docary.hxx>
28 #include <ddefld.hxx>
29 #include <swddetbl.hxx>
30 #include <ndindex.hxx>
31 #include <vector>
32 #include <osl/diagnose.h>
33 
34 
35 #ifdef DBG_UTIL
36 #define CHECK_TABLE(t) (t).CheckConsistency();
37 #else
38 #define CHECK_TABLE(t)
39 #endif
40 
41 namespace {
42 
43 // Structure for the mapping from old and new frame formats to the
44 // boxes and lines of a table
45 struct MapTableFrameFormat
46 {
47  const SwFrameFormat *pOld;
48  SwFrameFormat * const pNew;
49  MapTableFrameFormat( const SwFrameFormat *pOldFormat, SwFrameFormat*pNewFormat )
50  : pOld( pOldFormat ), pNew( pNewFormat )
51  {}
52 };
53 
54 }
55 
56 typedef std::vector<MapTableFrameFormat> MapTableFrameFormats;
57 
58 SwContentNode* SwTextNode::MakeCopy(SwDoc* pDoc, const SwNodeIndex& rIdx, bool const bNewFrames) const
59 {
60  // the Copy-Textnode is the Node with the Text, the Copy-Attrnode is the
61  // node with the collection and hard attributes. Normally is the same
62  // node, but if insert a glossary without formatting, then the Attrnode
63  // is the prev node of the destination position in dest. document.
64  SwTextNode* pCpyTextNd = const_cast<SwTextNode*>(this);
65  SwTextNode* pCpyAttrNd = pCpyTextNd;
66 
67  // Copy the formats to the other document
68  SwTextFormatColl* pColl = nullptr;
69  if( pDoc->IsInsOnlyTextGlossary() )
70  {
71  SwNodeIndex aIdx( rIdx, -1 );
72  if( aIdx.GetNode().IsTextNode() )
73  {
74  pCpyAttrNd = aIdx.GetNode().GetTextNode();
75  pColl = &pCpyAttrNd->GetTextColl()->GetNextTextFormatColl();
76  }
77  }
78  if( !pColl )
79  pColl = pDoc->CopyTextColl( *GetTextColl() );
80 
81  SwTextNode* pTextNd = pDoc->GetNodes().MakeTextNode(rIdx, pColl, bNewFrames);
82 
83  // METADATA: register copy
84  pTextNd->RegisterAsCopyOf(*pCpyTextNd);
85 
86  // Copy Attribute/Text
87  if( !pCpyAttrNd->HasSwAttrSet() )
88  // An AttrSet was added for numbering, so delete it
89  pTextNd->ResetAllAttr();
90 
91  // if Copy-Textnode unequal to Copy-Attrnode, then copy first
92  // the attributes into the new Node.
93  if( pCpyAttrNd != pCpyTextNd )
94  {
95  pCpyAttrNd->CopyAttr( pTextNd, 0, 0 );
96  if( pCpyAttrNd->HasSwAttrSet() )
97  {
98  SwAttrSet aSet( *pCpyAttrNd->GetpSwAttrSet() );
99  aSet.ClearItem( RES_PAGEDESC );
100  aSet.ClearItem( RES_BREAK );
101  aSet.CopyToModify( *pTextNd );
102  }
103  }
104 
105  // Is that enough? What about PostIts/Fields/FieldTypes?
106  // #i96213# - force copy of all attributes
107  pCpyTextNd->CopyText( pTextNd, SwIndex( pCpyTextNd ),
108  pCpyTextNd->GetText().getLength(), true );
109 
110  if( RES_CONDTXTFMTCOLL == pColl->Which() )
111  pTextNd->ChkCondColl();
112 
113  return pTextNd;
114 }
115 
116 static bool lcl_SrchNew( const MapTableFrameFormat& rMap, SwFrameFormat** pPara )
117 {
118  if( rMap.pOld != *pPara )
119  return true;
120  *pPara = rMap.pNew;
121  return false;
122 }
123 
124 namespace {
125 
126 struct CopyTable
127 {
128  SwDoc* m_pDoc;
129  sal_uLong const m_nOldTableSttIdx;
130  MapTableFrameFormats& m_rMapArr;
131  SwTableLine* m_pInsLine;
132  SwTableBox* m_pInsBox;
133  SwTableNode *m_pTableNd;
134  const SwTable *m_pOldTable;
135 
136  CopyTable(SwDoc* pDc, MapTableFrameFormats& rArr, sal_uLong nOldStt,
137  SwTableNode& rTableNd, const SwTable* pOldTable)
138  : m_pDoc(pDc), m_nOldTableSttIdx(nOldStt), m_rMapArr(rArr),
139  m_pInsLine(nullptr), m_pInsBox(nullptr), m_pTableNd(&rTableNd), m_pOldTable(pOldTable)
140  {}
141 };
142 
143 }
144 
145 static void lcl_CopyTableLine( const SwTableLine* pLine, CopyTable* pCT );
146 
147 static void lcl_CopyTableBox( SwTableBox* pBox, CopyTable* pCT )
148 {
149  SwTableBoxFormat * pBoxFormat = static_cast<SwTableBoxFormat*>(pBox->GetFrameFormat());
150  for (const auto& rMap : pCT->m_rMapArr)
151  if ( !lcl_SrchNew( rMap, reinterpret_cast<SwFrameFormat**>(&pBoxFormat) ) )
152  break;
153 
154  if (pBoxFormat == pBox->GetFrameFormat()) // Create a new one?
155  {
156  const SfxPoolItem* pItem;
157  if( SfxItemState::SET == pBoxFormat->GetItemState( RES_BOXATR_FORMULA, false,
158  &pItem ) && static_cast<const SwTableBoxFormula*>(pItem)->IsIntrnlName() )
159  {
160  const_cast<SwTableBoxFormula*>(static_cast<const SwTableBoxFormula*>(pItem))->PtrToBoxNm(pCT->m_pOldTable);
161  }
162 
163  pBoxFormat = pCT->m_pDoc->MakeTableBoxFormat();
164  pBoxFormat->CopyAttrs( *pBox->GetFrameFormat() );
165 
166  if( pBox->GetSttIdx() )
167  {
168  SvNumberFormatter* pN = pCT->m_pDoc->GetNumberFormatter(false);
169  if( pN && pN->HasMergeFormatTable() && SfxItemState::SET == pBoxFormat->
170  GetItemState( RES_BOXATR_FORMAT, false, &pItem ) )
171  {
172  sal_uLong nOldIdx = static_cast<const SwTableBoxNumFormat*>(pItem)->GetValue();
173  sal_uLong nNewIdx = pN->GetMergeFormatIndex( nOldIdx );
174  if( nNewIdx != nOldIdx )
175  pBoxFormat->SetFormatAttr( SwTableBoxNumFormat( nNewIdx ));
176 
177  }
178  }
179 
180  pCT->m_rMapArr.emplace_back(pBox->GetFrameFormat(), pBoxFormat);
181  }
182 
183  sal_uInt16 nLines = pBox->GetTabLines().size();
184  SwTableBox* pNewBox;
185  if( nLines )
186  pNewBox = new SwTableBox(pBoxFormat, nLines, pCT->m_pInsLine);
187  else
188  {
189  SwNodeIndex aNewIdx(*pCT->m_pTableNd, pBox->GetSttIdx() - pCT->m_nOldTableSttIdx);
190  assert(aNewIdx.GetNode().IsStartNode() && "Index is not on the start node");
191 
192  pNewBox = new SwTableBox(pBoxFormat, aNewIdx, pCT->m_pInsLine);
193  pNewBox->setRowSpan( pBox->getRowSpan() );
194  }
195 
196  pCT->m_pInsLine->GetTabBoxes().push_back( pNewBox );
197 
198  if (nLines)
199  {
200  CopyTable aPara(*pCT);
201  aPara.m_pInsBox = pNewBox;
202  for( const SwTableLine* pLine : pBox->GetTabLines() )
203  lcl_CopyTableLine( pLine, &aPara );
204  }
205  else if (pNewBox->IsInHeadline(&pCT->m_pTableNd->GetTable()))
206  {
207  // In the headline, the paragraphs must match conditional styles
208  pNewBox->GetSttNd()->CheckSectionCondColl();
209  }
210 }
211 
212 static void lcl_CopyTableLine( const SwTableLine* pLine, CopyTable* pCT )
213 {
214  SwTableLineFormat * pLineFormat = static_cast<SwTableLineFormat*>(pLine->GetFrameFormat());
215  for (const auto& rMap : pCT->m_rMapArr)
216  if ( !lcl_SrchNew( rMap, reinterpret_cast<SwFrameFormat**>(&pLineFormat) ) )
217  break;
218 
219  if( pLineFormat == pLine->GetFrameFormat() ) // Create a new one?
220  {
221  pLineFormat = pCT->m_pDoc->MakeTableLineFormat();
222  pLineFormat->CopyAttrs( *pLine->GetFrameFormat() );
223  pCT->m_rMapArr.emplace_back(pLine->GetFrameFormat(), pLineFormat);
224  }
225 
226  SwTableLine* pNewLine = new SwTableLine(pLineFormat, pLine->GetTabBoxes().size(), pCT->m_pInsBox);
227  // Insert the new row into the table
228  if (pCT->m_pInsBox)
229  {
230  pCT->m_pInsBox->GetTabLines().push_back(pNewLine);
231  }
232  else
233  {
234  pCT->m_pTableNd->GetTable().GetTabLines().push_back(pNewLine);
235  }
236 
237  pCT->m_pInsLine = pNewLine;
238  for( auto& rpBox : const_cast<SwTableLine*>(pLine)->GetTabBoxes() )
239  lcl_CopyTableBox(rpBox, pCT);
240 }
241 
243 {
244  // In which array are we? Nodes? UndoNodes?
245  SwNodes& rNds = const_cast<SwNodes&>(GetNodes());
246 
247  {
248  if( rIdx < pDoc->GetNodes().GetEndOfInserts().GetIndex() &&
249  rIdx >= pDoc->GetNodes().GetEndOfInserts().StartOfSectionIndex() )
250  return nullptr;
251  }
252 
253  // Copy the TableFrameFormat
254  OUString sTableName( GetTable().GetFrameFormat()->GetName() );
255  if( !pDoc->IsCopyIsMove() )
256  {
257  const SwFrameFormats& rTableFormats = *pDoc->GetTableFrameFormats();
258  for( size_t n = rTableFormats.size(); n; )
259  if( rTableFormats[ --n ]->GetName() == sTableName )
260  {
261  sTableName = pDoc->GetUniqueTableName();
262  break;
263  }
264  }
265 
266  SwFrameFormat* pTableFormat = pDoc->MakeTableFrameFormat( sTableName, pDoc->GetDfltFrameFormat() );
267  pTableFormat->CopyAttrs( *GetTable().GetFrameFormat() );
268  SwTableNode* pTableNd = new SwTableNode( rIdx );
269  SwEndNode* pEndNd = new SwEndNode( rIdx, *pTableNd );
270  SwNodeIndex aInsPos( *pEndNd );
271 
272  SwTable& rTable = pTableNd->GetTable();
273  rTable.RegisterToFormat( *pTableFormat );
274 
275  rTable.SetRowsToRepeat( GetTable().GetRowsToRepeat() );
276  rTable.SetTableChgMode( GetTable().GetTableChgMode() );
277  rTable.SetTableModel( GetTable().IsNewModel() );
278 
279  SwDDEFieldType* pDDEType = nullptr;
280  if( auto pSwDDETable = dynamic_cast<const SwDDETable*>( &GetTable() ) )
281  {
282  // We're copying a DDE table
283  // Is the field type available in the new document?
284  pDDEType = const_cast<SwDDETable*>(pSwDDETable)->GetDDEFieldType();
285  if( pDDEType->IsDeleted() )
286  pDoc->getIDocumentFieldsAccess().InsDeletedFieldType( *pDDEType );
287  else
288  pDDEType = static_cast<SwDDEFieldType*>(pDoc->getIDocumentFieldsAccess().InsertFieldType( *pDDEType ));
289  OSL_ENSURE( pDDEType, "unknown FieldType" );
290 
291  // Swap the table pointers in the node
292  std::unique_ptr<SwDDETable> pNewTable(new SwDDETable( pTableNd->GetTable(), pDDEType ));
293  pTableNd->SetNewTable( std::move(pNewTable), false );
294  }
295  // First copy the content of the tables, we will later assign the
296  // boxes/lines and create the frames
297  SwNodeRange aRg( *this, +1, *EndOfSectionNode() );
298 
299  // If there is a table in this table, the table format for the outer table
300  // does not seem to be used, because the table does not have any contents yet
301  // (see IsUsed). Therefore the inner table gets the same name as the outer table.
302  // We have to make sure that the table node of the SwTable is accessible, even
303  // without any content in m_TabSortContentBoxes. #i26629#
304  pTableNd->GetTable().SetTableNode( pTableNd );
305  rNds.Copy_( aRg, aInsPos, false );
306  pTableNd->GetTable().SetTableNode( nullptr );
307 
308  // Special case for a single box
309  if( 1 == GetTable().GetTabSortBoxes().size() )
310  {
311  aRg.aStart.Assign( *pTableNd, 1 );
312  aRg.aEnd.Assign( *pTableNd->EndOfSectionNode() );
313  pDoc->GetNodes().SectionDown( &aRg, SwTableBoxStartNode );
314  }
315 
316  // Delete all frames from the copied area, they will be created
317  // during the generation of the table frame
318  pTableNd->DelFrames();
319 
320  MapTableFrameFormats aMapArr;
321  CopyTable aPara( pDoc, aMapArr, GetIndex(), *pTableNd, &GetTable() );
322 
323  for( const SwTableLine* pLine : GetTable().GetTabLines() )
324  lcl_CopyTableLine( pLine, &aPara );
325 
326  if( pDDEType )
327  pDDEType->IncRefCnt();
328 
329  CHECK_TABLE( GetTable() );
330  return pTableNd;
331 }
332 
334 {
335  // Copy the formats into the other document:
336  // Special case for PageBreak/PageDesc/ColBrk
337  SwDoc* pDestDoc = rDestNd.GetDoc();
338  SwAttrSet aPgBrkSet( pDestDoc->GetAttrPool(), aBreakSetRange );
339  const SwAttrSet* pSet;
340 
341  if( nullptr != ( pSet = rDestNd.GetpSwAttrSet() ) )
342  {
343  // Special cases for Break-Attributes
344  const SfxPoolItem* pAttr;
345  if( SfxItemState::SET == pSet->GetItemState( RES_BREAK, false, &pAttr ) )
346  aPgBrkSet.Put( *pAttr );
347 
348  if( SfxItemState::SET == pSet->GetItemState( RES_PAGEDESC, false, &pAttr ) )
349  aPgBrkSet.Put( *pAttr );
350  }
351 
352  rDestNd.ChgFormatColl( pDestDoc->CopyTextColl( *GetTextColl() ));
353  if( nullptr != ( pSet = GetpSwAttrSet() ) )
354  pSet->CopyToModify( rDestNd );
355 
356  if( aPgBrkSet.Count() )
357  rDestNd.SetAttr( aPgBrkSet );
358 }
359 
360 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
SwTableFormat * MakeTableFrameFormat(const OUString &rFormatName, SwFrameFormat *pDerivedFrom)
Definition: docfmt.cxx:792
const SwEndNode * EndOfSectionNode() const
Definition: node.hxx:682
SwNode & GetEndOfInserts() const
Section for all footnotes.
Definition: ndarr.hxx:154
sal_uLong GetIndex() const
Definition: node.hxx:282
void SetRowsToRepeat(sal_uInt16 nNumOfRows)
Definition: swtable.hxx:194
Represents the style of a paragraph.
Definition: fmtcol.hxx:55
void RegisterToFormat(SwFormat &rFormat)
Definition: swtable.cxx:2742
void RegisterAsCopyOf(Metadatable const &i_rSource, const bool i_bCopyPrecedesSource=false)
#define RES_CONDTXTFMTCOLL
Definition: hintids.hxx:373
sal_uLong StartOfSectionIndex() const
Definition: node.hxx:673
void DelFrames(SwRootFrame const *pLayout=nullptr)
Method deletes all views of document for the node.
Definition: ndtbl.cxx:2414
const OUString & GetText() const
Definition: ndtxt.hxx:210
sal_uLong GetSttIdx() const
Definition: swtable.cxx:1879
virtual sal_uInt16 ResetAllAttr() override
Definition: ndtxt.cxx:5141
virtual bool SetAttr(const SfxPoolItem &) override
overriding to handle change of certain paragraph attributes
Definition: ndtxt.cxx:4883
std::string GetValue
const SwFrameFormats * GetTableFrameFormats() const
Definition: doc.hxx:810
sal_uIntPtr sal_uLong
SwTableNode * MakeCopy(SwDoc *, const SwNodeIndex &) const
Definition: ndcopy.cxx:242
OUString GetUniqueTableName() const
Definition: ndtbl.cxx:3872
bool IsDeleted() const
Definition: ddefld.hxx:86
sal_Int64 n
Definition: doc.hxx:186
SwTableLine is one table row in the document model.
Definition: swtable.hxx:344
SwNode & GetNode() const
Definition: ndindex.hxx:119
bool IsInHeadline(const SwTable *pTable) const
Definition: swtable.cxx:1863
void CheckSectionCondColl() const
Call ChkCondcoll to all ContentNodes of section.
Definition: node.cxx:927
void Copy_(const SwNodeRange &rRg, const SwNodeIndex &rInsPos, bool bNewFrames=true) const
Definition: ndarr.hxx:176
bool IsInsOnlyTextGlossary() const
Definition: doc.hxx:652
static bool lcl_SrchNew(const MapTableFrameFormat &rMap, SwFrameFormat **pPara)
Definition: ndcopy.cxx:116
size_type size() const
Definition: swtable.hxx:74
SwDoc * m_pDoc
Definition: docbm.cxx:1190
IDocumentFieldsAccess const & getIDocumentFieldsAccess() const
Definition: doc.cxx:356
SwNodeIndex aStart
Definition: ndindex.hxx:132
void SetTableModel(bool bNew)
Definition: swtable.hxx:184
#define CHECK_TABLE(t)
Definition: ndcopy.cxx:36
SwTextFormatColl * CopyTextColl(const SwTextFormatColl &rColl)
copy TextNodes
Definition: docfmt.cxx:1157
const SwTable & GetTable() const
Definition: node.hxx:497
void SetTableNode(SwTableNode *pNode)
Definition: swtable.hxx:318
void CopyText(SwTextNode *const pDest, const SwIndex &rStart, const sal_Int32 nLen, const bool bForceCopyOfAllAttrs)
Actions on text and attributes.
Definition: ndtxt.cxx:1987
void PtrToBoxNm(const SwTable *pTable)
create from the internal formula (for CORE) the external formula (for UI)
Definition: cellfml.cxx:543
Specific frame formats (frames, DrawObjects).
Definition: docary.hxx:201
const SwAttrSet * GetpSwAttrSet() const
Definition: node.hxx:443
sal_uInt16 ClearItem(sal_uInt16 nWhich=0)
Style of a layout element.
Definition: frmfmt.hxx:57
void SectionDown(SwNodeRange *pRange, SwStartNodeType=SwNormalStartNode)
create a start/end section pair
Definition: nodes.cxx:892
virtual SwContentNode * MakeCopy(SwDoc *, const SwNodeIndex &, bool bNewFrames) const override
Definition: ndcopy.cxx:58
static void lcl_CopyTableLine(const SwTableLine *pLine, CopyTable *pCT)
Definition: ndcopy.cxx:212
SAL_DLLPRIVATE void CopyAttr(SwTextNode *pDest, const sal_Int32 nStart, const sal_Int32 nOldPos)
Copies the attributes at nStart to pDest.
Definition: ndtxt.cxx:1927
SwDoc * GetDoc()
Definition: node.hxx:702
virtual SwFormatColl * ChgFormatColl(SwFormatColl *) override
Definition: ndtxt.cxx:3920
virtual void InsDeletedFieldType(SwFieldType &)=0
SwFrameFormat * GetFrameFormat()
Definition: swtable.hxx:366
size
SfxItemState GetItemState(sal_uInt16 nWhich, bool bSrchInParent=true, const SfxPoolItem **ppItem=nullptr) const
Definition: format.cxx:396
Marks a node in the document model.
Definition: ndindex.hxx:31
SwFrameFormat * GetFrameFormat()
Definition: swtable.hxx:425
SwNodes & GetNodes()
Node is in which nodes-array/doc?
Definition: node.hxx:693
bool HasSwAttrSet() const
Definition: node.hxx:444
SwTableNode(const SwNodeIndex &)
Definition: ndtbl.cxx:2316
bool HasMergeFormatTable() const
SwTable is one table in the document model, containing rows (which contain cells).
Definition: swtable.hxx:110
SwTableLines & GetTabLines()
Definition: swtable.hxx:418
const SwFrameFormat * GetDfltFrameFormat() const
Definition: doc.hxx:743
virtual bool SetFormatAttr(const SfxPoolItem &rAttr)
Definition: format.cxx:458
sal_uInt16 Which() const
for Querying of Writer-functions.
Definition: format.hxx:78
void SetTableChgMode(TableChgMode eMode)
Definition: swtable.hxx:329
void CopyCollFormat(SwTextNode &rDestNd)
Copy collection with all auto formats to dest-node.
Definition: ndcopy.cxx:333
SwTextNode is a paragraph in the document model.
Definition: ndtxt.hxx:79
SwTableBoxes & GetTabBoxes()
Definition: swtable.hxx:354
friend class SwIndex
Definition: index.hxx:112
const SwStartNode * GetSttNd() const
Definition: swtable.hxx:439
std::vector< MapTableFrameFormat > MapTableFrameFormats
Definition: ndcopy.cxx:56
long getRowSpan() const
Definition: swtable.cxx:101
void CopyAttrs(const SwFormat &)
Copy attributes even among documents.
Definition: format.cxx:178
void ChkCondColl()
Definition: node.cxx:1946
sal_uInt32 GetMergeFormatIndex(sal_uInt32 nOldFmt) const
virtual SwFieldType * InsertFieldType(const SwFieldType &)=0
bool IsCopyIsMove() const
Definition: doc.hxx:1368
friend class SwEndNode
to set the theEndOfSection !!
Definition: node.hxx:307
SwNodes & GetNodes()
Definition: doc.hxx:404
SwNodeIndex aEnd
Definition: ndindex.hxx:133
SwTableBox is one table cell in the document model.
Definition: swtable.hxx:386
static void lcl_CopyTableBox(SwTableBox *pBox, CopyTable *pCT)
Definition: ndcopy.cxx:147
size_t size() const
Definition: docary.hxx:225
Ends a section of nodes in the document model.
Definition: node.hxx:333
void SetNewTable(std::unique_ptr< SwTable >, bool bNewFrames=true)
Definition: ndtbl.cxx:2454
#define RES_PAGEDESC
Definition: hintids.hxx:293
#define RES_BREAK
Definition: hintids.hxx:294
sal_uInt16 const aBreakSetRange[]
Definition: init.cxx:142
bool IsTextNode() const
Definition: node.hxx:636
void IncRefCnt()
Definition: ddefld.hxx:98
#define RES_BOXATR_FORMAT
Definition: hintids.hxx:356
SwTextFormatColl & GetNextTextFormatColl() const
Definition: fmtcol.hxx:97
const SwAttrPool & GetAttrPool() const
Definition: doc.hxx:1315
SwTextNode * GetTextNode()
Inline methods from Node.hxx.
Definition: ndtxt.hxx:842
SwTextNode * MakeTextNode(const SwNodeIndex &rWhere, SwTextFormatColl *pColl, bool bNewFrames=true)
Implementations of "Make...Node" are in the given .cxx-files.
Definition: ndtxt.cxx:103
#define RES_BOXATR_FORMULA
Definition: hintids.hxx:357
SwNodeIndex & Assign(SwNodes const &rNds, sal_uLong)
Definition: ndindex.hxx:272
SwTextFormatColl * GetTextColl() const
Definition: ndtxt.hxx:836