CodeEditorTagIdentation.diff
CodeEditor.h (kopia robocza) | ||
---|---|---|
141 | 141 |
virtual ~EditorBar(); |
142 | 142 |
}; |
143 | 143 | |
144 |
class Ident { |
|
145 |
public: |
|
146 |
enum Type { |
|
147 |
Tab = 0, |
|
148 |
Space, |
|
149 |
Unknown |
|
150 |
}; |
|
151 | ||
152 |
public: |
|
153 |
static Type FindType(CodeEditor& editor); |
|
154 |
static Type FindType(const WString& line); |
|
155 |
static Type FindType(const WString& line, CodeEditor& editor); |
|
156 |
static int FindSize(const WString& line, Ident::Type type); |
|
157 |
static int FindSpaceSize(CodeEditor& editor); |
|
158 |
|
|
159 |
static char GetChar(Ident::Type type); |
|
160 |
static String GetString(Ident::Type type, int identLevel = 1); |
|
161 |
|
|
162 |
private: |
|
163 |
Ident(); |
|
164 |
Ident(const Ident&); |
|
165 |
Ident& operator=(Ident&); |
|
166 |
~Ident(); |
|
167 |
}; |
|
168 | ||
144 | 169 |
struct IdentPos { |
145 | 170 |
int begin; |
146 | 171 |
int end; |
CodeEditor.upp (kopia robocza) | ||
---|---|---|
29 | 29 |
TagSyntax.h, |
30 | 30 |
TagSyntax.cpp, |
31 | 31 |
PythonSyntax readonly separator, |
32 |
PythonSyntax.h, |
|
32 | 33 |
PythonSyntax.cpp, |
33 |
PythonSyntax.h, |
|
34 | 34 |
LogSyntax readonly separator, |
35 | 35 |
LogSyntax.h, |
36 | 36 |
LogSyntax.cpp, |
... | ... | |
38 | 38 |
EditorBar.cpp, |
39 | 39 |
FindReplace.cpp, |
40 | 40 |
Lang.cpp, |
41 |
Indent.cpp, |
|
41 | 42 |
CodeEditor.cpp, |
42 | 43 |
CodeEditor.lay, |
43 | 44 |
CodeEditor.iml, |
44 | 45 |
CodeEditor.t, |
46 |
Indent readonly separator, |
|
47 |
Indent.h, |
|
45 | 48 |
Info readonly separator, |
46 | 49 |
Copying; |
47 | 50 |
PythonSyntax.cpp (kopia robocza) | ||
---|---|---|
70 | 70 |
{ |
71 | 71 |
if(chr == '\n') { |
72 | 72 |
while(count--) { |
73 |
WString cursorLine = editor.GetWLine(editor.GetCursorLine());
|
|
73 |
WString cline = editor.GetWLine(editor.GetCursorLine());
|
|
74 | 74 |
editor.InsertChar('\n', 1); |
75 | 75 |
|
76 |
Identation::Type idType = FindIdentationType(editor, cursorLine);
|
|
77 |
char idChar = GetIdentationByType(idType);
|
|
76 |
Ident::Type identType = Ident::FindType(cline, editor);
|
|
77 |
char identChar = Ident::GetChar(identType);
|
|
78 | 78 |
int mult = 1; |
79 |
if(idType == Identation::Space)
|
|
80 |
mult = CalculateSpaceIndetationSize(editor);
|
|
81 |
if(LineHasColon(cursorLine))
|
|
82 |
editor.InsertChar(idChar, mult); |
|
83 |
editor.InsertChar(idChar, CalculateLineIndetations(cursorLine, idType));
|
|
79 |
if(identType == Ident::Space)
|
|
80 |
mult = Ident::FindSpaceSize(editor);
|
|
81 |
if(LineHasColon(cline))
|
|
82 |
editor.InsertChar(identChar, mult);
|
|
83 |
editor.InsertChar(identChar, Ident::FindSize(cline, identType));
|
|
84 | 84 |
} |
85 | 85 |
} |
86 | 86 |
if(count > 0) |
... | ... | |
149 | 149 |
return false; |
150 | 150 |
} |
151 | 151 | |
152 |
int PythonSyntax::CalculateLineIndetations(const WString& line, Identation::Type type) |
|
153 |
{ |
|
154 |
int count = 0; |
|
155 |
for(int i = 0; i < line.GetLength(); i++) { |
|
156 |
if(type == Identation::Tab && line[i] == '\t') |
|
157 |
count++; |
|
158 |
else |
|
159 |
if(type == Identation::Space && line[i] == ' ') |
|
160 |
count++; |
|
161 |
else |
|
162 |
break; |
|
163 |
} |
|
164 |
return count; |
|
165 |
} |
|
166 | ||
167 |
PythonSyntax::Identation::Type PythonSyntax::FindIdentationType(CodeEditor& editor, const WString& line) |
|
168 |
{ |
|
169 |
Identation::Type type = Identation::None; |
|
170 |
if(line.StartsWith("\t")) |
|
171 |
type = Identation::Tab; |
|
172 |
else |
|
173 |
if(line.StartsWith(" ")) |
|
174 |
type = Identation::Space; |
|
175 |
else { |
|
176 |
for(int i = 0; i < editor.GetLineCount(); i++) { |
|
177 |
WString cLine = editor.GetWLine(i); |
|
178 |
if(cLine.StartsWith("\t")) { |
|
179 |
type = Identation::Tab; |
|
180 |
break; |
|
181 |
} |
|
182 |
else |
|
183 |
if(cLine.StartsWith(" ")) { |
|
184 |
type = Identation::Space; |
|
185 |
break; |
|
186 |
} |
|
187 |
} |
|
188 |
} |
|
189 |
return type; |
|
190 |
} |
|
191 | ||
192 |
int PythonSyntax::CalculateSpaceIndetationSize(CodeEditor& editor) |
|
193 |
{ |
|
194 |
int current = 0; |
|
195 |
for(int i = 0; i < editor.GetLineCount(); i++) { |
|
196 |
WString line = editor.GetWLine(i); |
|
197 |
for(int j = 0; j < line.GetLength(); j++) { |
|
198 |
if(line[j] == ' ') |
|
199 |
current++; |
|
200 |
else |
|
201 |
break; |
|
202 |
} |
|
203 |
|
|
204 |
if(current > 0) |
|
205 |
break; |
|
206 |
} |
|
207 |
|
|
208 |
// TODO: 4 is magic numer - try to find the way to get this number from ide constants |
|
209 |
return current > 0 ? current : 4; |
|
210 |
} |
|
211 | ||
212 |
char PythonSyntax::GetIdentationByType(Identation::Type type) |
|
213 |
{ |
|
214 |
if(type == Identation::Space) |
|
215 |
return ' '; |
|
216 |
return '\t'; |
|
217 |
} |
|
218 | ||
219 | 152 |
END_UPP_NAMESPACE |
PythonSyntax.h (kopia robocza) | ||
---|---|---|
26 | 26 |
void LoadSyntax(const char* keywordsArray[], const char* specialVarsArray[]); |
27 | 27 |
|
28 | 28 |
bool LineHasColon(const WString& line); |
29 |
int CalculateLineIndetations(const WString& line, Identation::Type type); |
|
30 |
int CalculateSpaceIndetationSize(CodeEditor& editor); |
|
31 |
Identation::Type FindIdentationType(CodeEditor& editor, const WString& line); |
|
32 |
char GetIdentationByType(Identation::Type type); |
|
33 | 29 |
|
34 | 30 |
private: |
35 | 31 |
Index<String> keywords; |
TagSyntax.cpp (kopia robocza) | ||
---|---|---|
8 | 8 |
hout = NULL; |
9 | 9 |
html = true; |
10 | 10 |
witz = false; |
11 |
|
|
12 |
InitSpecialTags(); |
|
11 | 13 |
} |
12 | 14 | |
13 | 15 |
void TagSyntax::Clear() |
... | ... | |
278 | 280 | |
279 | 281 |
void TagSyntax::IndentInsert(CodeEditor& editor, int chr, int count) |
280 | 282 |
{ |
281 |
if(status == SCRIPT) |
|
283 |
if(status == SCRIPT) {
|
|
282 | 284 |
script.IndentInsert(editor, chr, count); |
285 |
return; |
|
286 |
} |
|
287 |
|
|
288 |
if(chr == '\n') { |
|
289 |
while(count--) { |
|
290 |
WString line = editor.GetWLine(editor.GetCursorLine()); |
|
291 |
Ident::Type type = Ident::FindType(line); |
|
292 |
|
|
293 |
int currentLevel = Ident::FindSize(line, type); |
|
294 |
int newLevel = GetNewIdnetations(editor); |
|
295 |
int wholeLevel = currentLevel + newLevel; |
|
296 |
|
|
297 |
String afterCursor; |
|
298 |
if(newLevel > 0) { |
|
299 |
WString rightSide = GetCursorRightSide(editor); |
|
300 |
if(rightSide.StartsWith("<")) { |
|
301 |
afterCursor = "\n"; |
|
302 |
for(int i = 0; i < wholeLevel - 1; i++) |
|
303 |
afterCursor += Ident::GetString(type); |
|
304 |
} |
|
305 |
else |
|
306 |
if(!rightSide.IsEmpty()) { |
|
307 |
wholeLevel = 0; |
|
308 |
} |
|
309 |
} |
|
310 |
|
|
311 |
editor.InsertChar('\n', 1); |
|
312 |
editor.InsertChar('\t', wholeLevel); |
|
313 |
editor.Insert(editor.GetCursor(), afterCursor); |
|
314 |
} |
|
315 |
} |
|
283 | 316 |
else |
317 |
if(count > 0) |
|
284 | 318 |
editor.InsertChar(chr, count); |
285 | 319 |
} |
286 | 320 | |
... | ... | |
291 | 325 |
return false; |
292 | 326 |
} |
293 | 327 | |
328 |
bool TagSyntax::HasHtmlTags() const |
|
329 |
{ |
|
330 |
return html || witz; |
|
331 |
} |
|
332 | ||
333 |
int TagSyntax::GetIdentationsLevel(CodeEditor& editor) const |
|
334 |
{ |
|
335 |
int level = 0; |
|
336 |
WString line = editor.GetWLine(editor.GetCursorLine()); |
|
337 |
for(int i = 0; i < line.GetCount(); i++) { |
|
338 |
if(line[i] == '\t') |
|
339 |
level++; |
|
340 |
else |
|
341 |
break; |
|
342 |
} |
|
343 |
return level; |
|
344 |
} |
|
345 | ||
346 |
int TagSyntax::GetNewIdnetations(CodeEditor& editor) const |
|
347 |
{ |
|
348 |
int level = 0; |
|
349 |
|
|
350 |
WString leftSide = GetCursorLeftSide(editor); |
|
351 |
WString rightSide = GetCursorRightSide(editor); |
|
352 |
Vector< Tuple2<String, int> > types = SplitTagsByType(leftSide); |
|
353 |
for(int i = 0; i < types.GetCount(); i++) { |
|
354 |
if(types[i].b == TAG) |
|
355 |
level++; |
|
356 |
else |
|
357 |
if(types[i].b == ENDTAG) { |
|
358 |
if(level > 0) |
|
359 |
level--; |
|
360 |
} |
|
361 |
} |
|
362 |
if(IsCursorInsideTag(leftSide, rightSide)) |
|
363 |
level++; |
|
364 |
|
|
365 |
if(level < 0) |
|
366 |
level++; |
|
367 |
|
|
368 |
return level; |
|
369 |
} |
|
370 | ||
371 |
Vector< Tuple2<String, int> > TagSyntax::SplitTagsByType(const WString& s) const |
|
372 |
{ |
|
373 |
Vector< Tuple2<String, int> > tags; |
|
374 |
|
|
375 |
wchar strc; |
|
376 |
bool isStr = false; |
|
377 |
bool isTag = false; |
|
378 |
int type = TAG; |
|
379 |
String name; |
|
380 |
for(int i = 0; i < s.GetCount(); i++) { |
|
381 |
wchar c = s[i]; |
|
382 |
|
|
383 |
if(c == '\'' || c == '\"') { |
|
384 |
if(!isStr) { |
|
385 |
isStr = true; |
|
386 |
strc = c; |
|
387 |
} |
|
388 |
else |
|
389 |
if(isStr && c == strc) |
|
390 |
isStr = false; |
|
391 |
} |
|
392 |
else |
|
393 |
if(c == '<') { |
|
394 |
isTag = true; |
|
395 |
if(i + 1 >= s.GetCount()) |
|
396 |
continue; |
|
397 |
wchar nc = s[i + 1]; |
|
398 |
if(nc == '/') { |
|
399 |
type = ENDTAG; |
|
400 |
i++; |
|
401 |
} |
|
402 |
else |
|
403 |
if(nc == '!' || nc == '?') { |
|
404 |
type = TAG0; |
|
405 |
i++; |
|
406 |
} |
|
407 |
i++; |
|
408 |
name = FindTagName(s, i); |
|
409 |
} |
|
410 |
else |
|
411 |
if(c == '>') { |
|
412 |
if(!isTag || i - 1 < 0) |
|
413 |
continue; |
|
414 |
|
|
415 |
wchar pc = s[i - 1]; |
|
416 |
if(pc == '/' && type == TAG) |
|
417 |
type = TAG0; |
|
418 |
|
|
419 |
if(HasHtmlTags() && type != TAG0) { |
|
420 |
if(htmlSpecialTags.Find(name) > -1) |
|
421 |
type = TAG0; |
|
422 |
} |
|
423 |
|
|
424 |
tags.Add(Tuple<String, int>(name, type)); |
|
425 |
type = TAG; |
|
426 |
isTag = false; |
|
427 |
} |
|
428 |
} |
|
429 |
|
|
430 |
return tags; |
|
431 |
} |
|
432 | ||
433 |
String TagSyntax::FindTagName(const WString& str, int& i) const |
|
434 |
{ |
|
435 |
String name; |
|
436 |
while(i < str.GetCount()) { |
|
437 |
if(str[i] == ' ' || str[i] == '>' || str[i] == '/') { |
|
438 |
i--; |
|
439 |
break; |
|
440 |
} |
|
441 |
name += str[i]; |
|
442 |
i++; |
|
443 |
} |
|
444 |
return name; |
|
445 |
} |
|
446 | ||
447 |
WString TagSyntax::GetCursorLeftSide(CodeEditor& editor) const |
|
448 |
{ |
|
449 |
int cursor = editor.GetCursor(); |
|
450 |
int line = editor.GetLinePos(cursor); |
|
451 |
WString lineStr = editor.GetWLine(line); |
|
452 |
if(cursor < lineStr.GetCount()) |
|
453 |
lineStr.Trim(cursor); |
|
454 |
return lineStr; |
|
455 |
} |
|
456 | ||
457 |
WString TagSyntax::GetCursorRightSide(CodeEditor& editor) const |
|
458 |
{ |
|
459 |
int cursor = editor.GetCursor(); |
|
460 |
int line = editor.GetLinePos(cursor); |
|
461 |
WString lineStr = editor.GetWLine(line); |
|
462 |
if(cursor < lineStr.GetCount()) |
|
463 |
lineStr.Remove(0, cursor); |
|
464 |
else |
|
465 |
lineStr = ""; |
|
466 |
return lineStr; |
|
467 |
} |
|
468 | ||
469 |
bool TagSyntax::IsCursorInsideTag(WString& leftSide, WString& rightSide) const |
|
470 |
{ |
|
471 |
for(int i = leftSide.GetCount() - 1; i >= 0; i--) { |
|
472 |
wchar c = leftSide[i]; |
|
473 |
|
|
474 |
if(c == '>') { |
|
475 |
break; |
|
476 |
} |
|
477 |
else |
|
478 |
if(c == '<') { |
|
479 |
return true; |
|
480 |
} |
|
481 |
} |
|
482 |
|
|
483 |
return false; |
|
484 |
} |
|
485 | ||
294 | 486 |
void TagSyntax::Serialize(Stream& s) |
295 | 487 |
{ |
296 | 488 |
s % hl_ink |
... | ... | |
302 | 494 |
% html; |
303 | 495 |
} |
304 | 496 | |
497 |
void TagSyntax::InitSpecialTags() |
|
498 |
{ |
|
499 |
static const char* htmlSpecialTags[] = { |
|
500 |
"meta", "link", |
|
501 |
"br", |
|
502 |
NULL |
|
503 |
}; |
|
504 |
|
|
505 |
InitHtmlSpecialTags(htmlSpecialTags); |
|
506 |
} |
|
507 | ||
508 |
void TagSyntax::InitHtmlSpecialTags(const char* specialTags[]) |
|
509 |
{ |
|
510 |
htmlSpecialTags.Clear(); |
|
511 |
while(*specialTags) { |
|
512 |
htmlSpecialTags.Add(*specialTags++); |
|
513 |
} |
|
514 |
} |
|
515 | ||
305 | 516 |
END_UPP_NAMESPACE |
TagSyntax.h (kopia robocza) | ||
---|---|---|
1 | 1 |
class TagSyntax : public EditorSyntax { // Tag based languages (XML, HTML) |
2 | 2 |
public: |
3 |
TagSyntax& Html(bool b) { html = b; return *this; } |
|
4 |
TagSyntax& Witz(bool b) { witz = b; return *this; } |
|
5 |
CSyntax *GetScript() { return status == SCRIPT ? &script : NULL; } |
|
6 | ||
7 |
TagSyntax(); |
|
8 |
|
|
9 |
public: |
|
3 | 10 |
virtual void Clear(); |
4 | 11 |
virtual void ScanSyntax(const wchar *ln, const wchar *e, int line, int tab_size); |
5 | 12 |
virtual void Serialize(Stream& s); |
... | ... | |
10 | 17 |
virtual bool CheckBrackets(CodeEditor& e, int& bpos0, int& bpos); |
11 | 18 | |
12 | 19 |
private: |
13 | ||
14 | 20 |
enum { TEXT, TAG0, TAG, ENDTAG, ATTR, COMMENT, DECL, PI, SCRIPT }; |
15 | 21 |
|
16 | 22 |
bool html; |
... | ... | |
22 | 28 | |
23 | 29 |
CSyntax script; // for <style> or <script> |
24 | 30 |
enum { CSS, JS }; |
25 |
int script_type;
|
|
31 |
int script_type; |
|
26 | 32 | |
27 | 33 |
HighlightOutput *hout; |
28 | 34 | |
... | ... | |
35 | 41 |
void Put(int n = 1) { Put0(hl_ink, n, hl_paper); } |
36 | 42 |
void SetPut(int ink, int n = 1, int paper = PAPER_NORMAL) { Set(ink, paper); Put(n); } |
37 | 43 | |
38 |
public: |
|
39 |
TagSyntax& Html(bool b) { html = b; return *this; } |
|
40 |
TagSyntax& Witz(bool b) { html = b; return *this; } |
|
41 |
CSyntax *GetScript() { return status == SCRIPT ? &script : NULL; } |
|
42 | ||
43 |
TagSyntax(); |
|
44 |
private: |
|
45 |
bool HasHtmlTags() const; |
|
46 |
|
|
47 |
private: |
|
48 |
int GetIdentationsLevel(CodeEditor& editor) const; |
|
49 |
int GetNewIdnetations(CodeEditor& editor) const; |
|
50 |
|
|
51 |
Vector< Tuple2<String, int> > SplitTagsByType(const WString& str) const; |
|
52 |
String FindTagName(const WString& str, int& i) const; |
|
53 |
|
|
54 |
WString GetCursorLeftSide(CodeEditor& editor) const; |
|
55 |
WString GetCursorRightSide(CodeEditor& editor) const; |
|
56 |
|
|
57 |
bool IsCursorInsideTag(WString& leftSide, WString& rightSide) const; |
|
58 |
|
|
59 |
private: |
|
60 |
void InitSpecialTags(); |
|
61 |
void InitHtmlSpecialTags(const char* specialTags[]); |
|
62 |
|
|
63 |
private: |
|
64 |
Index<String> htmlSpecialTags; |
|
44 | 65 |
}; |