1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
|
/*************************************************************************
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright 2000, 2010 Oracle and/or its affiliates.
*
* OpenOffice.org - a multi-platform office productivity suite
*
* This file is part of OpenOffice.org.
*
* OpenOffice.org is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 3
* only, as published by the Free Software Foundation.
*
* OpenOffice.org is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License version 3 for more details
* (a copy is included in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU Lesser General Public License
* version 3 along with OpenOffice.org. If not, see
* <http://www.openoffice.org/license.html>
* for a copy of the LGPLv3 License.
*
************************************************************************/
#ifndef _NDARR_HXX
#define _NDARR_HXX
#include <com/sun/star/embed/XEmbeddedObject.hpp>
#include <svtools/svarray.hxx>
#ifndef _BPARR_HXX
#include <bparr.hxx>
#endif
#include <ndtyp.hxx>
#include <svtools/embedhlp.hxx>
#include <vector>
class Graphic;
class GraphicObject;
class String;
class SwAttrSet;
class SfxItemSet;
class SwCntntNode;
class SwDoc;
class SwGrfFmtColl;
class SwGrfNode;
class SwHistory;
class SwNode;
class SwNodeIndex;
class SwNodeRange;
class SwOLENode;
class SwOutlineNodes;
class SwPaM;
class SwSection;
class SwSectionFmt;
class SwSectionNode;
class SwStartNode;
class SwTableBoxFmt;
class SwTableFmt;
class SwTableLine;
class SwTableLineFmt;
class SwTableNode;
class SwTblToTxtSaves;
class SwTxtFmtColl;
class SwTxtNode;
class SwUndoTblToTxt;
class SwUndoTxtToTbl;
struct SwPosition;
// --------------------
// class SwNodes
// --------------------
typedef SwNode * SwNodePtr;
typedef BOOL (*FnForEach_SwNodes)( const SwNodePtr&, void* pArgs );
SV_DECL_PTRARR_SORT( SwOutlineNodes, SwNodePtr, 0, 10 )
class SW_DLLPUBLIC SwNodes: private BigPtrArray
{
friend class SwDoc;
friend class SwNode;
friend class SwNodeIndex;
SwNodeIndex* pRoot; // Liste aller Indizies auf Nodes
// --> OD 2008-05-14 #refactorlists# - removed <bSyncNumberAndNumRule>
void InsertNode( const SwNodePtr pNode,
const SwNodeIndex& rPos );
void InsertNode( const SwNodePtr pNode,
ULONG nPos );
// <--
SwDoc* pMyDoc; // in diesem Doc ist das Nodes-Array
SwNode *pEndOfPostIts, *pEndOfInserts, // das sind die festen Bereiche
*pEndOfAutotext, *pEndOfRedlines,
*pEndOfContent;
mutable SwOutlineNodes* pOutlineNds; // Array aller GliederiungsNodes
BOOL bInNodesDel : 1; // falls rekursiv aufgerufen wird
// Num/Outline nicht aktualisierem
BOOL bInDelUpdOutl : 1; // Flags fuers aktualisieren von Outl.
BOOL bInDelUpdNum : 1; // Flags fuers aktualisieren von Outl.
// fuer dier Verwaltung der Indizies
void RegisterIndex( SwNodeIndex& rIdx );
void DeRegisterIndex( SwNodeIndex& rIdx );
void RemoveNode( ULONG nDelPos, ULONG nLen, BOOL bDel );
// Aktionen auf die Nodes
void SectionUpDown( const SwNodeIndex & aStart, const SwNodeIndex & aEnd );
void DelNodes( const SwNodeIndex& rStart, ULONG nCnt = 1 );
void ChgNode( SwNodeIndex& rDelPos, ULONG nSize,
SwNodeIndex& rInsPos, BOOL bNewFrms );
void UpdtOutlineIdx( const SwNode& ); // Update ab Node alle OutlineNodes
void _CopyNodes( const SwNodeRange&, const SwNodeIndex&,
BOOL bNewFrms = TRUE, BOOL bTblInsDummyNode = FALSE ) const;
void _DelDummyNodes( const SwNodeRange& rRg );
protected:
SwNodes( SwDoc* pDoc );
public:
~SwNodes();
SwNodePtr operator[]( ULONG n ) const
{ return (SwNodePtr)BigPtrArray::operator[] ( n ); }
//JP 29.09.97: impl. steht im ndindex.hxx - sollte moeglichst bald auf die
// neue Schnittstelle angepasst werden
inline SwNodePtr operator[]( const SwNodeIndex& rIdx ) const;
ULONG Count() const { return BigPtrArray::Count(); }
void ForEach( FnForEach_SwNodes fnForEach, void* pArgs = 0 )
{
BigPtrArray::ForEach( 0, BigPtrArray::Count(),
(FnForEach) fnForEach, pArgs );
}
void ForEach( ULONG nStt, ULONG nEnd, FnForEach_SwNodes fnForEach, void* pArgs = 0 )
{
BigPtrArray::ForEach( nStt, nEnd, (FnForEach) fnForEach, pArgs );
}
void ForEach( const SwNodeIndex& rStart, const SwNodeIndex& rEnd,
FnForEach_SwNodes fnForEach, void* pArgs = 0 );
// eine noch leere Section
SwNode& GetEndOfPostIts() const { return *pEndOfPostIts; }
// Section fuer alle Fussnoten
SwNode& GetEndOfInserts() const { return *pEndOfInserts; }
// Section fuer alle Flys/Header/Footers
SwNode& GetEndOfAutotext() const { return *pEndOfAutotext; }
// Section fuer alle Redlines
SwNode& GetEndOfRedlines() const { return *pEndOfRedlines; }
// das ist der letzte EndNode einer SonderSection. Hier nach kommt nur
// noch die normale ContentSection (also der BodyText)
SwNode& GetEndOfExtras() const { return *pEndOfRedlines; }
// die normale ContentSection (also der BodyText)
SwNode& GetEndOfContent() const { return *pEndOfContent; }
// ist das NodesArray das normale vom Doc? (nicht das UndoNds, .. )
// Implementierung steht im doc.hxx (weil man dazu Doc kennen muss) !
BOOL IsDocNodes() const;
USHORT GetSectionLevel(const SwNodeIndex &rIndex) const;
void Delete(const SwNodeIndex &rPos, ULONG nNodes = 1);
BOOL _MoveNodes( const SwNodeRange&, SwNodes& rNodes, const SwNodeIndex&,
BOOL bNewFrms = TRUE );
void MoveRange( SwPaM&, SwPosition&, SwNodes& rNodes );
void _Copy( const SwNodeRange& rRg, const SwNodeIndex& rInsPos,
BOOL bNewFrms = TRUE ) const
{ _CopyNodes( rRg, rInsPos, bNewFrms ); }
void SectionUp( SwNodeRange *);
void SectionDown( SwNodeRange *pRange, SwStartNodeType = SwNormalStartNode );
BOOL CheckNodesRange( const SwNodeIndex& rStt, const SwNodeIndex& rEnd ) const;
void GoStartOfSection(SwNodeIndex *) const;
void GoEndOfSection(SwNodeIndex *) const;
SwCntntNode* GoNext(SwNodeIndex *) const;
SwCntntNode* GoPrevious(SwNodeIndex *) const;
//Gehe zum naechsten/vorherigen Cntnt/Tabellennode, fuer den
//es LayoutFrames gibt, dabei Kopf-/Fusszeilen/Rahmen etc. nicht verlassen
SwNode* GoNextWithFrm(SwNodeIndex *) const;
SwNode* GoPreviousWithFrm(SwNodeIndex *) const;
// zum naechsten Content-Node, der nicht geschuetzt oder versteckt ist
// (beides auf FALSE ==> GoNext/GoPrevious!!!)
SwCntntNode* GoNextSection( SwNodeIndex *, int bSkipHidden = TRUE,
int bSkipProtect = TRUE ) const;
SwCntntNode* GoPrevSection( SwNodeIndex *, int bSkipHidden = TRUE,
int bSkipProtect = TRUE ) const;
// erzeuge ein leere Section von Start und EndNode. Darf nur gerufen
// werden, wenn eine neue Section mit Inhalt erzeugt werden soll.
// Zum Beispiel bei den Filtern/Undo/...
SwStartNode* MakeEmptySection( const SwNodeIndex& rIdx,
SwStartNodeType = SwNormalStartNode );
// die Impl. von "Make...Node" stehen in den angegebenen .ccx-Files
SwTxtNode *MakeTxtNode( const SwNodeIndex & rWhere,
SwTxtFmtColl *pColl,
SwAttrSet* pAutoAttr = 0 ); // in ndtxt.cxx
SwStartNode* MakeTextSection( const SwNodeIndex & rWhere,
SwStartNodeType eSttNdTyp,
SwTxtFmtColl *pColl,
SwAttrSet* pAutoAttr = 0 );
SwGrfNode *MakeGrfNode( const SwNodeIndex & rWhere,
const String& rGrfName,
const String& rFltName,
const Graphic* pGraphic,
SwGrfFmtColl *pColl,
SwAttrSet* pAutoAttr = 0,
BOOL bDelayed = FALSE ); // in ndgrf.cxx
SwGrfNode *MakeGrfNode( const SwNodeIndex & rWhere,
const GraphicObject& rGrfObj,
SwGrfFmtColl *pColl,
SwAttrSet* pAutoAttr = 0 ); // in ndgrf.cxx
SwOLENode *MakeOLENode( const SwNodeIndex & rWhere,
const svt::EmbeddedObjectRef&,
SwGrfFmtColl *pColl,
SwAttrSet* pAutoAttr = 0 ); // in ndole.cxx
SwOLENode *MakeOLENode( const SwNodeIndex & rWhere,
const String &rName,
sal_Int64 nAspect,
SwGrfFmtColl *pColl,
SwAttrSet* pAutoAttr ); // in ndole.cxx
// Array aller GliederiungsNodes;
const SwOutlineNodes& GetOutLineNds() const;
//void UpdateOutlineNode( const SwNode&, BYTE nOldLevel, BYTE nNewLevel );//#outline level,removed by zhaojianwei
// alle Nodes Updaten - Rule/Format-Aenderung
void UpdateOutlineNode(SwNode & rNd);
// fuege die Nodes fuer die Tabelle ein
// wenn Lines angegeben, erzeuge die Matrix aus Lines & Boxen
// ansonsten nur die Anzahl von Boxen.
/* #109161#
New parameter pAttrSet: If pAttrSet is non-null and contains an
adjust item it is propagated to the table cells. If there is an
adjust in pCntntTxtColl or pHeadlineTxtColl this adjust item
overrides the item in pAttrSet.
*/
SwTableNode* InsertTable( const SwNodeIndex& rNdIdx,
USHORT nBoxes, SwTxtFmtColl* pCntntTxtColl,
USHORT nLines = 0, USHORT nRepeat = 0,
SwTxtFmtColl* pHeadlineTxtColl = 0,
const SwAttrSet * pAttrSet = 0);
// erzeuge aus dem makierten Bereich eine ausgeglichene Tabelle
SwTableNode* TextToTable( const SwNodeRange& rRange, sal_Unicode cCh,
SwTableFmt* pTblFmt,
SwTableLineFmt* pLineFmt,
SwTableBoxFmt* pBoxFmt,
SwTxtFmtColl* pTxtColl,
SwUndoTxtToTbl* pUndo = 0 );
//create a table from a vector of NodeRanges - API support
SwTableNode* TextToTable( const std::vector< std::vector<SwNodeRange> >& rTableNodes,
SwTableFmt* pTblFmt,
SwTableLineFmt* pLineFmt,
SwTableBoxFmt* pBoxFmt,
SwTxtFmtColl* pTxtColl
/*, SwUndo... pUndo*/ );
// erzeuge aus der Tabelle wieder normalen Text
BOOL TableToText( const SwNodeRange& rRange, sal_Unicode cCh,
SwUndoTblToTxt* = 0 );
// steht im untbl.cxx und darf nur vom Undoobject gerufen werden
SwTableNode* UndoTableToText( ULONG nStt, ULONG nEnd,
const SwTblToTxtSaves& rSavedData );
// fuege in der Line, vor der InsPos eine neue Box ein. Das Format
// wird von der nachfolgenden (vorhergenden;wenn an Ende) genommen
// in der Line muss schon eine Box vorhanden sein !
BOOL InsBoxen( SwTableNode*, SwTableLine*, SwTableBoxFmt*,
// Formate fuer den TextNode der Box
SwTxtFmtColl*, const SfxItemSet* pAutoAttr,
USHORT nInsPos, USHORT nCnt = 1 );
// Splittet eine Tabelle in der Grund-Zeile, in der der Index steht.
// Alle GrundZeilen dahinter wandern in eine neue Tabelle/-Node.
// Ist das Flag bCalcNewSize auf TRUE, wird fuer beide neuen Tabellen
// die neue SSize aus dem Max der Boxen errechnet; vorrausgesetzt,
// die SSize ist "absolut" gesetzt (LONG_MAX)
// (Wird zur Zeit nur fuer den RTF-Parser benoetigt)
SwTableNode* SplitTable( const SwNodeIndex& rPos, BOOL bAfter = TRUE,
BOOL bCalcNewSize = FALSE );
// fuegt 2 Tabellen, die hintereinander stehen, wieder zusammen
BOOL MergeTable( const SwNodeIndex& rPos, BOOL bWithPrev = TRUE,
USHORT nMode = 0, SwHistory* pHistory = 0 );
// fuege eine neue SwSection ein
SwSectionNode* InsertSection( const SwNodeIndex& rNdIdx,
SwSectionFmt& rSectionFmt,
const SwSection&,
const SwNodeIndex* pEnde,
BOOL bInsAtStart = TRUE,
BOOL bCreateFrms = TRUE );
// in welchem Doc steht das Nodes-Array ?
SwDoc* GetDoc() { return pMyDoc; }
const SwDoc* GetDoc() const { return pMyDoc; }
// suche den vorhergehenden [/nachfolgenden ] ContentNode oder
// TabellenNode mit Frames. Wird kein Ende angeben, dann wird mit
// dem FrameIndex begonnen; ansonsten, wird mit dem vor rFrmIdx und
// dem hintern pEnd die Suche gestartet. Sollte kein gueltiger Node
// gefunden werden, wird 0 returnt. rFrmIdx zeigt auf dem Node mit
// Frames
SwNode* FindPrvNxtFrmNode( SwNodeIndex& rFrmIdx,
const SwNode* pEnd = 0 ) const;
//-> #112139#
SwNode * DocumentSectionStartNode(SwNode * pNode) const;
SwNode * DocumentSectionEndNode(SwNode * pNode) const;
//<- #112139#
private:
// privater Constructor, weil nie kopiert werden darf !!
SwNodes( const SwNodes & rNodes );
};
#endif
|
