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


﻿(*
    Copyright 2021-2023 Anton Krotov
 
    This file is part of CEdit.
 
    CEdit is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    CEdit 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 General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with CEdit. If not, see .
*)
 
MODULE CEdit;
 
IMPORT
    OpenDlg, K := KolibriOS, Args,
    U := Utils, Lines, Menu, List,
    G := Graph, T := Text, E := Encodings,
    CB := Clipboard, Languages,
    ChangeLog, Scroll, CheckBox, Icons,
    RW, Ini, EB := EditBox, Tabs, Toolbar, SB := StatusBar;
 
CONST
    HEADER = "CEdit (26-feb-2023)";
 
    ShellFilter = "";
    EditFilter = "sh|inc|txt|asm|ob07|c|cpp|h|pas|pp|lua|ini|json";
 
    fontWidth = K.fontWidth;
    fontHeight = K.fontHeight;
 
    btnClose = 1;
 
    btnNew = 20;
    btnOpen = 21;
    btnSave = 22;
    btnSearch = 23;
    btnUndo = 24;
    btnRedo = 25;
    btnUpper = 26;
    btnLower = 27;
    btnBuild = 28;
    btnRun = 29;
 
    btnYes = 40;
    btnNo = 41;
    btnFindNext = 42;
    btnReplace = 43;
    btnReplaceAll = 44;
    btnGoto = 45;
    btnCloseSearch = 46;
    btnHideSearch = 47;
 
    mainMenuBtn = 60;
 
    btnHeight = 25;
    btnWidth = 75;
 
    toolbarTop = Menu.MainMenuHeight + 3;
 
    TOP = toolbarTop + Toolbar.BtnSize + 9 + Tabs.tabHeight;
 
    minWinWidth = 635; minWinHeight = 550;
 
    SEARCH_PADDING = 10;
    LEFT_PADDING = 1;
    RIGHT_PADDING = 1;
 
    EditBox_Width = 180;
    EDITBOX_MAXCHARS = 500;
 
    menuCut = 1;
    menuCopy = 2;
    menuPaste = 3;
    menuDelete = 4;
    menuSelectAll = 5;
 
    menuUndo = 6;
    menuRedo = 7;
 
    menuCurLine = 100;
    menuIndent = 110;
    menuCase = 120;
 
    menuNew = 10;
    menuOpen = 11;
    menuSave = 12;
    menuSaveAs = 13;
    menuSaveAll = 14;
    menuFolder = 15;
    menuClose = 16;
    menuExit = 17;
 
    menuFontSmall = 20;
    menuFontMedium = menuFontSmall + 1;
    menuFontLarge = menuFontMedium + 1;
    menuColors = 1000;
    menuMaxColors = menuColors + Ini.MAX_SECTIONS - 1;
 
    menuText = 30;
    menuC = 31;
    menuFasm = 32;
    menuIni = 33;
    menuJSON = 34;
    menuLua = 35;
    menuOberon = 36;
    menuPascal = 37;
 
    menuBuild = 50;
    menuBuildScript = 51;
    menuRun = 52;
    menuRunScript = 53;
    menuDebug = 54;
    menuDebugScript = 55;
    menuFASM = 56;
 
    menuUTF8BOM = 60;
    menuUTF8 = 61;
    menuCP866 = 62;
    menuCP1251 = 63;
    menuEOL = 140;
    menuConv1251_866 = 64;
    menuConv866_1251 = 65;
 
    menuPipet = 70;
    menuMagnify = 71;
    menuBoard = 72;
    menuSysFunc = 73;
 
    menuFind = 80;
    menuFindNext = 81;
    menuFindPrev = 82;
    menuGoto = 83;
    menuBookmark = 130;
 
    menuLineNumbers  = 90;
    menuAutoIndents  = 91;
    menuAutoBrackets = 92;
    menuTrimSpace    = 93;
 
    menuMoveUp = 101;
    menuMoveDown = 102;
    menuDuplicate = 103;
    menuRemove = 104;
 
    menuIncInd = 111;
    menuDecInd = 112;
 
    menuUpper = 121;
    menuLower = 122;
 
    menuToggleBookmark = 131;
    menuNextBookmark = 132;
    menuPrevBookmark = 133;
 
    menuLF = 141;
    menuCRLF = 142;
    menuCR = 143;
 
    maxTexts = 32;
 
	SHIFT = Menu.SHIFT;
	CTRL  = Menu.CTRL;
 
	ClippingArea = 50;
 
 
VAR
	header: RW.tFileName;
    canvas: G.tCanvas;
    font: G.tFont;
 
    tabs: Tabs.tTabs;
    text: T.tText;
    texts: ARRAY maxTexts OF T.tText;
    textsCount, curText: INTEGER;
 
    winWidth, winHeight: INTEGER;
    SkinHeight, scrollWidth: INTEGER;
    AppPath, runScript, buildScript, debugScript, CurFolder: RW.tFileName;
    OD: OpenDlg.Dialog;
    confirm, notFound, menuFindClicked, search, searchOpened: BOOLEAN;
 
    switch, closing, newtab: BOOLEAN;
    leftButton: BOOLEAN;
    LEFT, RIGHT, BOTTOM: INTEGER;
 
    FindEdit, ReplaceEdit, GotoEdit: EB.tEditBox;
    hScroll, vScroll: Scroll.tScroll;
    CS, WH, BKW: CheckBox.tCheckBox;
 
    new_searchText, searchText, replaceText, gotoText: T.tString;
    cs, whole: BOOLEAN;
 
    replaced: INTEGER;
 
    context, menuFile, menuEdit, menuSearch, menuEncoding,
    menuView, menuLanguage, menuProgram, menuTools, menuOptions,
    subCurLine, subIndent, subCase, subBookmark, subEOL: Menu.tMenu;
 
    mainMenu: Menu.tMain;
 
    menuActive: BOOLEAN;
 
    toolbar: Toolbar.tToolbar;
 
    CursorTime, CurrentTime: INTEGER;
    timerEnabled: BOOLEAN;
 
    IPC: ARRAY 64 OF INTEGER; mainTID: INTEGER;
 
 
PROCEDURE EditBox_Focus (edit: EB.tEditBox): BOOLEAN;
	RETURN 1 IN edit.flags
END EditBox_Focus;
 
 
PROCEDURE resetTimer;
BEGIN
	IF EditBox_Focus(FindEdit) OR EditBox_Focus(ReplaceEdit) OR EditBox_Focus(GotoEdit) THEN
		T.hideCursor;
		timerEnabled := FALSE
	ELSE
		T.showCursor;
		timerEnabled := TRUE
	END;
	CursorTime := CurrentTime
END resetTimer;
 
 
PROCEDURE EditBox_SetFocus (VAR edit: EB.tEditBox; value: BOOLEAN);
BEGIN
    IF value THEN
    	INCL(edit.flags, 1)
    ELSE
    	EXCL(edit.flags, 1)
    END;
    IF search & searchOpened THEN
        EB.draw(edit)
    END
END EditBox_SetFocus;
 
 
PROCEDURE SetFocus (VAR edit: EB.tEditBox; value: BOOLEAN);
BEGIN
    EditBox_SetFocus(FindEdit, FALSE);
    EditBox_SetFocus(ReplaceEdit, FALSE);
    EditBox_SetFocus(GotoEdit, FALSE);
    EditBox_SetFocus(edit, value);
  	resetTimer
END SetFocus;
 
 
PROCEDURE Rect (left, top, right, bottom, color: INTEGER);
BEGIN
    K.DrawLine(left, top, right, top, color);
    K.DrawLine(left, bottom, right, bottom, color);
    K.DrawLine(left, top, left, bottom, color);
    K.DrawLine(right, top, right, bottom, color);
END Rect;
 
 
PROCEDURE Message (s: ARRAY OF WCHAR);
CONST
    minWidth = 30;
    height = 40;
VAR
    top, left, right, bottom, x, y, width: INTEGER;
BEGIN
	timerEnabled := FALSE;
	CursorTime := CurrentTime;
    width := minWidth + LENGTH(s)*fontWidth;
    left := (canvas.width - width) DIV 2 + LEFT;
    top := (canvas.height - height) DIV 2 + TOP;
    bottom := top + height - 1;
    right := left + width - 1;
    x := minWidth DIV 2 + left;
    y := (height - fontHeight) DIV 2 + top;
    K.DrawRect(left, top, width, height, K.colors.work);
    Rect(left, top, right, bottom, K.colors.line);
    K.DrawText(x, y, K.colors.work_text, s);
END Message;
 
 
PROCEDURE NotFound;
BEGIN
    IF notFound THEN
        Message("not found");
        IF menuFindClicked THEN
        	menuFindClicked := FALSE
        ELSE
        	notFound := FALSE
        END;
        SetFocus(FindEdit, TRUE)
    END
END NotFound;
 
 
PROCEDURE Replaced;
VAR
    s, s1: ARRAY 32 OF WCHAR;
BEGIN
    IF replaced # 0 THEN
        s := "replaced: ";
        U.int2str(replaced, s1);
        U.append(s, s1);
        Message(s);
        replaced := 0;
        SetFocus(FindEdit, TRUE)
    END
END Replaced;
 
 
PROCEDURE getIdx (text: T.tText): INTEGER;
VAR
    i: INTEGER;
BEGIN
    i := 0;
    WHILE texts[i] # text DO
        INC(i)
    END
    RETURN i
END getIdx;
 
 
PROCEDURE SetCaption (fileName: RW.tFileName);
VAR
	newHeader: RW.tFileName;
BEGIN
    newHeader := HEADER;
    IF text.fileName # "" THEN
    	U.append8(newHeader, " - ");
    	U.append8(newHeader, text.fileName)
    END;
    IF newHeader # header THEN
    	header := newHeader;
		K.SetCaption(header)
    END
END SetCaption;
 
 
PROCEDURE Status (text: T.tText; height: INTEGER);
VAR
	line, col, chars, lines: INTEGER;
BEGIN
	T.getPos(text, col, line);
	T.getSelCnt(text, chars, lines);
	SB.setWidth(canvas.width + scrollWidth);
	SB.setPos(line, col);
	SB.setSel(chars, lines);
	SB.setEnc(E.eolNames[T.getEol(text)], E.names[T.getEnc(text)]);
	SB.draw(LEFT, height - BOTTOM + scrollWidth - 1);
	Tabs.modify(tabs, getIdx(text), text.modified)
END Status;
 
 
PROCEDURE DrawScroll (VAR scroll: Scroll.tScroll; left, top, value, maxVal: INTEGER);
BEGIN
	scroll.maxVal := maxVal;
    scroll.left := left;
    scroll.top := top;
    Scroll.setValue(scroll, value);
    Scroll.draw(scroll)
END DrawScroll;
 
 
PROCEDURE drawText;
BEGIN
	G.SetColor(canvas, K.colors.line);
	G.VLine(canvas, 0, 0, canvas.height - 1);
	G.DrawCanvas(canvas, LEFT, TOP)
END drawText;
 
 
PROCEDURE repaint;
VAR
    width, height, scrollX, scrollY: INTEGER;
BEGIN
    IF (text # NIL) & ~K.RolledUp() THEN
        IF confirm THEN
            K.DeleteButton(btnYes);
            K.DeleteButton(btnNo);
            confirm := FALSE;
            resetTimer;
            closing := FALSE
        END;
        IF ~search OR (searchText = "") THEN
            T.wordSel(text)
        END;
        K.ClientSize(width, height);
        IF switch THEN
            Status(text, height);
            Tabs.draw(tabs);
            IF search & T.search(text, searchText, cs, whole) THEN END;
            switch := FALSE
        END;
        T.draw(text);
        Status(text, height);
 
        T.getScroll(text, scrollX, scrollY);
        DrawScroll(vScroll, LEFT + canvas.width, TOP - 1, scrollY, text.count - 1);
        DrawScroll(hScroll, LEFT, TOP + canvas.height, scrollX, text.maxLength);
        IF search & searchOpened THEN
	        CheckBox.draw(BKW);
	        CheckBox.draw(CS);
	        CheckBox.draw(WH);
        END;
        drawText;
        NotFound;
        Replaced;
        Toolbar.enable(toolbar, btnSave,  text.modified);
        Toolbar.enable(toolbar, btnUndo,  ~ChangeLog.isFirstGuard(text.edition));
        Toolbar.enable(toolbar, btnRedo,  ~ChangeLog.isLastGuard(text.edition));
        Toolbar.enable(toolbar, btnUpper, T.selected(text));
        Toolbar.enable(toolbar, btnLower, T.selected(text));
        Toolbar.enable(toolbar, btnBuild, (buildScript # "") OR text.fasm);
        Toolbar.enable(toolbar, btnRun,   (runScript # "") OR text.fasm);
        Toolbar.drawIcons(toolbar)
    END
END repaint;
 
 
PROCEDURE resize;
VAR
    cliWidth, cliHeight: INTEGER;
BEGIN
    K.WinSize(winWidth, winHeight);
    IF winWidth < minWinWidth THEN
        winWidth := minWinWidth
    END;
    IF winHeight < minWinHeight THEN
        winHeight := minWinHeight
    END;
    K.SetWinSize(winWidth, winHeight);
    K.WinSize(winWidth, winHeight);
    K.ClientSize(cliWidth, cliHeight);
    IF font # G.fonts[2] THEN
    	SB.SetFont(font)
    ELSE
    	SB.SetFont(G.fonts[1])
    END;
    BOTTOM := SB.height() + scrollWidth - 1;
    G.destroy(canvas);
    canvas := G.CreateCanvas(cliWidth - (LEFT + RIGHT + 2 + RIGHT_PADDING), cliHeight - (TOP + BOTTOM + 1 - ClippingArea));
    DEC(canvas.height, ClippingArea);
    Tabs.setArea(tabs, LEFT, TOP - Tabs.tabHeight, cliWidth - (LEFT + RIGHT + 2 + RIGHT_PADDING), Tabs.tabHeight);
    G.SetFont(canvas, font);
    T.setCanvas(canvas);
    T.resize(canvas.width, canvas.height);
    Scroll.resize(vScroll, vScroll.width, canvas.height + 2);
    Scroll.resize(hScroll, canvas.width + 1, hScroll.height);
END resize;
 
 
PROCEDURE SearchPanel (left, top: INTEGER);
VAR
    y, right, bottom: INTEGER;
BEGIN
    DEC(top, Tabs.tabHeight);
    right := left + EditBox_Width + SEARCH_PADDING*2;
    bottom := top + 395 + btnHeight + SEARCH_PADDING;
    Rect(left, top, right, bottom, K.colors.line);
 
    K.CreateButton(btnCloseSearch, right - 20, top, 20, 20, Tabs.btnCloseColor, "");
    K.DrawLine(right - 14, top + 5, right - 5, top + 14, 0FFFFFFH);
    K.DrawLine(right - 15, top + 5, right - 5, top + 15, 0FFFFFFH);
    K.DrawLine(right - 15, top + 6, right - 6, top + 15, 0FFFFFFH);
    K.DrawLine(right - 15, top + 14, right - 6, top + 5, 0FFFFFFH);
    K.DrawLine(right - 15, top + 15, right - 5, top + 5, 0FFFFFFH);
    K.DrawLine(right - 14, top + 15, right - 5, top + 6, 0FFFFFFH);
 
    K.CreateButton(btnHideSearch, right - 40, top, 20, 20, K.colors.button, "");
    K.DrawLine(right - 34, top + 14, right - 26, top + 14, K.colors.button_text);
    K.DrawLine(right - 34, top + 15, right - 26, top + 15, K.colors.button_text);
 
    INC(top, 15);
    INC(left, SEARCH_PADDING);
    K.DrawText866(left, top, K.colors.work_text, "find");
    K.DrawText866(left, top + 55, K.colors.work_text, "replace with");
    K.DrawText866(left, top + 330, K.colors.work_text, "go to line");
    BKW.top := top + 110;
    BKW.left := left;
    CS.top := top + 140;
    CS.left := left;
    WH.top := top + 170;
    WH.left := left;
    FindEdit.top := top + 20;
    ReplaceEdit.top := top + 75;
    GotoEdit.top := top + 350;
    FindEdit.left := left;
    ReplaceEdit.left := left;
    GotoEdit.left := left;
    EB.draw(FindEdit);
    EB.draw(ReplaceEdit);
    EB.draw(GotoEdit);
    y := top + 200;
    K.CreateButton(btnFindNext, left, y, btnWidth, btnHeight, K.colors.button, "next"); INC(y, btnHeight + 10);
    K.CreateButton(btnReplace, left, y, btnWidth, btnHeight, K.colors.button, "replace"); INC(y, btnHeight + 10);
    K.CreateButton(btnReplaceAll, left, y, btnWidth + 5*fontWidth - 2, btnHeight, K.colors.button, "replace all");
    K.CreateButton(btnGoto, left, top + 380, btnWidth, btnHeight, K.colors.button, "go");
END SearchPanel;
 
 
PROCEDURE draw_window;
VAR
    width, height: INTEGER;
BEGIN
    K.BeginDraw;
    K.CreateWindow(30 + K.GetTickCount() MOD 128, 30 + K.GetTickCount() MOD 128, winWidth, winHeight, K.colors.work, 73H, 0, 0, "");
    IF (text # NIL) & ~K.RolledUp() THEN
    	IF confirm THEN
    		resetTimer
    	END;
        confirm := FALSE;
        K.ClientSize(width, height);
 
        K.DrawRect(0, 0, width, TOP - 1, K.colors.work);
        K.DrawRect(0, 0, LEFT, height, K.colors.work);
        K.DrawRect(width - RIGHT_PADDING, 0, RIGHT_PADDING, height, K.colors.work);
        K.DrawRect(LEFT + canvas.width + 1, TOP + canvas.height + 1, scrollWidth - 1, scrollWidth - 1, K.colors.work);
        Menu.DrawMain(mainMenu);
 
        Toolbar.draw(toolbar);
		SetCaption(text.fileName);
        Status(text, height);
        IF search & searchOpened THEN
            SearchPanel(LEFT_PADDING, TOP)
        END;
        Tabs.draw(tabs);
        repaint
    END;
    K.EndDraw
END draw_window;
 
 
PROCEDURE mouse (VAR x, y: INTEGER);
VAR
    msState: SET;
BEGIN
	K.mouse(msState, x, y);
	DEC(x, LEFT);
	DEC(y, TOP)
END mouse;
 
 
PROCEDURE stopTimer;
BEGIN
	T.hideCursor;
    timerEnabled := FALSE;
    CursorTime := CurrentTime;
    repaint
END stopTimer;
 
 
PROCEDURE OpenFile (VAR FileName: RW.tFileName; filter: ARRAY OF CHAR);
BEGIN
    stopTimer;
    OpenDlg.SetFilter(OD, filter);
    OpenDlg.Show(OD, 500, 400);
    WHILE OD.status = 2 DO
        K.Pause(30)
    END;
    IF OD.status = 1 THEN
        COPY(OD.FilePath, FileName)
    ELSE
        FileName := ""
    END;
    resetTimer
END OpenFile;
 
 
PROCEDURE error (s: RW.tFileName);
VAR
    temp: RW.tFileName;
BEGIN
	temp := "'CEdit: ";
	U.append8(temp, s);
	U.append8(temp, "' -E");
    K.Run("/sys/@notify", temp)
END error;
 
 
PROCEDURE saveError (name: RW.tFileName);
VAR
    s: RW.tFileName;
BEGIN
    s := "error saving file ";
    U.append8(s, name);
    error(s)
END saveError;
 
 
PROCEDURE saveAs (text: T.tText);
VAR
    fileName, name: RW.tFileName;
    ext: ARRAY 8 OF CHAR;
BEGIN
    OD._type := OpenDlg.tsave;
    U.getFileName(text.fileName, OD.FileName, U.SLASH);
    IF OD.FileName = "" THEN
        OD.FileName := "NewFile.";
        Languages.getExt(text.lang, ext);
        U.append8(OD.FileName, ext)
    END;
    OpenFile(fileName, EditFilter);
    IF fileName # "" THEN
        IF T.save(text, fileName) THEN
            T.setName(text, fileName);
            U.getFileName(fileName, name, U.SLASH);
            Tabs.rename(tabs, curText, name)
        ELSE
            saveError(fileName)
        END
    END
END saveAs;
 
 
PROCEDURE Switch (txt: T.tText);
BEGIN
    Tabs.switch(tabs, curText);
    text := txt;
    T.switch(txt);
    switch := TRUE
END Switch;
 
 
PROCEDURE save (text: T.tText);
BEGIN
    IF text.modified THEN
        IF text.fileName # "" THEN
            IF ~T.save(text, text.fileName) THEN
                saveError(text.fileName)
            END
        ELSE
            curText := getIdx(text);
            Switch(text);
            saveAs(text)
        END;
   		Tabs.modify(tabs, getIdx(text), text.modified)
    END
END save;
 
 
PROCEDURE saveAll;
VAR
    i: INTEGER;
    txt: T.tText;
BEGIN
    i := textsCount - 1;
    WHILE i >= 0 DO
    	txt := texts[i];
        IF txt.modified THEN
        	T.switch(txt);
            save(txt)
        END;
        DEC(i)
    END;
    T.switch(text)
END saveAll;
 
 
PROCEDURE insert (pos: INTEGER; txt: T.tText);
VAR
    i: INTEGER;
    name: RW.tFileName;
BEGIN
    FOR i := textsCount - 1 TO pos BY -1 DO
        texts[i + 1] := texts[i]
    END;
    texts[pos] := txt;
    INC(textsCount);
    curText := pos;
    IF txt.fileName = "" THEN
        name := "new"
    ELSE
        U.getFileName(txt.fileName, name, U.SLASH)
    END;
    Tabs.add(tabs, name);
    Switch(txt)
END insert;
 
 
PROCEDURE Confirm;
CONST
    width  = btnWidth*2 + 30;
    height = btnHeight*2 + 20;
VAR
    left, top, right, bottom: INTEGER;
BEGIN
	stopTimer;
    draw_window;
    confirm := TRUE;
    left := (canvas.width - width) DIV 2 + LEFT;
    top := (canvas.height - height) DIV 2 + TOP;
    right := left + width - 1;
    bottom := top + height - 1;
    K.DrawRect(left, top, width, height, K.colors.work);
    Rect(left, top, right, bottom, K.colors.line);
    K.DrawText866(left + (width - 10*fontWidth) DIV 2, top + 10, K.colors.work_text, "save file?");
    K.CreateButton(btnYes, left + 10, top + 35, btnWidth, btnHeight, K.colors.button, "yes");
    K.CreateButton(btnNo, left + 20 + btnWidth, top + 35, btnWidth, btnHeight, K.colors.button, "no");
END Confirm;
 
 
PROCEDURE closeFile (conf: BOOLEAN; n: INTEGER);
VAR
    i: INTEGER;
BEGIN
    IF texts[n].modified & conf THEN
        Confirm
    ELSE
        Tabs.delete(tabs, n);
        T.destroy(texts[n]);
        FOR i := n + 1 TO textsCount - 1 DO
            texts[i - 1] := texts[i]
        END;
        DEC(textsCount);
        IF (curText = textsCount) OR (n < curText) THEN
            DEC(curText)
        END;
        IF curText >= 0 THEN
            Switch(texts[curText])
        ELSE
            K.Exit
        END;
        draw_window
    END
END closeFile;
 
 
PROCEDURE getFileNum (fileName: RW.tFileName): INTEGER;
VAR
    i: INTEGER;
 
    PROCEDURE nameEq (name1, name2: RW.tFileName): BOOLEAN;
    VAR
        n1, n2: RW.tFileName;
    BEGIN
        n1 := name1;
        n2 := name2;
        U.lowcase8(n1);
        U.lowcase8(n2)
        RETURN n1 = n2
    END nameEq;
 
BEGIN
    i := 0;
    WHILE (i < textsCount) & ~nameEq(texts[i].fileName, fileName) DO
        INC(i)
    END;
    IF i = textsCount THEN
        i := -1
    END
    RETURN i
END getFileNum;
 
 
PROCEDURE SwitchTab (n: INTEGER);
BEGIN
	curText := n;
	Tabs.switch(tabs, n);
	Switch(texts[n]);
	resetTimer;
	IF ~newtab THEN
		draw_window
	END
END SwitchTab;
 
 
PROCEDURE NewFile;
VAR
	nov: T.tText;
BEGIN
	IF textsCount < maxTexts THEN
		nov := T.New();
		T.SetPos(nov, 0, 0);
		insert(textsCount, nov);
		newtab := TRUE;
		SwitchTab(curText)
	ELSE
		error("too many files")
	END
END NewFile;
 
 
PROCEDURE open (_fileName: RW.tFileName): BOOLEAN;
VAR
	fileName: RW.tFileName;
    nov: T.tText;
    err, n: INTEGER;
    res, empty: BOOLEAN;
BEGIN
	res := TRUE;
    IF textsCount < maxTexts THEN
    	fileName := _fileName;
    	IF fileName = "" THEN
        	OD._type := OpenDlg.topen;
        	OpenFile(fileName, EditFilter)
        END;
        IF fileName # "" THEN
            n := getFileNum(fileName);
            IF n = -1 THEN
                nov := T.open(fileName, 0, 0, err);
                IF nov = NIL THEN
                    error("error opening file");
                    SwitchTab(curText);
                    res := FALSE
                ELSE
                	T.switch(text);
                	empty := (textsCount = 1) & (text.fileName = "") & T.empty(text) &
                		ChangeLog.isFirstGuard(text.edition) & ChangeLog.isLastGuard(text.edition);
                	T.switch(nov);
                	T.SetPos(nov, 0, 0);
                    insert(textsCount, nov);
                    IF empty THEN
                    	closeFile(FALSE, 0)
                    END;
                    Scroll.setValue(hScroll, 0);
                    Scroll.setValue(vScroll, 0)
                END
            ELSE
                SwitchTab(n)
            END
        END
    ELSE
        error("too many files");
        res := FALSE
    END
    RETURN res
END open;
 
 
PROCEDURE OpenDial;
VAR
	res: BOOLEAN;
BEGIN
	res := open("")
END OpenDial;
 
 
PROCEDURE createSearchForm;
BEGIN
	EB.create(LEFT_PADDING, TOP + 20, EditBox_Width, EDITBOX_MAXCHARS, FindEdit);
	EB.create(LEFT_PADDING, TOP + 20 + 55, EditBox_Width, EDITBOX_MAXCHARS, ReplaceEdit);
    EB.create(LEFT_PADDING, TOP + 20 + 330, EditBox_Width, EDITBOX_MAXCHARS, GotoEdit);
    INCL(GotoEdit.flags, 15);
    CheckBox.create("backward", BKW);
    CheckBox.create("match case", CS);
    CheckBox.create("whole word", WH);
END createSearchForm;
 
 
PROCEDURE EditBox_Get (edit: EB.tEditBox; VAR s: ARRAY OF WCHAR);
VAR
    str: ARRAY EDITBOX_MAXCHARS + 1 OF CHAR;
    i: INTEGER;
BEGIN
    EB.get(edit, str);
    i := 0;
    WHILE str[i] # 0X DO
        s[i] := WCHR(E.cp866[ORD(str[i])]);
        INC(i)
    END;
    s[i] := 0X
END EditBox_Get;
 
 
PROCEDURE Search;
BEGIN
    search := ~search;
    LEFT := LEFT_PADDING;
    IF search THEN
        searchOpened := TRUE;
        INC(LEFT, EditBox_Width + SEARCH_PADDING*2 + 4);
        IF T.search(text, searchText, cs, whole) THEN END
    ELSE
        IF T.search(text, "", FALSE, FALSE) THEN END
    END;
    SetFocus(FindEdit, search);
    resize;
    draw_window
END Search;
 
 
PROCEDURE click (x, y: INTEGER): INTEGER;
VAR
    scrollX, scrollY: INTEGER;
    shift, ctrl: BOOLEAN;
BEGIN
    K.getKBState(shift, ctrl);
    T.getScroll(text, scrollX, scrollY);
    T.scroll(text, hScroll.value - scrollX, vScroll.value - scrollY);
    IF U.between(0, x, canvas.width - 1) & U.between(0, y, canvas.height - 1) THEN
        leftButton := TRUE;
        SetFocus(FindEdit, FALSE);
        IF ~shift THEN
            T.resetSelect(text)
        END;
        T.mouse(text, x, y)
    END;
    repaint
    RETURN K.GetTickCount()
END click;
 
 
PROCEDURE Close;
VAR
    cont: BOOLEAN;
BEGIN
    closing := TRUE;
    cont := TRUE;
    WHILE (textsCount > 0) & cont DO
        IF text.modified THEN
            Confirm;
            cont := FALSE
        ELSE
            closeFile(FALSE, curText);
            repaint
        END
    END
END Close;
 
 
PROCEDURE CloseMenu;
BEGIN
    Menu.close(subEOL);
    Menu.close(subCurLine);
    Menu.close(subIndent);
    Menu.close(subCase);
    Menu.close(subBookmark);
    Menu.close(menuFile);
    Menu.close(menuEdit);
    Menu.close(menuSearch);
    Menu.close(menuEncoding);
    Menu.close(menuView);
    Menu.close(menuLanguage);
    Menu.close(menuProgram);
    Menu.close(menuTools);
    Menu.close(menuOptions);
    Menu.close(context)
END CloseMenu;
 
 
PROCEDURE goto;
VAR
    gotoVal: INTEGER;
BEGIN
    EditBox_Get(GotoEdit, gotoText);
    IF U.str2int(gotoText, gotoVal) & T.goto(text, gotoVal) THEN
    	SetFocus(GotoEdit, FALSE)
    END
END goto;
 
 
PROCEDURE Script (script: ARRAY OF CHAR);
BEGIN
    IF script # "" THEN
    	U.getPath(script, CurFolder);
    	K.SetCurFolder(CurFolder);
        K.Run("/sys/@open", script)
    END
END Script;
 
 
PROCEDURE ShowSearchPanel (goto: BOOLEAN);
VAR
	i: INTEGER;
BEGIN
	IF T.selected(text) & ~goto THEN
		T.getSelectedText(text, new_searchText);
		IF new_searchText # "" THEN
			i := 0;
			WHILE (new_searchText[i] # 0X) & (new_searchText[i] # Lines.TAB) DO
				INC(i)
			END;
			IF new_searchText[i] = 0X THEN
				searchText := new_searchText;
				EB.set(FindEdit, searchText);
				notFound := ~T.search(text, searchText, cs, whole);
			END
		END
	END;
    IF ~search THEN
        Search
    ELSIF ~searchOpened THEN
        search := FALSE;
        Search
    END;
    IF goto THEN
    	SetFocus(GotoEdit, TRUE)
    ELSE
    	SetFocus(FindEdit, TRUE)
    END
END ShowSearchPanel;
 
 
PROCEDURE CanvasToScreen (VAR x, y: INTEGER);
VAR
    cliX, cliY,
    winX, winY: INTEGER;
BEGIN
    K.WinPos(winX, winY);
    K.ClientPos(cliX, cliY);
    x := x + winX + cliX + LEFT;
    y := y + winY + cliY + TOP;
END CanvasToScreen;
 
 
PROCEDURE ShowMenu (menu: Menu.tMenu);
VAR
    winX, winY, cliX, cliY, x, y, i: INTEGER;
    selected, enabled: BOOLEAN;
BEGIN
    IF menu = context THEN
        mouse(x, y);
        IF ~(U.between(0, x, canvas.width - 1) & U.between(0, y, canvas.height - 1)) THEN
            menu := NIL
        END
    ELSE
        K.WinPos(winX, winY);
        K.ClientPos(cliX, cliY);
        x := winX + cliX;
        y := Menu.MainMenuHeight + winY + cliY
    END;
    selected := T.selected(text);
 
    IF menu = menuFile THEN
        Menu.setEnabled(menu, menuSave, text.modified);
        Menu.setEnabled(menu, menuFolder, text.fileName # "");
        i := 0;
        WHILE (i < textsCount) & ~texts[i].modified DO
            INC(i)
        END;
        Menu.setEnabled(menu, menuSaveAll, i < textsCount)
    ELSIF (menu = menuEdit) OR (menu = context) THEN
        Menu.setEnabled(menu, menuUndo, ~ChangeLog.isFirstGuard(text.edition));
        Menu.setEnabled(menu, menuRedo, ~ChangeLog.isLastGuard(text.edition));
        Menu.setEnabled(menu, menuCut, selected);
        Menu.setEnabled(menu, menuCopy, selected);
        Menu.setEnabled(menu, menuDelete, selected);
        Menu.setEnabled(menu, menuPaste, CB.available());
        IF menu = context THEN
            IF y + menu.height >= canvas.height THEN
                DEC(y, menu.height)
            END;
            IF x + menu.width >= canvas.width THEN
                DEC(x, menu.width)
            END;
            CanvasToScreen(x, y);
            menu.x := x;
            x := 0
        END
    ELSIF menu = menuEncoding THEN
        Menu.option(menu, menuUTF8BOM, T.getEnc(text) = E.UTF8BOM);
        Menu.option(menu, menuUTF8,    T.getEnc(text) = E.UTF8);
        Menu.option(menu, menuCP866,   T.getEnc(text) = E.CP866);
        Menu.option(menu, menuCP1251,  T.getEnc(text) = E.CP1251)
    ELSIF menu = menuView THEN
        Menu.option(menu, menuFontSmall,  font = G.fonts[0]);
        Menu.option(menu, menuFontMedium, font = G.fonts[1]);
        Menu.option(menu, menuFontLarge,  font = G.fonts[2]);
        FOR i := 0 TO Ini.sections.count - 1 DO
            Menu.option(menu, menuColors + i, Ini.curSectionNum = i)
        END
    ELSIF menu = menuLanguage THEN
        Menu.option(menu, menuText,   text.lang = Languages.langText);
        Menu.option(menu, menuC,      text.lang = Languages.langC);
        Menu.option(menu, menuFasm,   text.lang = Languages.langFasm);
        Menu.option(menu, menuIni,    text.lang = Languages.langIni);
        Menu.option(menu, menuJSON,   text.lang = Languages.langJSON);
        Menu.option(menu, menuLua,    text.lang = Languages.langLua);
        Menu.option(menu, menuOberon, text.lang = Languages.langOberon);
        Menu.option(menu, menuPascal, text.lang = Languages.langPascal);
    ELSIF menu = menuProgram THEN
        Menu.setEnabled(menu, menuBuild, (buildScript # "") OR text.fasm);
        Menu.setEnabled(menu, menuDebug, (debugScript # "") OR text.fasm);
        Menu.setEnabled(menu, menuRun,   (runScript # "") OR text.fasm);
        Menu.setEnabled(menu, menuBuildScript, ~text.fasm);
        Menu.setEnabled(menu, menuDebugScript, ~text.fasm);
        Menu.setEnabled(menu, menuRunScript,   ~text.fasm);
        Menu.check(menu, menuFASM, text.fasm)
    ELSIF menu = menuOptions THEN
    	Menu.check(menu, menuLineNumbers,  T.lineNumbers);
    	Menu.check(menu, menuAutoIndents,  T.autoIndents);
    	Menu.check(menu, menuAutoBrackets, T.autoBrackets);
    	Menu.check(menu, menuTrimSpace,    T.trimSpace)
    END;
 
    enabled := search & (searchText # "");
    Menu.setEnabled(menuSearch, menuFindNext, enabled);
    Menu.setEnabled(menuSearch, menuFindPrev, enabled);
 
    Menu.setEnabled(subIndent, menuIncInd, selected);
    Menu.setEnabled(subIndent, menuDecInd, selected);
 
    Menu.setEnabled(subCase, menuUpper, selected);
    Menu.setEnabled(subCase, menuLower, selected);
 
	Menu.option(subEOL, menuCRLF, T.getEol(text) = E.EOL_CRLF);
	Menu.option(subEOL, menuLF,   T.getEol(text) = E.EOL_LF);
	Menu.option(subEOL, menuCR,   T.getEol(text) = E.EOL_CR);
 
    IF menu # NIL THEN
    	timerEnabled := FALSE;
        IF Menu.opened(menu) THEN
            Menu.close(menu)
        END;
        Menu.open(menu, menu.x + x, y);
        menuActive := TRUE
    END
END ShowMenu;
 
 
PROCEDURE setScript (VAR script: RW.tFileName);
VAR
	temp: RW.tFileName;
BEGIN
	OpenFile(temp, ShellFilter);
	IF temp # "" THEN
		script := temp
	END
END setScript;
 
 
PROCEDURE FasmCompile (run, debug: BOOLEAN);
VAR
	curFileName, ext, outfile, path, param: RW.tFileName;
BEGIN
	curFileName := texts[curText].fileName;
	U.getFileName(curFileName, param, U.SLASH);
	U.getFileName(curFileName, ext, ".");
	U.getPath(curFileName, path);
	outfile := param;
	IF (ext # "") & ((LENGTH(ext) + 1) < LENGTH(outfile)) THEN
		outfile[LENGTH(outfile) - LENGTH(ext) - 1] := 0X
	ELSE
		U.append8(outfile, ".kex")
	END;
	U.append8(param, ",");
	U.append8(param, outfile);
	U.append8(param, ",");
	U.append8(param, path);
	U.append8(param, U.SLASH);
	IF run THEN
		U.append8(param, ",run")
	ELSIF debug THEN
		U.append8(param, ",dbg")
	END;
	K.Run("/sys/develop/fasm", param)
END FasmCompile;
 
 
PROCEDURE ProgramBuild;
BEGIN
	IF ~text.fasm THEN
    	Script(buildScript)
    ELSE
    	FasmCompile(FALSE, FALSE)
    END
END ProgramBuild;
 
 
PROCEDURE ProgramRun;
BEGIN
	IF ~text.fasm THEN
    	Script(runScript)
    ELSE
    	FasmCompile(TRUE, FALSE)
    END
END ProgramRun;
 
 
PROCEDURE ProgramDebug;
BEGIN
	IF ~text.fasm THEN
    	Script(debugScript)
    ELSE
    	FasmCompile(FALSE, TRUE)
    END
END ProgramDebug;
 
 
PROCEDURE ClickMenu;
VAR
	item: List.tItem;
BEGIN
	IF Menu.MenuItem < 0 THEN
		item := List.getItem(mainMenu, (-Menu.MenuItem - mainMenuBtn) MOD mainMenu.count);
		IF item # NIL THEN
			ShowMenu(item(Menu.tMainItem).menu)
		END;
		Menu.SetItem(0)
	END;
    CASE Menu.MenuItem OF
    |0:
    |menuCut:       T.key(text, ORD("X"), FALSE, TRUE)
    |menuCopy:      T.key(text, ORD("C"), FALSE, TRUE)
    |menuPaste:     T.key(text, ORD("V"), FALSE, TRUE)
    |menuDelete:    T.key(text,       46, FALSE, FALSE)
    |menuSelectAll: T.key(text, ORD("A"), FALSE, TRUE)
 
    |menuNew:
        NewFile
    |menuOpen:
        OpenDial
    |menuSave:
        save(text);
        repaint
    |menuSaveAs:
        saveAs(text);
        repaint
    |menuSaveAll:
        saveAll;
        repaint
    |menuClose:
        closeFile(TRUE, curText)
    |menuFolder:
        K.Run("/sys/File Managers/Eolite", text.fileName)
    |menuExit:
        Close
    |menuUndo:
        T.undo(text);
        repaint
    |menuRedo:
        T.redo(text);
        repaint
    |menuFind:
        ShowSearchPanel(FALSE)
    |menuFindNext:
        notFound := ~T.findNext(text, BKW.value);
        menuFindClicked := TRUE
    |menuFindPrev:
        notFound := ~T.findNext(text, ~BKW.value);
        menuFindClicked := TRUE
    |menuGoto:
        ShowSearchPanel(TRUE)
    |menuToggleBookmark:
    	T.toggleLabel(text)
    |menuNextBookmark:
    	T.gotoLabel(text, TRUE)
    |menuPrevBookmark:
    	T.gotoLabel(text, FALSE)
    |menuFontSmall..menuFontLarge:
    	font := G.fonts[Menu.MenuItem - menuFontSmall];
    	Ini.setInt("settings", "font", Menu.MenuItem - menuFontSmall);
    	resize
    |menuText:
        T.setLang(text, Languages.langText)
    |menuC:
        T.setLang(text, Languages.langC)
    |menuFasm:
        T.setLang(text, Languages.langFasm)
    |menuIni:
        T.setLang(text, Languages.langIni)
    |menuJSON:
        T.setLang(text, Languages.langJSON)
    |menuLua:
        T.setLang(text, Languages.langLua)
    |menuOberon:
        T.setLang(text, Languages.langOberon)
    |menuPascal:
        T.setLang(text, Languages.langPascal)
    |menuBuild:
    	ProgramBuild
    |menuBuildScript:
    	setScript(buildScript)
    |menuRun:
    	ProgramRun
    |menuRunScript:
    	setScript(runScript)
    |menuDebug:
    	ProgramDebug
    |menuDebugScript:
    	setScript(debugScript)
    |menuFASM:
    	text.fasm := ~text.fasm
    |menuUTF8BOM:
    	T.setEnc(text, E.UTF8BOM)
    |menuUTF8:
    	T.setEnc(text, E.UTF8)
    |menuCP866:
    	T.setEnc(text, E.CP866)
    |menuCP1251:
    	T.setEnc(text, E.CP1251)
    |menuLF:
    	T.setEol(text, E.EOL_LF)
    |menuCRLF:
    	T.setEol(text, E.EOL_CRLF)
    |menuCR:
    	T.setEol(text, E.EOL_CR)
    |menuConv1251_866:
    	T.convert(text, (*E.cp866,*) E.CP1251)
    |menuConv866_1251:
    	T.convert(text, (*E.cp1251,*) E.CP866)
    |menuPipet:
        K.Run("/sys/develop/pipet", "")
    |menuMagnify:
        K.Run("/sys/magnify", "")
    |menuBoard:
        K.Run("/sys/develop/board", "")
    |menuSysFunc:
        K.Run("/sys/docpack", "f")
    |menuLineNumbers:
        T.toggleNumbers;
        Ini.setInt("settings", "line_numbers", ORD(T.lineNumbers))
    |menuAutoIndents:
        T.toggleIndents;
        Ini.setInt("settings", "auto_indents", ORD(T.autoIndents))
    |menuAutoBrackets:
        T.toggleBrackets;
        Ini.setInt("settings", "auto_brackets", ORD(T.autoBrackets))
    |menuTrimSpace:
        T.toggleTrimSpace;
        Ini.setInt("settings", "trim_space", ORD(T.trimSpace))
    |menuColors..menuMaxColors:
        Ini.selectSection(Menu.MenuItem - menuColors);
        Ini.setInt("settings", "theme", Menu.MenuItem - menuColors)
    |menuMoveUp:
    	T.MoveLines(text, FALSE)
    |menuMoveDown:
		T.MoveLines(text, TRUE)
    |menuDuplicate:
    	T.dupLine(text)
    |menuRemove:
    	T.delLine(text)
    |menuIncInd:
    	T.Indent(text, TRUE)
	|menuDecInd:
		T.Indent(text, FALSE)
	|menuUpper:
		T.chCase(text, TRUE)
	|menuLower:
		T.chCase(text, FALSE)
    END;
    Menu.SetItem(0)
END ClickMenu;
 
 
PROCEDURE CreateContextMenu (): Menu.tMenu;
VAR
    menu: List.tList;
BEGIN
    menu := List.create(NIL);
    Menu.AddMenuItem(menu, menuUndo,      "undo         ctrl-Z");
    Menu.AddMenuItem(menu, menuRedo,      "redo         ctrl-Y");
    Menu.delimiter(menu);
    Menu.AddMenuItem(menu, menuCut,       "cut          ctrl-X");
    Menu.AddMenuItem(menu, menuCopy,      "copy         ctrl-C");
    Menu.AddMenuItem(menu, menuPaste,     "paste        ctrl-V");
    Menu.AddMenuItem(menu, menuDelete,    "delete");
    Menu.delimiter(menu);
    Menu.AddMenuItem(menu, menuSelectAll, "select all   ctrl-A");
    RETURN Menu.create(menu, mainTID)
END CreateContextMenu;
 
 
PROCEDURE CreateMenuFile (): Menu.tMenu;
VAR
    menu: List.tList;
BEGIN
    menu := List.create(NIL);
    Menu.AddMenuItem(menu, menuNew,     "new         ctrl-N");
    Menu.AddMenuItem(menu, menuOpen,    "open        ctrl-O");
    Menu.AddMenuItem(menu, menuSave,    "save        ctrl-S");
    Menu.AddMenuItem(menu, menuSaveAs,  "save as");
    Menu.AddMenuItem(menu, menuSaveAll, "save all");
    Menu.AddMenuItem(menu, menuFolder,  "folder");
    Menu.delimiter(menu);
    Menu.AddMenuItem(menu, menuClose,   "close       ctrl-W");
    Menu.delimiter(menu);
    Menu.AddMenuItem(menu, menuExit,    "exit");
    RETURN Menu.create(menu, mainTID)
END CreateMenuFile;
 
 
PROCEDURE CreateMenuEdit (): Menu.tMenu;
VAR
    menu: List.tList;
BEGIN
    menu := List.create(NIL);
    Menu.AddMenuItem(menu, menuUndo,      "undo            ctrl-Z");
    Menu.AddMenuItem(menu, menuRedo,      "redo            ctrl-Y");
    Menu.delimiter(menu);
    Menu.AddMenuItem(menu, menuCut,       "cut             ctrl-X");
    Menu.AddMenuItem(menu, menuCopy,      "copy            ctrl-C");
    Menu.AddMenuItem(menu, menuPaste,     "paste           ctrl-V");
    Menu.AddMenuItem(menu, menuDelete,    "delete");
    Menu.delimiter(menu);
    Menu.AddMenuItem(menu, menuSelectAll, "select all      ctrl-A");
    Menu.delimiter(menu);
    Menu.AddMenuItem(menu, menuCurLine,   "current line");
    Menu.child(menu, subCurLine);
    Menu.AddMenuItem(menu, menuIndent,    "indent");
    Menu.child(menu, subIndent);
    Menu.AddMenuItem(menu, menuCase,      "case");
    Menu.child(menu, subCase);
    RETURN Menu.create(menu, mainTID)
END CreateMenuEdit;
 
 
PROCEDURE CreateMenuSearch (): Menu.tMenu;
VAR
    menu: List.tList;
BEGIN
    menu := List.create(NIL);
    Menu.AddMenuItem(menu, menuFind,     "search           ctrl-F");
    Menu.AddMenuItem(menu, menuFindNext, "find next        F3");
    Menu.AddMenuItem(menu, menuFindPrev, "find previous    shift-F3");
    Menu.AddMenuItem(menu, menuGoto,     "go to line       ctrl-G");
    Menu.delimiter(menu);
    Menu.AddMenuItem(menu, menuBookmark, "bookmark");
    Menu.child(menu, subBookmark);
    RETURN Menu.create(menu, mainTID)
END CreateMenuSearch;
 
 
PROCEDURE CreateMenuEncoding (): Menu.tMenu;
VAR
    menu: List.tList;
BEGIN
    menu := List.create(NIL);
    Menu.AddMenuItem(menu, menuUTF8BOM, E.names[E.UTF8BOM]);
    Menu.AddMenuItem(menu, menuUTF8,    E.names[E.UTF8]);
    Menu.AddMenuItem(menu, menuCP866,   E.names[E.CP866]);
    Menu.AddMenuItem(menu, menuCP1251,  E.names[E.CP1251]);
    Menu.delimiter(menu);
    Menu.AddMenuItem(menu, menuConv1251_866, "convert 1251 >> 866");
    Menu.AddMenuItem(menu, menuConv866_1251, "convert 866 >> 1251");
    Menu.delimiter(menu);
    Menu.AddMenuItem(menu, menuEOL,     "EOL");
    Menu.child(menu, subEOL);
    RETURN Menu.create(menu, mainTID)
END CreateMenuEncoding;
 
 
PROCEDURE CreateMenuEOL (): Menu.tMenu;
VAR
    menu: List.tList;
BEGIN
    menu := List.create(NIL);
    Menu.AddMenuItem(menu, menuCRLF, E.eolNames[E.EOL_CRLF]);
    Menu.AddMenuItem(menu, menuLF,   E.eolNames[E.EOL_LF]);
    Menu.AddMenuItem(menu, menuCR,   E.eolNames[E.EOL_CR]);
    RETURN Menu.create(menu, mainTID)
END CreateMenuEOL;
 
 
PROCEDURE CreateMenuView (): Menu.tMenu;
VAR
    menu: List.tList;
    colors: Ini.tSection;
    idx: INTEGER;
BEGIN
    menu := List.create(NIL);
    Menu.AddMenuItem(menu, menuFontSmall,  "small");
    Menu.AddMenuItem(menu, menuFontMedium, "medium");
    Menu.AddMenuItem(menu, menuFontLarge,  "large");
    Menu.delimiter(menu);
 
    colors := Ini.sections.first(Ini.tSection);
    idx := menuColors;
    WHILE colors # NIL DO
        Menu.AddMenuItem(menu, idx, colors.name);
        INC(idx);
        colors := colors.next(Ini.tSection)
    END;
 
    RETURN Menu.create(menu, mainTID)
END CreateMenuView;
 
 
PROCEDURE CreateMenuLanguage (): Menu.tMenu;
VAR
    menu: List.tList;
BEGIN
    menu := List.create(NIL);
    Menu.AddMenuItem(menu, menuC,      "C");
    Menu.AddMenuItem(menu, menuFasm,   "Fasm");
    Menu.AddMenuItem(menu, menuIni,    "Ini");
    Menu.AddMenuItem(menu, menuJSON,   "JSON");
    Menu.AddMenuItem(menu, menuLua,    "Lua");
    Menu.AddMenuItem(menu, menuOberon, "Oberon");
    Menu.AddMenuItem(menu, menuPascal, "Pascal");
    Menu.delimiter(menu);
    Menu.AddMenuItem(menu, menuText,   "Text");
    RETURN Menu.create(menu, mainTID)
END CreateMenuLanguage;
 
 
PROCEDURE CreateMenuProgram (): Menu.tMenu;
VAR
    menu: List.tList;
BEGIN
    menu := List.create(NIL);
    Menu.AddMenuItem(menu, menuBuild,       "build    ctrl-F9");
    Menu.AddMenuItem(menu, menuBuildScript, "script");
    Menu.delimiter(menu);
    Menu.AddMenuItem(menu, menuRun,         "run           F9");
    Menu.AddMenuItem(menu, menuRunScript,   "script");
    Menu.delimiter(menu);
    Menu.AddMenuItem(menu, menuDebug,       "debug    ctrl-F8");
    Menu.AddMenuItem(menu, menuDebugScript, "script");
    Menu.delimiter(menu);
    Menu.AddMenuItem(menu, menuFASM, "Fasm");
    RETURN Menu.create(menu, mainTID)
END CreateMenuProgram;
 
 
PROCEDURE CreateMenuTools (): Menu.tMenu;
VAR
    menu: List.tList;
BEGIN
    menu := List.create(NIL);
    Menu.AddMenuItem(menu, menuPipet,   "pipet");
    Menu.AddMenuItem(menu, menuMagnify, "magnify");
    Menu.AddMenuItem(menu, menuBoard,   "board");
    Menu.AddMenuItem(menu, menuSysFunc, "system functions");
    RETURN Menu.create(menu, mainTID)
END CreateMenuTools;
 
 
PROCEDURE CreateMenuOptions (): Menu.tMenu;
VAR
    menu: List.tList;
BEGIN
    menu := List.create(NIL);
    Menu.AddMenuItem(menu, menuLineNumbers,  "line numbers");
    Menu.AddMenuItem(menu, menuAutoIndents,  "automatic indents");
    Menu.AddMenuItem(menu, menuAutoBrackets, "automatic brackets");
    Menu.AddMenuItem(menu, menuTrimSpace,    "trim trailing space");
    RETURN Menu.create(menu, mainTID)
END CreateMenuOptions;
 
 
PROCEDURE CreateMenuCurLine(): Menu.tMenu;
VAR
    menu: List.tList;
BEGIN
    menu := List.create(NIL);
    Menu.AddMenuItem(menu, menuMoveUp,    "move up     ctrl-Up");
    Menu.AddMenuItem(menu, menuMoveDown,  "move down   ctrl-Down");
    Menu.AddMenuItem(menu, menuDuplicate, "duplicate   ctrl-D");
    Menu.AddMenuItem(menu, menuRemove,    "remove      ctrl-Del");
    RETURN Menu.create(menu, mainTID)
END CreateMenuCurLine;
 
 
PROCEDURE CreateMenuIndent(): Menu.tMenu;
VAR
    menu: List.tList;
BEGIN
    menu := List.create(NIL);
    Menu.AddMenuItem(menu, menuIncInd, "increase    Tab");
    Menu.AddMenuItem(menu, menuDecInd, "decrease    shift-Bksp");
    RETURN Menu.create(menu, mainTID)
END CreateMenuIndent;
 
 
PROCEDURE CreateMenuCase(): Menu.tMenu;
VAR
    menu: List.tList;
BEGIN
    menu := List.create(NIL);
    Menu.AddMenuItem(menu, menuUpper, "UPPER    ctrl-U");
    Menu.AddMenuItem(menu, menuLower, "lower    ctrl-L");
    RETURN Menu.create(menu, mainTID)
END CreateMenuCase;
 
 
PROCEDURE CreateMenuBookmark(): Menu.tMenu;
VAR
    menu: List.tList;
BEGIN
    menu := List.create(NIL);
    Menu.AddMenuItem(menu, menuToggleBookmark, "toggle      ctrl-F2");
    Menu.AddMenuItem(menu, menuNextBookmark,   "next        F2");
    Menu.AddMenuItem(menu, menuPrevBookmark,   "previous    shift-F2");
    RETURN Menu.create(menu, mainTID)
END CreateMenuBookmark;
 
 
PROCEDURE Shortcuts;
BEGIN
    Menu.AddShortcut(17 + CTRL,  menuClose);
    Menu.AddShortcut(21 + CTRL,  menuRedo);
    Menu.AddShortcut(30 + CTRL,  menuSelectAll);
    Menu.AddShortcut(32 + CTRL,  menuDuplicate);
    Menu.AddShortcut(33 + CTRL,  menuFind);
    Menu.AddShortcut(35 + CTRL,  menuFind);
    Menu.AddShortcut(34 + CTRL,  menuGoto);
    Menu.AddShortcut(44 + CTRL,  menuUndo);
    Menu.AddShortcut(45 + CTRL,  menuCut);
    Menu.AddShortcut(46 + CTRL,  menuCopy);
    Menu.AddShortcut(47 + CTRL,  menuPaste);
    Menu.AddShortcut(24 + CTRL,  menuOpen);
    Menu.AddShortcut(31 + CTRL,  menuSave);
    Menu.AddShortcut(49 + CTRL,  menuNew);
    Menu.AddShortcut(67 + CTRL,  menuBuild);
    Menu.AddShortcut(66 + CTRL,  menuDebug);
    Menu.AddShortcut(83 + CTRL,  menuRemove);
    Menu.AddShortcut(22 + CTRL,  menuUpper);
    Menu.AddShortcut(38 + CTRL,  menuLower);
    Menu.AddShortcut(60 + CTRL,  menuToggleBookmark);
    Menu.AddShortcut(72 + CTRL,  menuMoveUp);
    Menu.AddShortcut(80 + CTRL,  menuMoveDown);
    Menu.AddShortcut(83,         menuDelete);
    Menu.AddShortcut(67,         menuRun);
    Menu.AddShortcut(15,         menuIncInd);
    Menu.AddShortcut(14 + SHIFT, menuDecInd);
    Menu.AddShortcut(60 + SHIFT, menuPrevBookmark);
    Menu.AddShortcut(60,         menuNextBookmark);
    Menu.AddShortcut(61 + SHIFT, menuFindPrev);
    Menu.AddShortcut(61,         menuFindNext);
END Shortcuts;
 
 
PROCEDURE HideSearch;
BEGIN
    SetFocus(FindEdit, FALSE);
    searchOpened := FALSE;
    LEFT := LEFT_PADDING;
    resize;
    draw_window
END HideSearch;
 
 
PROCEDURE KeyDown (key: INTEGER);
VAR
    keyCode: INTEGER;
    shift, ctrl: BOOLEAN;
BEGIN
	K.getKBState(shift, ctrl);
    keyCode := key DIV 65536;
    IF confirm THEN
        IF keyCode = 28 THEN (* Enter *)
            save(text);
            IF ~text.modified THEN
                closeFile(FALSE, curText)
            END
        END;
        key := -1
    ELSE
        IF keyCode = 61 THEN (* F3 *)
            key := -1;
            IF search & (searchText # "") THEN
                IF shift THEN
                    notFound := ~T.findNext(text, ~BKW.value)
                ELSE
                    notFound := ~T.findNext(text, BKW.value)
                END
            END
        ELSIF keyCode = 60 THEN (* F2 *)
            key := -1;
            IF ctrl THEN
                T.toggleLabel(text)
            ELSE
                T.gotoLabel(text, ~shift)
            END
        ELSIF keyCode = 66 THEN (* F8 *)
            key := -1;
            IF ctrl THEN
                ProgramDebug
            END
        ELSIF keyCode = 67 THEN (* F9 *)
            key := -1;
            IF ctrl THEN
                ProgramBuild
            ELSE
                ProgramRun
            END
        ELSIF keyCode = 68 THEN (* F10 *)
        	IF shift THEN
        		ShowMenu(context)
        	ELSE
        		ShowMenu(menuFile)
        	END;
            key := -1
        ELSIF keyCode = 1 THEN (* Esc *)
            IF search THEN
            	IF shift THEN
            		HideSearch
            	ELSE
                	Search
                END
            END;
            key := -1
        ELSIF (keyCode = 55) & (key DIV 256 MOD 256 = 52) THEN (* PrtScn *)
            key := -1
        ELSIF (keyCode = 14) & shift THEN (* shift+Backspace *)
            key := -1;
            T.input(text, -8)
        ELSIF (keyCode = 15) & ctrl THEN (* ctrl+Tab *)
            key := -1;
            SwitchTab((curText + 1) MOD textsCount)
        ELSIF ((keyCode = 33) OR (keyCode = 35)) & ctrl THEN (* ctrl+F, ctrl+H*)
            key := -1;
            ShowSearchPanel(FALSE)
        ELSIF (keyCode = 34) & ctrl THEN (* ctrl+G *)
            key := -1;
            ShowSearchPanel(TRUE)
        ELSIF (keyCode = 18) & ctrl THEN (* ctrl+E *)
            key := -1;
            T.selectWord(text)
        ELSE
            IF EditBox_Focus(FindEdit) THEN
            	IF keyCode = 15 THEN (* Tab *)
            		SetFocus(ReplaceEdit, TRUE)
            	ELSE
	                EB.key(FindEdit, key);
	                EditBox_Get(FindEdit, new_searchText);
	                IF new_searchText # searchText THEN
	                    searchText := new_searchText;
	                    notFound := ~T.search(text, searchText, cs, whole)
	                END
                END
            ELSIF EditBox_Focus(ReplaceEdit) THEN
            	IF keyCode = 15 THEN (* Tab *)
            		SetFocus(GotoEdit, TRUE)
            	ELSE
                	EB.key(ReplaceEdit, key);
                	EditBox_Get(ReplaceEdit, replaceText)
                END
            ELSIF EditBox_Focus(GotoEdit) THEN
            	IF keyCode = 15 THEN (* Tab *)
            		SetFocus(FindEdit, TRUE)
            	ELSE
	                IF (key DIV 256) MOD 256 = 13 THEN
	                    goto
	                ELSE
	                    EB.key(GotoEdit, key)
	                END
                END
            ELSE
                CASE keyCode OF
                |73: key := 33
                |81: key := 34
                |71: key := 36
                |79: key := 35
                |72: key := 38
                |80: key := 40
                |75: key := 37
                |77: key := 39
                |82, 91, 219, 92, 220: key := -1 (* insert, windows *)
                |93: ShowMenu(context); key := -1
                |83: key := 46
                |59, 62..66, 87, 88: key := -1 (* F1, F4..F8, F11, F12 *)
                ELSE
                    IF ctrl THEN
                        CASE keyCode OF
                        |17: closeFile(TRUE, curText);
                             key := -2
                        |21: T.redo(text);
                             key := -1
                        |22: key := ORD("U")
                        |24: key := -1;
                             OpenDial
                        |30: key := ORD("A")
                        |31: key := -1;
                             save(text)
                        |32: key := ORD("D")
                        |38: key := ORD("L")
                        |44: T.undo(text);
                             key := -1
                        |45: key := ORD("X")
                        |46: key := ORD("C")
                        |47: key := ORD("V")
                        |49,
                         20: key := -1;
                             NewFile
                        ELSE
                            key := -1
                        END
                    ELSE
                        T.input(text, E.cp866[key DIV 256 MOD 256]);
                        key := -1
                    END
                END;
                IF key >= 0 THEN
                    T.key(text, key, shift, ctrl)
                END
            END
        END
    END;
    IF key # -2 THEN
        repaint
    END
END KeyDown;
 
 
PROCEDURE BtnClick;
VAR
    btn: INTEGER;
    middle, exit: BOOLEAN;
    menu: Menu.tMenu;
BEGIN
	exit := FALSE;
    btn := K.ButtonCode(middle);
    IF U.between(Tabs.btnID, btn, Tabs.btnID + maxTexts - 1) THEN
        DEC(btn, Tabs.btnID);
        IF middle THEN
            IF texts[btn].modified THEN
                SwitchTab(btn)
            END;
            closeFile(TRUE, btn)
        ELSE
            SwitchTab(btn)
        END;
        btn := 0
    ELSIF U.between(Tabs.btnClose, btn, Tabs.btnClose + maxTexts - 1) THEN
        DEC(btn, Tabs.btnClose);
        IF texts[btn].modified THEN
            SwitchTab(btn)
        END;
        closeFile(TRUE, btn);
        middle := TRUE;
        btn := 0
    ELSE
        IF middle THEN
            btn := 0
        END
    END;
    IF btn # 0 THEN
    	menu := Menu.ClickMain(mainMenu, btn);
    	IF menu # NIL THEN
    		ShowMenu(menu);
    		btn := 0
    	END
    END;
 
    CASE btn OF
    |0:
    |Tabs.btnLeft, Tabs.btnRight:
    	Tabs.scroll(tabs, btn);
    	switch := TRUE
    |btnNo:
        exit := closing;
        closeFile(FALSE, curText);
        repaint
    |btnYes:
        exit := closing;
        save(text);
        IF ~text.modified THEN
            closeFile(FALSE, curText)
        END;
        repaint
    |btnClose:
    	exit := TRUE
    |btnNew:
        NewFile
    |btnOpen:
        OpenDial
    |btnSave:
        save(text)
    |btnSearch:
        ShowSearchPanel(FALSE)
    |btnCloseSearch:
        Search
    |btnHideSearch:
        HideSearch
    |btnUndo:
        T.undo(text)
    |btnRedo:
        T.redo(text)
    |btnUpper:
        T.chCase(text, TRUE)
    |btnLower:
        T.chCase(text, FALSE)
    |btnBuild:
    	ProgramBuild
    |btnRun:
    	ProgramRun
    |btnFindNext:
        IF searchText # "" THEN
            notFound := ~T.findNext(text, BKW.value);
            SetFocus(FindEdit, FALSE)
        END
    |btnReplace:
        T.replace(text, replaceText, LENGTH(searchText));
        SetFocus(FindEdit, FALSE)
    |btnReplaceAll:
        notFound := ~T.search(text, searchText, cs, whole);
        IF ~notFound THEN
            replaced := T.replaceAll(text, replaceText, LENGTH(searchText));
        END;
        SetFocus(FindEdit, FALSE)
    |btnGoto:
        goto
    END;
 
    IF ~middle THEN
		IF exit THEN
			Close
		ELSE
			repaint
		END
	END
END BtnClick;
 
 
PROCEDURE MouseEvent (VAR resized: BOOLEAN; VAR firstClickX, firstClickY, time: INTEGER);
CONST
    DELAY = 10;
VAR
    msState: SET;
    scroll, x, y, scrollX, scrollY: INTEGER;
    pos1, pos2: T.tPoint;
 
 
    PROCEDURE EditBox (VAR eb: EB.tEditBox);
    VAR
        focus: BOOLEAN;
    BEGIN
        focus := EditBox_Focus(eb);
        EB.mouse(eb);
        IF focus # EditBox_Focus(eb) THEN
            SetFocus(eb, TRUE);
            repaint
        END
    END EditBox;
 
 
BEGIN
	CloseMenu;
    IF ~resized THEN
        msState := K.MouseState();
        IF ~(0 IN msState) OR (16 IN msState) THEN
        	leftButton := FALSE
        END;
        scroll := K.Scroll();
        IF scroll # 0 THEN
            T.scroll(text, 0, scroll*3);
            repaint
        END;
        IF leftButton THEN
            IF K.GetTickCount() - time >= DELAY THEN
            	T.getPos(text, pos1.Y, pos1.X);
                mouse(x, y);
                T.mouse(text, x, y);
                T.getPos(text, pos2.Y, pos2.X);
                IF (pos1.X # pos2.X) OR (pos1.Y # pos2.Y) THEN
                	repaint
                END
            END
        END;
 
		Scroll.mouse(hScroll);
		Scroll.mouse(vScroll);
		msState := K.MouseState();
        T.getScroll(text, scrollX, scrollY);
        IF (hScroll.value # scrollX) OR (vScroll.value # scrollY) THEN
			T.scroll(text, hScroll.value - scrollX, vScroll.value - scrollY);
        	repaint
        END;
 
        IF (8 IN msState) & ~(24 IN msState) THEN
            mouse(firstClickX, firstClickY);
            time := click(firstClickX, firstClickY)
        END;
        IF 9 IN msState THEN
            ShowMenu(context)
        END;
        IF 24 IN msState THEN
            mouse(x, y);
            IF U.between(-4, x - firstClickX, 4) & U.between(-4, y - firstClickY, 4) THEN
                IF U.between(0, x, canvas.width - 1) & U.between(0, y, canvas.height - 1) THEN
                    leftButton := FALSE;
                    T.selectWord(text);
                    repaint
                ELSIF Tabs.DblClicked(tabs, x + LEFT, y + TOP) THEN
                	leftButton := FALSE;
                	NewFile;
                	repaint
                END
            ELSE
                firstClickX := x;
                firstClickY := y;
                time := click(firstClickX, firstClickY)
            END
        END;
        IF msState = {} THEN
        	mouse(x, y);
        	Menu.MouseMove(mainMenu, x + LEFT, y + TOP)
        END
    END;
    IF search & searchOpened THEN
	    CheckBox.mouse(BKW);
    	CheckBox.mouse(CS);
    	CheckBox.mouse(WH);
        EditBox(FindEdit);
        EditBox(ReplaceEdit);
        EditBox(GotoEdit);
        IF (CS.value # cs) OR (WH.value # whole) THEN
            cs := CS.value;
            whole := WH.value;
            notFound := ~T.search(text, searchText, cs, whole);
            repaint
        END
    END;
    resized := FALSE
END MouseEvent;
 
 
PROCEDURE Redraw (VAR resized: BOOLEAN; VAR width, height, cliWidth, cliHeight: INTEGER);
VAR
	onClose: BOOLEAN;
BEGIN
	onClose := (Menu.MenuItem = menuClose) OR (Menu.MenuItem = menuExit);
	IF ~onClose THEN
		ClickMenu
	END;
	K.GetSystemColors;
	IF ~K.RolledUp() THEN
		K.ClientSize(width, height);
		IF (width # cliWidth) OR (height # cliHeight) THEN
			cliWidth := width;
			cliHeight := height;
			resize;
			resized := TRUE
		END
	ELSE
		SetCaption(text.fileName)
	END;
	draw_window;
	IF SkinHeight # K.SkinHeight() THEN
		SkinHeight := K.SkinHeight();
		Redraw(resized, width, height, cliWidth, cliHeight)
	END;
	IF onClose THEN
		ClickMenu
	END
END Redraw;
 
 
PROCEDURE ScrollChange;
BEGIN
	T.scroll(text, hScroll.btn, vScroll.btn);
	IF menuActive THEN
		draw_window;
		menuActive := FALSE
	ELSE
		repaint
	END
END ScrollChange;
 
 
PROCEDURE receiveIPC;
VAR
	x, y, cliX, cliY, winX, winY: INTEGER;
BEGIN
	K.ClientPos(cliX, cliY);
	K.WinPos(winX, winY);
	x := IPC[2] DIV 65536 - cliX - winX;
	y := IPC[2] MOD 65536 - cliY - winY;
	Menu.MouseMove(mainMenu, x, y);
	IPC[1] := 0;
	IPC[0] := 0
END receiveIPC;
 
 
PROCEDURE main;
VAR
    fileName, filePath: RW.tFileName;
    width, height, cliWidth, cliHeight: INTEGER;
    resized: BOOLEAN;
    firstClickX, firstClickY, time, blink, i: INTEGER;
    key, scr: INTEGER;
    text_ptr, text_size, errno: INTEGER;
BEGIN
	mainTID := K.ThreadID();
	header := "";
    K.GetSystemColors;
    switch := FALSE;
    closing := FALSE;
    textsCount := 0;
    curText := 0;
    Args.GetArg(0, AppPath);
    Ini.load(AppPath);
    Ini.getSettings;
    runScript := Ini.runScript;
    buildScript := Ini.buildScript;
    debugScript := Ini.debugScript;
    leftButton := FALSE;
    resized := FALSE;
    newtab := FALSE;
    K.ScreenSize(winWidth, winHeight);
    scrollWidth := winHeight DIV 35;
    winWidth := (winWidth*80) DIV 100 - (128 + 30);
    winHeight := winHeight - (128 + 30);
    winWidth := MAX(winWidth, minWinWidth);
    winHeight := MAX(winHeight, minWinHeight);
    cliWidth := winWidth;
    cliHeight := winHeight;
 
    LEFT := LEFT_PADDING;
    RIGHT := scrollWidth - 2;
    BOTTOM := SB.height() + scrollWidth - 1;
    SkinHeight := K.SkinHeight();
    canvas := G.CreateCanvas(winWidth - (LEFT + RIGHT + 11 + RIGHT_PADDING), winHeight - (TOP + BOTTOM + 5 - ClippingArea) - SkinHeight);
    DEC(canvas.height, ClippingArea);
    tabs := Tabs.create();
    Tabs.setArea(tabs, LEFT, TOP - Tabs.tabHeight, canvas.width, Tabs.tabHeight);
    font := G.fonts[Ini.font];
    G.SetFont(canvas, font);
    T.init(resetTimer, Ini.lineNumbers, Ini.autoIndents, Ini.autoBrackets, Ini.trimSpace);
    Ini.selectSection(Ini.theme);
    T.setCanvas(canvas);
 
    mainMenu := Menu.CreateMain(mainMenuBtn);
 
    Menu.init(resetTimer);
    context := CreateContextMenu();
    menuFile := CreateMenuFile();
    subCurLine := CreateMenuCurLine();
    subIndent := CreateMenuIndent();
    subCase := CreateMenuCase();
    menuEdit := CreateMenuEdit();
    subCurLine.parent := menuEdit;
    subIndent.parent := menuEdit;
    subCase.parent := menuEdit;
    subBookmark := CreateMenuBookmark();
    menuSearch := CreateMenuSearch();
    subBookmark.parent := menuSearch;
    subEOL := CreateMenuEOL();
    menuEncoding := CreateMenuEncoding();
    subEOL.parent := menuEncoding;
    menuView := CreateMenuView();
    menuLanguage := CreateMenuLanguage();
    menuProgram := CreateMenuProgram();
    menuTools := CreateMenuTools();
    menuOptions := CreateMenuOptions();
 
 
    Menu.AddMainItem(mainMenu, "file", menuFile);
    Menu.AddMainItem(mainMenu, "edit", menuEdit);
    Menu.AddMainItem(mainMenu, "search", menuSearch);
    Menu.AddMainItem(mainMenu, "encoding", menuEncoding);
    Menu.AddMainItem(mainMenu, "view", menuView);
    Menu.AddMainItem(mainMenu, "language", menuLanguage);
    Menu.AddMainItem(mainMenu, "program", menuProgram);
    Menu.AddMainItem(mainMenu, "tools", menuTools);
    Menu.AddMainItem(mainMenu, "options", menuOptions);
    Shortcuts;
 
    Toolbar.create(toolbar, LEFT_PADDING + 5, toolbarTop);
    Toolbar.add(toolbar, btnNew,    Icons.icoNew, "");
    Toolbar.add(toolbar, btnOpen,   Icons.icoOpen, "");
    Toolbar.add(toolbar, btnSave,   Icons.icoSave, "");
    Toolbar.delimiter(toolbar);
    Toolbar.add(toolbar, btnSearch, Icons.icoSearch, "");
    Toolbar.delimiter(toolbar);
    Toolbar.add(toolbar, btnUndo,   Icons.icoUndo, "");
    Toolbar.add(toolbar, btnRedo,   Icons.icoRedo, "");
    Toolbar.delimiter(toolbar);
    Toolbar.add(toolbar, btnUpper,  -1, "AB");
    Toolbar.add(toolbar, btnLower,  -1, "ab");
    Toolbar.delimiter(toolbar);
    Toolbar.add(toolbar, btnBuild,  Icons.icoBuild, "");
    Toolbar.add(toolbar, btnRun,    Icons.icoRun, "");
 
    filePath := "/sys";
    IF Args.argc = 1 THEN
        text := T.New();
        insert(0, text);
        T.SetPos(text, 0, 0)
    END;
	FOR i := 1 TO Args.argc - 1 DO
		Args.GetArg(i, fileName);
		IF fileName[0] # "*" THEN
			IF open(fileName) THEN
				U.getPath(fileName, filePath)
			END
		ELSE
			K.docpack(fileName, text_ptr, text_size);
			IF text_ptr # 0 THEN
				text := T.open("", text_ptr, text_size, errno);
				IF text # NIL THEN
					insert(0, text);
					T.SetPos(text, 0, 0)
				END
			END
		END
	END;
	IF textsCount = 0 THEN
		K.Exit
	END;
	SwitchTab(textsCount - 1);
 
    Scroll.create(FALSE, canvas.width + 1, scrollWidth, scrollWidth, scrollWidth*3 DIV 2, ScrollChange, hScroll);
    Scroll.create(TRUE, scrollWidth, canvas.height + 2, scrollWidth, scrollWidth*3 DIV 2, ScrollChange, vScroll);
    T.resize(canvas.width, canvas.height);
    confirm := FALSE;
    notFound := FALSE;
    menuFindClicked := FALSE;
    menuActive := FALSE;
    search := FALSE;
    searchOpened := FALSE;
    createSearchForm;
    new_searchText := "";
    searchText := "";
    cs := FALSE;
    whole := FALSE;
    replaced := 0;
 
	OD := OpenDlg.Create(draw_window, OpenDlg.topen, filePath, "");
 
	IPC[1] := 0;
	IPC[0] := 0;
	K.SetIPC(IPC);
    K.SetEventsMask({0, 1, 2, 5, 6, 31});
    draw_window;
    blink := Ini.blink;
	IF blink <= 0 THEN
		blink := 0
	ELSIF blink < 30 THEN
		blink := 30
	END;
    timerEnabled := TRUE;
    CursorTime := K.GetTickCount();
    WHILE TRUE DO
 
    	CurrentTime := K.GetTickCount();
    	IF (CurrentTime - CursorTime > blink) & (blink > 0) & timerEnabled & ~K.RolledUp() THEN
    		CursorTime := CurrentTime;
    		T.cursor(text);
    		drawText
    	END;
 
        CASE K.EventTimeout(10) OF
        |0:
        |1:	Redraw(resized, width, height, cliWidth, cliHeight)
        |2:
        	key := K.GetKey();
        	IF ~K.RolledUp() THEN
        		KeyDown(key)
        	END
        |3: BtnClick
        |6:
        	IF ~K.RolledUp() THEN
        		MouseEvent(resized, firstClickX, firstClickY, time)
        	ELSE
        		scr := K.Scroll()
        	END
        |7: receiveIPC
        END;
        IF newtab THEN
        	Redraw(resized, width, height, cliWidth, cliHeight);
        	newtab := FALSE
        END
    END
END main;
 
 
BEGIN
    main
END CEdit.

Rev 9903	Rev 9904
1	(*	1	(*
2	Copyright 2021-2023 Anton Krotov	2	Copyright 2021-2023 Anton Krotov
3		3
4	This file is part of CEdit.	4	This file is part of CEdit.
5		5
6	CEdit is free software: you can redistribute it and/or modify	6	CEdit is free software: you can redistribute it and/or modify
7	it under the terms of the GNU General Public License as published by	7	it under the terms of the GNU General Public License as published by
8	the Free Software Foundation, either version 3 of the License, or	8	the Free Software Foundation, either version 3 of the License, or
9	(at your option) any later version.	9	(at your option) any later version.
10		10
11	CEdit is distributed in the hope that it will be useful,	11	CEdit is distributed in the hope that it will be useful,
12	but WITHOUT ANY WARRANTY; without even the implied warranty of	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	GNU General Public License for more details.	14	GNU General Public License for more details.
15		15
16	You should have received a copy of the GNU General Public License	16	You should have received a copy of the GNU General Public License
17	along with CEdit. If not, see .	17	along with CEdit. If not, see .
18	*)	18	*)
19		19
20	MODULE CEdit;	20	MODULE CEdit;
21		21
22	IMPORT	22	IMPORT
23	OpenDlg, K := KolibriOS, Args,	23	OpenDlg, K := KolibriOS, Args,
24	U := Utils, Lines, Menu, List,	24	U := Utils, Lines, Menu, List,
25	G := Graph, T := Text, E := Encodings,	25	G := Graph, T := Text, E := Encodings,
26	CB := Clipboard, Languages,	26	CB := Clipboard, Languages,
27	ChangeLog, Scroll, CheckBox, Icons,	27	ChangeLog, Scroll, CheckBox, Icons,
28	RW, Ini, EB := EditBox, Tabs, Toolbar, SB := StatusBar;	28	RW, Ini, EB := EditBox, Tabs, Toolbar, SB := StatusBar;
29		29
30	CONST	30	CONST
31	HEADER = "CEdit (24-feb-2023)";	31	HEADER = "CEdit (26-feb-2023)";
32		32
33	ShellFilter = "";	33	ShellFilter = "";
34	EditFilter = "sh\|inc\|txt\|asm\|ob07\|c\|cpp\|h\|pas\|pp\|lua\|ini\|json";	34	EditFilter = "sh\|inc\|txt\|asm\|ob07\|c\|cpp\|h\|pas\|pp\|lua\|ini\|json";
35		35
36	fontWidth = K.fontWidth;	36	fontWidth = K.fontWidth;
37	fontHeight = K.fontHeight;	37	fontHeight = K.fontHeight;
38		38
39	btnClose = 1;	39	btnClose = 1;
40		40
41	btnNew = 20;	41	btnNew = 20;
42	btnOpen = 21;	42	btnOpen = 21;
43	btnSave = 22;	43	btnSave = 22;
44	btnSearch = 23;	44	btnSearch = 23;
45	btnUndo = 24;	45	btnUndo = 24;
46	btnRedo = 25;	46	btnRedo = 25;
47	btnUpper = 26;	47	btnUpper = 26;
48	btnLower = 27;	48	btnLower = 27;
49	btnBuild = 28;	49	btnBuild = 28;
50	btnRun = 29;	50	btnRun = 29;
51		51
52	btnYes = 40;	52	btnYes = 40;
53	btnNo = 41;	53	btnNo = 41;
54	btnFindNext = 42;	54	btnFindNext = 42;
55	btnReplace = 43;	55	btnReplace = 43;
56	btnReplaceAll = 44;	56	btnReplaceAll = 44;
57	btnGoto = 45;	57	btnGoto = 45;
58	btnCloseSearch = 46;	58	btnCloseSearch = 46;
59	btnHideSearch = 47;	59	btnHideSearch = 47;
60		60
61	mainMenuBtn = 60;	61	mainMenuBtn = 60;
62		62
63	btnHeight = 25;	63	btnHeight = 25;
64	btnWidth = 75;	64	btnWidth = 75;
65		65
66	toolbarTop = Menu.MainMenuHeight + 3;	66	toolbarTop = Menu.MainMenuHeight + 3;
67		67
68	TOP = toolbarTop + Toolbar.BtnSize + 9 + Tabs.tabHeight;	68	TOP = toolbarTop + Toolbar.BtnSize + 9 + Tabs.tabHeight;
69		69
70	minWinWidth = 635; minWinHeight = 550;	70	minWinWidth = 635; minWinHeight = 550;
71		71
72	SEARCH_PADDING = 10;	72	SEARCH_PADDING = 10;
73	LEFT_PADDING = 1;	73	LEFT_PADDING = 1;
74	RIGHT_PADDING = 1;	74	RIGHT_PADDING = 1;
75		75
76	EditBox_Width = 180;	76	EditBox_Width = 180;
77	EDITBOX_MAXCHARS = 500;	77	EDITBOX_MAXCHARS = 500;
78		78
79	menuCut = 1;	79	menuCut = 1;
80	menuCopy = 2;	80	menuCopy = 2;
81	menuPaste = 3;	81	menuPaste = 3;
82	menuDelete = 4;	82	menuDelete = 4;
83	menuSelectAll = 5;	83	menuSelectAll = 5;
84		84
85	menuUndo = 6;	85	menuUndo = 6;
86	menuRedo = 7;	86	menuRedo = 7;
87		87
88	menuCurLine = 100;	88	menuCurLine = 100;
89	menuIndent = 110;	89	menuIndent = 110;
90	menuCase = 120;	90	menuCase = 120;
91		91
92	menuNew = 10;	92	menuNew = 10;
93	menuOpen = 11;	93	menuOpen = 11;
94	menuSave = 12;	94	menuSave = 12;
95	menuSaveAs = 13;	95	menuSaveAs = 13;
96	menuSaveAll = 14;	96	menuSaveAll = 14;
97	menuFolder = 15;	97	menuFolder = 15;
98	menuClose = 16;	98	menuClose = 16;
99	menuExit = 17;	99	menuExit = 17;
100		100
101	menuFontSmall = 20;	101	menuFontSmall = 20;
102	menuFontMedium = menuFontSmall + 1;	102	menuFontMedium = menuFontSmall + 1;
103	menuFontLarge = menuFontMedium + 1;	103	menuFontLarge = menuFontMedium + 1;
104	menuColors = 1000;	104	menuColors = 1000;
105	menuMaxColors = menuColors + Ini.MAX_SECTIONS - 1;	105	menuMaxColors = menuColors + Ini.MAX_SECTIONS - 1;
106		106
107	menuText = 30;	107	menuText = 30;
108	menuC = 31;	108	menuC = 31;
109	menuFasm = 32;	109	menuFasm = 32;
110	menuIni = 33;	110	menuIni = 33;
111	menuJSON = 34;	111	menuJSON = 34;
112	menuLua = 35;	112	menuLua = 35;
113	menuOberon = 36;	113	menuOberon = 36;
114	menuPascal = 37;	114	menuPascal = 37;
115		115
116	menuBuild = 50;	116	menuBuild = 50;
117	menuBuildScript = 51;	117	menuBuildScript = 51;
118	menuRun = 52;	118	menuRun = 52;
119	menuRunScript = 53;	119	menuRunScript = 53;
120	menuDebug = 54;	120	menuDebug = 54;
121	menuDebugScript = 55;	121	menuDebugScript = 55;
122	menuFASM = 56;	122	menuFASM = 56;
123		123
124	menuUTF8BOM = 60;	124	menuUTF8BOM = 60;
125	menuUTF8 = 61;	125	menuUTF8 = 61;
126	menuCP866 = 62;	126	menuCP866 = 62;
127	menuCP1251 = 63;	127	menuCP1251 = 63;
128	menuEOL = 140;	128	menuEOL = 140;
129	menuConv1251_866 = 64;	129	menuConv1251_866 = 64;
130	menuConv866_1251 = 65;	130	menuConv866_1251 = 65;
131		131
132	menuPipet = 70;	132	menuPipet = 70;
133	menuMagnify = 71;	133	menuMagnify = 71;
134	menuBoard = 72;	134	menuBoard = 72;
135	menuSysFunc = 73;	135	menuSysFunc = 73;
136		136
137	menuFind = 80;	137	menuFind = 80;
138	menuFindNext = 81;	138	menuFindNext = 81;
139	menuFindPrev = 82;	139	menuFindPrev = 82;
140	menuGoto = 83;	140	menuGoto = 83;
141	menuBookmark = 130;	141	menuBookmark = 130;
142		142
143	menuLineNumbers = 90;	143	menuLineNumbers = 90;
144	menuAutoIndents = 91;	144	menuAutoIndents = 91;
145	menuAutoBrackets = 92;	145	menuAutoBrackets = 92;
146	menuTrimSpace = 93;	146	menuTrimSpace = 93;
147		147
148	menuMoveUp = 101;	148	menuMoveUp = 101;
149	menuMoveDown = 102;	149	menuMoveDown = 102;
150	menuDuplicate = 103;	150	menuDuplicate = 103;
151	menuRemove = 104;	151	menuRemove = 104;
152		152
153	menuIncInd = 111;	153	menuIncInd = 111;
154	menuDecInd = 112;	154	menuDecInd = 112;
155		155
156	menuUpper = 121;	156	menuUpper = 121;
157	menuLower = 122;	157	menuLower = 122;
158		158
159	menuToggleBookmark = 131;	159	menuToggleBookmark = 131;
160	menuNextBookmark = 132;	160	menuNextBookmark = 132;
161	menuPrevBookmark = 133;	161	menuPrevBookmark = 133;
162		162
163	menuLF = 141;	163	menuLF = 141;
164	menuCRLF = 142;	164	menuCRLF = 142;
165	menuCR = 143;	165	menuCR = 143;
166		166
167	maxTexts = 32;	167	maxTexts = 32;
168		168
169	SHIFT = Menu.SHIFT;	169	SHIFT = Menu.SHIFT;
170	CTRL = Menu.CTRL;	170	CTRL = Menu.CTRL;
171		171
172	ClippingArea = 50;	172	ClippingArea = 50;
173		173
174		174
175	VAR	175	VAR
176	header: RW.tFileName;	176	header: RW.tFileName;
177	canvas: G.tCanvas;	177	canvas: G.tCanvas;
178	font: G.tFont;	178	font: G.tFont;
179		179
180	tabs: Tabs.tTabs;	180	tabs: Tabs.tTabs;
181	text: T.tText;	181	text: T.tText;
182	texts: ARRAY maxTexts OF T.tText;	182	texts: ARRAY maxTexts OF T.tText;
183	textsCount, curText: INTEGER;	183	textsCount, curText: INTEGER;
184		184
185	winWidth, winHeight: INTEGER;	185	winWidth, winHeight: INTEGER;
186	SkinHeight, scrollWidth: INTEGER;	186	SkinHeight, scrollWidth: INTEGER;
187	AppPath, runScript, buildScript, debugScript, CurFolder: RW.tFileName;	187	AppPath, runScript, buildScript, debugScript, CurFolder: RW.tFileName;
188	OD: OpenDlg.Dialog;	188	OD: OpenDlg.Dialog;
189	confirm, notFound, menuFindClicked, search, searchOpened: BOOLEAN;	189	confirm, notFound, menuFindClicked, search, searchOpened: BOOLEAN;
190		190
191	switch, closing, newtab: BOOLEAN;	191	switch, closing, newtab: BOOLEAN;
192	leftButton: BOOLEAN;	192	leftButton: BOOLEAN;
193	LEFT, RIGHT, BOTTOM: INTEGER;	193	LEFT, RIGHT, BOTTOM: INTEGER;
194		194
195	FindEdit, ReplaceEdit, GotoEdit: EB.tEditBox;	195	FindEdit, ReplaceEdit, GotoEdit: EB.tEditBox;
196	hScroll, vScroll: Scroll.tScroll;	196	hScroll, vScroll: Scroll.tScroll;
197	CS, WH, BKW: CheckBox.tCheckBox;	197	CS, WH, BKW: CheckBox.tCheckBox;
198		198
199	new_searchText, searchText, replaceText, gotoText: T.tString;	199	new_searchText, searchText, replaceText, gotoText: T.tString;
200	cs, whole: BOOLEAN;	200	cs, whole: BOOLEAN;
201		201
202	replaced: INTEGER;	202	replaced: INTEGER;
203		203
204	context, menuFile, menuEdit, menuSearch, menuEncoding,	204	context, menuFile, menuEdit, menuSearch, menuEncoding,
205	menuView, menuLanguage, menuProgram, menuTools, menuOptions,	205	menuView, menuLanguage, menuProgram, menuTools, menuOptions,
206	subCurLine, subIndent, subCase, subBookmark, subEOL: Menu.tMenu;	206	subCurLine, subIndent, subCase, subBookmark, subEOL: Menu.tMenu;
207		207
208	mainMenu: Menu.tMain;	208	mainMenu: Menu.tMain;
209		209
210	menuActive: BOOLEAN;	210	menuActive: BOOLEAN;
211		211
212	toolbar: Toolbar.tToolbar;	212	toolbar: Toolbar.tToolbar;
213		213
214	CursorTime, CurrentTime: INTEGER;	214	CursorTime, CurrentTime: INTEGER;
215	timerEnabled: BOOLEAN;	215	timerEnabled: BOOLEAN;
216		216
217	IPC: ARRAY 64 OF INTEGER; mainTID: INTEGER;	217	IPC: ARRAY 64 OF INTEGER; mainTID: INTEGER;
218		218
219		219
220	PROCEDURE EditBox_Focus (edit: EB.tEditBox): BOOLEAN;	220	PROCEDURE EditBox_Focus (edit: EB.tEditBox): BOOLEAN;
221	RETURN 1 IN edit.flags	221	RETURN 1 IN edit.flags
222	END EditBox_Focus;	222	END EditBox_Focus;
223		223
224		224
225	PROCEDURE resetTimer;	225	PROCEDURE resetTimer;
226	BEGIN	226	BEGIN
227	IF EditBox_Focus(FindEdit) OR EditBox_Focus(ReplaceEdit) OR EditBox_Focus(GotoEdit) THEN	227	IF EditBox_Focus(FindEdit) OR EditBox_Focus(ReplaceEdit) OR EditBox_Focus(GotoEdit) THEN
228	T.hideCursor;	228	T.hideCursor;
229	timerEnabled := FALSE	229	timerEnabled := FALSE
230	ELSE	230	ELSE
231	T.showCursor;	231	T.showCursor;
232	timerEnabled := TRUE	232	timerEnabled := TRUE
233	END;	233	END;
234	CursorTime := CurrentTime	234	CursorTime := CurrentTime
235	END resetTimer;	235	END resetTimer;
236		236
237		237
238	PROCEDURE EditBox_SetFocus (VAR edit: EB.tEditBox; value: BOOLEAN);	238	PROCEDURE EditBox_SetFocus (VAR edit: EB.tEditBox; value: BOOLEAN);
239	BEGIN	239	BEGIN
240	IF value THEN	240	IF value THEN
241	INCL(edit.flags, 1)	241	INCL(edit.flags, 1)
242	ELSE	242	ELSE
243	EXCL(edit.flags, 1)	243	EXCL(edit.flags, 1)
244	END;	244	END;
245	IF search & searchOpened THEN	245	IF search & searchOpened THEN
246	EB.draw(edit)	246	EB.draw(edit)
247	END	247	END
248	END EditBox_SetFocus;	248	END EditBox_SetFocus;
249		249
250		250
251	PROCEDURE SetFocus (VAR edit: EB.tEditBox; value: BOOLEAN);	251	PROCEDURE SetFocus (VAR edit: EB.tEditBox; value: BOOLEAN);
252	BEGIN	252	BEGIN
253	EditBox_SetFocus(FindEdit, FALSE);	253	EditBox_SetFocus(FindEdit, FALSE);
254	EditBox_SetFocus(ReplaceEdit, FALSE);	254	EditBox_SetFocus(ReplaceEdit, FALSE);
255	EditBox_SetFocus(GotoEdit, FALSE);	255	EditBox_SetFocus(GotoEdit, FALSE);
256	EditBox_SetFocus(edit, value);	256	EditBox_SetFocus(edit, value);
257	resetTimer	257	resetTimer
258	END SetFocus;	258	END SetFocus;
259		259
260		260
261	PROCEDURE Rect (left, top, right, bottom, color: INTEGER);	261	PROCEDURE Rect (left, top, right, bottom, color: INTEGER);
262	BEGIN	262	BEGIN
263	K.DrawLine(left, top, right, top, color);	263	K.DrawLine(left, top, right, top, color);
264	K.DrawLine(left, bottom, right, bottom, color);	264	K.DrawLine(left, bottom, right, bottom, color);
265	K.DrawLine(left, top, left, bottom, color);	265	K.DrawLine(left, top, left, bottom, color);
266	K.DrawLine(right, top, right, bottom, color);	266	K.DrawLine(right, top, right, bottom, color);
267	END Rect;	267	END Rect;
268		268
269		269
270	PROCEDURE Message (s: ARRAY OF WCHAR);	270	PROCEDURE Message (s: ARRAY OF WCHAR);
271	CONST	271	CONST
272	minWidth = 30;	272	minWidth = 30;
273	height = 40;	273	height = 40;
274	VAR	274	VAR
275	top, left, right, bottom, x, y, width: INTEGER;	275	top, left, right, bottom, x, y, width: INTEGER;
276	BEGIN	276	BEGIN
277	timerEnabled := FALSE;	277	timerEnabled := FALSE;
278	CursorTime := CurrentTime;	278	CursorTime := CurrentTime;
279	width := minWidth + LENGTH(s)*fontWidth;	279	width := minWidth + LENGTH(s)*fontWidth;
280	left := (canvas.width - width) DIV 2 + LEFT;	280	left := (canvas.width - width) DIV 2 + LEFT;
281	top := (canvas.height - height) DIV 2 + TOP;	281	top := (canvas.height - height) DIV 2 + TOP;
282	bottom := top + height - 1;	282	bottom := top + height - 1;
283	right := left + width - 1;	283	right := left + width - 1;
284	x := minWidth DIV 2 + left;	284	x := minWidth DIV 2 + left;
285	y := (height - fontHeight) DIV 2 + top;	285	y := (height - fontHeight) DIV 2 + top;
286	K.DrawRect(left, top, width, height, K.colors.work);	286	K.DrawRect(left, top, width, height, K.colors.work);
287	Rect(left, top, right, bottom, K.colors.line);	287	Rect(left, top, right, bottom, K.colors.line);
288	K.DrawText(x, y, K.colors.work_text, s);	288	K.DrawText(x, y, K.colors.work_text, s);
289	END Message;	289	END Message;
290		290
291		291
292	PROCEDURE NotFound;	292	PROCEDURE NotFound;
293	BEGIN	293	BEGIN
294	IF notFound THEN	294	IF notFound THEN
295	Message("not found");	295	Message("not found");
296	IF menuFindClicked THEN	296	IF menuFindClicked THEN
297	menuFindClicked := FALSE	297	menuFindClicked := FALSE
298	ELSE	298	ELSE
299	notFound := FALSE	299	notFound := FALSE
300	END;	300	END;
301	SetFocus(FindEdit, TRUE)	301	SetFocus(FindEdit, TRUE)
302	END	302	END
303	END NotFound;	303	END NotFound;
304		304
305		305
306	PROCEDURE Replaced;	306	PROCEDURE Replaced;
307	VAR	307	VAR
308	s, s1: ARRAY 32 OF WCHAR;	308	s, s1: ARRAY 32 OF WCHAR;
309	BEGIN	309	BEGIN
310	IF replaced # 0 THEN	310	IF replaced # 0 THEN
311	s := "replaced: ";	311	s := "replaced: ";
312	U.int2str(replaced, s1);	312	U.int2str(replaced, s1);
313	U.append(s, s1);	313	U.append(s, s1);
314	Message(s);	314	Message(s);
315	replaced := 0;	315	replaced := 0;
316	SetFocus(FindEdit, TRUE)	316	SetFocus(FindEdit, TRUE)
317	END	317	END
318	END Replaced;	318	END Replaced;
319		319
320		320
321	PROCEDURE getIdx (text: T.tText): INTEGER;	321	PROCEDURE getIdx (text: T.tText): INTEGER;
322	VAR	322	VAR
323	i: INTEGER;	323	i: INTEGER;
324	BEGIN	324	BEGIN
325	i := 0;	325	i := 0;
326	WHILE texts[i] # text DO	326	WHILE texts[i] # text DO
327	INC(i)	327	INC(i)
328	END	328	END
329	RETURN i	329	RETURN i
330	END getIdx;	330	END getIdx;
331		331
332		332
333	PROCEDURE SetCaption (fileName: RW.tFileName);	333	PROCEDURE SetCaption (fileName: RW.tFileName);
334	VAR	334	VAR
335	newHeader: RW.tFileName;	335	newHeader: RW.tFileName;
336	BEGIN	336	BEGIN
337	newHeader := HEADER;	337	newHeader := HEADER;
338	IF text.fileName # "" THEN	338	IF text.fileName # "" THEN
339	U.append8(newHeader, " - ");	339	U.append8(newHeader, " - ");
340	U.append8(newHeader, text.fileName)	340	U.append8(newHeader, text.fileName)
341	END;	341	END;
342	IF newHeader # header THEN	342	IF newHeader # header THEN
343	header := newHeader;	343	header := newHeader;
344	K.SetCaption(header)	344	K.SetCaption(header)
345	END	345	END
346	END SetCaption;	346	END SetCaption;
347		347
348		348
349	PROCEDURE Status (text: T.tText; height: INTEGER);	349	PROCEDURE Status (text: T.tText; height: INTEGER);
350	VAR	350	VAR
351	line, col, chars, lines: INTEGER;	351	line, col, chars, lines: INTEGER;
352	BEGIN	352	BEGIN
353	T.getPos(text, col, line);	353	T.getPos(text, col, line);
354	T.getSelCnt(text, chars, lines);	354	T.getSelCnt(text, chars, lines);
355	SB.setWidth(canvas.width + scrollWidth);	355	SB.setWidth(canvas.width + scrollWidth);
356	SB.setPos(line, col);	356	SB.setPos(line, col);
357	SB.setSel(chars, lines);	357	SB.setSel(chars, lines);
358	SB.setEnc(E.eolNames[T.getEol(text)], E.names[T.getEnc(text)]);	358	SB.setEnc(E.eolNames[T.getEol(text)], E.names[T.getEnc(text)]);
359	SB.draw(LEFT, height - BOTTOM + scrollWidth - 1);	359	SB.draw(LEFT, height - BOTTOM + scrollWidth - 1);
360	Tabs.modify(tabs, getIdx(text), text.modified)	360	Tabs.modify(tabs, getIdx(text), text.modified)
361	END Status;	361	END Status;
362		362
363		363
364	PROCEDURE DrawScroll (VAR scroll: Scroll.tScroll; left, top, value, maxVal: INTEGER);	364	PROCEDURE DrawScroll (VAR scroll: Scroll.tScroll; left, top, value, maxVal: INTEGER);
365	BEGIN	365	BEGIN
366	scroll.maxVal := maxVal;	366	scroll.maxVal := maxVal;
367	scroll.left := left;	367	scroll.left := left;
368	scroll.top := top;	368	scroll.top := top;
369	Scroll.setValue(scroll, value);	369	Scroll.setValue(scroll, value);
370	Scroll.draw(scroll)	370	Scroll.draw(scroll)
371	END DrawScroll;	371	END DrawScroll;
372		372
373		373
374	PROCEDURE drawText;	374	PROCEDURE drawText;
375	BEGIN	375	BEGIN
376	G.SetColor(canvas, K.colors.line);	376	G.SetColor(canvas, K.colors.line);
377	G.VLine(canvas, 0, 0, canvas.height - 1);	377	G.VLine(canvas, 0, 0, canvas.height - 1);
378	G.DrawCanvas(canvas, LEFT, TOP)	378	G.DrawCanvas(canvas, LEFT, TOP)
379	END drawText;	379	END drawText;
380		380
381		381
382	PROCEDURE repaint;	382	PROCEDURE repaint;
383	VAR	383	VAR
384	width, height, scrollX, scrollY: INTEGER;	384	width, height, scrollX, scrollY: INTEGER;
385	BEGIN	385	BEGIN
386	IF (text # NIL) & ~K.RolledUp() THEN	386	IF (text # NIL) & ~K.RolledUp() THEN
387	IF confirm THEN	387	IF confirm THEN
388	K.DeleteButton(btnYes);	388	K.DeleteButton(btnYes);
389	K.DeleteButton(btnNo);	389	K.DeleteButton(btnNo);
390	confirm := FALSE;	390	confirm := FALSE;
391	resetTimer;	391	resetTimer;
392	closing := FALSE	392	closing := FALSE
393	END;	393	END;
394	IF ~search OR (searchText = "") THEN	394	IF ~search OR (searchText = "") THEN
395	T.wordSel(text)	395	T.wordSel(text)
396	END;	396	END;
397	K.ClientSize(width, height);	397	K.ClientSize(width, height);
398	IF switch THEN	398	IF switch THEN
399	Status(text, height);	399	Status(text, height);
400	Tabs.draw(tabs);	400	Tabs.draw(tabs);
401	IF search & T.search(text, searchText, cs, whole) THEN END;	401	IF search & T.search(text, searchText, cs, whole) THEN END;
402	switch := FALSE	402	switch := FALSE
403	END;	403	END;
404	T.draw(text);	404	T.draw(text);
405	Status(text, height);	405	Status(text, height);
406		406
407	T.getScroll(text, scrollX, scrollY);	407	T.getScroll(text, scrollX, scrollY);
408	DrawScroll(vScroll, LEFT + canvas.width, TOP - 1, scrollY, text.count - 1);	408	DrawScroll(vScroll, LEFT + canvas.width, TOP - 1, scrollY, text.count - 1);
409	DrawScroll(hScroll, LEFT, TOP + canvas.height, scrollX, text.maxLength);	409	DrawScroll(hScroll, LEFT, TOP + canvas.height, scrollX, text.maxLength);
410	IF search & searchOpened THEN	410	IF search & searchOpened THEN
411	CheckBox.draw(BKW);	411	CheckBox.draw(BKW);
412	CheckBox.draw(CS);	412	CheckBox.draw(CS);
413	CheckBox.draw(WH);	413	CheckBox.draw(WH);
414	END;	414	END;
415	drawText;	415	drawText;
416	NotFound;	416	NotFound;
417	Replaced;	417	Replaced;
418	Toolbar.enable(toolbar, btnSave, text.modified);	418	Toolbar.enable(toolbar, btnSave, text.modified);
419	Toolbar.enable(toolbar, btnUndo, ~ChangeLog.isFirstGuard(text.edition));	419	Toolbar.enable(toolbar, btnUndo, ~ChangeLog.isFirstGuard(text.edition));
420	Toolbar.enable(toolbar, btnRedo, ~ChangeLog.isLastGuard(text.edition));	420	Toolbar.enable(toolbar, btnRedo, ~ChangeLog.isLastGuard(text.edition));
421	Toolbar.enable(toolbar, btnUpper, T.selected(text));	421	Toolbar.enable(toolbar, btnUpper, T.selected(text));
422	Toolbar.enable(toolbar, btnLower, T.selected(text));	422	Toolbar.enable(toolbar, btnLower, T.selected(text));
423	Toolbar.enable(toolbar, btnBuild, (buildScript # "") OR text.fasm);	423	Toolbar.enable(toolbar, btnBuild, (buildScript # "") OR text.fasm);
424	Toolbar.enable(toolbar, btnRun, (runScript # "") OR text.fasm);	424	Toolbar.enable(toolbar, btnRun, (runScript # "") OR text.fasm);
425	Toolbar.drawIcons(toolbar)	425	Toolbar.drawIcons(toolbar)
426	END	426	END
427	END repaint;	427	END repaint;
428		428
429		429
430	PROCEDURE resize;	430	PROCEDURE resize;
431	VAR	431	VAR
432	cliWidth, cliHeight: INTEGER;	432	cliWidth, cliHeight: INTEGER;
433	BEGIN	433	BEGIN
434	K.WinSize(winWidth, winHeight);	434	K.WinSize(winWidth, winHeight);
435	IF winWidth < minWinWidth THEN	435	IF winWidth < minWinWidth THEN
436	winWidth := minWinWidth	436	winWidth := minWinWidth
437	END;	437	END;
438	IF winHeight < minWinHeight THEN	438	IF winHeight < minWinHeight THEN
439	winHeight := minWinHeight	439	winHeight := minWinHeight
440	END;	440	END;
441	K.SetWinSize(winWidth, winHeight);	441	K.SetWinSize(winWidth, winHeight);
442	K.WinSize(winWidth, winHeight);	442	K.WinSize(winWidth, winHeight);
443	K.ClientSize(cliWidth, cliHeight);	443	K.ClientSize(cliWidth, cliHeight);
444	IF font # G.fonts[2] THEN	444	IF font # G.fonts[2] THEN
445	SB.SetFont(font)	445	SB.SetFont(font)
446	ELSE	446	ELSE
447	SB.SetFont(G.fonts[1])	447	SB.SetFont(G.fonts[1])
448	END;	448	END;
449	BOTTOM := SB.height() + scrollWidth - 1;	449	BOTTOM := SB.height() + scrollWidth - 1;
450	G.destroy(canvas);	450	G.destroy(canvas);
451	canvas := G.CreateCanvas(cliWidth - (LEFT + RIGHT + 2 + RIGHT_PADDING), cliHeight - (TOP + BOTTOM + 1 - ClippingArea));	451	canvas := G.CreateCanvas(cliWidth - (LEFT + RIGHT + 2 + RIGHT_PADDING), cliHeight - (TOP + BOTTOM + 1 - ClippingArea));
452	DEC(canvas.height, ClippingArea);	452	DEC(canvas.height, ClippingArea);
453	Tabs.setArea(tabs, LEFT, TOP - Tabs.tabHeight, cliWidth - (LEFT + RIGHT + 2 + RIGHT_PADDING), Tabs.tabHeight);	453	Tabs.setArea(tabs, LEFT, TOP - Tabs.tabHeight, cliWidth - (LEFT + RIGHT + 2 + RIGHT_PADDING), Tabs.tabHeight);
454	G.SetFont(canvas, font);	454	G.SetFont(canvas, font);
455	T.setCanvas(canvas);	455	T.setCanvas(canvas);
456	T.resize(canvas.width, canvas.height);	456	T.resize(canvas.width, canvas.height);
457	Scroll.resize(vScroll, vScroll.width, canvas.height + 2);	457	Scroll.resize(vScroll, vScroll.width, canvas.height + 2);
458	Scroll.resize(hScroll, canvas.width + 1, hScroll.height);	458	Scroll.resize(hScroll, canvas.width + 1, hScroll.height);
459	END resize;	459	END resize;
460		460
461		461
462	PROCEDURE SearchPanel (left, top: INTEGER);	462	PROCEDURE SearchPanel (left, top: INTEGER);
463	VAR	463	VAR
464	y, right, bottom: INTEGER;	464	y, right, bottom: INTEGER;
465	BEGIN	465	BEGIN
466	DEC(top, Tabs.tabHeight);	466	DEC(top, Tabs.tabHeight);
467	right := left + EditBox_Width + SEARCH_PADDING*2;	467	right := left + EditBox_Width + SEARCH_PADDING*2;
468	bottom := top + 395 + btnHeight + SEARCH_PADDING;	468	bottom := top + 395 + btnHeight + SEARCH_PADDING;
469	Rect(left, top, right, bottom, K.colors.line);	469	Rect(left, top, right, bottom, K.colors.line);
470		470
471	K.CreateButton(btnCloseSearch, right - 20, top, 20, 20, Tabs.btnCloseColor, "");	471	K.CreateButton(btnCloseSearch, right - 20, top, 20, 20, Tabs.btnCloseColor, "");
472	K.DrawLine(right - 14, top + 5, right - 5, top + 14, 0FFFFFFH);	472	K.DrawLine(right - 14, top + 5, right - 5, top + 14, 0FFFFFFH);
473	K.DrawLine(right - 15, top + 5, right - 5, top + 15, 0FFFFFFH);	473	K.DrawLine(right - 15, top + 5, right - 5, top + 15, 0FFFFFFH);
474	K.DrawLine(right - 15, top + 6, right - 6, top + 15, 0FFFFFFH);	474	K.DrawLine(right - 15, top + 6, right - 6, top + 15, 0FFFFFFH);
475	K.DrawLine(right - 15, top + 14, right - 6, top + 5, 0FFFFFFH);	475	K.DrawLine(right - 15, top + 14, right - 6, top + 5, 0FFFFFFH);
476	K.DrawLine(right - 15, top + 15, right - 5, top + 5, 0FFFFFFH);	476	K.DrawLine(right - 15, top + 15, right - 5, top + 5, 0FFFFFFH);
477	K.DrawLine(right - 14, top + 15, right - 5, top + 6, 0FFFFFFH);	477	K.DrawLine(right - 14, top + 15, right - 5, top + 6, 0FFFFFFH);
478		478
479	K.CreateButton(btnHideSearch, right - 40, top, 20, 20, K.colors.button, "");	479	K.CreateButton(btnHideSearch, right - 40, top, 20, 20, K.colors.button, "");
480	K.DrawLine(right - 34, top + 14, right - 26, top + 14, K.colors.button_text);	480	K.DrawLine(right - 34, top + 14, right - 26, top + 14, K.colors.button_text);
481	K.DrawLine(right - 34, top + 15, right - 26, top + 15, K.colors.button_text);	481	K.DrawLine(right - 34, top + 15, right - 26, top + 15, K.colors.button_text);
482		482
483	INC(top, 15);	483	INC(top, 15);
484	INC(left, SEARCH_PADDING);	484	INC(left, SEARCH_PADDING);
485	K.DrawText866(left, top, K.colors.work_text, "find");	485	K.DrawText866(left, top, K.colors.work_text, "find");
486	K.DrawText866(left, top + 55, K.colors.work_text, "replace with");	486	K.DrawText866(left, top + 55, K.colors.work_text, "replace with");
487	K.DrawText866(left, top + 330, K.colors.work_text, "go to line");	487	K.DrawText866(left, top + 330, K.colors.work_text, "go to line");
488	BKW.top := top + 110;	488	BKW.top := top + 110;
489	BKW.left := left;	489	BKW.left := left;
490	CS.top := top + 140;	490	CS.top := top + 140;
491	CS.left := left;	491	CS.left := left;
492	WH.top := top + 170;	492	WH.top := top + 170;
493	WH.left := left;	493	WH.left := left;
494	FindEdit.top := top + 20;	494	FindEdit.top := top + 20;
495	ReplaceEdit.top := top + 75;	495	ReplaceEdit.top := top + 75;
496	GotoEdit.top := top + 350;	496	GotoEdit.top := top + 350;
497	FindEdit.left := left;	497	FindEdit.left := left;
498	ReplaceEdit.left := left;	498	ReplaceEdit.left := left;
499	GotoEdit.left := left;	499	GotoEdit.left := left;
500	EB.draw(FindEdit);	500	EB.draw(FindEdit);

Subversion Repositories Kolibri OS

(root)/programs/develop/cedit/SRC/CEdit.ob07 – Rev 9903 → 9904