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 <frameformats.hxx>
32 #include <vector>
33 #include <osl/diagnose.h>
34 
35 
36 #ifdef DBG_UTIL
37 #define CHECK_TABLE(t) (t).CheckConsistency();
38 #else
39 #define CHECK_TABLE(t)
40 #endif
41 
42 namespace {
43 
44 // Structure for the mapping from old and new frame formats to the
45 // boxes and lines of a table
46 struct MapTableFrameFormat
47 {
48  const SwFrameFormat *pOld;
49  SwFrameFormat *pNew;
50  MapTableFrameFormat( const SwFrameFormat *pOldFormat, SwFrameFormat*pNewFormat )
51  : pOld( pOldFormat ), pNew( pNewFormat )
52  {}
53 };
54 
55 }
56 
57 typedef std::vector<MapTableFrameFormat> MapTableFrameFormats;
58 
59 SwContentNode* SwTextNode::MakeCopy(SwDoc* pDoc, const SwNodeIndex& rIdx, bool const bNewFrames) const
60 {
61  // the Copy-Textnode is the Node with the Text, the Copy-Attrnode is the
62  // node with the collection and hard attributes. Normally is the same
63  // node, but if insert a glossary without formatting, then the Attrnode
64  // is the prev node of the destination position in dest. document.
65  SwTextNode* pCpyTextNd = const_cast<SwTextNode*>(this);
66  SwTextNode* pCpyAttrNd = pCpyTextNd;
67 
68  // Copy the formats to the other document
69  SwTextFormatColl* pColl = nullptr;
70  if( pDoc->IsInsOnlyTextGlossary() )
71  {
72  SwNodeIndex aIdx( rIdx, -1 );
73  if( aIdx.GetNode().IsTextNode() )
74  {
75  pCpyAttrNd = aIdx.GetNode().GetTextNode();
76  pColl = &pCpyAttrNd->GetTextColl()->GetNextTextFormatColl();
77  }
78  }
79  if( !pColl )
80  pColl = pDoc->CopyTextColl( *GetTextColl() );
81 
82  SwTextNode* pTextNd = pDoc->GetNodes().MakeTextNode(rIdx, pColl, bNewFrames);
83 
84  // METADATA: register copy
85  pTextNd->RegisterAsCopyOf(*pCpyTextNd);
86 
87  // Copy Attribute/Text
88  if( !pCpyAttrNd->HasSwAttrSet() )
89  // An AttrSet was added for numbering, so delete it
90  pTextNd->ResetAllAttr();
91 
92  // if Copy-Textnode unequal to Copy-Attrnode, then copy first
93  // the attributes into the new Node.
94  if( pCpyAttrNd != pCpyTextNd )
95  {
96  pCpyAttrNd->CopyAttr( pTextNd, 0, 0 );
97  if( pCpyAttrNd->HasSwAttrSet() )
98  {
99  SwAttrSet aSet( *pCpyAttrNd->GetpSwAttrSet() );
100  aSet.ClearItem( RES_PAGEDESC );
101  aSet.ClearItem( RES_BREAK );
102  aSet.CopyToModify( *pTextNd );
103  }
104  }
105 
106  // Is that enough? What about PostIts/Fields/FieldTypes?
107  // #i96213# - force copy of all attributes
108  pCpyTextNd->CopyText( pTextNd, SwIndex( pCpyTextNd ),
109  pCpyTextNd->GetText().getLength(), true );
110 
111  if( RES_CONDTXTFMTCOLL == pColl->Which() )
112  pTextNd->ChkCondColl();
113 
114  return pTextNd;
115 }
116 
117 static bool lcl_SrchNew( const MapTableFrameFormat& rMap, SwFrameFormat** pPara )
118 {
119  if( rMap.pOld != *pPara )
120  return true;
121  *pPara = rMap.pNew;
122  return false;
123 }
124 
125 namespace {
126 
127 struct CopyTable
128 {
129  SwDoc* m_pDoc;
130  sal_uLong m_nOldTableSttIdx;
131  MapTableFrameFormats& m_rMapArr;
132  SwTableLine* m_pInsLine;
133  SwTableBox* m_pInsBox;
134  SwTableNode *m_pTableNd;
135  const SwTable *m_pOldTable;
136 
137  CopyTable(SwDoc* pDc, MapTableFrameFormats& rArr, sal_uLong nOldStt,
138  SwTableNode& rTableNd, const SwTable* pOldTable)
139  : m_pDoc(pDc), m_nOldTableSttIdx(nOldStt), m_rMapArr(rArr),
140  m_pInsLine(nullptr), m_pInsBox(nullptr), m_pTableNd(&rTableNd), m_pOldTable(pOldTable)
141  {}
142 };
143 
144 }
145 
146 static void lcl_CopyTableLine( const SwTableLine* pLine, CopyTable* pCT );
147 
148 static void lcl_CopyTableBox( SwTableBox* pBox, CopyTable* pCT )
149 {
150  SwTableBoxFormat * pBoxFormat = static_cast<SwTableBoxFormat*>(pBox->GetFrameFormat());
151  for (const auto& rMap : pCT->m_rMapArr)
152  if ( !lcl_SrchNew( rMap, reinterpret_cast<SwFrameFormat**>(&pBoxFormat) ) )
153  break;
154 
155  if (pBoxFormat == pBox->GetFrameFormat()) // Create a new one?
156  {
157  const SfxPoolItem* pItem;
158  if( SfxItemState::SET == pBoxFormat->GetItemState( RES_BOXATR_FORMULA, false,
159  &pItem ) && static_cast<const SwTableBoxFormula*>(pItem)->IsIntrnlName() )
160  {
161  const_cast<SwTableBoxFormula*>(static_cast<const SwTableBoxFormula*>(pItem))->PtrToBoxNm(pCT->m_pOldTable);
162  }
163 
164  pBoxFormat = pCT->m_pDoc->MakeTableBoxFormat();
165  pBoxFormat->CopyAttrs( *pBox->GetFrameFormat() );
166 
167  if( pBox->GetSttIdx() )
168  {
169  SvNumberFormatter* pN = pCT->m_pDoc->GetNumberFormatter(false);
170  if( pN && pN->HasMergeFormatTable() && SfxItemState::SET == pBoxFormat->
171  GetItemState( RES_BOXATR_FORMAT, false, &pItem ) )
172  {
173  sal_uLong nOldIdx = static_cast<const SwTableBoxNumFormat*>(pItem)->GetValue();
174  sal_uLong nNewIdx = pN->GetMergeFormatIndex( nOldIdx );
175  if( nNewIdx != nOldIdx )
176  pBoxFormat->SetFormatAttr( SwTableBoxNumFormat( nNewIdx ));
177 
178  }
179  }
180 
181  pCT->m_rMapArr.emplace_back(pBox->GetFrameFormat(), pBoxFormat);
182  }
183 
184  sal_uInt16 nLines = pBox->GetTabLines().size();
185  SwTableBox* pNewBox;
186  if( nLines )
187  pNewBox = new SwTableBox(pBoxFormat, nLines, pCT->m_pInsLine);
188  else
189  {
190  SwNodeIndex aNewIdx(*pCT->m_pTableNd, pBox->GetSttIdx() - pCT->m_nOldTableSttIdx);
191  assert(aNewIdx.GetNode().IsStartNode() && "Index is not on the start node");
192 
193  pNewBox = new SwTableBox(pBoxFormat, aNewIdx, pCT->m_pInsLine);
194  pNewBox->setRowSpan( pBox->getRowSpan() );
195  }
196 
197  pCT->m_pInsLine->GetTabBoxes().push_back( pNewBox );
198 
199  if (nLines)
200  {
201  CopyTable aPara(*pCT);
202  aPara.m_pInsBox = pNewBox;
203  for( const SwTableLine* pLine : pBox->GetTabLines() )
204  lcl_CopyTableLine( pLine, &aPara );
205  }
206  else if (pNewBox->IsInHeadline(&pCT->m_pTableNd->GetTable()))
207  {
208  // In the headline, the paragraphs must match conditional styles
209  pNewBox->GetSttNd()->CheckSectionCondColl();
210  }
211 }
212 
213 static void lcl_CopyTableLine( const SwTableLine* pLine, CopyTable* pCT )
214 {
215  SwTableLineFormat * pLineFormat = static_cast<SwTableLineFormat*>(pLine->GetFrameFormat());
216  for (const auto& rMap : pCT->m_rMapArr)
217  if ( !lcl_SrchNew( rMap, reinterpret_cast<SwFrameFormat**>(&pLineFormat) ) )
218  break;
219 
220  if( pLineFormat == pLine->GetFrameFormat() ) // Create a new one?
221  {
222  pLineFormat = pCT->m_pDoc->MakeTableLineFormat();
223  pLineFormat->CopyAttrs( *pLine->GetFrameFormat() );
224  pCT->m_rMapArr.emplace_back(pLine->GetFrameFormat(), pLineFormat);
225  }
226 
227  SwTableLine* pNewLine = new SwTableLine(pLineFormat, pLine->GetTabBoxes().size(), pCT->m_pInsBox);
228  // Insert the new row into the table
229  if (pCT->m_pInsBox)
230  {
231  pCT->m_pInsBox->GetTabLines().push_back(pNewLine);
232  }
233  else
234  {
235  pCT->m_pTableNd->GetTable().GetTabLines().push_back(pNewLine);
236  }
237 
238  pCT->m_pInsLine = pNewLine;
239  for( auto& rpBox : const_cast<SwTableLine*>(pLine)->GetTabBoxes() )
240  lcl_CopyTableBox(rpBox, pCT);
241 }
242 
244 {
245  // In which array are we? Nodes? UndoNodes?
246  SwNodes& rNds = const_cast<SwNodes&>(GetNodes());
247 
248  {
249  if( rIdx < pDoc->GetNodes().GetEndOfInserts().GetIndex() &&
250  rIdx >= pDoc->GetNodes().GetEndOfInserts().StartOfSectionIndex() )
251  return nullptr;
252  }
253 
254  // Copy the TableFrameFormat
255  OUString sTableName( GetTable().GetFrameFormat()->GetName() );
256  if( !pDoc->IsCopyIsMove() )
257  {
258  const SwFrameFormats& rTableFormats = *pDoc->GetTableFrameFormats();
259  for( size_t n = rTableFormats.size(); n; )
260  if( rTableFormats[ --n ]->GetName() == sTableName )
261  {
262  sTableName = pDoc->GetUniqueTableName();
263  break;
264  }
265  }
266 
267  SwFrameFormat* pTableFormat = pDoc->MakeTableFrameFormat( sTableName, pDoc->GetDfltFrameFormat() );
268  pTableFormat->CopyAttrs( *GetTable().GetFrameFormat() );
269  SwTableNode* pTableNd = new SwTableNode( rIdx );
270  SwEndNode* pEndNd = new SwEndNode( rIdx, *pTableNd );
271  SwNodeIndex aInsPos( *pEndNd );
272 
273  SwTable& rTable = pTableNd->GetTable();
274  rTable.RegisterToFormat( *pTableFormat );
275 
276  rTable.SetRowsToRepeat( GetTable().GetRowsToRepeat() );
277  rTable.SetTableChgMode( GetTable().GetTableChgMode() );
278  rTable.SetTableModel( GetTable().IsNewModel() );
279 
280  SwDDEFieldType* pDDEType = nullptr;
281  if( auto pSwDDETable = dynamic_cast<const SwDDETable*>( &GetTable() ) )
282  {
283  // We're copying a DDE table
284  // Is the field type available in the new document?
285  pDDEType = const_cast<SwDDETable*>(pSwDDETable)->GetDDEFieldType();
286  if( pDDEType->IsDeleted() )
287  pDoc->getIDocumentFieldsAccess().InsDeletedFieldType( *pDDEType );
288  else
289  pDDEType = static_cast<SwDDEFieldType*>(pDoc->getIDocumentFieldsAccess().InsertFieldType( *pDDEType ));
290  OSL_ENSURE( pDDEType, "unknown FieldType" );
291 
292  // Swap the table pointers in the node
293  std::unique_ptr<SwDDETable> pNewTable(new SwDDETable( pTableNd->GetTable(), pDDEType ));
294  pTableNd->SetNewTable( std::move(pNewTable), false );
295  }
296  // First copy the content of the tables, we will later assign the
297  // boxes/lines and create the frames
298  SwNodeRange aRg( *this, +1, *EndOfSectionNode() );
299 
300  // If there is a table in this table, the table format for the outer table
301  // does not seem to be used, because the table does not have any contents yet
302  // (see IsUsed). Therefore the inner table gets the same name as the outer table.
303  // We have to make sure that the table node of the SwTable is accessible, even
304  // without any content in m_TabSortContentBoxes. #i26629#
305  pTableNd->GetTable().SetTableNode( pTableNd );
306  rNds.Copy_( aRg, aInsPos, false );
307  pTableNd->GetTable().SetTableNode( nullptr );
308 
309  // Special case for a single box
310  if( 1 == GetTable().GetTabSortBoxes().size() )
311  {
312  aRg.aStart.Assign( *pTableNd, 1 );
313  aRg.aEnd.Assign( *pTableNd->EndOfSectionNode() );
314  pDoc->GetNodes().SectionDown( &aRg, SwTableBoxStartNode );
315  }
316 
317  // Delete all frames from the copied area, they will be created
318  // during the generation of the table frame
319  pTableNd->DelFrames();
320 
321  MapTableFrameFormats aMapArr;
322  CopyTable aPara( pDoc, aMapArr, GetIndex(), *pTableNd, &GetTable() );
323 
324  for( const SwTableLine* pLine : GetTable().GetTabLines() )
325  lcl_CopyTableLine( pLine, &aPara );
326 
327  if( pDDEType )
328  pDDEType->IncRefCnt();
329 
330  CHECK_TABLE( GetTable() );
331  return pTableNd;
332 }
333 
335 {
336  // Copy the formats into the other document:
337  // Special case for PageBreak/PageDesc/ColBrk
338  SwDoc* pDestDoc = rDestNd.GetDoc();
339  SwAttrSet aPgBrkSet( pDestDoc->GetAttrPool(), aBreakSetRange );
340  const SwAttrSet* pSet;
341 
342  if( nullptr != ( pSet = rDestNd.GetpSwAttrSet() ) )
343  {
344  // Special cases for Break-Attributes
345  const SfxPoolItem* pAttr;
346  if( SfxItemState::SET == pSet->GetItemState( RES_BREAK, false, &pAttr ) )
347  aPgBrkSet.Put( *pAttr );
348 
349  if( SfxItemState::SET == pSet->GetItemState( RES_PAGEDESC, false, &pAttr ) )
350  aPgBrkSet.Put( *pAttr );
351  }
352 
353  rDestNd.ChgFormatColl( pDestDoc->CopyTextColl( *GetTextColl() ));
354  if( nullptr != ( pSet = GetpSwAttrSet() ) )
355  pSet->CopyToModify( rDestNd );
356 
357  if( aPgBrkSet.Count() )
358  rDestNd.SetAttr( aPgBrkSet );
359 }
360 
361 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
SwTableFormat * MakeTableFrameFormat(const OUString &rFormatName, SwFrameFormat *pDerivedFrom)
Definition: docfmt.cxx:799
const SwEndNode * EndOfSectionNode() const
Definition: node.hxx:682
constexpr TypedWhichId< SwFormatPageDesc > RES_PAGEDESC(93)
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)
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:2415
constexpr TypedWhichId< SwTableBoxNumFormat > RES_BOXATR_FORMAT(RES_BOXATR_BEGIN)
const OUString & GetText() const
Definition: ndtxt.hxx:211
sal_uLong GetSttIdx() const
Definition: swtable.cxx:1879
virtual sal_uInt16 ResetAllAttr() override
Definition: ndtxt.cxx:5142
virtual bool SetAttr(const SfxPoolItem &) override
overriding to handle change of certain paragraph attributes
Definition: ndtxt.cxx:4884
std::string GetValue
const SwFrameFormats * GetTableFrameFormats() const
Definition: doc.hxx:810
sal_uIntPtr sal_uLong
SwTableNode * MakeCopy(SwDoc *, const SwNodeIndex &) const
Definition: ndcopy.cxx:243
OUString GetUniqueTableName() const
Definition: ndtbl.cxx:3873
bool IsDeleted() const
Definition: ddefld.hxx:86
sal_Int64 n
Definition: doc.hxx:186
constexpr TypedWhichId< SvxFormatBreakItem > RES_BREAK(94)
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:928
void Copy_(const SwNodeRange &rRg, const SwNodeIndex &rInsPos, bool bNewFrames=true) const
Definition: ndarr.hxx:176
bool IsInsOnlyTextGlossary() const
Definition: doc.hxx:653
static bool lcl_SrchNew(const MapTableFrameFormat &rMap, SwFrameFormat **pPara)
Definition: ndcopy.cxx:117
size_type size() const
Definition: swtable.hxx:74
SwDoc * m_pDoc
Definition: docbm.cxx:1192
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:37
SwTextFormatColl * CopyTextColl(const SwTextFormatColl &rColl)
copy TextNodes
Definition: docfmt.cxx:1164
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:1988
void PtrToBoxNm(const SwTable *pTable)
create from the internal formula (for CORE) the external formula (for UI)
Definition: cellfml.cxx:544
Specific frame formats (frames, DrawObjects).
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:59
static void lcl_CopyTableLine(const SwTableLine *pLine, CopyTable *pCT)
Definition: ndcopy.cxx:213
SAL_DLLPRIVATE void CopyAttr(SwTextNode *pDest, const sal_Int32 nStart, const sal_Int32 nOldPos)
Copies the attributes at nStart to pDest.
Definition: ndtxt.cxx:1928
SwDoc * GetDoc()
Definition: node.hxx:702
virtual SwFormatColl * ChgFormatColl(SwFormatColl *) override
Definition: ndtxt.cxx:3921
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:2317
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:744
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:334
SwTextNode is a paragraph in the document model.
Definition: ndtxt.hxx:80
SwTableBoxes & GetTabBoxes()
Definition: swtable.hxx:354
friend class SwIndex
Definition: index.hxx:112
constexpr TypedWhichId< SwTableBoxFormula > RES_BOXATR_FORMULA(149)
const SwStartNode * GetSttNd() const
Definition: swtable.hxx:439
std::vector< MapTableFrameFormat > MapTableFrameFormats
Definition: ndcopy.cxx:57
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:1960
sal_uInt32 GetMergeFormatIndex(sal_uInt32 nOldFmt) const
virtual SwFieldType * InsertFieldType(const SwFieldType &)=0
bool IsCopyIsMove() const
Definition: doc.hxx:1370
friend class SwEndNode
to set the theEndOfSection !!
Definition: node.hxx:307
SwNodes & GetNodes()
Definition: doc.hxx:405
SwNodeIndex aEnd
Definition: ndindex.hxx:133
SwTableBox is one table cell in the document model.
Definition: swtable.hxx:386
constexpr TypedWhichId< SwConditionTextFormatColl > RES_CONDTXTFMTCOLL(158)
static void lcl_CopyTableBox(SwTableBox *pBox, CopyTable *pCT)
Definition: ndcopy.cxx:148
size_t size() const
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:2455
sal_uInt16 const aBreakSetRange[]
Definition: init.cxx:142
bool IsTextNode() const
Definition: node.hxx:636
void IncRefCnt()
Definition: ddefld.hxx:98
SwTextFormatColl & GetNextTextFormatColl() const
Definition: fmtcol.hxx:97
const SwAttrPool & GetAttrPool() const
Definition: doc.hxx:1317
SwTextNode * GetTextNode()
Inline methods from Node.hxx.
Definition: ndtxt.hxx:836
SwTextNode * MakeTextNode(const SwNodeIndex &rWhere, SwTextFormatColl *pColl, bool bNewFrames=true)
Implementations of "Make...Node" are in the given .cxx-files.
Definition: ndtxt.cxx:104
SwNodeIndex & Assign(SwNodes const &rNds, sal_uLong)
Definition: ndindex.hxx:272
SwTextFormatColl * GetTextColl() const
Definition: ndtxt.hxx:830