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
|
/* This file is part of the KDE libraries
Copyright (C) 2002 Joseph Wenninger <jowenn@kde.org>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License version 2 as published by the Free Software Foundation.
This library 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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#ifndef _KATE_CODEFOLDING_HELPERS_
#define _KATE_CODEFOLDING_HELPERS_
//BEGIN INCLUDES + FORWARDS
#include <tqptrlist.h>
#include <tqvaluelist.h>
#include <tqobject.h>
#include <tqintdict.h>
#include <tqmemarray.h>
class KateCodeFoldingTree;
class KateTextCursor;
class KateBuffer;
class TQString;
//END
class KateHiddenLineBlock
{
public:
unsigned int start;
unsigned int length;
};
class KateLineInfo
{
public:
bool topLevel;
bool startsVisibleBlock;
bool startsInVisibleBlock;
bool endsBlock;
bool invalidBlockEnd;
};
class KateCodeFoldingNode
{
friend class KateCodeFoldingTree;
public:
KateCodeFoldingNode ();
KateCodeFoldingNode (KateCodeFoldingNode *par, signed char typ, unsigned int sLRel);
~KateCodeFoldingNode ();
inline int nodeType () { return type;}
inline bool isVisible () {return visible;}
inline KateCodeFoldingNode *getParentNode () {return parentNode;}
bool getBegin (KateCodeFoldingTree *tree, KateTextCursor* begin);
bool getEnd (KateCodeFoldingTree *tree, KateTextCursor *end);
/**
* accessors for the child nodes
*/
protected:
inline bool noChildren () const { return m_children.isEmpty(); }
inline uint childCount () const { return m_children.size(); }
inline KateCodeFoldingNode *child (uint index) const { return m_children[index]; }
inline int findChild (KateCodeFoldingNode *node, uint start = 0) const { return m_children.tqfind (node, start); }
inline void appendChild (KateCodeFoldingNode *node) { m_children.resize(m_children.size()+1); m_children[m_children.size()-1] = node; }
void insertChild (uint index, KateCodeFoldingNode *node);
KateCodeFoldingNode *takeChild (uint index);
void clearChildren ();
int cmpPos(KateCodeFoldingTree *tree, uint line, uint col);
/**
* data members
*/
private:
KateCodeFoldingNode *parentNode;
unsigned int startLineRel;
unsigned int endLineRel;
unsigned int startCol;
unsigned int endCol;
bool startLineValid;
bool endLineValid;
signed char type; // 0 -> toplevel / invalid
bool visible;
bool deleteOpening;
bool deleteEnding;
TQMemArray<KateCodeFoldingNode*> m_children;
};
class KateCodeFoldingTree : public TQObject
{
friend class KateCodeFoldingNode;
Q_OBJECT
public:
KateCodeFoldingTree (KateBuffer *buffer);
~KateCodeFoldingTree ();
KateCodeFoldingNode *findNodeForLine (unsigned int line);
unsigned int getRealLine (unsigned int virtualLine);
unsigned int getVirtualLine (unsigned int realLine);
unsigned int getHiddenLinesCount (unsigned int docLine);
bool isTopLevel (unsigned int line);
void lineHasBeenInserted (unsigned int line);
void lineHasBeenRemoved (unsigned int line);
void debugDump ();
void getLineInfo (KateLineInfo *info,unsigned int line);
unsigned int getStartLine (KateCodeFoldingNode *node);
void fixRoot (int endLRel);
void clear ();
KateCodeFoldingNode *findNodeForPosition(unsigned int line, unsigned int column);
private:
KateCodeFoldingNode m_root;
KateBuffer *m_buffer;
TQIntDict<unsigned int> lineMapping;
TQIntDict<bool> dontIgnoreUnchangedLines;
TQPtrList<KateCodeFoldingNode> markedForDeleting;
TQPtrList<KateCodeFoldingNode> nodesForLine;
TQValueList<KateHiddenLineBlock> hiddenLines;
unsigned int hiddenLinesCountCache;
bool something_changed;
bool hiddenLinesCountCacheValid;
static bool trueVal;
KateCodeFoldingNode *findNodeForLineDescending (KateCodeFoldingNode *, unsigned int, unsigned int, bool oneStepOnly=false);
bool correctEndings (signed char data, KateCodeFoldingNode *node, unsigned int line, unsigned int endCol, int insertPos);
void dumpNode (KateCodeFoldingNode *node, const TQString &prefix);
void addOpening (KateCodeFoldingNode *node, signed char nType,TQMemArray<uint>* list, unsigned int line,unsigned int charPos);
void addOpening_further_iterations (KateCodeFoldingNode *node,signed char nType, TQMemArray<uint>*
list,unsigned int line,int current,unsigned int startLine,unsigned int charPos);
void incrementBy1 (KateCodeFoldingNode *node, KateCodeFoldingNode *after);
void decrementBy1 (KateCodeFoldingNode *node, KateCodeFoldingNode *after);
void cleanupUnneededNodes (unsigned int line);
/**
* if returns true, this node has been deleted !!
*/
bool removeEnding (KateCodeFoldingNode *node,unsigned int line);
/**
* if returns true, this node has been deleted !!
*/
bool removeOpening (KateCodeFoldingNode *node,unsigned int line);
void findAndMarkAllNodesforRemovalOpenedOrClosedAt (unsigned int line);
void findAllNodesOpenedOrClosedAt (unsigned int line);
void addNodeToFoundList (KateCodeFoldingNode *node,unsigned int line,int childpos);
void addNodeToRemoveList (KateCodeFoldingNode *node,unsigned int line);
void addHiddenLineBlock (KateCodeFoldingNode *node,unsigned int line);
bool existsOpeningAtLineAfter(unsigned int line, KateCodeFoldingNode *node);
void dontDeleteEnding (KateCodeFoldingNode*);
void dontDeleteOpening (KateCodeFoldingNode*);
void updateHiddenSubNodes (KateCodeFoldingNode *node);
void moveSubNodesUp (KateCodeFoldingNode *node);
public slots:
void updateLine (unsigned int line,TQMemArray<uint>* regionChanges, bool *updated, bool changed,bool colschanged);
void toggleRegionVisibility (unsigned int);
void collapseToplevelNodes ();
void expandToplevelNodes (int numLines);
int collapseOne (int realLine);
void expandOne (int realLine, int numLines);
/**
Ensures that all nodes surrounding @p line are open
*/
void ensureVisible( uint line );
signals:
void regionVisibilityChangedAt (unsigned int);
void regionBeginEndAddedRemoved (unsigned int);
};
#endif
// kate: space-indent on; indent-width 2; replace-tabs on;
|
