WebSVN – Kolibri OS – Diff – /programs/develop/cedit/SRC/Text.ob07

     Lang := Languages;
 CONST
     SPACE = Lines.SPACE;
-    SPACE = 20X;
+    TAB = Lines.TAB;
-    TAB = RW.TAB_SIZE;
+    TAB1 = Lines.TAB1;
     lenEOL = CB.lenEOL;
     colors*: RECORD
                 text, back, seltext, selback, modified, saved, curline, numtext, numback: INTEGER;
                 comment, string, num, delim, key1, key2, key3: INTEGER
              END;
     canvas: G.tCanvas;
-    drawCursor*: BOOLEAN;
+    drawCursor: BOOLEAN;
     padding: RECORD left, top: INTEGER END;
     size, textsize: tPoint;
     charWidth, charHeight: INTEGER;
         text.lang := Lang.langFasm
     ELSIF ext = "LUA" THEN
         text.lang := Lang.langLua
     ELSIF ext = "INI" THEN
         text.lang := Lang.langIni
+    ELSIF ext = "JSON" THEN
+        text.lang := Lang.langJSON
     ELSE
         text.lang := Lang.langNone
     END
 END setName;
 BEGIN
     drawCursor := ~drawCursor
 END toggleCursor;
+PROCEDURE showCursor*;
+BEGIN
+	drawCursor := TRUE
+END showCursor;
+PROCEDURE hideCursor*;
+BEGIN
+	drawCursor := FALSE
+END hideCursor;
 PROCEDURE getChar (line: tLine; i: INTEGER): WCHAR;
 VAR
     res: WCHAR;
                 DEC(i);
                 PrintLex(text, line, k, i, y, colors.num, backColor)
             END
-        ELSIF lang = Lang.langC THEN
+        ELSIF (lang = Lang.langC) OR (lang = Lang.langJSON) THEN
         IF depth = 0 THEN
             ELSIF (c = "*") & (cond = 1) THEN
                 depth := 1;
                 INC(i);
                 PrintComment(text, line, depth, i, y, backColor);
                 cond := 0
+            ELSIF U.isLetter(c) OR (c = "_") OR (c = "'") OR (c = '"') THEN
+            	k := i;
-            ELSIF (c = "'") OR (c = '"') THEN
+            	IF (c = "'") OR (c = '"') THEN
-                String(text, line, i, y, backColor);
+            		String(text, line, i, y, backColor);
+            	ELSE
+            		ident(text, i, i - ORD((lang = Lang.langC) & (i > 0) & (getChar(line, i - 1) = "#")), y, line, backColor, Lang.isCS(lang))
+            	END;
+                IF lang = Lang.langJSON THEN
+	                WHILE Lines.isSpace(getChar(line, i + 1)) DO
+	                	INC(i)
-                cond := 0
+	                END;
-            ELSIF (U.isLetter(c) OR (c = "_")) THEN
+	                IF getChar(line, i + 1) = ":" THEN
-                ident(text, i, i - ORD((i > 0) & (getChar(line, i - 1) = "#")), y, line, backColor, Lang.isCS(lang));
+	                	PrintLex(text, line, k, i, y, colors.key1, backColor)
+	                END
+                END;
                 cond := 0
             ELSIF U.isDigit(c) THEN
                 k := i;
                 INC(i);
                 c := getChar(line, i);
 PROCEDURE leadingSpaces (line: tLine): INTEGER;
 VAR
     i: INTEGER;
 BEGIN
     i := 0;
-    WHILE getChar(line, i) = SPACE DO
+    WHILE Lines.isSpace(getChar(line, i)) DO
         INC(i)
     END
     RETURN i
 END leadingSpaces;
 END getLine;
 PROCEDURE SetPos* (text: tText; x, y: INTEGER);
 VAR
+    deltaY, n, L, R: INTEGER;
-    deltaY: INTEGER;
+    cursor: pPoint;
-    cursor: pPoint;
+    c: WCHAR;
    (* trimLength: INTEGER; *)
 BEGIN
     cursor := text.cursor;
         ELSE
             text.curLine := getLine(text, y)
         END
     END;
     cursor.X := MIN(MAX(x, 0), text.curLine.length);
+    c := getChar(text.curLine, cursor.X);
+    IF c = TAB1 THEN
+        n := cursor.X;
+        WHILE getChar(text.curLine, n) = TAB1 DO
+            INC(n)
+        END;
+        R := n - cursor.X;
+        n := cursor.X;
+        WHILE getChar(text.curLine, n) # TAB DO
+            DEC(n)
+        END;
+        L := cursor.X - n;
+        IF L < R THEN
+            DEC(cursor.X, L)
+        ELSE
+            INC(cursor.X, R)
+        END
+    END;
     IF text.scroll.Y > cursor.Y THEN
         text.scroll.Y := cursor.Y
     ELSIF text.scroll.Y + textsize.Y <= cursor.Y THEN
         text.scroll.Y := cursor.Y - textsize.Y + 1
     END;
         text.select.X := text.curLine.length
     END;
     setSelect(text);
     text.foundSel := 0;
     ShowCursor;
-    drawCursor := TRUE;
     text.CurX := -1
 END SetPos;
 END delSelect;
 PROCEDURE delete (text: tText);
 VAR
-    i: INTEGER;
+    i, n: INTEGER;
     nextLine, curLine: tLine;
 BEGIN
     IF selected(text) THEN
         delSelect(text)
     ELSE
         i := text.cursor.X;
+        curLine := text.curLine;
+        IF i < curLine.length THEN
+            n := i;
+            INC(i);
+            IF getChar(curLine, i - 1) = TAB THEN
+                WHILE getChar(curLine, i) = TAB1 DO
+                    INC(i)
-        curLine := text.curLine;
+                END
-        IF i < curLine.length THEN
+            END;
-            Lines.delChar(curLine, i);
+            Lines.delCharN(curLine, n, i - n);
             Lines.modify(curLine);
             modify(text)
         ELSE
-            nextLine := curLine.next(tLine);
-            IF nextLine # NIL THEN
-                Lines.modify(curLine);
+            nextLine := curLine.next(tLine);
-                modify(text);
+            IF nextLine # NIL THEN
+                Lines.insert2(curLine, i, nextLine);
+                DelLine(text, nextLine);
-                Lines.insert2(curLine, i, nextLine);
+                Lines.modify(curLine);
-                DelLine(text, nextLine)
+                modify(text)
             END
         END
     END;
+    setSelect(text)
+END delete;
+PROCEDURE move (text: tText; d: INTEGER);
+VAR
+    pos: INTEGER;
+BEGIN
+    pos := text.cursor.X + d;
+    WHILE getChar(text.curLine, pos) = TAB1 DO
+        INC(pos, d)
+    END;
-    setSelect(text)
+    SetPos(text, pos, text.cursor.Y)
-END delete;
+END move;
 PROCEDURE BkSpace (text: tText);
 VAR
-    i, n, k: INTEGER;
+    i, k, n: INTEGER;
-    curLine, line: tLine;
+    curLine, line, line2: tLine;
 BEGIN
-    IF selected(text) THEN
-        delSelect(text)
+    IF selected(text) THEN
-    ELSE
+        delSelect(text)
-        resetSelect(text);
+    ELSE
-        i := text.cursor.X;
+        resetSelect(text);
         curLine := text.curLine;
-        IF i > 0 THEN
+        IF text.cursor.X > 0 THEN
-            modify(text);
+            i := text.cursor.X;
             n := leadingSpaces(curLine);
             IF n < i THEN
-                Lines.delChar(curLine, i - 1);
+                modify(text);
-                Lines.modify(curLine);
+                move(text, -1);
+                delete(text)
-                k := 1
+            ELSE
-            ELSE
+                n := i;
-                n := i;
+                line := curLine.prev(tLine);
-                line := curLine.prev(tLine);
+                line2 := line;
+                k := n;
-                k := n;
+                WHILE (line # NIL) & (k >= n) DO
-                WHILE (line # NIL) & (k >= n) DO
+                    IF Lines.trimLength(line) # 0 THEN
-                    IF Lines.trimLength(line) # 0 THEN
+                        k := leadingSpaces(line);
-                        k := leadingSpaces(line)
+                        line2 := line;
                     END;
                     PrevLine(line)
                 END;
                 IF k >= n THEN
                     k := 0
+                END;
-                END;
+                n := k;
+                Lines.delCharN(curLine, 0, i);
-                DEC(n, k);
+                Lines.insert3(curLine, 0, k);
+                WHILE k > 0 DO
-                k := n;
+                    Lines.setChar(curLine, k - 1, getChar(line2, k - 1));
+                    DEC(k)
-                Lines.modify(curLine);
+                END;
-                Lines.delCharN(curLine, 0, n)
+                Lines.modify(curLine);
-            END;
+                SetPos(text, n, text.cursor.Y)
-            SetPos(text, text.cursor.X - k, text.cursor.Y)
+            END
         ELSE
 PROCEDURE enter (text: tText);
 VAR
     n: INTEGER;
-    curLine, newLine, line: tLine;
+    curLine, newLine, line, line2: tLine;
 BEGIN
-    delSelect(text);
-    newLine := Lines.create(FALSE);
+    delSelect(text);
-    Lines.modify(newLine);
+    newLine := Lines.create(FALSE);
     modify(text);
     curLine := text.curLine;
     IF text.cursor.X < curLine.length THEN
-        Lines.modify(curLine);
+        Lines.wrap(curLine, newLine, text.cursor.X);
-        Lines.wrap(curLine, newLine, text.cursor.X)
+        Lines.modify(curLine)
     END;
     List._insert(text, curLine, newLine);
     SetPos(text, 0, text.cursor.Y + 1);
     line := text.curLine.prev(tLine);
     n := -1;
     WHILE (line # NIL) & (n = -1) DO
+        IF (*line.length*)Lines.trimLength(line) # 0 THEN
-        IF (*line.length*)Lines.trimLength(line) # 0 THEN
+            n := leadingSpaces(line);
-            n := leadingSpaces(line)
+            line2 := line
         END;
         PrevLine(line)
     END;
     IF n = -1 THEN
         n := 0
     END;
     Lines.insert3(text.curLine, 0, n);
     SetPos(text, n, text.cursor.Y);
     resetSelect(text);
     WHILE n > 0 DO
-        Lines.setChar(text.curLine, n - 1, SPACE);
+        Lines.setChar(text.curLine, n - 1, getChar(line2, n - 1));
+        DEC(n)
-        DEC(n)
+    END;
+    Lines.modify(newLine)
+END enter;
+PROCEDURE incIndent (line: tLine);
+VAR
+	c: WCHAR;
+	i: INTEGER;
+BEGIN
+	Lines.modify(line);
+	Lines.insert3(line, 0, Lines.tab);
+	IF Lines.tabs THEN
+		c := TAB1
+	ELSE
+		c := SPACE
+	END;
+	i := Lines.tab - 1;
+	WHILE i >= 0 DO
+		Lines.setChar(line, i, c);
+		DEC(i)
+	END;
+	IF Lines.tabs THEN
+		Lines.setChar(line, 0, TAB)
+	END
+END incIndent;
+PROCEDURE decIndent (line: tLine): BOOLEAN;
+VAR
+	n: INTEGER;
+BEGIN
+	n := leadingSpaces(line);
+	IF n > 0 THEN
+		Lines.delCharN(line, 0, MIN(Lines.tab, n));
+		Lines.modify(line)
+	END
+	RETURN n > 0
+END decIndent;
+PROCEDURE Indent* (text: tText; incr: BOOLEAN);
+VAR
+    i: INTEGER;
+    line: tLine;
+    selBeg, selEnd: tPoint;
+    modified: BOOLEAN;
+BEGIN
+	getSelect(text, selBeg, selEnd);
+	i := selEnd.Y - selBeg.Y + 1;
+	line := getLine(text, selBeg.Y);
+	modified := incr;
+	WHILE i > 0 DO
+		IF incr THEN
+			incIndent(line)
+		ELSE
+    		modified := decIndent(line) OR modified
+		END;
+		NextLine(line);
+		DEC(i)
+	END;
+	line := getLine(text, selEnd.Y);
+	text.select^ := selBeg;
+	text.select.X := 0;
+	SetPos(text, line.length, selEnd.Y);
+	IF modified THEN
+   		modify(text)
-    END
+	END
-END enter;
+END Indent;
 PROCEDURE input* (text: tText; code: INTEGER);
-PROCEDURE input* (text: tText; code: INTEGER);
+VAR
-VAR
+    curLine: tLine;
     curLine: tLine;
     PROCEDURE tab (text: tText);
-    PROCEDURE tab (text: tText);
+    VAR
-    VAR
+        i, x: INTEGER;
-        i, x: INTEGER;
+        curLine: tLine;
-        curLine: tLine;
-    BEGIN
-        delSelect(text);
+        c: WCHAR;
-        curLine := text.curLine;
+    BEGIN
-        x := text.cursor.X;
+		delSelect(text);
+		curLine := text.curLine;
+		x := text.cursor.X;
+		i := Lines.tab - x MOD Lines.tab;
+		Lines.insert3(curLine, x, i);
+		SetPos(text, x + i, text.cursor.Y);
-        Lines.modify(curLine);
+		IF Lines.tabs THEN
-        modify(text);
+			c := TAB1
-        i := TAB - x MOD TAB;
+		ELSE
+			c := SPACE
+		END;
+		WHILE i > 0 DO
-        Lines.insert3(curLine, x, i);
+			Lines.setChar(curLine, x + i - 1, c);
+			DEC(i)
+		END;
-        SetPos(text, x + i, text.cursor.Y);
+		IF Lines.tabs THEN
+			Lines.setChar(curLine, x + i, TAB)
-        WHILE i > 0 DO
+		END;
-            Lines.setChar(curLine, x + i - 1, SPACE);
+		Lines.modify(curLine);
-            DEC(i)
+		modify(text)
-        END
+    END tab;
     END tab;
 BEGIN
     IF (code >= ORD(SPACE)) & (code # 127) THEN
         delSelect(text);
         curLine := text.curLine;
+        Lines.insert(curLine, text.cursor.X, WCHR(code));
+        Lines.modify(curLine);
+        modify(text);
+        SetPos(text, text.cursor.X + 1, text.cursor.Y)
-        Lines.insert(curLine, text.cursor.X, WCHR(code));
+    ELSIF code = 8 THEN
+		BkSpace(text)
+    ELSIF code = -8 THEN
+    	IF selected(text) THEN
-        Lines.modify(curLine);
+    		Indent(text, FALSE)
+        END
-        modify(text);
+    ELSIF code = 9 THEN
-        SetPos(text, text.cursor.X + 1, text.cursor.Y)
+    	IF selected(text) THEN
-    ELSIF code = 8 THEN
+    		Indent(text, TRUE)
-        BkSpace(text)
+    	ELSE
         ChangeLog.redo(item);
         item := item.next
     END;
     redoGuard(text, guard);
     ChangeLog.setGuard(guard);
-    text.modified := ~guard.saved
+    text.modified := ~guard.saved;
+    ShowCursor
 END undo;
     IF item # NIL THEN
         guard := item(tGuard);
         redoGuard(text, guard)
     END;
     ChangeLog.setGuard(guard);
-    text.modified := ~guard.saved
+    text.modified := ~guard.saved;
+    ShowCursor
 END redo;
 PROCEDURE paste (text: tText);
 VAR
     line, newLine, curLine: tLine;
-    L: INTEGER;
+    w: INTEGER;
     cliptext: RW.tInput;
+    eol: BOOLEAN;
+    cursor: pPoint;
+    PROCEDURE lineWidth (line: tLine; pos: INTEGER): INTEGER;
+    VAR
+    	i, res: INTEGER;
+    	c: WCHAR;
+    BEGIN
+    	res := pos;
+    	i := 0;
+    	REPEAT
+	    	c := getChar(line, i);
+	    	IF c = TAB THEN
+	    		INC(res, Lines.tab - res MOD Lines.tab)
+	    	ELSIF c # TAB1 THEN
+	    		INC(res)
+	    	END;
+	    	INC(i)
+    	UNTIL c = 0X
+    	RETURN res - pos - 1
+    END lineWidth;
     eol: BOOLEAN;
     cursor: pPoint;
 BEGIN
     line := Lines.create(TRUE);
     cliptext := RW.clipboard();
     delSelect(text);
     cursor := text.cursor;
-    WHILE (cliptext # NIL) & (RW.getString(cliptext, line, eol) >= 0) DO
+    WHILE (cliptext # NIL) & (RW.getString(cliptext, line, Lines.tabs, eol) >= 0) DO
-        L := line.length;
+        IF line.length > 0 THEN
-        IF L > 0 THEN
+        	w := lineWidth(line, cursor.X);
             Lines.insert2(text.curLine, cursor.X, line);
             Lines.modify(text.curLine);
             modify(text);
-            SetPos(text, cursor.X + L, cursor.Y);
+            SetPos(text, cursor.X + w, cursor.Y);
             resetSelect(text)
         END;
-        IF eol THEN
-            newLine := Lines.create(FALSE);
+        IF eol THEN
-            Lines.modify(newLine);
+            newLine := Lines.create(FALSE);
             modify(text);
             curLine := text.curLine;
             IF cursor.X < curLine.length THEN
-                Lines.modify(curLine);
+                Lines.wrap(curLine, newLine, cursor.X);
-                Lines.wrap(curLine, newLine, cursor.X)
+                Lines.modify(curLine)
+            END;
-            END;
+            List._insert(text, curLine, newLine);
-            List._insert(text, curLine, newLine);
+            Lines.modify(newLine);
             SetPos(text, 0, cursor.Y + 1);
             resetSelect(text)
         END;
         delete(text)
     END
 END delLine;
-PROCEDURE dupLine (text: tText);
+PROCEDURE dupLine* (text: tText);
 VAR
     newLine, curLine: tLine;
 BEGIN
-    curLine := text.curLine;
-    newLine := Lines.create(FALSE);
+    curLine := text.curLine;
-    Lines.modify(newLine);
+    newLine := Lines.create(FALSE);
     modify(text);
     Lines.insert3(newLine, 0, curLine.length);
+    List._insert(text, curLine, newLine);
-    List._insert(text, curLine, newLine);
+    Lines.move(curLine, newLine);
-    Lines.move(curLine, newLine)
+    Lines.modify(newLine)
 END dupLine;
     modify(text);
     UpDown(text, 0)
 END exchange;
+PROCEDURE upLine* (text: tText);
-PROCEDURE upLine (text: tText);
+BEGIN
-BEGIN
+	resetSelect(text);
     IF text.cursor.Y > 0 THEN
         DEC(text.cursor.Y);
         exchange(text, text.curLine.prev(tLine), text.curLine)
     END
 END upLine;
 PROCEDURE downLine* (text: tText);
-PROCEDURE downLine (text: tText);
+BEGIN
-BEGIN
+	resetSelect(text);
     IF text.cursor.Y < text.count - 1 THEN
     IF search(text, str, Lang.isCS(text.lang), TRUE) THEN END
 END wordSel;
+PROCEDURE key* (text: tText; code: INTEGER; shift, ctrl: BOOLEAN);
 VAR
-PROCEDURE key* (text: tText; code: INTEGER; shift, ctrl: BOOLEAN);
+	n: INTEGER;
 BEGIN
     IF shift THEN
         setSelect(text)
         END
     |36:
         IF ctrl THEN
             SetPos(text, 0, 0)
         ELSE
+        	n := leadingSpaces(text.curLine);
+        	IF text.cursor.X > n THEN
+	            SetPos(text, n, text.cursor.Y)
+        	ELSE
-            SetPos(text, 0, text.cursor.Y)
+        		SetPos(text, 0, text.cursor.Y)
-        END
+        	END
+        END
     |37:
         IF (text.cursor.X = 0) & (text.curLine.prev # NIL) THEN
             SetPos(text, text.curLine.prev(tLine).length, text.cursor.Y - 1)
         ELSE
-            SetPos(text, text.cursor.X - 1, text.cursor.Y)
+            move(text, -1)
         END
     |38:
         IF ctrl THEN
             upLine(text)
         ELSE
         END
     |39:
         IF (text.cursor.X = text.curLine.length) & (text.curLine.next # NIL) THEN
             SetPos(text, 0, text.cursor.Y + 1)
         ELSE
-            SetPos(text, text.cursor.X + 1, text.cursor.Y)
+            move(text, 1)
         END
     |40:
         IF ctrl THEN
             downLine(text)
         ELSE
         END
     |46:
         IF ctrl THEN
             delLine(text)
         ELSE
-            delete(text); ShowCursor; drawCursor := TRUE
+            delete(text);
+            ShowCursor
         END
     |ORD("C"):
         IF ctrl THEN
             IF selected(text) THEN
                 copy(text)
             text.select := text.select2;
             SetPos(text, text.last(tLine).length, text.count - 1)
         END
     |ORD("L"), ORD("U"):
         IF ctrl THEN
+        	IF selected(text) THEN
+            	chCase(text, code = ORD("U"))
+            ELSE
-            changeCase(text, code = ORD("U"))
+            	changeCase(text, code = ORD("U"))
+            END;
+            ShowCursor
         END
     |ORD("D"):
         IF ctrl THEN
             dupLine(text)
         END
     IF file # NIL THEN
         text := create(name);
         text.enc := enc;
         REPEAT
             line := Lines.create(FALSE);
-            n := RW.getString(file, line, eol);
+            n := RW.getString(file, line, Lines.tabs, eol);
             IF n >= 0 THEN
                 List._append(text, line)
             ELSE
                 Lines.destroy(line)
             END
     resetSelect(text)
     RETURN text
 END New;
-PROCEDURE empty;
-END empty;
-PROCEDURE init* (pShowCursor: tProcedure);
-BEGIN
-    ShowCursor := empty;
+PROCEDURE init* (pShowCursor: tProcedure);
-    IF pShowCursor # NIL THEN
-        ShowCursor := pShowCursor
+BEGIN
-    END;
+    ShowCursor := pShowCursor;
     pdelete := delete;
     drawCursor := TRUE;
     padding.left := pad_left;

Subversion Repositories Kolibri OS

(root)/programs/develop/cedit/SRC/Text.ob07 – Rev 9073 → 9174