home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / sp15demo.zip / libsrc.zip / LIBSRC / OEDITORS.PAS < prev    next >
Pascal/Delphi Source File  |  1996-02-21  |  206KB  |  6,992 lines
  1. UNIT OEditors;
  2.  
  3. {**************************************************************************
  4.  *                                                                        *
  5.  *    General definitions for OEditors                                    *
  6.  *    (C) 1993,94,95  NL SpeedSoft                                        *
  7.  *                                                                        *
  8.  **************************************************************************}
  9.  
  10. INTERFACE
  11.  
  12. {$Z+}
  13.  
  14. USES Dos,Crt,Os2Def,ObjectPm,ODialogs,BseDos,PMWin,PMGpi,PMStdDlg,PMDev,PMSpl,
  15.      PMShl;
  16.  
  17.  
  18. CONST StringLength       = 250;
  19.       NormalChars        : SET OF CHAR = ['0'..'9','A'..'Z','a'..'z','_',
  20.                                           'ä','Ä','ö','Ö','ü','Ü','ß'];
  21.       MaxUndoEvents      = 32;
  22.       MaxRedoEvents      = 32;
  23.  
  24.       FRD_Forward        = 1;
  25.       FRD_FromCursor     = 2;
  26.       FRD_CaseSensitiv   = 4;
  27.       FRD_WordsOnly      = 8;
  28.       FRD_Confirm        = 16;
  29.       FRD_ReplaceAll     = 32;
  30.       FR_Find            = 1;
  31.       FR_Replace         = 2;
  32.  
  33.       EOD_UseCUA         = 1;
  34.       EOD_CreateBackup   = 2;
  35.       EOD_InsertMode     = 4;
  36.       EOD_AutoIndentMode = 8;
  37.       EOD_Unindent       = 16;
  38.  
  39.       CI_Normal          = 0;
  40.       CI_Selected        = 1;
  41.  
  42.       BM_0               = 4096;
  43.       Mask4MSB           = 61440;
  44.  
  45.       UG_NoGroup         = 0;
  46.       UG_CursorMove      = 1;
  47.       UG_InsertChar      = 2;
  48.       UG_OverwriteChar   = 4;
  49.       UG_DeleteChar      = 8;
  50.       UG_BackspaceChar   = 16;
  51.  
  52.       kbPreCtrlK         = kb_Ctrl + 4096;
  53.       kbPreCtrlQ         = kb_Ctrl + 8192;
  54.       kbPreCtrlO         = kb_Ctrl + 16384;
  55.       kbPreCtrlB         = kb_Ctrl + 32768;
  56.       kbPreCtrlU         = kb_Ctrl + 65536;
  57.  
  58.       {Ctrl-K Codes}
  59.       kbCtrlKA           = kbPreCtrlK + 65;
  60.       kbCtrlKB           = kbPreCtrlK + 66;
  61.       kbCtrlKC           = kbPreCtrlK + 67;
  62.       kbCtrlKD           = kbPreCtrlK + 68;
  63.       kbCtrlKE           = kbPreCtrlK + 69;
  64.       kbCtrlKF           = kbPreCtrlK + 70;
  65.       kbCtrlKG           = kbPreCtrlK + 71;
  66.       kbCtrlKH           = kbPreCtrlK + 72;
  67.       kbCtrlKI           = kbPreCtrlK + 73;
  68.       kbCtrlKJ           = kbPreCtrlK + 74;
  69.       kbCtrlKK           = kbPreCtrlK + 75;
  70.       kbCtrlKL           = kbPreCtrlK + 76;
  71.       kbCtrlKM           = kbPreCtrlK + 77;
  72.       kbCtrlKN           = kbPreCtrlK + 78;
  73.       kbCtrlKO           = kbPreCtrlK + 79;
  74.       kbCtrlKP           = kbPreCtrlK + 80;
  75.       kbCtrlKQ           = kbPreCtrlK + 81;
  76.       kbCtrlKR           = kbPreCtrlK + 82;
  77.       kbCtrlKS           = kbPreCtrlK + 83;
  78.       kbCtrlKT           = kbPreCtrlK + 84;
  79.       kbCtrlKU           = kbPreCtrlK + 85;
  80.       kbCtrlKV           = kbPreCtrlK + 86;
  81.       kbCtrlKW           = kbPreCtrlK + 87;
  82.       kbCtrlKX           = kbPreCtrlK + 88;
  83.       kbCtrlKY           = kbPreCtrlK + 89;
  84.       kbCtrlKZ           = kbPreCtrlK + 90;
  85.  
  86.       {Ctrl-Q Codes}
  87.       kbCtrlQA           = kbPreCtrlQ + 65;
  88.       kbCtrlQB           = kbPreCtrlQ + 66;
  89.       kbCtrlQC           = kbPreCtrlQ + 67;
  90.       kbCtrlQD           = kbPreCtrlQ + 68;
  91.       kbCtrlQE           = kbPreCtrlQ + 69;
  92.       kbCtrlQF           = kbPreCtrlQ + 70;
  93.       kbCtrlQG           = kbPreCtrlQ + 71;
  94.       kbCtrlQH           = kbPreCtrlQ + 72;
  95.       kbCtrlQI           = kbPreCtrlQ + 73;
  96.       kbCtrlQJ           = kbPreCtrlQ + 74;
  97.       kbCtrlQK           = kbPreCtrlQ + 75;
  98.       kbCtrlQL           = kbPreCtrlQ + 76;
  99.       kbCtrlQM           = kbPreCtrlQ + 77;
  100.       kbCtrlQN           = kbPreCtrlQ + 78;
  101.       kbCtrlQO           = kbPreCtrlQ + 79;
  102.       kbCtrlQP           = kbPreCtrlQ + 80;
  103.       kbCtrlQQ           = kbPreCtrlQ + 81;
  104.       kbCtrlQR           = kbPreCtrlQ + 82;
  105.       kbCtrlQS           = kbPreCtrlQ + 83;
  106.       kbCtrlQT           = kbPreCtrlQ + 84;
  107.       kbCtrlQU           = kbPreCtrlQ + 85;
  108.       kbCtrlQV           = kbPreCtrlQ + 86;
  109.       kbCtrlQW           = kbPreCtrlQ + 87;
  110.       kbCtrlQX           = kbPreCtrlQ + 88;
  111.       kbCtrlQY           = kbPreCtrlQ + 89;
  112.       kbCtrlQZ           = kbPreCtrlQ + 90;
  113.  
  114.       kbCtrlShiftCLeft   = kb_Ctrl + kb_Shift + kbCLeft;
  115.       kbCtrlShiftCRight  = kb_Ctrl + kb_Shift + kbCRight;
  116.       kbCtrlShiftPageUp  = kb_Ctrl + kb_Shift + kbPageUp;
  117.       kbCtrlShiftPageDown= kb_Ctrl + kb_Shift + kbPageDown;
  118.       kbCtrlShiftPos1    = kb_Ctrl + kb_Shift + kbPos1;
  119.       kbCtrlShiftEnd     = kb_Ctrl + kb_Shift + kbEnd;
  120.  
  121.       kbShiftAltBS       = kb_Shift + kb_Alt + kbBS;
  122.  
  123.       kbCtrlSlash        = kb_Ctrl + 47;
  124.       kbCtrlBackSlash    = kb_Ctrl + 92;
  125.  
  126.       kbCtrlOI           = kbPreCtrlO + 73;
  127.       kbCtrlK0           = kbPreCtrlK + 48;
  128.       kbCtrlK9           = kbPreCtrlK + 57;
  129.       kbCtrlQ0           = kbPreCtrlQ + 48;
  130.       kbCtrlQ9           = kbPreCtrlQ + 57;
  131.       kbCtrlU0           = kbPreCtrlU + 48;
  132.       kbCtrlU9           = kbPreCtrlU + 57;
  133.       kbCtrlUU           = kbPreCtrlU + 85;
  134.  
  135.       WM_DISMISS         = WM_SPEED_USER + 1;
  136.  
  137.  
  138. TYPE PLine=^TLine;
  139.      TLine=RECORD
  140.                  prev  : PLine;
  141.                  zk    : PSTRING;
  142.                  color : WORD;
  143.                  next  : PLine;
  144.             END;
  145.  
  146.  
  147.      PLineColor=^TLineColor;
  148.      TLineColor=RECORD
  149.                       Color     : INTEGER;
  150.                       BackColor : INTEGER;
  151.                 END;
  152.  
  153.  
  154.      PPrintInfo=^TPrintInfo;
  155.      TPrintInfo=RECORD
  156.                       PRN_LeftIndent  : LONGINT;
  157.                       PRN_UpperIndent : LONGINT;
  158.                       PRN_LowerIndent : LONGINT;
  159.                       PRN_LineDist    : LONGINT;
  160.                       OffsX           : LONGWORD;
  161.                       OffsY           : LONGWORD;
  162.                       OffsFL          : LONGWORD;
  163.                       PrinterDC       : HDC;
  164.                       PrinterPS       : HPS;
  165.                       Text            : POINTER;
  166.                       TextLen         : LONGWORD;
  167.                       AbortHwnd       : HWND;
  168.                       Status          : BYTE;
  169.                       PTid            : TID;
  170.                 END;
  171.  
  172.  
  173.      PSliderData=^SliderData;
  174.      SliderData=RECORD
  175.                       scrollbottom : LONGWORD; { Scroll lower border  }
  176.                       scrolltop    : LONGWORD; { Scroll upper border  }
  177.                       viewarea     : LONGWORD; { View area of window  }
  178.                       acvalue      : LONGWORD; { actual Slider value  }
  179.                 END;
  180.  
  181.  
  182.      TICB=RECORD                               {Internal Clipboard}
  183.                 FirstLine : PLine;
  184.                 FirstX    : WORD;
  185.                 LastLine  : PLine;
  186.                 LastX     : WORD;
  187.           END;
  188.  
  189.  
  190.      TUNDO=RECORD
  191.                  Event         : BYTE;
  192.                  Modified      : BOOLEAN;
  193.                  ICBFL         : LONGWORD;
  194.                  ICBFX         : WORD;
  195.                  ICBLL         : LONGWORD;
  196.                  ICBLX         : WORD;
  197.                  FCX           : WORD;
  198.                  FCY           : LONGWORD;
  199.                  FrameBegin    : LONGWORD;
  200.                  FrameEnd      : LONGWORD;
  201.                  FirstUndoLine : PLine;
  202.                  LastUndoLine  : PLine;
  203.                  Lines         : LONGWORD;
  204.            END;
  205.  
  206.  
  207.      TUndoList=ARRAY[0..MaxUndoEvents-1] OF TUNDO;
  208.  
  209.  
  210.      PEditorWindow=^TEditorWindow;
  211.      TEditorWindow=OBJECT(TWindow)
  212.                    FileName        : STRING;
  213.                    StdExt          : STRING;
  214.                    NewEditorPtr    : LONGWORD;
  215.                    ResidentHPS     : HPS;
  216.                    HSlider         : SliderData;
  217.                    VSlider         : SliderData;
  218.                    WindowRect      : RECTL;
  219.                    WinSizeX        : LONGWORD;
  220.                    WinSizeY        : LONGWORD;
  221.                    Sel_Color       : INTEGER;
  222.                    Sel_BackColor   : INTEGER;
  223.                    ICBVisible      : BOOLEAN;
  224.                    ClearFullBkGr   : BOOLEAN;
  225.                    Modified        : BOOLEAN;
  226.                    Untitled        : BOOLEAN;
  227.                    WLactivated     : BOOLEAN;
  228.                    IgnoreRedraw    : BOOLEAN;
  229.                    WindowGetFocus  : BOOLEAN;
  230.                    FirstLine       : PLine;
  231.                    ActLine         : PLine;
  232.                    LastLine        : PLine;
  233.                    FirstScreenLine : PLine;
  234.                    FileCursorY     : LONGWORD;
  235.                    FileCursorX     : WORD;
  236.                    ScrCursorY      : WORD;
  237.                    ScrCursorX      : WORD;
  238.                    CountLines      : LONGWORD;
  239.                    WorkLine        : PSTRING;
  240.                    ICB             : TICB;
  241.                    OldICB          : TICB;
  242.                    FindICB         : BOOLEAN;
  243.                    UndoEvents      : WORD;
  244.                    LastUndo        : WORD;
  245.                    UndoEvent       : TUndoList;
  246.                    RedoEvents      : WORD;
  247.                    LastRedo        : WORD;
  248.                    RedoEvent       : TUndoList;
  249.                    LastUndoGroup   : WORD;
  250.                    szDriverName    : CSTRING;
  251.                    szDeviceName    : CSTRING;
  252.                    szLogAddress    : CSTRING;
  253.                    szDataType      : CSTRING;
  254.                    PrintInfo       : TPrintInfo;
  255.                    BookMarkColumn  : ARRAY[0..9] OF WORD;
  256.  
  257.                    CONSTRUCTOR Init(AParent:PWindowsObject; ATitle:STRING);
  258.                    FUNCTION    CanClose:BOOLEAN;VIRTUAL;
  259.                    PROCEDURE   SetupWindow;VIRTUAL;
  260.                    PROCEDURE   HandleCharEvent(Win:HWND; param,Rep:WORD);VIRTUAL;
  261.                    PROCEDURE   HandleScanEvent(Win:HWND; param,Rep:WORD);VIRTUAL;
  262.                    PROCEDURE   Redraw(VAR ahps:HPS; VAR rc:RECTL);VIRTUAL;
  263.                    PROCEDURE   WindowDestroyed;VIRTUAL;
  264.  
  265.                    PROCEDURE   WMPresParamChanged(VAR Msg:TMessage);
  266.                                VIRTUAL WM_FIRST+WM_PRESPARAMCHANGED;
  267.                    PROCEDURE   WMSize(VAR Msg:TMessage);
  268.                                VIRTUAL WM_FIRST+WM_SIZE;
  269.                    PROCEDURE   WMSetFocus(VAR Msg:TMessage);
  270.                                VIRTUAL WM_FIRST+WM_SETFOCUS;
  271.                    PROCEDURE   WMButton1Up(VAR Msg:TMessage);
  272.                                VIRTUAL WM_FIRST+WM_BUTTON1UP;
  273.                    PROCEDURE   WMButton1Down(VAR Msg:TMessage);
  274.                                VIRTUAL WM_FIRST+WM_BUTTON1DOWN;
  275.                    PROCEDURE   WMButton1DBLCLK(VAR Msg:TMessage);
  276.                                VIRTUAL WM_FIRST+WM_BUTTON1DBLCLK;
  277.                    PROCEDURE   WMMouseDrag1(VAR Msg:TMessage);
  278.                                VIRTUAL WM_FIRST+WM_MOUSEDRAG1;
  279.                    PROCEDURE   WMMouseMove(VAR Msg:TMessage);
  280.                                VIRTUAL WM_FIRST+WM_MOUSEMOVE;
  281.                    PROCEDURE   WMHScroll(VAR Msg:TMessage);
  282.                                VIRTUAL WM_FIRST+WM_HSCROLL;
  283.                    PROCEDURE   WMVScroll(VAR Msg:TMessage);
  284.                                VIRTUAL WM_FIRST+WM_VSCROLL;
  285.                    PROCEDURE   WMBeginDrag(VAR Msg:TMessage);
  286.                                VIRTUAL WM_FIRST+WM_BEGINDRAG;
  287.                    PROCEDURE   DMDragOver(VAR Msg:TMessage);
  288.                                VIRTUAL WM_FIRST+DM_DRAGOVER;
  289.                    PROCEDURE   DMDrop(VAR Msg:TMessage);
  290.                                VIRTUAL WM_FIRST+DM_DROP;
  291.                    PROCEDURE   DMDropHelp(VAR Msg:TMessage);
  292.                                VIRTUAL WM_FIRST+DM_DROPHELP;
  293.                    PROCEDURE   DMPrintObject(VAR Msg:TMessage);
  294.                                VIRTUAL WM_FIRST+DM_PRINTOBJECT;
  295.  
  296.                    PROCEDURE   SetSliderValues;
  297.                    PROCEDURE   SetSliderPosition;
  298.                    PROCEDURE   SetCursorXY;
  299.                    PROCEDURE   SetEditorPtr(id,res:LONGWORD);VIRTUAL;
  300.                    PROCEDURE   UpdateEditorStatus;VIRTUAL;
  301.                    PROCEDURE   SetStatusMessage(sm:STRING);VIRTUAL;
  302.                    PROCEDURE   SetWindowTitleText(str:STRING);VIRTUAL;
  303.                    PROCEDURE   SetErrorMessage(button:LONGWORD;titel,text:STRING);
  304.                                VIRTUAL;
  305.                    FUNCTION    SetQueryMessage(titel,text:STRING;buttons:LONGWORD):
  306.                                LONGWORD;VIRTUAL;
  307.                    FUNCTION    UpdateLineColorFlag(PL:PLine):BOOLEAN;VIRTUAL;
  308.                    PROCEDURE   SetLineColorFlag(PL1,PL2:PLine);VIRTUAL;
  309.                    PROCEDURE   CalcLineColor(PL:PLine);VIRTUAL;
  310.                    PROCEDURE   InvalidateEditorLine(PL:PLine; CY:WORD);VIRTUAL;
  311.                    PROCEDURE   InvalidateSingleLine;VIRTUAL;
  312.                    PROCEDURE   InvalidateEditorWindow(ab:WORD);VIRTUAL;
  313.  
  314.                    PROCEDURE   LoadFile(Name:STRING);VIRTUAL;
  315.                    FUNCTION    CopyLinesLinear(VAR Len:LONGWORD):POINTER;
  316.                    FUNCTION    SaveFile:BOOLEAN;VIRTUAL;
  317.                    PROCEDURE   SaveAsFile;VIRTUAL;
  318.                    PROCEDURE   CloseFile;VIRTUAL;
  319.                    FUNCTION    GetTextFromCursor:STRING;
  320.                    FUNCTION    FindTextPos(s:STRING; w:WORD;
  321.                                VAR CY:LONGWORD; VAR CX:LONGWORD):BOOLEAN;
  322.                    PROCEDURE   FindText(s:STRING; w:WORD);VIRTUAL;
  323.                    PROCEDURE   ReplaceText(s,s1:STRING; w:WORD);VIRTUAL;
  324.                    PROCEDURE   SearchTextAgain;VIRTUAL;
  325.                    FUNCTION    GotoLine(y,x:LONGWORD):BOOLEAN;VIRTUAL;
  326.                    PROCEDURE   UpdateFont;
  327.                    PROCEDURE   _WriteWorkLine;
  328.                    PROCEDURE   _ReadWorkLine;
  329.                    FUNCTION    _Long2PLine(L:LONGWORD):PLine;
  330.                    FUNCTION    _PLine2Long(PL:PLine):LONGWORD;
  331.                    FUNCTION    _HorizMove:BOOLEAN;
  332.                    FUNCTION    _ReadString(PL:PLine; CX,count:WORD):STRING;
  333.                    FUNCTION    _InsertString(CX:WORD; str:STRING):BOOLEAN;
  334.                    FUNCTION    _WriteString(CX:WORD; str:STRING):BOOLEAN;
  335.                    FUNCTION    _DeleteString(CX:WORD; anz:WORD):BOOLEAN;
  336.                    FUNCTION    _InsertLine(PL:PLine):BOOLEAN;
  337.                    FUNCTION    _DeleteLine(PL:PLine):BOOLEAN;
  338.                    PROCEDURE   _Connect(PL1,PL2:PLine);
  339.                    PROCEDURE   DeleteChar;
  340.                    PROCEDURE   BackSpace;
  341.                    FUNCTION    _FindNextTab(PL:PLine; CX:WORD):WORD;
  342.                    PROCEDURE   Tabulator;
  343.                    PROCEDURE   CarriageReturn;
  344.                    PROCEDURE   DeleteLine;
  345.                    PROCEDURE   LineInsert;
  346.                    PROCEDURE   DeleteUntilEnd;
  347.                    PROCEDURE   DeleteRightWord;
  348.                    PROCEDURE   ToggleInsertMode;
  349.                    PROCEDURE   ToggleICBVisibility;
  350.                    PROCEDURE   CursorDown(rep:WORD);
  351.                    PROCEDURE   CursorUp(rep:WORD);
  352.                    PROCEDURE   CursorRight;
  353.                    PROCEDURE   CursorLeft;
  354.                    PROCEDURE   PageDown;
  355.                    PROCEDURE   PageUp;
  356.                    PROCEDURE   RollUp;
  357.                    PROCEDURE   RollDown;
  358.                    PROCEDURE   CursorPos1;
  359.                    PROCEDURE   CursorEnd;
  360.                    PROCEDURE   WordRight;
  361.                    PROCEDURE   WordLeft;
  362.                    PROCEDURE   GotoBegin;
  363.                    PROCEDURE   GotoEnd;
  364.                    PROCEDURE   PageHome;
  365.                    PROCEDURE   PageEnd;
  366.                    FUNCTION    _CuaICBPresent:BOOLEAN;
  367.                    PROCEDURE   _CuaClearMark;
  368.                    PROCEDURE   _CuaOverWriteBlock;
  369.                    PROCEDURE   CuaCursorDown(rep:WORD);
  370.                    PROCEDURE   CuaCursorUp(rep:WORD);
  371.                    PROCEDURE   CuaCursorRight;
  372.                    PROCEDURE   CuaCursorLeft;
  373.                    PROCEDURE   CuaPageDown;
  374.                    PROCEDURE   CuaPageUp;
  375.                    PROCEDURE   CuaRollUp;
  376.                    PROCEDURE   CuaRollDown;
  377.                    PROCEDURE   CuaCursorPos1;
  378.                    PROCEDURE   CuaCursorEnd;
  379.                    PROCEDURE   CuaWordRight;
  380.                    PROCEDURE   CuaWordLeft;
  381.                    PROCEDURE   CuaGotoBegin;
  382.                    PROCEDURE   CuaGotoEnd;
  383.                    PROCEDURE   CuaPageHome;
  384.                    PROCEDURE   CuaPageEnd;
  385.                    PROCEDURE   CuaDeleteChar;
  386.                    PROCEDURE   CuaBackSpace;
  387.  
  388.                    PROCEDURE   CuaTabulator;
  389.                    PROCEDURE   CuaCarriageReturn;
  390.                    PROCEDURE   CuaPasteFromClipBoard;
  391.                    PROCEDURE   CuaPasteFromFile(s:STRING);
  392.  
  393.                    PROCEDURE   _ICBClearMark;
  394.                    PROCEDURE   _ICBSetMark;
  395.                    PROCEDURE   _CheckICB;
  396.                    FUNCTION    _ICBPos(PL:PLine; CX:WORD):BYTE;
  397.                    PROCEDURE   ICBSetBegin;
  398.                    PROCEDURE   ICBSetEnd;
  399.                    PROCEDURE   ICBSelectWord;
  400.                    PROCEDURE   ICBSelectLine;
  401.                    PROCEDURE   ICBSelectAll;
  402.                    PROCEDURE   ICBDeselectAll;
  403.                    PROCEDURE   ICBGotoBegin;
  404.                    PROCEDURE   ICBGotoEnd;
  405.                    PROCEDURE   ICBCopyBlock;
  406.                    PROCEDURE   ICBMoveBlock;
  407.                    PROCEDURE   ICBDeleteBlock;
  408.                    PROCEDURE   ICBReadBlock;
  409.                    PROCEDURE   ICBWriteBlock;
  410.                    PROCEDURE   ICBMoveLeft;
  411.                    PROCEDURE   ICBMoveRight;
  412.                    PROCEDURE   _ICBExtSetICB;
  413.                    PROCEDURE   _ICBExtCorrectICB;
  414.                    PROCEDURE   ICBExtLeft;
  415.                    PROCEDURE   ICBExtRight;
  416.                    PROCEDURE   ICBExtUp;
  417.                    PROCEDURE   ICBExtDown;
  418.                    PROCEDURE   ICBExtPageUp;
  419.                    PROCEDURE   ICBExtPageDown;
  420.                    PROCEDURE   ICBExtPos1;
  421.                    PROCEDURE   ICBExtEnd;
  422.                    PROCEDURE   ICBExtWordLeft;
  423.                    PROCEDURE   ICBExtWordRight;
  424.                    PROCEDURE   ICBExtFileBegin;
  425.                    PROCEDURE   ICBExtFileEnd;
  426.                    FUNCTION    _CopyICBLinear(VAR Len:LONGWORD):POINTER;
  427.                    PROCEDURE   _PasteICBLinear(P:POINTER; Len:LONGWORD);
  428.                    FUNCTION    _SetClipBoardText(P:POINTER; Len:LONGWORD):BOOLEAN;
  429.                    FUNCTION    _GetClipBoardText(VAR Len:LONGWORD):POINTER;
  430.                    FUNCTION    _GetFileText(s:STRING; VAR Len:LONGWORD):POINTER;
  431.                    PROCEDURE   CutToClipBoard;
  432.                    PROCEDURE   CopyToClipBoard;
  433.                    PROCEDURE   PasteFromClipBoard;
  434.                    PROCEDURE   PasteFromFile(s:STRING);
  435.                    PROCEDURE   EnableCopyCut;VIRTUAL;
  436.                    PROCEDURE   DisableCopyCut;VIRTUAL;
  437.                    PROCEDURE   EnablePaste;VIRTUAL;
  438.                    PROCEDURE   DisablePaste;VIRTUAL;
  439.                    PROCEDURE   EnableUndo;VIRTUAL;
  440.                    PROCEDURE   DisableUndo;VIRTUAL;
  441.                    PROCEDURE   EnableRedo;VIRTUAL;
  442.                    PROCEDURE   DisableRedo;VIRTUAL;
  443.                    FUNCTION    _CountLines(FirstL,LastL:PLine):LONGWORD;
  444.                    PROCEDURE   _StoreUndoCursor;
  445.                    FUNCTION    _CopyUndoLines(FirstL,LastL:PLine):LONGWORD;
  446.                    FUNCTION    _MoveUndoLines(FirstL,LastL:PLine):LONGWORD;
  447.                    PROCEDURE   _CreateUndoEvent(U:TUNDO);
  448.                    PROCEDURE   _DeleteUndoEvent(Nr:WORD);
  449.                    PROCEDURE   Undo;
  450.                    FUNCTION    _MoveRedoLines(FirstL,LastL:PLine):LONGWORD;
  451.                    PROCEDURE   _CreateRedoEvent(U:TUNDO);
  452.                    PROCEDURE   _DeleteRedoEvent(Nr:WORD);
  453.                    PROCEDURE   Redo;
  454.                    FUNCTION    _FindBookMark(BM:WORD):PLine;
  455.                    PROCEDURE   GotoBookMark(Scan:LONGWORD);
  456.                    PROCEDURE   SetBookMark(Scan:LONGWORD);
  457.                    PROCEDURE   DeleteBookMark(Scan:LONGWORD);
  458.                    PROCEDURE   DeleteAllBookMarks;
  459.                    FUNCTION    GetPrinterDevice(VAR dopPrinter:DEVOPENSTRUC):
  460.                                BOOLEAN;VIRTUAL;
  461.                    PROCEDURE   PrintFile;VIRTUAL;
  462.                    PROCEDURE   InitializePrinting;VIRTUAL;
  463.                    END;
  464.  
  465.  
  466.  
  467.      TAvailFont=RECORD
  468.                       PointSize : BYTE;
  469.                       FontName  : STRING[32];
  470.                       Height    : BYTE;
  471.                       Width     : BYTE;
  472.                       BaseLine  : BYTE;
  473.                 END;
  474.  
  475.  
  476.      FUNCTION QueryFonts(ahps:HPS):BYTE;
  477.  
  478.  
  479. VAR  OutputString   : STRING;
  480.      LineColor      : ARRAY[1..260] OF TLineColor;
  481.      EditOptions    : LONGWORD;
  482.      FindOptions    : WORD;
  483.      ReplOptions    : WORD;
  484.      LastFRD        : BYTE;
  485.      aSearchString  : STRING;
  486.      aReplaceString : STRING;
  487.      DragStaticX    : WORD;
  488.      DragStaticY    : LONGWORD;
  489.      DragStaticLine : PLine;
  490.      PreCtrl        : LONGWORD;
  491.      ChangeICB      : BOOLEAN;
  492.      WinReadOnly    : BOOLEAN;
  493.      FaceName       : CSTRING;
  494.      CharHeight     : BYTE;
  495.      CharWidth      : BYTE;
  496.      CharBaseLine   : BYTE;
  497.      AvailFontCount : BYTE;
  498.      AvailFont      : ARRAY[0..99] OF TAvailFont;
  499.      NLSTable       : ARRAY[1..29] OF STRING[80]; {Language Support Table}
  500.      CursorRate     : LONGWORD;
  501.  
  502.  
  503.  
  504. IMPLEMENTATION
  505.  
  506. CONST
  507.      POS_OUTICB         = 0;
  508.      POS_BEFOREICBFIRST = 1;
  509.      POS_AFTERICBFIRST  = 2;
  510.      POS_INICB          = 4;
  511.      POS_BEFOREICBLAST  = 8;
  512.      POS_AFTERICBLAST   = 16;
  513.      POS_FIRSTICBLINE   = 3;      {Bit 1 or 2 set}
  514.      POS_LASTICBLINE    = 24;     {Bit 8 or 16 set}
  515.  
  516.  
  517.  
  518. { ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  519.  
  520.  
  521. PROCEDURE TEditorWindow._WriteWorkLine;
  522. {Write back content of WORKLINE}
  523. BEGIN
  524.      WHILE (Length(WorkLine^) > 0) AND (WorkLine^[Length(WorkLine^)] = ' ')
  525.        DO dec(WorkLine^[0]);
  526.      IF Length(WorkLine^) > StringLength THEN WorkLine^[0] := chr(StringLength);
  527.  
  528.      GetMem(ActLine^.zk,Length(WorkLine^)+1);    {+1 Byte for Length}
  529.      move(WorkLine^[0],ActLine^.zk^[0],Length(WorkLine^)+1);
  530.      WLactivated := FALSE;
  531. END;
  532.  
  533.  
  534.  
  535. PROCEDURE TEditorWindow._ReadWorkLine;
  536. {Read content of a line into WORKLINE}
  537. BEGIN
  538.      FillChar(WorkLine^[1],StringLength,32);
  539.  
  540.      move(ActLine^.zk^[0],WorkLine^[0],Length(ActLine^.zk^)+1);
  541.      FreeMem(ActLine^.zk,Length(ActLine^.zk^)+1);
  542.      ActLine^.zk := NIL;
  543.      WLactivated := TRUE;
  544. END;
  545.  
  546.  
  547.  
  548. FUNCTION TEditorWindow._PLine2Long(PL:PLine):LONGWORD;
  549. {convert pointer to linenumber}
  550. VAR  ptline : PLine;
  551.      L : LONGWORD;
  552. BEGIN
  553.      L := 0;
  554.      IF PL <> NIL THEN
  555.      BEGIN
  556.           ptline := FirstLine;
  557.           L := 1;
  558.           WHILE (ptline <> PL) AND (ptline <> NIL) DO
  559.           BEGIN
  560.                ptline := ptline^.next;
  561.                inc(L);
  562.           END;
  563.           IF ptline = NIL THEN L := 0;
  564.      END;
  565.      _PLine2Long := L;
  566. END;
  567.  
  568.  
  569.  
  570. FUNCTION TEditorWindow._Long2PLine(L:LONGWORD):PLine;
  571. {convert linenumber to pointer}
  572. VAR  ptline : PLine;
  573.      i : LONGWORD;
  574. BEGIN
  575.      ptline := NIL;
  576.      IF (L >= 1) AND (L <= CountLines) THEN
  577.      BEGIN
  578.           ptline := FirstLine;
  579.           FOR i := 2 TO L DO
  580.              IF ptline^.next <> NIL THEN ptline := ptline^.next
  581.      END;
  582.      _Long2PLine := ptline;
  583. END;
  584.  
  585.  
  586.  
  587. FUNCTION TEditorWindow._HorizMove:BOOLEAN;
  588. BEGIN
  589.      _HorizMove := HSlider.acvalue <> FileCursorX-ScrCursorX+1;
  590. END;
  591.  
  592.  
  593. FUNCTION QueryFonts(ahps:HPS):BYTE;
  594. TYPE tFM=ARRAY[0..999] OF FONTMETRICS;
  595.      pFM=^tFM;
  596. VAR  ahdc : HDC;
  597.      lRequestFonts,FontCount : LONGINT;
  598.      lHorzRes,lVertRes : LONGINT;
  599.      i : INTEGER;
  600.      count : WORD;
  601.      FM : pFM;
  602.      PointSize : WORD;
  603. BEGIN
  604.      QueryFonts := 0;
  605.  
  606.      ahdc := GpiQueryDevice(ahps);
  607.      DevQueryCaps(ahdc, CAPS_HORIZONTAL_FONT_RES, 1, lHorzRes);
  608.      DevQueryCaps(ahdc, CAPS_VERTICAL_FONT_RES, 1, lVertRes);
  609.  
  610.      lRequestFonts := 0;
  611.  
  612.      FontCount := GpiQueryFonts(ahps,
  613.                                 QF_PUBLIC,
  614.                                 NIL,
  615.                                 lRequestFonts,
  616.                                 0,
  617.                                 NIL);
  618.  
  619.      IF FontCount <= 0 THEN exit;
  620.  
  621.      GetMem(FM,FontCount*SizeOf(FONTMETRICS));
  622.  
  623.      GpiQueryFonts(ahps,
  624.                    QF_PUBLIC,
  625.                    NIL,
  626.                    FontCount,
  627.                    SizeOf(FONTMETRICS),
  628.                    FM^[0]);
  629.  
  630.      count := 0;
  631.      FOR i := 0 TO FontCount-1 DO
  632.      IF (FM^[i].sXDeviceRes = lHorzRes) AND
  633.         (FM^[i].sYDeviceRes = lVertRes) AND
  634.         ((FM^[i].fsDefn AND FM_DEFN_OUTLINE) = 0) AND      {is Bitmap font}
  635.         ((FM^[i].fsType AND FM_TYPE_FIXED) <> 0) THEN      {is monospaced}
  636.      BEGIN
  637.           PointSize := FM^[i].sNominalPointSize DIV 10;
  638.           AvailFont[count].PointSize := PointSize;
  639.           AvailFont[count].FontName := FM^[i].szFaceName;
  640.           AvailFont[count].Height := FM^[i].lMaxBaseLineExt;
  641.           AvailFont[count].Width := FM^[i].lAveCharWidth;
  642.           AvailFont[count].BaseLine := FM^[i].lMaxDescender;
  643.           inc(count);
  644.           IF count > 99 THEN break;
  645.      END;
  646.  
  647.      FreeMem(FM,FontCount*SizeOf(FONTMETRICS));
  648.  
  649.      QueryFonts := count;
  650. END;
  651.  
  652.  
  653. PROCEDURE TEditorWindow.UpdateFont;
  654. VAR  FCX, FCY : LONGWORD;
  655.      rc : RECTL;
  656. BEGIN
  657.      WinSizeX := (WindowRect.XRight-4) DIV CharWidth;
  658.      WinSizeY := (WindowRect.yTop-2-CharBaseLine) DIV CharHeight;
  659.      IF ScrCursorY > WinSizeY
  660.      THEN FCY := FileCursorY-ScrCursorY+WinSizeY
  661.      ELSE FCY := FileCursorY;
  662.      IF ScrCursorX > WinSizeX
  663.      THEN FCX := FileCursorX-ScrCursorX+WinSizeX
  664.      ELSE FCX := FileCursorX;
  665.  
  666.      CreateLogFont(ResidentHPS,FaceName,CharHeight,CharWidth,0);
  667.      SetSliderValues;
  668.      GotoLine(FCY,FCX);
  669.      Redraw(ResidentHPS,rc);
  670.      IgnoreRedraw := WinSizeY = 0;
  671. END;
  672.  
  673.  
  674. { +++ Block ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  675.  
  676.  
  677. PROCEDURE TEditorWindow._ICBClearMark;
  678. {Delete all ICB marks}
  679. VAR  ptline : PLine;
  680. BEGIN
  681.      _CheckICB;
  682.      IF (ICB.FirstLine = NIL) OR (ICB.LastLine = NIL) THEN exit;
  683.      ptline := ICB.FirstLine;
  684.      WHILE ptline <> ICB.LastLine DO
  685.      BEGIN
  686.           ptline^.color := ptline^.color AND NOT CI_Selected;
  687.           ptline := ptline^.next;
  688.      END;
  689.      ptline^.color := ptline^.color AND NOT CI_Selected;
  690. END;
  691.  
  692.  
  693.  
  694. PROCEDURE TEditorWindow._ICBSetMark;
  695. {mark lines of current ICB}
  696. VAR  ptline : PLine;
  697. BEGIN
  698.      _CheckICB;
  699.      IF (ICB.FirstLine = NIL) OR (ICB.LastLine = NIL) THEN exit;
  700.      ptline := ICB.FirstLine;
  701.      WHILE ptline <> ICB.LastLine DO
  702.      BEGIN
  703.           ptline^.color := ptline^.color OR CI_Selected;
  704.           ptline := ptline^.next;
  705.      END;
  706.      ptline^.color := ptline^.color OR CI_Selected;
  707.      ICBVisible := TRUE;
  708. END;
  709.  
  710.  
  711.  
  712. PROCEDURE TEditorWindow._CheckICB;
  713. BEGIN
  714.      IF (ICB.FirstLine = NIL) OR (ICB.LastLine = NIL) THEN DisableCopyCut
  715.      ELSE
  716.      BEGIN
  717.           IF (ICB.FirstLine = ICB.LastLine) AND (ICB.FirstX = ICB.LastX)
  718.           THEN DisableCopyCut
  719.           ELSE EnableCopyCut;
  720.      END;
  721.  
  722.      IF ICB.FirstX > StringLength THEN ICB.FirstX := StringLength;
  723.      IF ICB.LastX > StringLength THEN ICB.LastX := StringLength;
  724. END;
  725.  
  726.  
  727.  
  728. FUNCTION TEditorWindow._ICBPos(PL:PLine; CX:WORD):BYTE;
  729. {Calculate code of current position to ICB}
  730. VAR  P : BYTE;
  731. BEGIN
  732.      P := 0;
  733.      IF PL = NIL THEN exit;
  734.  
  735.      IF PL = ICB.FirstLine THEN
  736.      BEGIN
  737.           IF CX < ICB.FirstX THEN P := P OR POS_BEFOREICBFIRST
  738.           ELSE P := P OR POS_AFTERICBFIRST;
  739.      END;
  740.  
  741.      IF PL = ICB.LastLine THEN
  742.      BEGIN
  743.           IF CX < ICB.LastX THEN P := P OR POS_BEFOREICBLAST
  744.           ELSE P := P OR POS_AFTERICBLAST;
  745.      END;
  746.  
  747.      IF (PL^.color AND CI_Selected <> 0) AND (P = 0) THEN P := POS_INICB;
  748.      _ICBPos := P;
  749. END;
  750.  
  751.  
  752.  
  753. FUNCTION TEditorWindow._SetClipBoardText(P:POINTER; Len:LONGWORD):BOOLEAN;
  754. VAR  PBuf : POINTER;
  755. BEGIN
  756.      _SetClipBoardText := FALSE;
  757.      IF WinOpenClipBrd(AppHandle) THEN
  758.      BEGIN
  759.           DosAllocSharedMem(PBuf,NIL,Len,PAG_WRITE OR PAG_COMMIT OR OBJ_GIVEABLE);
  760.           IF PBuf = NIL THEN
  761.           BEGIN
  762.                WinCloseClipBrd(AppHandle);
  763.                SetErrorMessage(MB_ICONHAND,NLSTable[1],NLSTable[2]);
  764.                exit;
  765.           END;
  766.           ASM
  767.              MOV ESI,$P
  768.              MOV EDI,$PBuf
  769.              MOV ECX,$Len
  770.              CLD
  771.              MOV EDX,ECX
  772.              SHR ECX,2
  773.              REP
  774.              MOVSD
  775.              MOV ECX,EDX
  776.              AND ECX,3
  777.              REP
  778.              MOVSB
  779.           END;
  780.           WinEmptyClipBrd(AppHandle);
  781.           WinSetClipBrdData(AppHandle,LONGWORD(PBuf),CF_TEXT,CFI_POINTER);
  782.           WinCloseClipBrd(AppHandle);
  783.           _SetClipBoardText := TRUE;
  784.      END
  785.      ELSE SetErrorMessage(MB_ICONHAND,NLSTable[1],NLSTable[3]);
  786. END;
  787.  
  788.  
  789.  
  790. FUNCTION TEditorWindow._GetClipBoardText(VAR Len:LONGWORD):POINTER;
  791. VAR  Clip : ^LONGWORD;
  792.      P : ^LONGWORD;
  793.      Leng : LONGWORD;
  794. BEGIN
  795.      _GetClipBoardText := NIL;
  796.      IF WinOpenClipBrd(AppHandle) THEN
  797.      BEGIN
  798.           Clip := POINTER(WinQueryClipBrdData(AppHandle,CF_TEXT));
  799.           IF Clip = NIL THEN
  800.           BEGIN
  801.                WinCloseClipBrd(AppHandle);
  802.                exit;
  803.           END;
  804.           ASM
  805.              CLD
  806.              MOV ECX,0
  807.              MOV ESI,$Clip
  808. !gt:
  809.              INC ECX
  810.              LODSB
  811.              CMP AL,0
  812.              JNE !gt
  813.              MOV $Leng,ECX
  814.           END;
  815.           IF Leng > 1 THEN
  816.           BEGIN
  817.                Len := Leng;
  818.                Getmem(P,Len);
  819.                Move(Clip^,P^,Len);
  820.               _GetClipBoardText := P;
  821.           END;
  822.           WinCloseClipBrd(AppHandle);
  823.      END
  824.      ELSE SetErrorMessage(MB_ICONHAND,NLSTable[1],NLSTable[3]);
  825. END;
  826.  
  827.  
  828.  
  829. FUNCTION TEditorWindow._CopyICBLinear(VAR Len:LONGWORD):POINTER;
  830. VAR  ptline : PLine;
  831.      LinearStart : ^LONGWORD;
  832.      LinearPtr : ^LONGWORD;
  833.      pstr : PSTRING;
  834.      icbstr : STRING;
  835. BEGIN
  836.      IF (ICB.FirstLine = NIL) OR (ICB.LastLine = NIL) THEN
  837.      BEGIN
  838.           _CopyICBLinear := NIL;
  839.           exit;
  840.      END;
  841.      IF WLactivated THEN _WriteWorkLine;
  842.      IF ICB.FirstLine = ICB.LastLine THEN
  843.      BEGIN
  844.           Len := ICB.LastX-ICB.FirstX;
  845.           IF Len > 0 THEN
  846.           BEGIN
  847.                inc(Len);         {#0}
  848.                GetMem(LinearStart,Len);
  849.                icbstr := _ReadString(ICB.FirstLine,ICB.FirstX,Len-1);
  850.                icbstr := icbstr + #0;
  851.                Move(icbstr[1],LinearStart^,Length(icbstr));
  852.           END
  853.           ELSE LinearStart := NIL;
  854.      END
  855.      ELSE
  856.      BEGIN
  857.           ptline := ICB.FirstLine;
  858.           Len := Length(ptline^.zk^)-ICB.FirstX+1+2;     {first ICB line}
  859.           ptline := ptline^.next;
  860.           WHILE ptline <> ICB.LastLine DO
  861.           BEGIN
  862.                inc(Len,Length(ptline^.zk^)+2);
  863.                ptline := ptline^.next;
  864.           END;
  865.           inc(Len,ICB.LastX-1);                          {last ICB line}
  866.           inc(Len);        {#0}
  867.           GetMem(LinearStart,Len);
  868.  
  869.           ptline := ICB.FirstLine;
  870.           LinearPtr := LinearStart;
  871.           {first ICB line}
  872.           icbstr := _ReadString(ICB.FirstLine,ICB.FirstX,
  873.                                 Length(ICB.FirstLine^.zk^)-ICB.FirstX+1);
  874.           icbstr := icbstr + #13#10;
  875.           Move(icbstr[1],LinearPtr^,Length(icbstr));
  876.           inc(LinearPtr,Length(icbstr));
  877.           ptline := ptline^.next;
  878.           WHILE ptline <> ICB.LastLine DO
  879.           BEGIN
  880.                pstr := ptline^.zk;
  881.                ASM
  882.                   CLD
  883.                   MOV EDI,$LinearPtr
  884.                   MOV ESI,$pstr
  885.                   XOR ECX,ECX
  886.                   MOV CL,[ESI+0]
  887.                   INC ESI
  888.                   MOV EDX,ECX
  889.                   SHR ECX,2
  890.                   REP
  891.                   MOVSD
  892.                   MOV ECX,EDX
  893.                   AND ECX,3
  894.                   REP
  895.                   MOVSB
  896.                   MOV AX,$0A0D
  897.                   STOSW
  898.                   MOV $LinearPtr,EDI
  899.                END;
  900.                ptline := ptline^.next;
  901.           END;
  902.           {last ICB line}
  903.           icbstr := _ReadString(ICB.LastLine,1,ICB.LastX-1);
  904.           icbstr := icbstr + #0;
  905.           Move(icbstr[1],LinearPtr^,Length(icbstr));
  906.      END;
  907.      _CopyICBLinear := LinearStart;
  908. END;
  909.  
  910.  
  911.  
  912. PROCEDURE TEditorWindow._PasteICBLinear(P:POINTER; Len:LONGWORD);
  913. VAR  TabSize : LONGWORD;
  914.      StrL : LONGWORD;
  915.      laststr : STRING;
  916.      str : STRING;
  917. BEGIN
  918.      ICB.FirstLine := ActLine;
  919.      ICB.FirstX := FileCursorX;
  920.      IF NOT WLactivated THEN _ReadWorkLine;
  921.      IF FileCursorX <= Length(WorkLine^)
  922.      THEN laststr := copy(WorkLine^,FileCursorX,Length(WorkLine^)-FileCursorX+1)
  923.      ELSE laststr := '';
  924.      WorkLine^[0] := chr(FileCursorX-1);
  925.  
  926.      {Copy the object varriables to access via assembler}
  927.      TabSize := EditOptions DIV $1000000;
  928.      IF TabSize = 0 THEN TabSize := 8;
  929.      StrL := StringLength;
  930.      str := '';
  931.  
  932.      WHILE Len > 0 DO
  933.      BEGIN
  934.           ASM
  935.              CLD
  936.              LEA EDI,$str
  937.              MOV ESI,$P
  938.              INC EDI
  939.              XOR ECX,ECX
  940. !pl1:
  941.              CMPD $Len,0
  942.              JE !pl6
  943.              LODSB
  944.              DECD $Len
  945.              CMP AL,13
  946.              JE !pl3
  947.              CMP AL,10
  948.              JE !pl4
  949.              CMP AL,9
  950.              JE !pl2
  951.              CMP AL,0
  952.              JE !pl6
  953.              CMP AL,32
  954.              JAE !pl5
  955.              MOV AL,32
  956.              JMP !pl5
  957. !pl2:
  958.              MOV EBX,ECX
  959.              MOV EDX,$TabSize
  960.              // insert spaces til to the next tab mark
  961. !pl8:
  962.              CMP EDX,EBX
  963.              JA !pl7
  964.              ADD EDX,$TabSize
  965.              JMP !pl8
  966. !pl7:
  967.              SUB EDX,EBX
  968.              // EDX = count of spaces
  969.              ADD EBX,EDX
  970.              CMP EBX,$StrL
  971.              JAE !pl6
  972.              MOV ECX,EDX
  973.              MOV AL,32
  974.              REP
  975.              STOSB
  976.              MOV ECX,EBX
  977.              JMP !pl1
  978. !pl3:
  979.              CMPB [ESI],10
  980.              JNE !pl6
  981.              LODSB
  982.              DECD $Len
  983.              JMP !pl6
  984. !pl4:
  985.              CMPB [ESI],13
  986.              JNE !pl6
  987.              LODSB
  988.              DECD $Len
  989.              JMP !pl6
  990. !pl5:
  991.              STOSB
  992.              INC ECX
  993.              CMP ECX,$StrL
  994.              JB !pl1
  995. !pl6:
  996.              MOV $P,ESI
  997.              MOV $str,CL
  998.           END;
  999.  
  1000.           _WriteString(FileCursorX,str);
  1001.           GetMem(ActLine^.zk,Length(WorkLine^)+1);
  1002.           move(WorkLine^[0],ActLine^.zk^[0],Length(WorkLine^)+1);
  1003.  
  1004.           _InsertLine(ActLine);
  1005.           ActLine := ActLine^.next;
  1006.           FileCursorX := 1;
  1007.           WorkLine^ := '';
  1008.           WLactivated := TRUE;
  1009.      END;
  1010.      ActLine := ActLine^.prev;
  1011.      _DeleteLine(ActLine^.next);
  1012.      ICB.LastLine := ActLine;
  1013.      ICB.LastX := Length(ActLine^.zk^)+1;
  1014.      _ReadWorkLine;
  1015.      _WriteString(ICB.LastX,laststr);
  1016.      _WriteWorkLine;
  1017.      _ICBSetMark;
  1018. END;
  1019.  
  1020.  
  1021. { +++ WORKLINE +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1022.  
  1023.  
  1024. FUNCTION TEditorWindow._ReadString(PL:PLine; CX, count:WORD):STRING;
  1025. VAR  L : BYTE;
  1026.      s : STRING;
  1027. BEGIN
  1028.      IF WLactivated THEN _WriteWorkLine;
  1029.      _ReadString := '';
  1030.      IF PL = NIL THEN exit;
  1031.      IF PL^.zk = NIL THEN exit;
  1032.      FillChar(s[1],StringLength,32);
  1033.      move(PL^.zk^[1],s[1],Length(PL^.zk^));
  1034.      s[0] := chr(StringLength);
  1035.      _ReadString := copy(s,CX,count);
  1036. END;
  1037.  
  1038.  
  1039.  
  1040. FUNCTION TEditorWindow._InsertString(CX:WORD; str:STRING):BOOLEAN;
  1041. {insert a string in the current line at position CX}
  1042. {Result FALSE if line will be to long and cut at end of line}
  1043. VAR  endline : WORD;
  1044.      Lstr : WORD;
  1045.      appstr : STRING;
  1046. BEGIN
  1047.      IF NOT WLactivated THEN _ReadWorkLine;
  1048.      _InsertString := TRUE;
  1049.      Lstr := Length(str);
  1050.      IF Lstr = 0 THEN exit;
  1051.  
  1052.      IF CX > Length(WorkLine^) THEN
  1053.      BEGIN
  1054.           IF Lstr + CX > StringLength THEN _InsertString := FALSE;
  1055.           WorkLine^[0] := chr(CX-1);
  1056.           WorkLine^ := WorkLine^ + str;
  1057.      END
  1058.      ELSE
  1059.      BEGIN
  1060.           IF Lstr + Length(WorkLine^) > StringLength THEN _InsertString:=FALSE;
  1061.           appstr := copy(WorkLine^,CX,Length(WorkLine^)-CX+1);
  1062.           WorkLine^[0] := chr(CX-1);
  1063.           WorkLine^ := WorkLine^ + str + appstr;
  1064.      END;
  1065.      IF Length(WorkLine^) > StringLength THEN WorkLine^[0] := chr(StringLength);
  1066.      Modified := TRUE;
  1067. END;
  1068.  
  1069.  
  1070.  
  1071. FUNCTION TEditorWindow._WriteString(CX:WORD; str:STRING):BOOLEAN;
  1072. {overwrite current line at position CX with STR}
  1073. {Result FALSE if line will be to long and cut at end of line}
  1074. VAR  newend : WORD;
  1075. BEGIN
  1076.      IF NOT WLactivated THEN _ReadWorkLine;
  1077.      _WriteString := TRUE;
  1078.      IF Length(str) = 0 THEN exit;
  1079.  
  1080.      IF CX+(Length(str)-1) > StringLength THEN
  1081.      BEGIN
  1082.           str[0] := chr(StringLength-CX+1);
  1083.           _WriteString := FALSE;
  1084.      END;
  1085.  
  1086.      move(str[1],Workline^[CX],Length(str));
  1087.      newend := CX + (Length(str)-1);
  1088.      IF Length(WorkLine^) < newend THEN WorkLine^[0] := chr(newend);
  1089.      Modified := TRUE;
  1090. END;
  1091.  
  1092.  
  1093.  
  1094. FUNCTION TEditorWindow._DeleteString(CX, anz:WORD):BOOLEAN;
  1095. {Delete ANZ characters at position CX in the current line}
  1096. BEGIN
  1097.      IF NOT WLactivated THEN _ReadWorkLine;
  1098.      IF anz = 0 THEN exit;
  1099.      IF CX > Length(WorkLine^) THEN exit;
  1100.      IF CX+anz > Length(WorkLine^) THEN anz := Length(WorkLine^)-CX+1;
  1101.      delete(WorkLine^,CX,anz);
  1102.      Modified := TRUE;
  1103. END;
  1104.  
  1105.  
  1106.  
  1107. FUNCTION TEditorWindow._InsertLine(PL:PLine):BOOLEAN;
  1108. {insert a line after PL}
  1109. VAR  ptline : PLine;
  1110.      newnextline : PLine;
  1111. BEGIN
  1112.      IF PL = NIL THEN newnextline := FirstLine
  1113.      ELSE newnextline := PL^.next;
  1114.  
  1115.      New(ptline);
  1116.      ptline^.color := CI_Normal;
  1117.      ptline^.zk := NIL;
  1118.      _Connect(ptline,newnextline);
  1119.      _Connect(PL,ptline);
  1120.  
  1121.      inc(CountLines);
  1122.      Modified := TRUE;
  1123.      _InsertLine := TRUE;
  1124. END;
  1125.  
  1126.  
  1127.  
  1128. FUNCTION TEditorWindow._DeleteLine(PL:PLine):BOOLEAN;
  1129. {Delete a line}
  1130. VAR  ptline : PLine;
  1131.      prevline : PLine;
  1132.      nextline : PLine;
  1133. BEGIN
  1134.      IF (CountLines = 1) OR (PL = NIL) THEN
  1135.      BEGIN
  1136.           _DeleteLine := FALSE;
  1137.           exit;
  1138.      END;
  1139.      IF PL^.zk <> NIL THEN FreeMem(PL^.zk,Length(PL^.zk^)+1);
  1140.  
  1141.      _Connect(PL^.prev,PL^.next);
  1142.      Dispose(PL);
  1143.      dec(CountLines);
  1144.      Modified := TRUE;
  1145.      _DeleteLine := TRUE;
  1146. END;
  1147.  
  1148.  
  1149.  
  1150. PROCEDURE TEditorWindow._Connect(PL1, PL2:PLine);
  1151. BEGIN
  1152.      IF PL1 <> NIL THEN PL1^.next := PL2
  1153.      ELSE FirstLine := PL2;
  1154.      IF PL2 <> NIL THEN PL2^.prev := PL1
  1155.      ELSE LastLine := PL1;
  1156. END;
  1157.  
  1158.  
  1159. { +++ Undo +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1160.  
  1161.  
  1162. FUNCTION TEditorWindow._CountLines(FirstL,LastL:PLine):LONGWORD;
  1163. VAR  lines : LONGWORD;
  1164.      TempL : PLine;
  1165. BEGIN
  1166.      lines := 1;
  1167.      TempL := FirstL;
  1168.      WHILE (TempL <> LastL) AND (TempL <> NIL) DO
  1169.      BEGIN
  1170.           TempL := TempL^.next;
  1171.           inc(lines);
  1172.      END;
  1173.  
  1174.      IF TempL <> NIL THEN  {FirstL <= LastL}
  1175.      BEGIN
  1176.           {Reset Color}
  1177.           TempL := FirstL;
  1178.           WHILE TempL <> LastL DO
  1179.           BEGIN
  1180.                TempL^.color := CI_Normal;
  1181.                TempL := TempL^.next;
  1182.           END;
  1183.           IF LastL <> NIL THEN LastL^.color := CI_Normal;
  1184.           _CountLines := lines;
  1185.      END
  1186.      ELSE _CountLines := 0;
  1187. END;
  1188.  
  1189.  
  1190.  
  1191. PROCEDURE TEditorWindow._StoreUndoCursor;
  1192. VAR  U : TUNDO;
  1193. BEGIN
  1194.      U.Event := 0;
  1195.      U.Modified := Modified;
  1196.      U.ICBFL := _PLine2Long(ICB.FirstLine);
  1197.      U.ICBFX := ICB.FirstX;
  1198.      U.ICBLL := _PLine2Long(ICB.LastLine);
  1199.      U.ICBLX := ICB.LastX;
  1200.      U.FCX := FileCursorX;
  1201.      U.FCY := FileCursorY;
  1202.      _CreateUndoEvent(U);
  1203. END;
  1204.  
  1205.  
  1206.  
  1207. FUNCTION TEditorWindow._CopyUndoLines(FirstL,LastL:PLine):LONGWORD;
  1208. VAR  U : TUNDO;
  1209.      FUL,LUL : PLine;
  1210.      ptline : PLine;
  1211.      ptnew : PLine;
  1212.      ptlast : PLine;
  1213.      cl : LONGWORD;
  1214. BEGIN
  1215.      IF Wlactivated THEN _WriteWorkLine;
  1216.      cl := 0;
  1217.      ptnew := NIL;
  1218.      ptline := FirstL;
  1219.      WHILE ptline <> LastL^.next DO
  1220.      BEGIN
  1221.            New(ptnew);
  1222.            IF cl = 0 THEN FUL := ptnew;
  1223.            GetMem(ptnew^.zk,Length(ptline^.zk^)+1);
  1224.            ptnew^.zk^ := ptline^.zk^;
  1225.            ptnew^.color := CI_Normal;
  1226.            IF cl > 0 THEN _Connect(ptlast,ptnew);
  1227.            ptline := ptline^.next;
  1228.            ptlast := ptnew;
  1229.            inc(cl);
  1230.      END;
  1231.      LUL := ptnew;
  1232.  
  1233.      U.Event := 1;
  1234.      U.Modified := Modified;
  1235.      U.ICBFL := _PLine2Long(ICB.FirstLine);
  1236.      U.ICBFX := ICB.FirstX;
  1237.      U.ICBLL := _PLine2Long(ICB.LastLine);
  1238.      U.ICBLX := ICB.LastX;
  1239.      U.FCX := FileCursorX;
  1240.      U.FCY := FileCursorY;
  1241.      U.FrameBegin := _PLine2Long(FirstL)-1;
  1242.      U.FrameEnd := _PLine2Long(LastL)+1;   {default: count of lines constant}
  1243.      U.FirstUndoLine := FUL;
  1244.      U.LastUndoLine := LUL;
  1245.      U.Lines := cl;
  1246.      _CreateUndoEvent(U);
  1247.      _CopyUndoLines := cl;
  1248. END;
  1249.  
  1250.  
  1251.  
  1252. FUNCTION TEditorWindow._MoveUndoLines(FirstL,LastL:PLine):LONGWORD;
  1253. VAR  U : TUNDO;
  1254. BEGIN
  1255.      IF WLactivated THEN _WriteWorkLine;
  1256.      U.Event := 1;
  1257.      U.Modified := Modified;
  1258.      U.ICBFL := _PLine2Long(ICB.FirstLine);
  1259.      U.ICBFX := ICB.FirstX;
  1260.      U.ICBLL := _PLine2Long(ICB.LastLine);
  1261.      U.ICBLX := ICB.LastX;
  1262.      U.FCX := FileCursorX;
  1263.      U.FCY := FileCursorY;
  1264.  
  1265.      U.Lines := _CountLines(FirstL,LastL);    {count lines for UNDO stack}
  1266.      IF U.Lines > 0 THEN
  1267.      BEGIN
  1268.           U.FrameBegin := _PLine2Long(FirstL)-1;
  1269.           U.FirstUndoLine := FirstL;
  1270.           U.LastUndoLine := LastL;
  1271.      END
  1272.      ELSE
  1273.      BEGIN
  1274.           U.FrameBegin := _PLine2Long(LastL);
  1275.           U.FirstUndoLine := NIL;
  1276.           U.LastUndoLine := NIL;
  1277.      END;
  1278.      _CreateUndoEvent(U);
  1279.      _MoveUndoLines := U.Lines;
  1280. END;
  1281.  
  1282.  
  1283.  
  1284. PROCEDURE TEditorWindow._CreateUndoEvent(U:TUNDO);
  1285. BEGIN
  1286.      LastUndo := (LastUndo+1) MOD MaxUndoEvents;
  1287.      IF UndoEvents < MaxUndoEvents THEN inc(UndoEvents);
  1288.      _DeleteUndoEvent(LastUndo);
  1289.      UndoEvent[LastUndo] := U;
  1290.      EnableUndo;
  1291. END;
  1292.  
  1293.  
  1294.  
  1295. PROCEDURE TEditorWindow._DeleteUndoEvent(Nr:WORD);
  1296. VAR  ptline : PLine;
  1297.      ptnext : PLine;
  1298.      i : LONGWORD;
  1299. BEGIN
  1300.      IF UndoEvent[Nr].Event = 0 THEN exit;
  1301.      UndoEvent[Nr].Event := 0;
  1302.  
  1303.      ptline := UndoEvent[Nr].FirstUndoLine;
  1304.      FOR i := 1 TO UndoEvent[Nr].Lines DO
  1305.      BEGIN
  1306.           IF ptline = NIL THEN exit;
  1307.           ptnext := ptline^.next;
  1308.           IF ptline^.zk <> NIL THEN FreeMem(ptline^.zk,Length(ptline^.zk^)+1);
  1309.           Dispose(ptline);
  1310.           ptline := ptnext;
  1311.      END;
  1312. END;
  1313.  
  1314.  
  1315.  
  1316. PROCEDURE TEditorWindow.Undo;
  1317. VAR  U,U2 : TUNDO;
  1318.      cl : LONGWORD;
  1319.      FL,LL : PLine;
  1320.      FFL,LFL : PLine;
  1321.      SRE : WORD;
  1322. LABEL l;
  1323. BEGIN
  1324.      IF WinReadOnly THEN exit;
  1325.      IF UndoEvents = 0 THEN
  1326.      BEGIN
  1327.           DisableUndo;
  1328.           exit;
  1329.      END;
  1330.      _ICBClearMark;
  1331.      U := UndoEvent[LastUndo];
  1332.      IF U.Event = 0 THEN
  1333.      BEGIN
  1334.            U2.Event := 0;
  1335.            U2.Modified := Modified;
  1336.            U2.ICBFL := _PLine2Long(ICB.FirstLine);
  1337.            U2.ICBFX := ICB.FirstX;
  1338.            U2.ICBLL := _PLine2Long(ICB.LastLine);
  1339.            U2.ICBLX := ICB.LastX;
  1340.            U2.FCX := FileCursorX;
  1341.            U2.FCY := FileCursorY;
  1342.           _CreateRedoEvent(U2);
  1343.           goto l; {only cursor event}
  1344.      END;
  1345.  
  1346.      {save into redo stack}
  1347.      FL := _Long2PLine(U.FrameBegin+1);
  1348.      IF U.FrameEnd = 0 THEN LL := LastLine
  1349.      ELSE LL := _Long2PLine(U.FrameEnd-1);
  1350.      cl := _MoveRedoLines(FL,LL);
  1351.      FFL := FL^.prev;
  1352.      IF LL <> NIL THEN LFL := LL^.next
  1353.      ELSE LFL := FirstLine;
  1354.  
  1355.      IF U.Lines > 0 THEN
  1356.      BEGIN
  1357.           _Connect(FFL,U.FirstUndoLine);
  1358.           _Connect(U.LastUndoLine,LFL);
  1359.      END
  1360.      ELSE _Connect(FFL,LFL);
  1361.      SetLineColorFlag(FFL,LFL);
  1362.  
  1363.      RedoEvent[LastRedo].FrameEnd := _PLine2Long(LFL);
  1364.      UndoEvent[LastUndo].Event := 0;
  1365.  
  1366.      inc(CountLines,U.Lines);
  1367.      dec(CountLines,cl);
  1368. l:
  1369.      LastUndo := (LastUndo+MaxUndoEvents-1) MOD MaxUndoEvents;
  1370.      dec(UndoEvents);
  1371.      IF UndoEvents = 0 THEN DisableUndo;
  1372.      ICB.FirstLine := _Long2PLine(U.ICBFL);
  1373.      ICB.FirstX := U.ICBFX;
  1374.      ICB.LastLine := _Long2PLine(U.ICBLL);
  1375.      ICB.LastX := U.ICBLX;
  1376.      _ICBSetMark;
  1377.      Modified := U.Modified;
  1378.      SRE := RedoEvents;
  1379.      LastUndoGroup := UG_CursorMove; {for gotoline}
  1380.      GotoLine(U.FCY,U.FCX);
  1381.      RedoEvents := SRE;
  1382.      IF RedoEvents > 0 THEN EnableRedo;
  1383.      LastUndoGroup := UG_NoGroup;
  1384. END;
  1385.  
  1386.  
  1387.  
  1388. FUNCTION TEditorWindow._MoveRedoLines(FirstL,LastL:PLine):LONGWORD;
  1389. VAR  U : TUNDO;
  1390. BEGIN
  1391.      IF WLactivated THEN _WriteWorkLine;
  1392.      U.Event := 1;
  1393.      U.Modified := Modified;
  1394.      U.ICBFL := _PLine2Long(ICB.FirstLine);
  1395.      U.ICBFX := ICB.FirstX;
  1396.      U.ICBLL := _PLine2Long(ICB.LastLine);
  1397.      U.ICBLX := ICB.LastX;
  1398.      U.FCX := FileCursorX;
  1399.      U.FCY := FileCursorY;
  1400.  
  1401.      U.Lines := _CountLines(FirstL,LastL);
  1402.      IF U.Lines > 0 THEN
  1403.      BEGIN
  1404.           U.FrameBegin := _PLine2Long(FirstL)-1;
  1405.           U.FirstUndoLine := FirstL;
  1406.           U.LastUndoLine := LastL;
  1407.      END
  1408.      ELSE
  1409.      BEGIN
  1410.           U.FrameBegin := _PLine2Long(LastL);
  1411.           U.FirstUndoLine := NIL;
  1412.           U.LastUndoLine := NIL;
  1413.      END;
  1414.      _CreateRedoEvent(U);
  1415.      _MoveRedoLines := U.Lines;
  1416. END;
  1417.  
  1418.  
  1419.  
  1420. PROCEDURE TEditorWindow._CreateRedoEvent(U:TUNDO);
  1421. BEGIN
  1422.      LastRedo := (LastRedo+1) MOD MaxRedoEvents;
  1423.      IF RedoEvents < MaxRedoEvents THEN inc(RedoEvents);
  1424.      _DeleteRedoEvent(LastRedo);
  1425.      RedoEvent[LastRedo] := U;
  1426. END;
  1427.  
  1428.  
  1429.  
  1430. PROCEDURE TEditorWindow._DeleteRedoEvent(Nr:WORD);
  1431. VAR  ptline : PLine;
  1432.      ptnext : PLine;
  1433.      i : LONGWORD;
  1434. BEGIN
  1435.      IF RedoEvent[Nr].Event = 0 THEN exit;
  1436.      RedoEvent[Nr].Event := 0;
  1437.  
  1438.      ptline := RedoEvent[Nr].FirstUndoLine;
  1439.      FOR i := 1 TO RedoEvent[Nr].Lines DO
  1440.      BEGIN
  1441.           IF ptline = NIL THEN exit;
  1442.           ptnext := ptline^.next;
  1443.           IF ptline^.zk <> NIL THEN FreeMem(ptline^.zk,Length(ptline^.zk^)+1);
  1444.           Dispose(ptline);
  1445.           ptline := ptnext;
  1446.      END;
  1447. END;
  1448.  
  1449.  
  1450.  
  1451. PROCEDURE TEditorWindow.Redo;
  1452. VAR  U,U2 : TUNDO;
  1453.      cl : LONGWORD;
  1454.      FL,LL : PLine;
  1455.      FFL,LFL : PLine;
  1456.      SRE : WORD;
  1457. LABEL l;
  1458. BEGIN
  1459.      IF WinReadOnly THEN exit;
  1460.      IF RedoEvents = 0 THEN
  1461.      BEGIN
  1462.           DisableRedo;
  1463.           exit;
  1464.      END;
  1465.      _ICBClearMark;
  1466.      U := RedoEvent[LastRedo];
  1467.      IF U.Event = 0 THEN
  1468.      BEGIN
  1469.            U2.Event := 0;
  1470.            U2.Modified := Modified;
  1471.            U2.ICBFL := _PLine2Long(ICB.FirstLine);
  1472.            U2.ICBFX := ICB.FirstX;
  1473.            U2.ICBLL := _PLine2Long(ICB.LastLine);
  1474.            U2.ICBLX := ICB.LastX;
  1475.            U2.FCX := FileCursorX;
  1476.            U2.FCY := FileCursorY;
  1477.           _CreateUndoEvent(U2);
  1478.           goto l; {only cursor event}
  1479.      END;
  1480.  
  1481.      {save into undo stack}
  1482.      FL := _Long2PLine(U.FrameBegin+1);
  1483.      IF U.FrameEnd = 0 THEN LL := LastLine
  1484.      ELSE LL := _Long2PLine(U.FrameEnd-1);
  1485.      cl := _MoveUndoLines(FL,LL);
  1486.      FFL := FL^.prev;
  1487.      IF LL <> NIL THEN LFL := LL^.next
  1488.      ELSE LFL := FirstLine;
  1489.  
  1490.      IF U.Lines > 0 THEN
  1491.      BEGIN
  1492.           _Connect(FFL,U.FirstUndoLine);
  1493.           _Connect(U.LastUndoLine,LFL);
  1494.      END
  1495.      ELSE _Connect(FFL,LFL);
  1496.      SetLineColorFlag(FFL,LFL);
  1497.  
  1498.      UndoEvent[LastUndo].FrameEnd := _PLine2Long(LFL);
  1499.      RedoEvent[LastRedo].Event := 0;
  1500.  
  1501.      inc(CountLines,U.Lines);
  1502.      dec(CountLines,cl);
  1503. l:
  1504.      LastRedo := (LastRedo+MaxRedoEvents-1) MOD MaxRedoEvents;
  1505.      dec(RedoEvents);
  1506.      IF RedoEvents = 0 THEN DisableRedo;
  1507.      ICB.FirstLine := _Long2PLine(U.ICBFL);
  1508.      ICB.FirstX := U.ICBFX;
  1509.      ICB.LastLine := _Long2PLine(U.ICBLL);
  1510.      ICB.LastX := U.ICBLX;
  1511.      _ICBSetMark;
  1512.      Modified := U.Modified;
  1513.      SRE := RedoEvents;
  1514.      LastUndoGroup := UG_CursorMove; {for gotoline}
  1515.      GotoLine(U.FCY,U.FCX);
  1516.      RedoEvents := SRE;
  1517.      IF UndoEvents > 0 THEN EnableUndo;
  1518.      LastUndoGroup := UG_NoGroup;
  1519. END;
  1520.  
  1521.  
  1522. { +++ Block-Manipulating +++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1523.  
  1524.  
  1525. PROCEDURE TEditorWindow.ICBSetBegin; {Crtl-K B}
  1526. VAR  ptline : PLine;
  1527.      L : WORD;
  1528. BEGIN
  1529.      IF WLactivated THEN _WriteWorkLine;
  1530.      IF ICB.LastLine <> NIL THEN
  1531.      BEGIN
  1532.           _ICBClearMark;
  1533.  
  1534.           ptline := ICB.LastLine;
  1535.           WHILE (ptline <> NIL) AND (ActLine <> ptline) DO
  1536.                ptline := ptline^.prev;
  1537.           IF (ActLine = ICB.LastLine) AND (FileCursorX >= ICB.LastX)
  1538.           THEN ptline := NIL;
  1539.  
  1540.           IF ptline = NIL THEN ICB.LastLine := NIL;
  1541.      END;
  1542.  
  1543.      {set new the begin mark}
  1544.      ICB.FirstLine := ActLine;
  1545.      L := Length(ActLine^.zk^);
  1546.      IF L < FileCursorX THEN ICB.FirstX := L+1
  1547.      ELSE ICB.FirstX := FileCursorX;
  1548.      _ICBSetMark;
  1549.      InvalidateEditorWindow(1);
  1550. END;
  1551.  
  1552.  
  1553.  
  1554. PROCEDURE TEditorWindow.ICBSetEnd;
  1555. VAR  ptline : PLine;
  1556.      L : WORD;
  1557. BEGIN
  1558.      IF WLactivated THEN _WriteWorkLine;
  1559.      IF ICB.FirstLine <> NIL THEN
  1560.      BEGIN
  1561.           _ICBClearMark;
  1562.  
  1563.           ptline := ICB.FirstLine;
  1564.           WHILE (ptline <> NIL) AND (ActLine <> ptline) DO
  1565.                ptline := ptline^.next;
  1566.           IF (ActLine = ICB.FirstLine) AND (FileCursorX <= ICB.FirstX)
  1567.           THEN ptline := NIL;
  1568.  
  1569.           IF ptline = NIL THEN ICB.FirstLine := NIL;
  1570.      END;
  1571.  
  1572.      {set new the end mark}
  1573.      ICB.LastLine := ActLine;
  1574.      L := Length(ActLine^.zk^);
  1575.      IF L < FileCursorX THEN ICB.LastX := L+1
  1576.      ELSE ICB.LastX := FileCursorX;
  1577.      _ICBSetMark;
  1578.      InvalidateEditorWindow(1);
  1579. END;
  1580.  
  1581.  
  1582.  
  1583. PROCEDURE TEditorWindow.ICBSelectWord;
  1584. VAR  FCX : WORD;
  1585. BEGIN
  1586.      IF WLactivated THEN _WriteWorkLine;
  1587.      FCX := FileCursorX;
  1588.      IF FileCursorX > Length(ActLine^.zk^) THEN
  1589.      BEGIN
  1590.           CursorEnd;
  1591.           IF FileCursorX = 1 THEN exit;
  1592.           FCX := FileCursorX-1;
  1593.      END;
  1594.      _ICBClearMark;
  1595.  
  1596.      WHILE (ActLine^.zk^[FCX-1] IN NormalChars) AND (FCX > 1) DO dec(FCX);
  1597.      ICB.FirstLine := ActLine;
  1598.      ICB.FirstX := FCX;
  1599.  
  1600.      WHILE (ActLine^.zk^[FCX] IN NormalChars) AND (FCX < StringLength) DO inc(FCX);
  1601.      ICB.LastLine := ActLine;
  1602.      ICB.LastX := FCX;
  1603.  
  1604.      _ICBSetMark;
  1605.      InvalidateEditorWindow(1);
  1606. END;
  1607.  
  1608.  
  1609.  
  1610. PROCEDURE TEditorWindow.ICBSelectLine;
  1611. BEGIN
  1612.      IF WLactivated THEN _WriteWorkLine;
  1613.      _ICBClearMark;
  1614.      ICB.FirstLine := ActLine;
  1615.      ICB.FirstX := 1;
  1616.      IF ActLine^.next <> NIL THEN
  1617.      BEGIN
  1618.           ICB.LastLine := ActLine^.next;
  1619.           ICB.LastX := 1;
  1620.      END
  1621.      ELSE
  1622.      BEGIN
  1623.           ICB.LastLine := ActLine;
  1624.           ICB.LastX := Length(ActLine^.zk^)+1;
  1625.      END;
  1626.      _ICBSetMark;
  1627.      InvalidateEditorWindow(1);
  1628. END;
  1629.  
  1630.  
  1631.  
  1632. PROCEDURE TEditorWindow.ICBSelectAll;
  1633. BEGIN
  1634.      IF WLactivated THEN _WriteWorkLine;
  1635.      ICB.FirstLine := FirstLine;
  1636.      ICB.FirstX := 1;
  1637.      ICB.LastLine := LastLine;
  1638.      ICB.LastX := Length(LastLine^.zk^)+1;
  1639.      _ICBSetMark;
  1640.      InvalidateEditorWindow(1);
  1641. END;
  1642.  
  1643.  
  1644.  
  1645. PROCEDURE TEditorWindow.ICBDeselectAll;
  1646. BEGIN
  1647.      _ICBClearMark;
  1648.      ICB.FirstLine := NIL;
  1649.      ICB.LastLine := NIL;
  1650.      InvalidateEditorWindow(1);
  1651. END;
  1652.  
  1653.  
  1654.  
  1655. PROCEDURE TEditorWindow.ICBGotoBegin;
  1656. VAR  cy : LONGWORD;
  1657. BEGIN
  1658.      (*gotoline set the UNDO*)
  1659.      IF ICB.FirstLine = NIL THEN exit;
  1660.      cy := _PLine2Long(ICB.FirstLine);
  1661.      IF cy <> 0 THEN GotoLine(cy,ICB.FirstX);
  1662. END;
  1663.  
  1664.  
  1665.  
  1666. PROCEDURE TEditorWindow.ICBGotoEnd;
  1667. VAR  cy : LONGWORD;
  1668. BEGIN
  1669.      (*gotoline set the UNDO*)
  1670.      IF ICB.LastLine = NIL THEN exit;
  1671.      cy := _PLine2Long(ICB.LastLine);
  1672.      IF cy <> 0 THEN GotoLine(cy,ICB.LastX);
  1673. END;
  1674.  
  1675.  
  1676.  
  1677. PROCEDURE TEditorWindow.ICBCopyBlock;
  1678. VAR  laststr : STRING;
  1679.      icbstr : STRING;
  1680.      CurX : WORD;
  1681.      CurLine : PLine;
  1682.      ptline : PLine;
  1683.      Actnext : PLine;
  1684.      ptlnext : PLine;
  1685.      insanchor : PLine;
  1686.      first : BOOLEAN;
  1687. BEGIN
  1688.      IF NOT ICBVisible THEN
  1689.      BEGIN
  1690.           ToggleICBVisibility;
  1691.           exit;
  1692.      END;
  1693.      IF WinReadOnly THEN exit;
  1694.      IF (ICB.FirstLine = NIL) OR (ICB.LastLine = NIL) THEN exit;
  1695.      (*UNDO*)
  1696.      _CopyUndoLines(ActLine,ActLine);
  1697.      (*UNDO*)
  1698.      _ICBClearMark;
  1699.      CurLine := ActLine;
  1700.      CurX := FileCursorX;
  1701.      IF WLactivated THEN _WriteWorkLine;
  1702.      IF ICB.FirstLine = ICB.LastLine THEN
  1703.      BEGIN
  1704.           icbstr := _ReadString(ICB.FirstLine,ICB.FirstX,ICB.LastX-ICB.FirstX);
  1705.           _ReadWorkLine;
  1706.           IF NOT _InsertString(CurX,icbstr) THEN beep(1000,10);
  1707.           ICB.LastLine := CurLine;
  1708.           ICB.LastX := CurX+(ICB.LastX-ICB.FirstX);
  1709.           _CheckICB;
  1710.           _WriteWorkLine;
  1711.      END
  1712.      ELSE
  1713.      BEGIN
  1714.           ptline := ICB.FirstLine;
  1715.           icbstr := _ReadString(ptline,ICB.FirstX,
  1716.                                 Length(ptline^.zk^)-ICB.FirstX+1);
  1717.           laststr := _ReadString(CurLine,CurX,Length(ActLine^.zk^)-CurX+1);
  1718.  
  1719.           first := TRUE;
  1720.           Actnext := ActLine^.next;
  1721.           ptlnext := ptline^.next;
  1722.           REPEAT
  1723.                 _InsertLine(ActLine);
  1724.                 ptline := ptline^.next;
  1725.                 ActLine := ActLine^.next;
  1726.                 IF first THEN
  1727.                 BEGIN
  1728.                      insanchor := Actline;
  1729.                      CurLine^.next := Actnext;
  1730.                      ptline := ptlnext;
  1731.                      first := FALSE;
  1732.                 END;
  1733.                 WorkLine^ := _ReadString(ptline,1,Length(ptline^.zk^));
  1734.                 _WriteWorkLine;
  1735.                 Actline^.color := ptline^.color;
  1736.           UNTIL ptline = ICB.LastLine;
  1737.  
  1738.           _ReadWorkLine;
  1739.           WorkLine^[0] := chr(ICB.LastX-1);
  1740.           _WriteString(Length(WorkLine^)+1,laststr);
  1741.           _WriteWorkLine;
  1742.           _Connect(CurLine,insanchor);
  1743.           ICB.LastLine := ActLine;
  1744.  
  1745.           ActLine := CurLine;
  1746.           _ReadWorkLine;
  1747.           WorkLine^[0] := chr(CurX-1);
  1748.           _WriteString(CurX,icbstr);
  1749.           _WriteWorkLine;
  1750.           SetSliderValues;
  1751.      END;
  1752.  
  1753.      ICB.FirstLine := CurLine;
  1754.      ICB.FirstX := CurX;
  1755.      _ICBSetMark;
  1756.      LastUndoGroup := UG_CursorMove;
  1757.      SetLineColorFlag(ICB.FirstLine,ICB.LastLine);
  1758.      ICBGotoBegin;
  1759.      (*UNDO*)
  1760.      UndoEvent[LastUndo].FrameEnd := _PLine2Long(ICB.LastLine^.next);
  1761.      LastUndoGroup := UG_NoGroup;
  1762.      (*UNDO*)
  1763. END;
  1764.  
  1765.  
  1766.  
  1767. PROCEDURE TEditorWindow.ICBMoveBlock;
  1768. VAR  art : BYTE;
  1769.      CurX : WORD;
  1770.      CurLine : PLine;
  1771.      laststr : STRING;
  1772.      icbstr : STRING;
  1773.      B, icb1 : STRING;
  1774.      Licb : WORD;
  1775.      CurLinenext : PLine;
  1776.      ICBFirstLnext : PLine;
  1777.      ICBLastLnext : PLine;
  1778.      FL,LL : PLine;
  1779.      AL,IFL,ILL : LONGWORD;
  1780. BEGIN
  1781.      IF NOT ICBVisible THEN
  1782.      BEGIN
  1783.           ToggleICBVisibility;
  1784.           exit;
  1785.      END;
  1786.      IF WinReadOnly THEN exit;
  1787.      IF (ICB.FirstLine = NIL) OR (ICB.LastLine = NIL) THEN exit;
  1788.  
  1789.      IF ActLine^.color AND CI_Selected <> 0 THEN
  1790.      BEGIN
  1791.           art := 0; {CurPos is within the ICB}
  1792.           IF (ActLine = ICB.FirstLine) AND (FileCursorX < ICB.FirstX)
  1793.           THEN art := 1; {CurPos in ICB firstline, before ICBFirstX}
  1794.           IF (ActLine = ICB.LastLine) AND (FileCursorX > ICB.LastX)
  1795.           THEN art := 2; {CurPos in ICB endline, after ICBLastX}
  1796.      END
  1797.      ELSE art := 3; {CurPos not within the ICB lines}
  1798.  
  1799.      IF art = 0 THEN exit;
  1800.      (*UNDO*)
  1801.      AL := _PLine2Long(ActLine);
  1802.      IFL := _PLine2Long(ICB.FirstLine);
  1803.      ILL := _PLine2Long(ICB.LastLine);
  1804.      IF AL < IFL THEN FL := ActLine
  1805.      ELSE FL := ICB.FirstLine;
  1806.      IF AL > ILL THEN LL := ActLine
  1807.      ELSE LL := ICB.LastLine;
  1808.      _CopyUndoLines(FL,LL);
  1809.      (*UNDO*)
  1810.  
  1811.      IF WLactivated THEN _WriteWorkLine;
  1812.      CurLine := ActLine;
  1813.      CurX := FileCursorX;
  1814.      CASE art OF
  1815.           1 :
  1816.           BEGIN
  1817.                laststr := _ReadString(ICB.FirstLine,CurX,ICB.FirstX-CurX);
  1818.                _DeleteString(CurX,Length(laststr));
  1819.                _WriteWorkLine;
  1820.                ActLine := ICB.LastLine;
  1821.                IF ICB.FirstLine = ICB.LastLine
  1822.                THEN ICB.LastX := ICB.LastX - Length(laststr);
  1823.                IF NOT _InsertString(ICB.LastX,laststr) THEN beep(1000,10);
  1824.                _WriteWorkLine;
  1825.                ICB.FirstX := CurX;
  1826.           END;
  1827.           2 :
  1828.           BEGIN
  1829.                laststr := _ReadString(ICB.LastLine,ICB.LastX,CurX-ICB.LastX);
  1830.                _DeleteString(ICB.LastX,Length(laststr));
  1831.                _WriteWorkLine;
  1832.                ActLine := ICB.FirstLine;
  1833.                IF NOT _InsertString(ICB.FirstX,laststr) THEN beep(1000,10);
  1834.                _WriteWorkLine;
  1835.                IF ICB.FirstLine = ICB.LastLine
  1836.                THEN ICB.LastX := ICB.LastX + Length(laststr);
  1837.                ICB.FirstX := ICB.FirstX + Length(laststr);
  1838.           END;
  1839.           3 :
  1840.           BEGIN
  1841.                IF ICB.FirstLine = ICB.LastLine THEN
  1842.                BEGIN
  1843.                     Licb := ICB.LastX-ICB.FirstX;
  1844.                     icbstr := _ReadString(ICB.FirstLine,ICB.FirstX,Licb);
  1845.                     IF NOT _InsertString(CurX,icbstr) THEN beep(1000,10);
  1846.                     _ICBClearMark;
  1847.                     _WriteWorkLine;
  1848.                     ActLine := ICB.FirstLine;
  1849.                     _DeleteString(ICB.FirstX,Licb);
  1850.                     _WriteWorkLine;
  1851.                     ICB.FirstLine := CurLine;
  1852.                     ICB.FirstX := CurX;
  1853.                     ICB.LastLine := CurLine;
  1854.                     ICB.LastX := CurX + Licb;
  1855.                     _ICBSetMark;
  1856.                END
  1857.                ELSE
  1858.                BEGIN
  1859.                     laststr := _ReadString(CurLine,CurX,
  1860.                                            Length(CurLine^.zk^)-CurX+1);
  1861.                     B := _ReadString(ICB.LastLine,ICB.LastX,
  1862.                                      Length(ICB.LastLine^.zk^)-ICB.LastX+1);
  1863.                     icb1 := _ReadString(ICB.FirstLine,ICB.FirstX,
  1864.                                  Length(ICB.FirstLine^.zk^)-ICB.FirstX+1);
  1865.                     _ReadWorkLine;
  1866.                     WorkLine^[0] := chr(CurX-1);
  1867.                     _WriteString(CurX,icb1);
  1868.                     _WriteWorkLine;
  1869.                      Actline^.color := Actline^.color OR CI_Selected;
  1870.  
  1871.                     ActLine := ICB.FirstLine;
  1872.                     _ReadWorkLine;
  1873.                     WorkLine^[0] := chr(ICB.FirstX-1);
  1874.                     _WriteString(ICB.FirstX,B);
  1875.                     _WriteWorkLine;
  1876.                     Actline^.color := Actline^.color AND NOT CI_Selected;
  1877.  
  1878.                     ActLine := ICB.LastLine;
  1879.                     _ReadWorkLine;
  1880.                     WorkLine^[0] := chr(ICB.LastX-1);
  1881.                     _WriteString(ICB.LastX,laststr);
  1882.                     _WriteWorkLine;
  1883.  
  1884.                     CurLinenext := CurLine^.next;
  1885.                     ICBFirstLnext := ICB.FirstLine^.next;
  1886.                     ICBLastLnext := ICB.LastLine^.next;
  1887.                     _Connect(CurLine,ICBFirstLnext);
  1888.                     _Connect(ICB.LastLine,CurLinenext);
  1889.                     _Connect(ICB.FirstLine,ICBLastLnext);
  1890.                     IF CurLinenext = NIL THEN LastLine := ICB.LastLine;
  1891.  
  1892.                     ICB.FirstLine := CurLine;
  1893.                     ICB.FirstX := CurX;
  1894.                     {solid reference point for ICBGotoBegin}
  1895.                     FileCursorY := 1;
  1896.                     ScrCursorY := 1;
  1897.                     ActLine := FirstLine;
  1898.                     FirstScreenLine := FirstLine;
  1899.                END;
  1900.           END;
  1901.      END;
  1902.      _CheckICB;
  1903.  
  1904.      IF AL < IFL THEN FL := _Long2PLine(AL)
  1905.      ELSE FL := _Long2PLine(IFL);
  1906.      IF AL > ILL THEN LL := _Long2PLine(AL)
  1907.      ELSE LL := _Long2PLine(ILL);
  1908.      SetLineColorFlag(FL,LL);
  1909.  
  1910.      LastUndoGroup := UG_CursorMove;
  1911.      ICBGotoBegin;
  1912.      (*UNDO*)
  1913.      LastUndoGroup := UG_NoGroup;
  1914.      (*UNDO*)
  1915. END;
  1916.  
  1917.  
  1918.  
  1919. PROCEDURE TEditorWindow.ICBDeleteBlock;
  1920. VAR  FrameFirst : PLine;
  1921.      FrameLast  : PLine;
  1922.      firststring : STRING;
  1923.      laststring : STRING;
  1924.      cl : LONGWORD;
  1925. BEGIN
  1926.      IF NOT ICBVisible THEN
  1927.      BEGIN
  1928.           ToggleICBVisibility;
  1929.           exit;
  1930.      END;
  1931.      IF WinReadOnly THEN exit;
  1932.      IF (ICB.FirstLine = NIL) OR (ICB.LastLine = NIL) THEN exit;
  1933.  
  1934.      IgnoreRedraw := TRUE;
  1935.      ICBGotoBegin;
  1936.  
  1937.      firststring := _ReadString(ICB.FirstLine,1,ICB.FirstX-1);
  1938.      laststring := _ReadString(ICB.LastLine,ICB.LastX,
  1939.                                Length(ICB.LastLine^.zk^)-ICB.LastX+1);
  1940.  
  1941.      FrameFirst := ICB.FirstLine^.prev;
  1942.      FrameLast := ICB.LastLine^.next;
  1943.      (*UNDO*)
  1944.      cl := _MoveUndoLines(ICB.FirstLine,ICB.LastLine);
  1945.      (*UNDO*)
  1946.      _Connect(FrameFirst,FrameLast);
  1947.      dec(countlines,cl);
  1948.      Modified := TRUE;
  1949.  
  1950.      _InsertLine(FrameFirst);
  1951.      IF FrameFirst = NIL THEN ActLine := FirstLine
  1952.      ELSE ActLine := FrameFirst^.next;
  1953.      IF ScrCursorY = 1 THEN FirstScreenLine := ActLine;
  1954.      WorkLine^ := firststring + laststring;
  1955.      _WriteWorkLine;
  1956.  
  1957.      ICB.FirstLine := ActLine;
  1958.      ICB.FirstX := FileCursorX;
  1959.      ICB.LastLine := ActLine;
  1960.      ICB.LastX := FileCursorX;
  1961.      _ICBSetMark;     {includes _CheckICB and mark the line}
  1962.  
  1963.      IgnoreRedraw := FALSE;
  1964.      SetSliderValues;
  1965.      IF FrameFirst <> NIL THEN SetLineColorFlag(FrameFirst,Actline)
  1966.      ELSE UpdateLineColorFlag(ActLine);
  1967.      InvalidateEditorWindow(1);
  1968.      (*UNDO*)
  1969.      UndoEvent[LastUndo].FrameEnd := _PLine2Long(FrameLast);
  1970.      LastUndoGroup := UG_NoGroup;
  1971.      (*UNDO*)
  1972. END;
  1973.  
  1974.  
  1975.  
  1976. PROCEDURE TEditorWindow.ICBReadBlock;
  1977. VAR  s : STRING;
  1978.      dir,name,ext : STRING;
  1979.      F : FILE;
  1980. BEGIN
  1981.      FileOpenDlgWildCards := '';
  1982.      FileOpenDlgTitle := NLSTable[4];
  1983.      FileOpenDlgOkname := NLSTable[27];
  1984.      IF FileOpenDialog(Application^.MainWindow^.HWindow,s) THEN
  1985.      BEGIN
  1986.           WinUpdateWindow(Application^.MainWindow^.HWindow);
  1987.           {Cut long filenames}
  1988.           FSplit(s,dir,name,ext);
  1989.           s := dir + name + ext;
  1990.           Assign(F,s);
  1991.           FileMode := fmInput;
  1992.           {$i-}
  1993.           Reset(F,1);
  1994.           {$i+}
  1995.           FileMode := fmInOut;
  1996.           IF IOResult <> 0 THEN
  1997.           BEGIN
  1998.                s := NLSTable[12] + name + ext + NLSTable[29];
  1999.                SetErrorMessage(MB_ICONHAND,NLSTable[1], s);
  2000.           END
  2001.           ELSE
  2002.           BEGIN
  2003.                {$i-}
  2004.                Close(F);
  2005.                {$i+}
  2006.                PasteFromFile(s);
  2007.           END;
  2008.      END;
  2009.      FileOpenDlgTitle := NLSTable[5];
  2010. END;
  2011.  
  2012.  
  2013.  
  2014. PROCEDURE TEditorWindow.ICBWriteBlock;
  2015. VAR  s : STRING;
  2016.      P : POINTER;
  2017.      Len : LONGWORD;
  2018.      utF : FILE;
  2019.      dir,name,ext : STRING;
  2020. BEGIN
  2021.      FileSaveDlgWildCards := '';
  2022.      FileSaveDlgTitle := NLSTable[6];
  2023.      FileSaveDlgOkname := NLSTable[28];
  2024.      IF FileSaveDialog(Application^.MainWindow^.HWindow,s) THEN
  2025.      BEGIN
  2026.           WinUpdateWindow(Application^.MainWindow^.HWindow);
  2027.           {Cut long filenames}
  2028.           FSplit(s,dir,name,ext);
  2029.           s := dir + name + ext;
  2030.           FileSaveDlgTitle := NLSTable[7];
  2031.           P := _CopyICBLinear(Len);
  2032.           IF P = NIL THEN exit;       {Length=0}
  2033.           Assign(utF,s);
  2034.           {$i-}
  2035.           Rewrite(utF,1);
  2036.           {$i+}
  2037.           IF IoResult = 0 THEN
  2038.           BEGIN
  2039.                {$i-}
  2040.                BlockWrite(utF,P^,Len-1);     {without #0}
  2041.                {$i+}
  2042.                IF Ioresult <> 0
  2043.                THEN SetErrorMessage(MB_ICONHAND,NLSTable[1],NLSTable[8]+s);
  2044.                {$i-}
  2045.                Close(utF);
  2046.                {$i+}
  2047.           END
  2048.           ELSE SetErrorMessage(MB_ICONHAND,NLSTable[1],NLSTable[8]+s);
  2049.           FreeMem(P,Len);
  2050.      END;
  2051.      FileSaveDlgTitle := NLSTable[7];
  2052. END;
  2053.  
  2054.  
  2055.  
  2056. PROCEDURE TEditorWindow.ICBMoveLeft;
  2057. BEGIN
  2058.      IF NOT ICBVisible THEN exit;
  2059.      IF WinReadOnly THEN exit;
  2060.      IF (ICB.FirstLine = NIL) OR (ICB.LastLine = NIL) THEN exit;
  2061.      IF WLactivated THEN _WriteWorkLine;
  2062.      (*UNDO*)
  2063.      _CopyUndoLines(ICB.FirstLine,ICB.LastLine);
  2064.      (*UNDO*)
  2065.      IF Length(ICB.FirstLine^.zk^) > 0 THEN
  2066.        IF (ICB.FirstLine^.zk^[1] = #32) AND (ICB.FirstX > 1)
  2067.        THEN dec(ICB.FirstX);
  2068.  
  2069.      ActLine := ICB.FirstLine;
  2070.      WHILE ActLine <> ICB.LastLine DO
  2071.      BEGIN
  2072.           IF Length(ActLine^.zk^) > 0 THEN
  2073.             IF ActLine^.zk^[1] = #32 THEN
  2074.             BEGIN
  2075.                  _ReadWorkLine;
  2076.                  _DeleteString(1,1);
  2077.                  _WriteWorkLine;
  2078.             END;
  2079.           ActLine := ActLine^.next;
  2080.      END;
  2081.      IF (Length(ICB.LastLine^.zk^) > 0) AND (ICB.LastX > 1) THEN
  2082.        IF ICB.LastLine^.zk^[1] = #32 THEN
  2083.        BEGIN
  2084.             _ReadWorkLine;
  2085.             _DeleteString(1,1);
  2086.             _WriteWorkLine;
  2087.             dec(ICB.LastX);
  2088.        END;
  2089.      LastUndoGroup := UG_CursorMove;
  2090.      ICBGotoBegin;
  2091.      (*UNDO*)
  2092.      LastUndoGroup := UG_NoGroup;
  2093.      (*UNDO*)
  2094. END;
  2095.  
  2096.  
  2097.  
  2098. PROCEDURE TEditorWindow.ICBMoveRight;
  2099. BEGIN
  2100.      IF NOT ICBVisible THEN exit;
  2101.      IF WinReadOnly THEN exit;
  2102.      IF (ICB.FirstLine = NIL) OR (ICB.LastLine = NIL) THEN exit;
  2103.      IF WLactivated THEN _WriteWorkLine;
  2104.      (*UNDO*)
  2105.      _CopyUndoLines(ICB.FirstLine,ICB.LastLine);
  2106.      (*UNDO*)
  2107.  
  2108.      ActLine := ICB.FirstLine;
  2109.      WHILE ActLine <> ICB.LastLine DO
  2110.      BEGIN
  2111.           IF Length(ActLine^.zk^) < StringLength THEN
  2112.           BEGIN
  2113.                _ReadWorkLine;
  2114.                _InsertString(1,' ');
  2115.                _WriteWorkLine;
  2116.           END;
  2117.           ActLine := ActLine^.next;
  2118.      END;
  2119.      IF (Length(ICB.LastLine^.zk^) < StringLength) AND (ICB.LastX > 1) THEN
  2120.      BEGIN
  2121.           _ReadWorkLine;
  2122.           _InsertString(1,' ');
  2123.           _WriteWorkLine;
  2124.           IF ICB.LastX < StringLength THEN inc(ICB.LastX);
  2125.      END;
  2126.      LastUndoGroup := UG_CursorMove;
  2127.      ICBGotoBegin;
  2128.      (*UNDO*)
  2129.      LastUndoGroup := UG_NoGroup;
  2130.      (*UNDO*)
  2131. END;
  2132.  
  2133.  
  2134.  
  2135. PROCEDURE TEditorWindow._ICBExtSetICB;
  2136. VAR  FCX : WORD;
  2137. BEGIN
  2138.      IF WLactivated THEN _WriteWorkLine;
  2139.      ChangeICB := FALSE;
  2140.  
  2141.      IF FileCursorX <= Length(ActLine^.zk^) THEN FCX := FileCursorX
  2142.      ELSE FCX := Length(ActLine^.zk^)+1;
  2143.      IF FCX > StringLength THEN FCX := StringLength;
  2144.  
  2145.      _ICBClearMark;
  2146.      IF NOT ICBVisible THEN ICB.FirstLine := NIL; {force to create new ICB}
  2147.  
  2148.      IF (ICB.FirstLine = NIL) OR (ICB.LastLine = NIL) THEN
  2149.      BEGIN
  2150.           ICB.FirstLine := ActLine;
  2151.           ICB.FirstX := FCX;
  2152.           ICB.LastLine := ActLine;
  2153.           ICB.LastX := FCX;
  2154.           exit;
  2155.      END;
  2156.  
  2157.      IF ((ICB.FirstLine = ActLine) AND (ICB.FirstX = FCX)) OR
  2158.         ((ICB.LastLine = ActLine) AND (ICB.LastX = FCX)) THEN exit;
  2159.  
  2160.      ICB.FirstLine := ActLine;
  2161.      ICB.FirstX := FCX;
  2162.      ICB.LastLine := ActLine;
  2163.      ICB.LastX := FCX;
  2164.      InvalidateEditorWindow(1);
  2165.      ChangeICB := TRUE;
  2166. END;
  2167.  
  2168.  
  2169.  
  2170. PROCEDURE TEditorWindow._ICBExtCorrectICB;
  2171. VAR  ptline : PLine;
  2172.      FL : PLine;
  2173.      FX : WORD;
  2174. BEGIN
  2175.      ptline := ICB.FirstLine;
  2176.  
  2177.      IF (ICB.FirstLine = ICB.LastLine) AND (ICB.FirstX > ICB.LastX)
  2178.      THEN ptline := NIL;
  2179.  
  2180.      WHILE (ptline <> ICB.LastLine) AND (ptline <> NIL) DO
  2181.           ptline := ptline^.next;
  2182.  
  2183.      IF ptline <> NIL THEN exit;
  2184.  
  2185.      {exchange first & last}
  2186.      FL := ICB.FirstLine;
  2187.      FX := ICB.FirstX;
  2188.      ICB.FirstLine := ICB.LastLine;
  2189.      ICB.FirstX := ICB.LastX;
  2190.      ICB.LastLine := FL;
  2191.      ICB.LastX := FX;
  2192. END;
  2193.  
  2194.  
  2195.  
  2196. PROCEDURE TEditorWindow.ICBExtLeft;
  2197. LABEL l;
  2198. BEGIN
  2199.      (*UNDO*)
  2200.      IF LastUndoGroup <> UG_CursorMove THEN _StoreUndoCursor;
  2201.      LastUndoGroup := UG_CursorMove;
  2202.      (*UNDO*)
  2203.      _ICBExtSetICB;
  2204.      IF FileCursorX > Length(ActLine^.zk^)+1 THEN goto l;
  2205.  
  2206.      IF (ICB.FirstLine = ActLine) AND (ICB.FirstX = FileCursorX) THEN
  2207.      BEGIN
  2208.           IF ICB.FirstX > 1 THEN dec(ICB.FirstX);
  2209.           goto l;
  2210.      END;
  2211.  
  2212.      IF (ICB.LastLine = ActLine) AND (ICB.LastX = FileCursorX) THEN
  2213.      BEGIN
  2214.           IF ICB.LastX > 1 THEN dec(ICB.LastX);
  2215.      END;
  2216. l:
  2217.      _ICBSetMark;
  2218.      CursorLeft;
  2219.      InvalidateSingleLine;
  2220. END;
  2221.  
  2222.  
  2223.  
  2224. PROCEDURE TEditorWindow.ICBExtRight;
  2225. LABEL l;
  2226. BEGIN
  2227.      (*UNDO*)
  2228.      IF LastUndoGroup <> UG_CursorMove THEN _StoreUndoCursor;
  2229.      LastUndoGroup := UG_CursorMove;
  2230.      (*UNDO*)
  2231.      _ICBExtSetICB;
  2232.      IF FileCursorX > Length(ActLine^.zk^)+1 THEN goto l;
  2233.  
  2234.      IF (ICB.LastLine = ActLine) AND (ICB.LastX = FileCursorX) THEN
  2235.      BEGIN
  2236.           IF ICB.LastX <= Length(ActLine^.zk^) THEN inc(ICB.LastX);
  2237.           goto l;
  2238.      END;
  2239.  
  2240.      IF (ICB.FirstLine = ActLine) AND (ICB.FirstX = FileCursorX) THEN
  2241.      BEGIN
  2242.           IF ICB.FirstX <= Length(ActLine^.zk^) THEN inc(ICB.FirstX);
  2243.      END;
  2244. l:
  2245.      _ICBSetMark;
  2246.      CursorRight;
  2247.      InvalidateSingleLine;
  2248. END;
  2249.  
  2250.  
  2251.  
  2252. PROCEDURE TEditorWindow.ICBExtUp;
  2253. VAR  FCX : WORD;
  2254. BEGIN
  2255.      (*UNDO*)
  2256.      IF LastUndoGroup <> UG_CursorMove THEN _StoreUndoCursor;
  2257.      LastUndoGroup := UG_CursorMove;
  2258.      (*UNDO*)
  2259.      _ICBExtSetICB;
  2260.      IF FileCursorX <= Length(ActLine^.zk^) THEN FCX := FileCursorX
  2261.      ELSE FCX := Length(ActLine^.zk^)+1;
  2262.      IF FCX > StringLength THEN FCX := StringLength;
  2263.  
  2264.      IF (ICB.FirstLine = ActLine) AND (ICB.FirstX = FCX) THEN
  2265.      BEGIN
  2266.           IF ICB.FirstLine^.prev <> NIL THEN
  2267.           BEGIN
  2268.                ICB.FirstLine := ICB.FirstLine^.prev;
  2269.                IF FileCursorX <= Length(ICB.FirstLine^.zk^)
  2270.                THEN ICB.FirstX := FileCursorX
  2271.                ELSE ICB.FirstX := Length(ICB.FirstLine^.zk^)+1;
  2272.           END;
  2273.      END
  2274.      ELSE
  2275.      BEGIN
  2276.           IF ICB.LastLine^.prev <> NIL THEN
  2277.           BEGIN
  2278.                ICB.LastLine := ICB.LastLine^.prev;
  2279.                IF FileCursorX <= Length(ICB.LastLine^.zk^)
  2280.                THEN ICB.LastX := FileCursorX
  2281.                ELSE ICB.LastX := Length(ICB.LastLine^.zk^)+1;
  2282.           END;
  2283.      END;
  2284.  
  2285.      _ICBExtCorrectICB;
  2286.      _ICBSetMark;
  2287.      InvalidateSingleLine;
  2288.      CursorUp(1);
  2289.      InvalidateSingleLine;
  2290. END;
  2291.  
  2292.  
  2293.  
  2294. PROCEDURE TEditorWindow.ICBExtDown;
  2295. VAR  FCX : WORD;
  2296. BEGIN
  2297.      (*UNDO*)
  2298.      IF LastUndoGroup <> UG_CursorMove THEN _StoreUndoCursor;
  2299.      LastUndoGroup := UG_CursorMove;
  2300.      (*UNDO*)
  2301.      _ICBExtSetICB;
  2302.      IF FileCursorX <= Length(ActLine^.zk^) THEN FCX := FileCursorX
  2303.      ELSE FCX := Length(ActLine^.zk^)+1;
  2304.      IF FCX > StringLength THEN FCX := StringLength;
  2305.  
  2306.      IF (ICB.LastLine = ActLine) AND (ICB.LastX = FCX) THEN
  2307.      BEGIN
  2308.           IF ICB.LastLine^.next <> NIL THEN
  2309.           BEGIN
  2310.                ICB.LastLine := ICB.LastLine^.next;
  2311.                IF FileCursorX <= Length(ICB.LastLine^.zk^)
  2312.                THEN ICB.LastX := FileCursorX
  2313.                ELSE ICB.LastX := Length(ICB.LastLine^.zk^)+1;
  2314.           END;
  2315.      END
  2316.      ELSE
  2317.      BEGIN
  2318.           IF ICB.FirstLine^.next <> NIL THEN
  2319.           BEGIN
  2320.                ICB.FirstLine := ICB.FirstLine^.next;
  2321.                IF FileCursorX <= Length(ICB.FirstLine^.zk^)
  2322.                THEN ICB.FirstX := FileCursorX
  2323.                ELSE ICB.FirstX := Length(ICB.FirstLine^.zk^)+1;
  2324.           END;
  2325.      END;
  2326.  
  2327.      _ICBExtCorrectICB;
  2328.      _ICBSetMark;
  2329.      InvalidateSingleLine;
  2330.      CursorDown(1);
  2331.      InvalidateSingleLine;
  2332. END;
  2333.  
  2334.  
  2335.  
  2336. PROCEDURE TEditorWindow.ICBExtPageUp;
  2337. VAR  OldLine : PLine;
  2338.      OldX : WORD;
  2339.      FCX : WORD;
  2340.      i : WORD;
  2341. BEGIN
  2342.      (*UNDO*)
  2343.      IF LastUndoGroup <> UG_CursorMove THEN _StoreUndoCursor;
  2344.      LastUndoGroup := UG_CursorMove;
  2345.      (*UNDO*)
  2346.      IgnoreRedraw := TRUE;
  2347.      _ICBExtSetICB;
  2348.      IF FileCursorX <= Length(ActLine^.zk^) THEN OldX := FileCursorX
  2349.      ELSE OldX := Length(ActLine^.zk^)+1;
  2350.      IF OldX > StringLength THEN OldX := StringLength;
  2351.      OldLine := ActLine;
  2352.  
  2353.      PageUp;
  2354.      IgnoreRedraw := FALSE;
  2355.  
  2356.      IF (OldLine = ICB.FirstLine) AND (OldX = ICB.FirstX) THEN
  2357.      BEGIN
  2358.           ICB.FirstLine := ActLine;
  2359.           IF FileCursorX <= Length(ActLine^.zk^)
  2360.           THEN ICB.FirstX := FileCursorX
  2361.           ELSE ICB.FirstX := Length(ActLine^.zk^)+1;
  2362.      END
  2363.      ELSE
  2364.      BEGIN
  2365.           ICB.LastLine := ActLine;
  2366.           IF FileCursorX <= Length(ActLine^.zk^)
  2367.           THEN ICB.LastX := FileCursorX
  2368.           ELSE ICB.LastX := Length(ActLine^.zk^)+1;
  2369.      END;
  2370.  
  2371.      _ICBExtCorrectICB;
  2372.      _ICBSetMark;
  2373.      InvalidateEditorWindow(1);
  2374. END;
  2375.  
  2376.  
  2377.  
  2378. PROCEDURE TEditorWindow.ICBExtPageDown;
  2379. VAR  OldLine : PLine;
  2380.      OldX : WORD;
  2381.      FCX : WORD;
  2382.      i : WORD;
  2383. BEGIN
  2384.      (*UNDO*)
  2385.      IF LastUndoGroup <> UG_CursorMove THEN _StoreUndoCursor;
  2386.      LastUndoGroup := UG_CursorMove;
  2387.      (*UNDO*)
  2388.      IgnoreRedraw := TRUE;
  2389.      _ICBExtSetICB;
  2390.      IF FileCursorX <= Length(ActLine^.zk^) THEN OldX := FileCursorX
  2391.      ELSE OldX := Length(ActLine^.zk^)+1;
  2392.      IF OldX > StringLength THEN OldX := StringLength;
  2393.      OldLine := ActLine;
  2394.  
  2395.      PageDown;
  2396.      IgnoreRedraw := FALSE;
  2397.  
  2398.      IF (OldLine = ICB.FirstLine) AND (OldX = ICB.FirstX) THEN
  2399.      BEGIN
  2400.           ICB.FirstLine := ActLine;
  2401.           IF FileCursorX <= Length(ActLine^.zk^)
  2402.           THEN ICB.FirstX := FileCursorX
  2403.           ELSE ICB.FirstX := Length(ActLine^.zk^)+1;
  2404.      END
  2405.      ELSE
  2406.      BEGIN
  2407.           ICB.LastLine := ActLine;
  2408.           IF FileCursorX <= Length(ActLine^.zk^)
  2409.           THEN ICB.LastX := FileCursorX
  2410.           ELSE ICB.LastX := Length(ActLine^.zk^)+1;
  2411.      END;
  2412.  
  2413.      _ICBExtCorrectICB;
  2414.      _ICBSetMark;
  2415.      InvalidateEditorWindow(1);
  2416. END;
  2417.  
  2418.  
  2419.  
  2420. PROCEDURE TEditorWindow.ICBExtPos1;
  2421. VAR  FCX : WORD;
  2422. BEGIN
  2423.      (*UNDO*)
  2424.      IF LastUndoGroup <> UG_CursorMove THEN _StoreUndoCursor;
  2425.      LastUndoGroup := UG_CursorMove;
  2426.      (*UNDO*)
  2427.      _ICBExtSetICB;
  2428.      IF FileCursorX <= Length(ActLine^.zk^) THEN FCX := FileCursorX
  2429.      ELSE FCX := Length(ActLine^.zk^)+1;
  2430.      IF FCX > StringLength THEN FCX := StringLength;
  2431.  
  2432.      IF (ICB.FirstLine = ActLine) AND (ICB.FirstX = FCX)
  2433.      THEN ICB.FirstX := 1
  2434.      ELSE ICB.LastX := 1;
  2435.  
  2436.      _ICBExtCorrectICB;
  2437.      _ICBSetMark;
  2438.      CursorPos1;
  2439.      InvalidateSingleLine;
  2440. END;
  2441.  
  2442.  
  2443.  
  2444. PROCEDURE TEditorWindow.ICBExtEnd;
  2445. VAR  FCX : WORD;
  2446. BEGIN
  2447.      (*UNDO*)
  2448.      IF LastUndoGroup <> UG_CursorMove THEN _StoreUndoCursor;
  2449.      LastUndoGroup := UG_CursorMove;
  2450.      (*UNDO*)
  2451.      _ICBExtSetICB;
  2452.      IF FileCursorX <= Length(ActLine^.zk^) THEN FCX := FileCursorX
  2453.      ELSE FCX := Length(ActLine^.zk^)+1;
  2454.      IF FCX > StringLength THEN FCX := StringLength;
  2455.  
  2456.      IF (ICB.LastLine = ActLine) AND (ICB.LastX = FCX)
  2457.      THEN ICB.LastX := Length(ActLine^.zk^)+1
  2458.      ELSE ICB.FirstX := Length(ActLine^.zk^)+1;
  2459.  
  2460.      _ICBExtCorrectICB;
  2461.      _ICBSetMark;
  2462.      CursorEnd;
  2463.      InvalidateSingleLine;
  2464. END;
  2465.  
  2466.  
  2467.  
  2468. PROCEDURE TEditorWindow.ICBExtWordLeft;
  2469. VAR  OldLine : PLine;
  2470.      OldX : WORD;
  2471. BEGIN
  2472.      (*UNDO*)
  2473.      IF LastUndoGroup <> UG_CursorMove THEN _StoreUndoCursor;
  2474.      LastUndoGroup := UG_CursorMove;
  2475.      (*UNDO*)
  2476.      IgnoreRedraw := TRUE;
  2477.      _ICBExtSetICB;
  2478.      IF FileCursorX <= Length(ActLine^.zk^) THEN OldX := FileCursorX
  2479.      ELSE OldX := Length(ActLine^.zk^)+1;
  2480.      IF OldX > StringLength THEN OldX := StringLength;
  2481.      OldLine := ActLine;
  2482.  
  2483.      WordLeft;
  2484.      IgnoreRedraw := FALSE;
  2485.  
  2486.      IF (OldLine = ICB.FirstLine) AND (OldX = ICB.FirstX) THEN
  2487.      BEGIN
  2488.           ICB.FirstLine := ActLine;
  2489.           IF FileCursorX <= Length(ActLine^.zk^)
  2490.           THEN ICB.FirstX := FileCursorX
  2491.           ELSE ICB.FirstX := Length(ActLine^.zk^)+1;
  2492.      END
  2493.      ELSE
  2494.      BEGIN
  2495.           ICB.LastLine := ActLine;
  2496.           IF FileCursorX <= Length(ActLine^.zk^)
  2497.           THEN ICB.LastX := FileCursorX
  2498.           ELSE ICB.LastX := Length(ActLine^.zk^)+1;
  2499.      END;
  2500.  
  2501.      _ICBExtCorrectICB;
  2502.      _ICBSetMark;
  2503.      IF (OldLine = ActLine) AND (NOT _HorizMove) AND (NOT ChangeICB) THEN
  2504.      BEGIN
  2505.           SetCursorXY;
  2506.           InvalidateSingleLine;
  2507.      END
  2508.      ELSE InvalidateEditorWindow(1);
  2509. END;
  2510.  
  2511.  
  2512.  
  2513. PROCEDURE TEditorWindow.ICBExtWordRight;
  2514. VAR  OldLine : PLine;
  2515.      OldX : WORD;
  2516. BEGIN
  2517.      (*UNDO*)
  2518.      IF LastUndoGroup <> UG_CursorMove THEN _StoreUndoCursor;
  2519.      LastUndoGroup := UG_CursorMove;
  2520.      (*UNDO*)
  2521.      IgnoreRedraw := TRUE;
  2522.      _ICBExtSetICB;
  2523.      IF FileCursorX <= Length(ActLine^.zk^) THEN OldX := FileCursorX
  2524.      ELSE OldX := Length(ActLine^.zk^)+1;
  2525.      IF OldX > StringLength THEN OldX := StringLength;
  2526.      OldLine := ActLine;
  2527.  
  2528.      WordRight;
  2529.      IgnoreRedraw := FALSE;
  2530.  
  2531.      IF (OldLine = ICB.LastLine) AND (OldX = ICB.LastX) THEN
  2532.      BEGIN
  2533.           ICB.LastLine := ActLine;
  2534.           IF FileCursorX <= Length(ActLine^.zk^)
  2535.           THEN ICB.LastX := FileCursorX
  2536.           ELSE ICB.LastX := Length(ActLine^.zk^)+1;
  2537.      END
  2538.      ELSE
  2539.      BEGIN
  2540.           ICB.FirstLine := ActLine;
  2541.           IF FileCursorX <= Length(ActLine^.zk^)
  2542.           THEN ICB.FirstX := FileCursorX
  2543.           ELSE ICB.FirstX := Length(ActLine^.zk^)+1;
  2544.      END;
  2545.  
  2546.      _ICBExtCorrectICB;
  2547.      _ICBSetMark;
  2548.      IF (OldLine = ActLine) AND (NOT _HorizMove) AND (NOT ChangeICB) THEN
  2549.      BEGIN
  2550.           SetCursorXY;
  2551.           InvalidateSingleLine;
  2552.      END
  2553.      ELSE InvalidateEditorWindow(1);
  2554. END;
  2555.  
  2556.  
  2557.  
  2558. PROCEDURE TEditorWindow.ICBExtFileBegin;
  2559. VAR  FCX : WORD;
  2560. BEGIN
  2561.      (*UNDO*)
  2562.      IF LastUndoGroup <> UG_CursorMove THEN _StoreUndoCursor;
  2563.      LastUndoGroup := UG_CursorMove;
  2564.      (*UNDO*)
  2565.      IgnoreRedraw := TRUE;
  2566.      _ICBExtSetICB;
  2567.      IgnoreRedraw := FALSE;
  2568.      IF FileCursorX <= Length(ActLine^.zk^) THEN FCX := FileCursorX
  2569.      ELSE FCX := Length(ActLine^.zk^)+1;
  2570.      IF FCX > StringLength THEN FCX := StringLength;
  2571.  
  2572.      IF (ICB.FirstLine = ActLine) AND (ICB.FirstX = FCX) THEN
  2573.      BEGIN
  2574.           ICB.FirstLine := FirstLine;
  2575.           ICB.FirstX := 1;
  2576.      END
  2577.      ELSE
  2578.      BEGIN
  2579.           ICB.LastLine := FirstLine;
  2580.           ICB.LastX := 1;
  2581.      END;
  2582.  
  2583.      _ICBExtCorrectICB;
  2584.      _ICBSetMark;
  2585.      GotoBegin;
  2586. END;
  2587.  
  2588.  
  2589.  
  2590. PROCEDURE TEditorWindow.ICBExtFileEnd;
  2591. VAR  FCX : WORD;
  2592. BEGIN
  2593.      (*UNDO*)
  2594.      IF LastUndoGroup <> UG_CursorMove THEN _StoreUndoCursor;
  2595.      LastUndoGroup := UG_CursorMove;
  2596.      (*UNDO*)
  2597.      IgnoreRedraw := TRUE;
  2598.      _ICBExtSetICB;
  2599.      IgnoreRedraw := FALSE;
  2600.      IF FileCursorX <= Length(ActLine^.zk^) THEN FCX := FileCursorX
  2601.      ELSE FCX := Length(ActLine^.zk^)+1;
  2602.      IF FCX > StringLength THEN FCX := StringLength;
  2603.  
  2604.      IF (ICB.LastLine = ActLine) AND (ICB.LastX = FCX) THEN
  2605.      BEGIN
  2606.           ICB.LastLine := LastLine;
  2607.           ICB.LastX := Length(LastLine^.zk^)+1;
  2608.      END
  2609.      ELSE
  2610.      BEGIN
  2611.           ICB.FirstLine := LastLine;
  2612.           ICB.FirstX := Length(LastLine^.zk^)+1;
  2613.      END;
  2614.  
  2615.      _ICBExtCorrectICB;
  2616.      _ICBSetMark;
  2617.      GotoEnd;
  2618. END;
  2619.  
  2620.  
  2621. { +++ Clipboard-Functions ++++++++++++++++++++++++++++++++++++++++++++++++++ }
  2622.  
  2623.  
  2624. PROCEDURE TEditorWindow.CutToClipBoard;
  2625. VAR  P : POINTER;
  2626.      Len : LONGWORD;
  2627. BEGIN
  2628.      IF NOT ICBVisible THEN exit;
  2629.      IF WinReadOnly THEN exit;
  2630.      P := _CopyICBLinear(Len);
  2631.      IF P = NIL THEN exit;       {Length=0}
  2632.      IF _SetClipBoardText(P,Len) THEN
  2633.      BEGIN
  2634.           ICBDeleteBlock;        {ICBDeleteBlock includes UNDO settings}
  2635.           EnablePaste;
  2636.      END;
  2637.      FreeMem(P,Len);
  2638. END;
  2639.  
  2640.  
  2641.  
  2642. PROCEDURE TEditorWindow.CopyToClipBoard;
  2643. VAR  P : POINTER;
  2644.      Len : LONGWORD;
  2645. BEGIN
  2646.      IF NOT ICBVisible THEN exit;
  2647.      P := _CopyICBLinear(Len);
  2648.      IF P = NIL THEN exit;       {Length=0}
  2649.      IF _SetClipBoardText(P,Len) THEN EnablePaste;
  2650.      FreeMem(P,Len);
  2651. END;
  2652.  
  2653.  
  2654.  
  2655. PROCEDURE TEditorWindow.PasteFromClipBoard;
  2656. VAR  P : POINTER;
  2657.      Len : LONGWORD;
  2658. BEGIN
  2659.      IF WinReadOnly THEN exit;
  2660.      IF WLactivated THEN _WriteWorkLine;
  2661.      P := _GetClipBoardText(Len);
  2662.      IF P <> NIL THEN
  2663.      BEGIN
  2664.           (*UNDO*)
  2665.           _CopyUndoLines(ActLine,ActLine);
  2666.           LastUndoGroup := UG_CursorMove;
  2667.           (*UNDO*)
  2668.           _ICBClearMark;
  2669.           _PasteICBLinear(P,Len);
  2670.           SetSliderValues;
  2671.           SetLineColorFlag(ICB.FirstLine,ICB.LastLine);
  2672.           ICBGotoBegin;
  2673.           FreeMem(P,Len);
  2674.           (*UNDO*)
  2675.           UndoEvent[LastUndo].FrameEnd := _PLine2Long(ICB.LastLine^.next);
  2676.           LastUndoGroup := UG_NoGroup;
  2677.           (*UNDO*)
  2678.      END;
  2679. END;
  2680.  
  2681.  
  2682.  
  2683. PROCEDURE TEditorWindow.EnableCopyCut;
  2684. BEGIN
  2685. END;
  2686.  
  2687.  
  2688. PROCEDURE TEditorWindow.DisableCopyCut;
  2689. BEGIN
  2690. END;
  2691.  
  2692.  
  2693. PROCEDURE TEditorWindow.EnablePaste;
  2694. BEGIN
  2695. END;
  2696.  
  2697.  
  2698. PROCEDURE TEditorWindow.DisablePaste;
  2699. BEGIN
  2700. END;
  2701.  
  2702.  
  2703. PROCEDURE TEditorWindow.EnableUndo;
  2704. BEGIN
  2705. END;
  2706.  
  2707.  
  2708. PROCEDURE TEditorWindow.DisableUndo;
  2709. BEGIN
  2710. END;
  2711.  
  2712.  
  2713. PROCEDURE TEditorWindow.EnableRedo;
  2714. BEGIN
  2715. END;
  2716.  
  2717.  
  2718. PROCEDURE TEditorWindow.DisableRedo;
  2719. BEGIN
  2720.      RedoEvents := 0;
  2721. END;
  2722.  
  2723.  
  2724. { +++ Procedures of TEditorWindow ++++++++++++++++++++++++++++++++++++++++++ }
  2725.  
  2726.  
  2727. CONSTRUCTOR TEditorWindow.Init(AParent:PWindowsObject; ATitle:STRING);
  2728. VAR  i : WORD;
  2729. BEGIN
  2730.      Inherited.Init(AParent,ATitle);
  2731.      Attr.FrameFlags:=Attr.FrameFlags OR FCF_VERTSCROLL OR FCF_HORZSCROLL;
  2732.      StdExt := '.TXT';
  2733.      WinColor := CLR_BLACK;
  2734.      WinBackColor := CLR_WHITE;
  2735.      Sel_Color := CLR_WHITE;
  2736.      Sel_BackColor := CLR_BLACK;
  2737.      WLactivated := FALSE;
  2738.      ICBVisible := TRUE;
  2739.      IgnoreRedraw := FALSE;
  2740.      Untitled := TRUE;
  2741.      Modified := FALSE;
  2742.      FileCursorY := 1;
  2743.      FileCursorX := 1;
  2744.      ScrCursorY := 1;
  2745.      ScrCursorX := 1;
  2746.      HSlider.acvalue := 1;
  2747.      CountLines := 1;
  2748.      NewEditorPtr := WinQuerySysPointer(HWND_DESKTOP,SPTR_TEXT,FALSE);
  2749.      FileName := '';
  2750.      ICB.FirstLine := NIL;
  2751.      ICB.FirstX := 0;
  2752.      ICB.LastLine := NIL;
  2753.      ICB.LastX := 0;
  2754.      OldICB := ICB;
  2755.      FindICB := FALSE;
  2756.      New(WorkLine);
  2757.      WorkLine^ := '';
  2758.      {create anchor}
  2759.      New(FirstLine);
  2760.      FirstLine^.color := CI_Normal;
  2761.      FirstLine^.prev := NIL;
  2762.      FirstLine^.next := NIL;
  2763.      LastLine := FirstLine;
  2764.      ActLine := FirstLine;
  2765.      FirstScreenLine := FirstLine;
  2766.      _WriteWorkLine;
  2767.      CountLines := 1;
  2768.      SetFlags(WF_DELETEDOUBLESCAN,TRUE); {delete multiple scan events}
  2769.      MaxDoubleChars := 15;
  2770.      MaxDoubleScans := 15;
  2771.      UndoEvents := 0;
  2772.      LastUndo := 0;
  2773.      FOR i := 0 TO MaxUndoEvents-1 DO UndoEvent[i].Event := 0;
  2774.      RedoEvents := 0;
  2775.      LastRedo := 0;
  2776.      FOR i := 0 TO MaxRedoEvents-1 DO RedoEvent[i].Event := 0;
  2777.      LastUndoGroup := UG_NoGroup;
  2778.      PrintInfo.Status := 0;
  2779. END;
  2780.  
  2781.  
  2782.  
  2783. PROCEDURE TEditorWindow.WindowDestroyed;
  2784. BEGIN
  2785.      CloseFile;
  2786. END;
  2787.  
  2788.  
  2789. FUNCTION TEditorWindow.CanClose:BOOLEAN;
  2790. VAR  resp : LONGWORD;
  2791.      text,titel : STRING;
  2792. BEGIN
  2793.      CanClose := TRUE;
  2794.      IF Modified THEN
  2795.      BEGIN
  2796.           IF Untitled THEN text := Attr.Title + NLSTable[9]
  2797.           ELSE text := FileName + NLSTable[9];
  2798.           titel := NLSTable[10];
  2799.           resp := SetQueryMessage(titel,text,MB_YESNOCANCEL OR MB_MOVEABLE OR
  2800.                                              MB_QUERY);
  2801.           CASE resp OF
  2802.                MBID_YES    : IF NOT SaveFile THEN CanClose := FALSE;
  2803.                MBID_CANCEL : CanClose := FALSE;
  2804.           END;
  2805.      END;
  2806. END;
  2807.  
  2808.  
  2809. { +++ Drag & Drop Procedures +++++++++++++++++++++++++++++++++++++++++++++++ }
  2810.  
  2811.  
  2812. FUNCTION TEditorWindow._GetFileText(s: STRING; VAR Len:LONGWORD):POINTER;
  2813. VAR  utF : FILE;
  2814.      P : ^LONGWORD;
  2815. BEGIN
  2816.      Assign(utF,s);
  2817.      FileMode := fmInput;
  2818.      {$i-}
  2819.      Reset(utF,1);
  2820.      FileMode := fmInOut;
  2821.      IF IOResult <> 0 THEN Len := 0
  2822.      ELSE Len := FileSize(utF);
  2823.      {$i+}
  2824.      IF Len > 0 THEN
  2825.      BEGIN
  2826.           GetMem(P,Len);
  2827.           {$i-}
  2828.           Blockread(utF,P^,Len);
  2829.           {$i+}
  2830.      END
  2831.      ELSE P := NIL;
  2832.      {$i-}
  2833.      Close(utF);
  2834.      {$i+}
  2835.      _GetFileText := P;
  2836. END;
  2837.  
  2838.  
  2839.  
  2840. PROCEDURE TEditorWindow.PasteFromFile(s:STRING);
  2841. VAR  P : POINTER;
  2842.      Len : LONGWORD;
  2843. BEGIN
  2844.      IF WinReadOnly THEN exit;
  2845.      IF WLactivated THEN _WriteWorkLine;
  2846.      P := _GetFileText(s,Len);
  2847.      IF P <> NIL THEN
  2848.      BEGIN
  2849.           (*UNDO*)
  2850.           _CopyUndoLines(ActLine,ActLine);
  2851.           LastUndoGroup := UG_CursorMove;
  2852.           (*UNDO*)
  2853.           _ICBClearMark;
  2854.           _PasteICBLinear(P,Len);
  2855.           SetSliderValues;
  2856.           SetLineColorFlag(ICB.FirstLine,ICB.LastLine);
  2857.           ICBGotoBegin;
  2858.           FreeMem(P,Len);
  2859.           (*UNDO*)
  2860.           UndoEvent[LastUndo].FrameEnd := _PLine2Long(ICB.LastLine^.next);
  2861.           LastUndoGroup := UG_NoGroup;
  2862.           (*UNDO*)
  2863.      END;
  2864. END;
  2865.  
  2866.  
  2867. { +++ Procedures for Drag & Drop +++++++++++++++++++++++++++++++++++++++++++ }
  2868.  
  2869. {Initiate drag operation}
  2870. PROCEDURE TEditorWindow.WMBeginDrag(VAR Msg:TMessage);
  2871. VAR  P : POINTER;
  2872.      Len : LONGWORD;
  2873.      utF : FILE;
  2874.      fname,fdir : STRING;
  2875.      cType,cRMF,cContainer,cSource : CSTRING;
  2876.      h,m,s,s100 : WORD;
  2877.      TargetWin : HWND;
  2878.      ditem : DragItem;
  2879.      dimage : DragImage;
  2880.      pdinfo : PDragInfo;
  2881.      TempFilename : STRING;
  2882. LABEL l;
  2883. BEGIN
  2884.      Msg.Result := 0;
  2885.      Msg.Handled := TRUE;
  2886.  
  2887.      {Create temp file}
  2888.      P := _CopyICBLinear(Len);
  2889.      IF P = NIL THEN exit;                    {Length=0}
  2890.      FSplit(ParamStr(0),fdir,fname,fname);    {only fdir is relevant}
  2891.      IF fdir = '' THEN fdir := 'c:\';
  2892.      GetTime(h,m,s,s100);
  2893.      fname := tostr(s)+tostr(s100)+'.tmp';    {random filename}
  2894.      TempFilename := fdir+fname;
  2895.      Assign(utF,TempFilename);
  2896.      {$i-}
  2897.      Rewrite(utF,1);
  2898.      {$i+}
  2899.      IF IoResult <> 0 THEN
  2900.      BEGIN
  2901. l:
  2902.           FreeMem(P,Len);
  2903.           exit;
  2904.      END;
  2905.      {$i-}
  2906.      BlockWrite(utF,P^,Len-1);                {without #0}
  2907.      {$i+}
  2908.      IF IoResult <> 0 THEN goto l;
  2909.      {$i-}
  2910.      Close(utF);
  2911.      {$i+}
  2912.      IF IoResult <> 0 THEN goto l;
  2913.      FreeMem(P,Len);
  2914.  
  2915.      {Init dragitem struct}
  2916.      ditem.hwndItem := HWindow;
  2917.      ditem.ulItemID := 0;
  2918.      cType := 'Plain Text';
  2919.      ditem.hstrType := DrgAddStrHandle(cType);
  2920.      cRMF := '(DRM_OS2FILE,DRM_PRINT) x (DRF_TEXT,DRF_UNKNOWN)';
  2921.      ditem.hstrRMF  := DrgAddStrHandle(cRMF);
  2922.      cContainer := fdir;
  2923.      ditem.hstrContainerName := DrgAddStrHandle(cContainer);
  2924.      cSource := fname;
  2925.      ditem.hstrSourceName := DrgAddStrHandle(cSource);
  2926.      ditem.hstrTargetName := DrgAddStrHandle(cSource);
  2927.      ditem.cxOffset := 0;
  2928.      ditem.cyOffset := 0;
  2929.      ditem.fsControl := 0;
  2930.      ditem.fsSupportedOps := DO_COPYABLE OR DO_MOVEABLE;
  2931.  
  2932.      {Init dragimage struct}
  2933.      dimage.cb := SizeOf(DragImage);
  2934.      dimage.hImage := WinQuerySysPointer(HWND_DESKTOP,SPTR_TEXT,TRUE);
  2935.      dimage.fl := DRG_ICON;
  2936.      dimage.cxOffset := 0;
  2937.      dimage.cyOffset := 0;
  2938.  
  2939.      {Initiate drag}
  2940.      pdinfo := DrgAllocDragInfo(1);
  2941.      IF pdinfo = NIL THEN exit;
  2942.      pdinfo^.usOperation := DO_COPY;    {default is copy}
  2943.      DrgSetDragItem(pdinfo^,ditem,SizeOf(DragItem),0);
  2944.      TargetWin := DrgDrag(HWindow,pdinfo^,dimage,1,VK_ENDDRAG,NIL);
  2945.  
  2946.      IF TargetWin <> 0 THEN
  2947.      BEGIN
  2948.           IF TargetWin <> HWindow THEN
  2949.           BEGIN
  2950.                IF pdinfo^.usOperation = DO_MOVE THEN ICBDeleteBlock;
  2951.           END
  2952.           ELSE
  2953.           BEGIN
  2954.                IF pdinfo^.usOperation = DO_MOVE THEN ICBMoveBlock
  2955.                ELSE ICBCopyBlock;
  2956.           END;
  2957.      END;
  2958.  
  2959.      DrgFreeDragInfo(pdinfo^);
  2960.  
  2961.      Assign(utF,TempFilename);
  2962.      {$i-}
  2963.      Erase(utF);     {delete temp file if possible}
  2964.      {$i+}
  2965. END;
  2966.  
  2967.  
  2968.  
  2969. PROCEDURE TEditorWindow.DMDragOver(VAR Msg:TMessage);
  2970. VAR  pdinfo : PDragInfo;
  2971.      ditem : DragItem;
  2972.      szNativeRMF : CSTRING;
  2973.      szDropDirectory : CSTRING;
  2974.      szDropFileName : CSTRING;
  2975.      s,sDir,sFile : STRING;
  2976.      i : WORD;
  2977.      F : FILE;
  2978. BEGIN
  2979.      pdinfo := PDragInfo(Msg.Param1);
  2980.      IF NOT WinReadOnly THEN
  2981.        IF DrgAccessDraginfo(pdinfo^) THEN
  2982.        BEGIN
  2983.             IF pdinfo^.usOperation = DO_LINK THEN {no valid operation}
  2984.             BEGIN
  2985.                  Msg.Result := (DO_UNKNOWN SHL 16) OR DOR_NODROPOP;
  2986.                  Msg.Handled := TRUE;
  2987.                  exit;
  2988.             END;
  2989.             FOR i := 0 TO pdinfo^.cditem-1 DO
  2990.             BEGIN
  2991.                  IF DrgQueryDragitem(pdinfo^,sizeof(ditem),ditem,i) THEN
  2992.                    IF DrgQueryNativeRMF(ditem,255,szNativeRMF) THEN
  2993.                    BEGIN
  2994.                         s := szNativeRMF;
  2995.                         IF pos('DRM_OS2FILE,DRF_TEXT',s) <> 0 THEN
  2996.                           IF (ditem.fsSupportedOps AND DO_COPYABLE <> 0) OR
  2997.                              (ditem.fsSupportedOps AND DO_MOVEABLE <> 0) THEN
  2998.                           BEGIN
  2999.                                DrgQueryStrName(ditem.hstrContainerName,
  3000.                                           sizeof(szDropDirectory),szDropDirectory);
  3001.                                sDir := szDropDirectory;
  3002.                                IF sDir[Length(sDir)] <> '\' THEN sDir := sDir + '\';
  3003.                                DrgQueryStrName(ditem.hstrSourceName,
  3004.                                                sizeof(szDropFileName),szDropFileName);
  3005.                                sFile := szDropFileName;
  3006.  
  3007.                                Assign(F,sDir+sFile);
  3008.                                FileMode := fmInput;
  3009.                                {$i-}
  3010.                                Reset(F);
  3011.                                {$i+}
  3012.                                FileMode := fmInOut;
  3013.                                IF IoResult = 0 THEN
  3014.                                BEGIN
  3015.                                     {$i-}
  3016.                                     Close(F);
  3017.                                     {$i+}
  3018.                                     Msg.Result := (DO_UNKNOWN SHL 16) OR DOR_DROP;
  3019.                                     Msg.Handled := TRUE;
  3020.                                     exit;
  3021.                                END;
  3022.                         END;
  3023.                    END;
  3024.             END;
  3025.        END;
  3026.      Msg.Result := (DO_UNKNOWN SHL 16) OR DOR_NEVERDROP;
  3027.      Msg.Handled := TRUE;
  3028. END;
  3029.  
  3030.  
  3031.  
  3032. PROCEDURE TEditorWindow.DMDrop(VAR Msg:TMessage);
  3033. VAR  pdinfo : PDragInfo;
  3034.      ditem : DragItem;
  3035.      szNativeRMF : CSTRING;
  3036.      szDropDirectory : CSTRING;
  3037.      szDropFileName : CSTRING;
  3038.      s,sDir,sFile : STRING;
  3039.      i : WORD;
  3040. BEGIN
  3041.      pdinfo := PDragInfo(Msg.Param1);
  3042.      IF NOT WinReadOnly THEN
  3043.        IF DrgAccessDraginfo(pdinfo^) THEN
  3044.          FOR i := 0 TO pdinfo^.cditem-1 DO
  3045.          IF pdinfo^.hwndSource <> HWindow THEN  {else WMBeginDrag does it}
  3046.            IF DrgQueryDragitem(pdinfo^,sizeof(ditem),ditem,i) THEN
  3047.              IF DrgQueryNativeRMF(ditem,255,szNativeRMF) THEN
  3048.              BEGIN
  3049.                   s := szNativeRMF;
  3050.                   IF pos('DRM_OS2FILE,DRF_TEXT',s) <> 0 THEN
  3051.                     IF (ditem.fsSupportedOps AND DO_COPYABLE <> 0) OR
  3052.                        (ditem.fsSupportedOps AND DO_MOVEABLE <> 0) THEN
  3053.                     BEGIN
  3054.                          DrgQueryStrName(ditem.hstrContainerName,
  3055.                                          sizeof(szDropDirectory),szDropDirectory);
  3056.                          sDir := szDropDirectory;
  3057.                          IF sDir[Length(sDir)] <> '\' THEN sDir := sDir + '\';
  3058.                          DrgQueryStrName(ditem.hstrSourceName,
  3059.                                          sizeof(szDropFileName),szDropFileName);
  3060.                          sFile := szDropFileName;
  3061.                          IF EditOptions AND EOD_UseCUA <> 0
  3062.                          THEN CuaPasteFromFile(sDir+sFile)
  3063.                          ELSE PasteFromFile(sDir+sFile);
  3064.  
  3065.                          DrgSendTransferMsg(ditem.hwndItem,DM_ENDCONVERSATION,
  3066.                                             MPFROMLONG(ditem.ulItemID),
  3067.                                             MPFROMSHORT(DMFL_TARGETSUCCESSFUL));
  3068.                     END
  3069.                     ELSE DrgSendTransferMsg(ditem.hwndItem,DM_ENDCONVERSATION,
  3070.                                             MPFROMLONG(ditem.ulItemID),
  3071.                                             MPFROMSHORT(DMFL_TARGETFAIL));
  3072.              END;
  3073.      DrgDeleteDraginfoStrHandles(pdinfo^);
  3074.      DrgFreeDraginfo(pdinfo^);
  3075.      Msg.Result := 0;
  3076.      Msg.Handled := TRUE;
  3077. END;
  3078.  
  3079.  
  3080.  
  3081. PROCEDURE TEditorWindow.DMDropHelp(VAR Msg:TMessage);
  3082. BEGIN
  3083.      Msg.Handled := TRUE;
  3084.      Msg.Result := 0;
  3085. END;
  3086.  
  3087.  
  3088.  
  3089. PROCEDURE TEditorWindow.DMPrintObject(VAR Msg:TMessage);
  3090. CONST g : SIZEL = (cx:0; cy:0);
  3091. TYPE  PPrintDest = ^PrintDest;
  3092. VAR  dopPrinter : DEVOPENSTRUC;
  3093.      InfoDC : HDC;
  3094.      InfoPS : HPS;
  3095.      PrinterDC : HDC;
  3096.      PrinterPS : HPS;
  3097.      ptl : POINTL;
  3098.      ptlRes : POINTL;
  3099.      lSizeHC : LONGWORD;
  3100.      pHCInfo : ^HCINFO;
  3101.      pHCI : ^HCINFO;
  3102.      physPageSize : SIZEL;
  3103.      PrintArea : SIZEL;
  3104.      PrintOffset : SIZEL;
  3105.      Len : LONGWORD;
  3106.      i : WORD;
  3107.      pp : PPrintDest;
  3108. BEGIN
  3109.      IF WLactivated THEN _WriteWorkLine;
  3110.      IF PrintInfo.Status <> 0 THEN exit;
  3111.      PrintInfo.PRN_LeftIndent := 100;
  3112.      PrintInfo.PRN_UpperIndent := 100;
  3113.      PrintInfo.PRN_LowerIndent := 150;
  3114.      PrintInfo.PRN_LineDist := 45;
  3115.  
  3116.      pp := PPrintDest(Msg.Param2);
  3117.      IF pp = NIL THEN exit;
  3118.      {Get Printer Device Open Structure}
  3119.      dopPrinter := DEVOPENSTRUC(pp^.pdopData^);
  3120.  
  3121.      {Open Info DC}
  3122.      InfoDC := DevOpenDC(HInstance, OD_INFO, '*', 4, dopPrinter, 0);
  3123.      IF InfoDC = 0 THEN
  3124.      BEGIN
  3125.           SetErrorMessage(MB_ICONHAND, NLSTable[1],NLSTable[22]);
  3126.           exit;
  3127.      END;
  3128.      InfoPS := GpiCreatePS(HInstance, InfoDC, g,
  3129.                            PU_LOMETRIC OR GPIT_MICRO OR GPIA_ASSOC);
  3130.      IF InfoPS = 0 THEN
  3131.      BEGIN
  3132.           SetErrorMessage(MB_ICONHAND, NLSTable[1],NLSTable[23]);
  3133.           exit;
  3134.      END;
  3135.  
  3136.      GpiQueryPS(InfoPS,PrintArea);
  3137.  
  3138.      lSizeHC := DevQueryHardcopyCaps(InfoDC,0,0,NIL);
  3139.      IF lSizeHC = 0 THEN
  3140.      BEGIN
  3141.           SetErrorMessage(MB_ICONHAND, NLSTable[1],NLSTable[24]);
  3142.           exit;
  3143.      END;
  3144.  
  3145.      GetMem(pHCInfo,lSizeHC*SizeOf(HCINFO));
  3146.      DevQueryHardcopyCaps(InfoDC,0,lSizeHC,pHCInfo^);
  3147.  
  3148.      pHCI := pHCInfo;
  3149.      FOR i := 0 TO lSizeHC-1 DO
  3150.      BEGIN
  3151.           IF pHCI^.flAttributes AND HCAPS_CURRENT <> 0 THEN
  3152.           BEGIN
  3153.                /* Get Resolution */
  3154.                DevQueryCaps (InfoDC,CAPS_HORIZONTAL_RESOLUTION,1,ptlRes.x);
  3155.                DevQueryCaps (InfoDC,CAPS_VERTICAL_RESOLUTION,1,ptlRes.y);
  3156.  
  3157.                /* Calculate the physical page size */
  3158.                physPageSize.cx := round((ptlRes.x * pHCI^.cx) / 1000);
  3159.                physPageSize.cy := round((ptlRes.y * pHCI^.cy) / 1000);
  3160.                /* Convert from device to world coordinate space */
  3161.                GpiConvert(InfoPS,CVTC_DEVICE,CVTC_WORLD,1,POINTL(physPageSize));
  3162.  
  3163.                /* Calculate Print Offset */
  3164.                PrintOffset.cx := round((ptlRes.x * pHCI^.xLeftClip) / 1000);
  3165.                PrintOffset.cy := round((ptlRes.y * pHCI^.yBottomClip) / 1000);
  3166.                /* Convert from device to world coordinate space */
  3167.                GpiConvert(InfoPS,CVTC_DEVICE,CVTC_WORLD,1,POINTL(PrintOffset));
  3168.  
  3169.                /* Correct Print Offset if necessary */
  3170.                DevQueryCaps (InfoDC,CAPS_WIDTH,1,ptl.x);
  3171.                DevQueryCaps (InfoDC,CAPS_HEIGHT,1,ptl.y);
  3172.                /* Convert from device to world coordinate space */
  3173.                GpiConvert(InfoPS,CVTC_DEVICE,CVTC_WORLD,1,ptl);
  3174.                IF PrintOffset.cx = 0
  3175.                THEN PrintOffset.cx := (physPageSize.cx - ptl.x) DIV 2;
  3176.                IF PrintOffset.cy = 0
  3177.                THEN PrintOffset.cy := (physPageSize.cy - ptl.y) DIV 2;
  3178.            END;
  3179.            inc(pHCI,SizeOf(HCINFO));
  3180.      END;
  3181.      FreeMem(pHCInfo,lSizeHC*SizeOf(HCINFO));
  3182.      GpiAssociate(InfoPS,0);
  3183.      GpiDestroyPS(InfoPS);
  3184.      DevCloseDC(InfoDC);
  3185.  
  3186.  
  3187.      {Open Printer DC}
  3188.      PrinterDC := DevOpenDC(HInstance, OD_QUEUED, '*', 4, dopPrinter, 0);
  3189.      IF PrinterDC = 0 THEN
  3190.      BEGIN
  3191.           SetErrorMessage(MB_ICONHAND, NLSTable[1],NLSTable[25]);
  3192.           exit;
  3193.      END;
  3194.      {Set DeviceContext and PresentationSpace}
  3195.      PrinterPS := GpiCreatePS(HInstance, PrinterDC, g,
  3196.                          PU_LOMETRIC OR GPIT_MICRO OR GPIA_ASSOC);
  3197.      IF PrinterPS = 0 THEN
  3198.      BEGIN
  3199.           SetErrorMessage(MB_ICONHAND, NLSTable[1],NLSTable[26]);
  3200.           DevCloseDC(PrinterDC);
  3201.           exit;
  3202.      END;
  3203.  
  3204.      {Calculate PrintOffset within the Presentation space}
  3205.      IF PrintOffset.cx < PrintInfo.PRN_LeftIndent
  3206.      THEN PrintInfo.OffsX := PrintInfo.PRN_LeftIndent-PrintOffset.cx
  3207.      ELSE PrintInfo.OffsX := 0;
  3208.  
  3209.      IF PrintOffset.cy < PrintInfo.PRN_LowerIndent
  3210.      THEN PrintInfo.OffsY := PrintInfo.PRN_LowerIndent-PrintOffset.cy
  3211.      ELSE PrintInfo.OffsY := 0;
  3212.  
  3213.      PrintInfo.OffsFL := physPageSize.cy-PrintOffset.cy-PrintInfo.PRN_UpperIndent;
  3214.      IF PrintInfo.OffsFL > PrintArea.cy THEN PrintInfo.OffsFL := PrintArea.cy;
  3215.  
  3216.      PrintInfo.PrinterDC := PrinterDC;
  3217.      PrintInfo.PrinterPS := PrinterPS;
  3218.      PrintInfo.Text := _CopyICBLinear(Len);
  3219.      PrintInfo.TextLen := Len;
  3220.      PrintInfo.AbortHwnd := 0;
  3221.      PrintInfo.Status := 1;
  3222.  
  3223.      InitializePrinting;
  3224. END;
  3225.  
  3226.  
  3227. { +++ Procedures to Window management ++++++++++++++++++++++++++++++++++++++ }
  3228.  
  3229.  
  3230. PROCEDURE TEditorWindow.WMPresParamChanged(VAR Msg:TMessage);
  3231. VAR  PPid : LONGWORD;
  3232.      cFNS : CSTRING;
  3233.      FNS,s : STRING;
  3234.      Size,p : BYTE;
  3235.      c,i : INTEGER;
  3236. BEGIN
  3237.      PPid := Msg.Param1;
  3238.      IF PPid = PP_FONTNAMESIZE THEN
  3239.      BEGIN
  3240.           WinQueryPresParam(HWindow,
  3241.                             PPid,
  3242.                             0,
  3243.                             NIL,
  3244.                             SizeOf(cFNS),
  3245.                             cFNS,
  3246.                             QPF_NOINHERIT);
  3247.           FNS := cFNS;
  3248.           p := pos('.',FNS);
  3249.           IF p = 0 THEN exit;
  3250.           Val(copy(FNS,1,p-1),Size,c);
  3251.           IF c <> 0 THEN exit;
  3252.           delete(FNS,1,p);
  3253.           UpcaseStr(FNS);
  3254.  
  3255.           FOR i := 0 TO AvailFontCount-1 DO
  3256.           BEGIN
  3257.                s := AvailFont[i].FontName;
  3258.                UpcaseStr(s);
  3259.                IF (s = FNS) AND (AvailFont[i].PointSize = Size) THEN
  3260.                BEGIN
  3261.                     FaceName := AvailFont[i].FontName;
  3262.                     CharHeight := AvailFont[i].Height;
  3263.                     CharWidth := AvailFont[i].Width;
  3264.                     CharBaseLine := AvailFont[i].BaseLine;
  3265.                     UpdateFont;
  3266.                     exit;
  3267.                END;
  3268.           END;
  3269.           beep(100,10); {Font not available}
  3270.      END;
  3271. END;
  3272.  
  3273.  
  3274. PROCEDURE TEditorWindow.WMSize(VAR Msg:TMessage);
  3275. VAR  CursorMoved : BOOLEAN;
  3276.      FCX : WORD;
  3277.      FCY : LONGWORD;
  3278. BEGIN
  3279.      Inherited.WMSize(Msg);
  3280.      ClearFullBkGr := TRUE;
  3281.      WinQueryWindowRect(HWindow,WindowRect);
  3282.      WinSizeX := (WindowRect.XRight - 4) DIV CharWidth;
  3283.      WinSizeY := (WindowRect.yTop - 2 - CharBaseLine) DIV CharHeight;
  3284.      CursorMoved := FALSE;
  3285.      IF ScrCursorY > WinSizeY THEN
  3286.      BEGIN
  3287.           FCY := FileCursorY-ScrCursorY+WinSizeY;
  3288.           CursorMoved := TRUE;
  3289.      END
  3290.      ELSE FCY := FileCursorY;
  3291.      IF ScrCursorX > WinSizeX THEN
  3292.      BEGIN
  3293.           FCX := FileCursorX-ScrCursorX+WinSizeX;
  3294.           CursorMoved := TRUE;
  3295.      END
  3296.      ELSE FCX := FileCursorX;
  3297.      IF CursorMoved THEN
  3298.      BEGIN
  3299.           IgnoreRedraw := TRUE;
  3300.           GotoLine(FCY,FCX);
  3301.      END;
  3302.      IgnoreRedraw := WinSizeY = 0;
  3303.      SetCursorXY;
  3304.      SetSliderValues;
  3305. END;
  3306.  
  3307.  
  3308.  
  3309. PROCEDURE TEditorWindow.SetupWindow;
  3310. BEGIN
  3311.      Inherited.SetupWindow;
  3312.      DisableAutoFill;  {No background fill}
  3313.      ResidentHPS:=WinGetPS(HWindow);
  3314.      GpiSetBackMix(ResidentHPS,BM_OVERPAINT);
  3315.      CreateLogFont(ResidentHPS,FaceName,CharHeight,CharWidth,0);
  3316.  
  3317.      IF AvailFontCount = 0
  3318.      THEN AvailFontCount := QueryFonts(ResidentHPS); {enumerate available Fonts}
  3319. END;
  3320.  
  3321.  
  3322. { +++ Procedures to screen output ++++++++++++++++++++++++++++++++++++++++++ }
  3323.  
  3324.  
  3325. PROCEDURE TEditorWindow.SetCursorXY;
  3326. VAR  cux,cuy:LONGWORD;
  3327. BEGIN
  3328.      WinShowCursor(HWindow,FALSE);  {Hide cursor}
  3329.      cux:=2+((ScrCursorX-1)*CharWidth);
  3330.      cuy:=WindowRect.yTop-(ScrCursorY*CharHeight);
  3331.      dec(cuy,CharBaseLine);
  3332.      WinCreateCursor(HWindow,cux,cuy,CharWidth,2,$8004,NIL);
  3333.      WinShowCursor(HWindow,TRUE);
  3334.      UpdateEditorStatus;
  3335.      IF RedoEvents > 0 THEN DisableRedo;
  3336. END;
  3337.  
  3338.  
  3339.  
  3340. PROCEDURE TEditorWindow.SetStatusMessage(sm:STRING);
  3341. BEGIN
  3342. END;
  3343.  
  3344.  
  3345.  
  3346. PROCEDURE TEditorWindow.UpdateEditorStatus;
  3347. BEGIN
  3348. END;
  3349.  
  3350.  
  3351.  
  3352. PROCEDURE TEditorWindow.SetWindowTitleText(str:STRING);
  3353. VAR  cs : CSTRING;
  3354. BEGIN
  3355.      cs := str;
  3356.      WinSetWindowText(HWindowFrame,cs);
  3357.      Attr.Title := str;
  3358. END;
  3359.  
  3360.  
  3361.  
  3362. PROCEDURE TEditorWindow.SetErrorMessage(button:LONGWORD; titel,text:STRING);
  3363. BEGIN
  3364.      ErrorBox(button,titel,text);
  3365. END;
  3366.  
  3367.  
  3368.  
  3369. FUNCTION TEditorWindow.SetQueryMessage(titel,text:STRING;buttons:LONGWORD):LONGWORD;
  3370. VAR  ct,cx : CSTRING;
  3371. BEGIN
  3372.      ct := titel;
  3373.      cx := text;
  3374.      SetQueryMessage := WinMessageBox(HWND_DESKTOP,HWindowframe,cx,ct,0,buttons);
  3375. END;
  3376.  
  3377.  
  3378.  
  3379. FUNCTION TEditorWindow.UpdateLineColorFlag(PL:PLine):BOOLEAN;
  3380. BEGIN
  3381.      UpdateLineColorFlag := FALSE;
  3382. END;
  3383.  
  3384.  
  3385. PROCEDURE TEditorWindow.SetLineColorFlag(PL1,PL2:PLine);
  3386. BEGIN
  3387. END;
  3388.  
  3389.  
  3390.  
  3391. PROCEDURE TEditorWindow.CalcLineColor(PL:PLine);
  3392. VAR  i : WORD;
  3393.      SelAnfang : WORD;
  3394.      SelEnde : WORD;
  3395.      ac : LONGWORD;
  3396.      asmCol:LONGINT;
  3397.      asmBCol:LONGINT;
  3398.      asmLen:LONGWORD;
  3399. BEGIN
  3400.      ac := HSlider.acvalue;
  3401.      asmCol := WinColor;
  3402.      asmBCol := WinBackColor;
  3403.      asmLen := ac+WinSizeX-1;
  3404.      ASM
  3405.         LEA EDI,OEDITORS.LINECOLOR
  3406.         MOV EAX,$asmBCol
  3407.         SHL EAX,16         //shift into high word
  3408.         MOV AX,$asmCol
  3409.         MOV ECX,$asmLen
  3410.         CLD
  3411.         REP
  3412.         STOSD
  3413.      END;
  3414.  
  3415.      IF PL = NIL THEN exit;
  3416.      IF (PL^.color AND CI_Selected = 0) OR NOT ICBVisible THEN exit;
  3417.  
  3418.      IF ICB.FirstLine = PL THEN SelAnfang := ICB.FirstX
  3419.      ELSE SelAnfang := 1;
  3420.      IF ICB.LastLine = PL THEN SelEnde := ICB.LastX-1
  3421.      ELSE SelEnde := asmLen;
  3422.      IF SelAnfang > asmLen THEN exit;
  3423.      IF SelEnde > asmLen THEN SelEnde := asmLen;
  3424.  
  3425.      FOR i := SelAnfang TO SelEnde DO
  3426.      BEGIN
  3427.           LineColor[i].Color := Sel_Color;
  3428.           LineColor[i].BackColor := Sel_BackColor;
  3429.      END;
  3430. END;
  3431.  
  3432.  
  3433.  
  3434. PROCEDURE TEditorWindow.InvalidateEditorLine(PL:PLine; CY:WORD);
  3435. VAR  pt : POINTL;
  3436.      ac : WORD;
  3437.      i : WORD;
  3438.      Color : INTEGER;
  3439.      BackColor : INTEGER;
  3440.      count : WORD;
  3441.      pos : WORD;
  3442.      w : WORD;
  3443. BEGIN
  3444.      IF IgnoreRedraw THEN exit;
  3445.      ac := HSlider.acvalue;
  3446.      IF PL <> NIL THEN
  3447.      BEGIN
  3448.           IF PL^.zk <> NIL THEN OutputString := PL^.zk^
  3449.           ELSE OutputString := WorkLine^;
  3450.      END
  3451.      ELSE OutputString := '';
  3452.  
  3453.      CalcLineColor(PL);
  3454.  
  3455.      FOR i := Length(OutputString)+1 TO ac+WinsizeX-1 DO
  3456.      BEGIN
  3457.           OutputString[i]:=#32;
  3458.           inc(OutputString[0]);
  3459.      END;
  3460.      OutputString[Length(OutputString)+1]:=#0;
  3461.  
  3462.      {BookMark}
  3463.      IF PL <> NIL THEN
  3464.      BEGIN
  3465.           w := (PL^.color AND Mask4MSB) DIV BM_0;
  3466.           IF (w > 0) AND (w < 11) THEN
  3467.           BEGIN
  3468.                LineColor[ac+WinSizeX-2].Color := CLR_RED;
  3469.                LineColor[ac+WinSizeX-1].Color := CLR_RED;
  3470.                OutputString[ac+WinSizeX-2] := chr(174);
  3471.                OutputString[ac+WinSizeX-1] := chr(w+47);
  3472.           END;
  3473.      END;
  3474.  
  3475.      Color := LineColor[ac].color;
  3476.      BackColor := LineColor[ac].backcolor;
  3477.      count := 0;
  3478.      pos := 0;
  3479.      pt.y := WindowRect.yTop-(CY*CharHeight);
  3480.      FOR i := ac TO ac+WinSizeX-1 DO
  3481.      BEGIN
  3482.           IF (Color=LineColor[i].color) AND (BackColor=LineColor[i].backcolor)
  3483.           THEN inc(count)
  3484.           ELSE
  3485.           BEGIN
  3486.                pt.x:=2+pos*CharWidth;
  3487.  
  3488.                GpiSetColor(ResidentHPS,Color);
  3489.                GpiSetBackColor(ResidentHPS,BackColor);
  3490.                GpiCharStringAt(ResidentHPS,pt,count,OutputString[pos+ac]);
  3491.  
  3492.                inc(pos,count);
  3493.                count := 1;
  3494.                Color := LineColor[i].color;
  3495.                BackColor := LineColor[i].backcolor;
  3496.           END;
  3497.      END;
  3498.      IF count <> 0 THEN
  3499.      BEGIN
  3500.           pt.x := 2+(pos)*CharWidth;
  3501.           GpiSetColor(ResidentHPS,Color);
  3502.           GpiSetBackColor(ResidentHPS,BackColor);
  3503.           GpiCharStringAt(ResidentHPS,pt,count,OutputString[pos+ac]);
  3504.      END;
  3505. END;
  3506.  
  3507.  
  3508.  
  3509. PROCEDURE TEditorWindow.InvalidateSingleLine;
  3510. BEGIN
  3511.      IF IgnoreRedraw THEN exit;
  3512.      IF NOT UpdateLineColorFlag(ActLine) THEN
  3513.      BEGIN
  3514.           WinShowCursor(HWindow,FALSE); {Hide cursor}
  3515.           InvalidateEditorLine(ActLine,ScrCursorY);
  3516.           SetCursorXY;
  3517.           WinShowCursor(HWindow,TRUE);  {Show cursor}
  3518.      END
  3519.      ELSE InvalidateEditorWindow(ScrCursorY);
  3520. END;
  3521.  
  3522.  
  3523.  
  3524. PROCEDURE TEditorWindow.InvalidateEditorWindow(ab:WORD);
  3525. VAR  ptline : PLine;
  3526.      CursorY : WORD;
  3527.      i : WORD;
  3528. BEGIN
  3529.      IF IgnoreRedraw THEN exit;
  3530.      IF ab < 1 THEN ab := 1;
  3531.      IF ab > WinSizeY THEN ab := WinSizeY;
  3532.      SetSliderPosition;
  3533.      WinShowCursor(HWindow,FALSE);  {Hide cursor}
  3534.      IF WLactivated THEN _WriteWorkLine;
  3535.      ptline := FirstScreenLine;
  3536.      FOR i := 2 TO ab DO
  3537.         IF ptline <> NIL THEN ptline := ptline^.next;
  3538.      FOR CursorY := ab TO WinSizeY DO
  3539.      BEGIN
  3540.           InvalidateEditorLine(ptline,CursorY);
  3541.           IF ptline <> NIL THEN ptline := ptline^.next;
  3542.      END;
  3543.  
  3544.      SetCursorXY;
  3545.      WinShowCursor(HWindow,TRUE);  {Show cursor again}
  3546. END;
  3547.  
  3548.  
  3549.  
  3550. PROCEDURE TEditorWindow.Redraw(VAR ahps:HPS;VAR rc:RECTL);
  3551. VAR  rec : RECTL;
  3552.      ptline : PLine;
  3553.      CursorY : WORD;
  3554.      SaveIR : BOOLEAN;
  3555. BEGIN
  3556.      WinShowCursor(HWindow,FALSE);  {Hide cursor}
  3557.      IF ClearFullBkGr THEN
  3558.      BEGIN
  3559.           WinFillRect(ResidentHPS,WindowRect,WinBackColor);
  3560.           ClearFullBkGr := FALSE;
  3561.      END
  3562.      ELSE
  3563.      BEGIN
  3564.           rec := WindowRect;
  3565.           rec.yTop := rec.yTop-(WinSizeY*CharHeight+CharBaseLine-1);
  3566.           WinFillRect(ResidentHPS,rec,WinBackColor);    {down}
  3567.           rec := WindowRect;
  3568.           rec.yBottom := rec.yTop-CharBaseLine;
  3569.           WinFillRect(ResidentHPS,rec,WinBackColor);    {up}
  3570.           rec := WindowRect;
  3571.           rec.xRight := 3;
  3572.           WinFillRect(ResidentHPS,rec,WinBackColor);    {left}
  3573.           rec := WindowRect;
  3574.           rec.xLeft := WinSizeX*CharWidth+2;
  3575.           WinFillRect(ResidentHPS,rec,WinBackColor);    {right}
  3576.      END;
  3577.  
  3578.      SaveIR := IgnoreRedraw;
  3579.      IgnoreRedraw := FALSE;
  3580.      IF WLactivated THEN _WriteWorkLine;
  3581.      ptline := FirstScreenLine;
  3582.      FOR CursorY := 1 TO WinSizeY DO
  3583.      BEGIN
  3584.           InvalidateEditorLine(ptline,CursorY);
  3585.           IF ptline <> NIL THEN ptline := ptline^.next;
  3586.      END;
  3587.      IgnoreRedraw := SaveIR;
  3588.      WinShowCursor(HWindow,TRUE);  {Show cursor again}
  3589. END;
  3590.  
  3591.  
  3592. { +++ Menu select procedures +++++++++++++++++++++++++++++++++++++++++++++++ }
  3593.  
  3594.  
  3595. PROCEDURE TEditorWindow.LoadFile(Name:STRING);
  3596. VAR  utF : FILE;
  3597.      LinearStart : ^LONGWORD;
  3598.      LinearPtr : ^LONGWORD;
  3599.      fsize : LONGINT;
  3600.      storedfsize : LONGWORD;
  3601.      asmWorkLine : PSTRING;
  3602.      asmStringLength : LONGWORD;
  3603.      asmTabSize : LONGWORD;
  3604.      dir1,name1,ext1 : STRING;
  3605. BEGIN
  3606.      {Cut long filename}
  3607.      FSplit(Name,dir1,name1,ext1);
  3608.      Name := dir1 + name1 + ext1;
  3609.  
  3610.      {UpcaseStr(Name);}
  3611.      Assign(utF,Name);
  3612.      FileMode := fmInput;
  3613.      {$i-}
  3614.      Reset(utF,1);
  3615.      FileMode := fmInOut;
  3616.      IF IOResult <> 0 THEN fsize := 0
  3617.      ELSE fsize := FileSize(utF);
  3618.      {$i+}
  3619.  
  3620.      IF fsize > 0 THEN
  3621.      BEGIN
  3622.           SetStatusMessage(NLSTable[11]+Name);
  3623.           {Copy the object varriables to access via assembler}
  3624.           asmWorkLine := WorkLine;
  3625.           asmStringLength := StringLength;
  3626.           asmTabSize := EditOptions DIV $1000000;
  3627.           IF asmTabSize = 0 THEN asmTabSize := 8;
  3628.  
  3629.           GetMem(LinearStart,fsize+1);
  3630.           {$i-}
  3631.           Blockread(utF,LinearStart^,fsize);
  3632.           {$i+}
  3633.           storedfsize := fsize;
  3634.  
  3635.           _ReadWorkLine;
  3636.           LinearPtr := LinearStart;
  3637.           WHILE fsize > 0 do
  3638.           BEGIN
  3639.                WLactivated := TRUE;
  3640.                ASM
  3641.                   CLD
  3642.                   MOV EDI,$asmWorkLine
  3643.                   MOV ESI,$LinearPtr
  3644.                   INC EDI
  3645.                   XOR ECX,ECX
  3646. !lf1:
  3647.                   CMPD $fsize,0
  3648.                   JE !lf6
  3649.                   LODSB
  3650.                   DECD $fsize
  3651.                   CMP AL,32
  3652.                   JAE !lf5
  3653.                   CMP AL,13
  3654.                   JE !lf3
  3655.                   CMP AL,10
  3656.                   JE !lf4
  3657.                   CMP AL,9
  3658.                   JE !lf2
  3659.                   MOV AL,32
  3660.                   JMP !lf5
  3661. !lf2:
  3662.                   MOV EBX,ECX
  3663.                   MOV EDX,$asmTabSize
  3664.                   // insert spaces til to the next tab mark
  3665. !lf8:
  3666.                   CMP EDX,EBX
  3667.                   JA !lf7
  3668.                   ADD EDX,$asmTabSize
  3669.                   JMP !lf8
  3670. !lf7:
  3671.                   SUB EDX,EBX
  3672.                   // EDX = count of spaces
  3673.                   ADD EBX,EDX
  3674.                   CMP EBX,$asmStringLength
  3675.                   JAE !lf6
  3676.                   MOV ECX,EDX
  3677.                   MOV AL,32
  3678.                   REP
  3679.                   STOSB
  3680.                   MOV ECX,EBX
  3681.                   JMP !lf1
  3682. !lf3:
  3683.                   CMPB [ESI],10
  3684.                   JNE !lf6
  3685.                   LODSB
  3686.                   DECD $fsize
  3687.                   JMP !lf6
  3688. !lf4:
  3689.                   CMPB [ESI],13
  3690.                   JNE !lf6
  3691.                   LODSB
  3692.                   DECD $fsize
  3693.                   JMP !lf6
  3694. !lf5:
  3695.                   STOSB
  3696.                   INC ECX
  3697.                   CMP ECX,$asmStringLength
  3698.                   JB !lf1
  3699. !lf6:
  3700.                   MOV $LinearPtr,ESI
  3701.                   MOV EDI,$asmWorkLine
  3702.                   MOV [EDI+0],CL
  3703.                END;
  3704.                _WriteWorkLine;
  3705.                _InsertLine(ActLine);
  3706.                ActLine := ActLine^.next;
  3707.           END;
  3708.           _DeleteLine(ActLine);
  3709.           FreeMem(LinearStart,storedfsize+1);
  3710.      END;
  3711.      {$i-}
  3712.      Close(utF);
  3713.      {$i+}
  3714.      ActLine := FirstLine;
  3715.      FirstScreenLine := FirstLine;
  3716.      FileName := Name;
  3717.      SetWindowTitleText(FileName);
  3718.      SetStatusMessage('');
  3719.      Untitled := FALSE;
  3720.      Modified := FALSE;
  3721.      SetSliderValues;
  3722.      UpdateEditorStatus;
  3723.      SetLineColorFlag(FirstLine,LastLine);
  3724. END;
  3725.  
  3726.  
  3727.  
  3728. FUNCTION TEditorWindow.CopyLinesLinear(VAR Len:LONGWORD):POINTER;
  3729. VAR  ptline : PLine;
  3730.      LinearStart : POINTER;
  3731.      LinearPtr : POINTER;
  3732.      pstr : PSTRING;
  3733. BEGIN
  3734.      IF WLactivated THEN _WriteWorkLine;
  3735.      ptline := FirstLine;
  3736.      Len := 0;
  3737.      WHILE ptline <> NIL DO
  3738.      BEGIN
  3739.           inc(Len,Length(ptline^.zk^)+2);
  3740.           ptline := ptline^.next;
  3741.      END;
  3742.      GetMem(LinearStart,Len);
  3743.      ptline := FirstLine;
  3744.  
  3745.      LinearPtr := LinearStart;
  3746.      WHILE ptline <> NIL DO
  3747.      BEGIN
  3748.           pstr := ptline^.zk;
  3749.           ASM
  3750.              CLD
  3751.              MOV EDI,$LinearPtr
  3752.              MOV ESI,$pstr
  3753.              XOR ECX,ECX
  3754.              MOV CL,[ESI+0]
  3755.              INC ESI
  3756.              MOV EDX,ECX
  3757.              SHR ECX,2
  3758.              REP
  3759.              MOVSD
  3760.              MOV ECX,EDX
  3761.              AND ECX,3
  3762.              REP
  3763.              MOVSB
  3764.              MOV AX,$0A0D
  3765.              STOSW
  3766.              MOV $LinearPtr,EDI
  3767.           END;
  3768.           ptline := ptline^.next;
  3769.      END;
  3770.      CopyLinesLinear := LinearStart;
  3771. END;
  3772.  
  3773.  
  3774.  
  3775. FUNCTION TEditorWindow.SaveFile:BOOLEAN;
  3776. VAR  ptline : PLine;
  3777.      utF : FILE;
  3778.      eF : FILE;
  3779.      F : FILE;
  3780.      StartLinear : ^LONGWORD;
  3781.      Len : LONGWORD;
  3782.      p,IoR : WORD;
  3783.      BackupName : STRING;
  3784.      FName : STRING;
  3785.      name,dir,ext : STRING;
  3786.      titel,text : STRING;
  3787.      resp : LONGWORD;
  3788. BEGIN
  3789.      SaveFile := FALSE;
  3790.      IF Untitled THEN
  3791.      BEGIN
  3792.           FileSaveDlgWildCards := '*' + StdExt;
  3793.           FileSaveDlgTitle := NLSTable[7];
  3794.           FileSaveDlgOkname := NLSTable[28];
  3795.           IF NOT FileSaveDialog(Application^.MainWindow^.HWindow,FName) THEN exit;
  3796.           WinUpdateWindow(Application^.MainWindow^.HWindow);
  3797.  
  3798.           IF pos('.',FName) = 0 THEN FName := FName + StdExt;
  3799.           Assign(F,FName);
  3800.           {$i-}
  3801.           Reset(F);
  3802.           {$i+}
  3803.           IF IoResult = 0 THEN
  3804.           BEGIN
  3805.                {$i-}
  3806.                Close(F);
  3807.                {$i+}
  3808.                text := NLSTable[12] + FName + NLSTable[13];
  3809.                titel := NLSTable[14];
  3810.                resp := SetQueryMessage(titel,text,MB_OKCANCEL OR MB_MOVEABLE OR
  3811.                                                   MB_QUERY);
  3812.                IF resp = MBID_CANCEL THEN exit;
  3813.           END;
  3814.      END
  3815.      ELSE FName := FileName;
  3816.  
  3817.      p := pos('.',FName);
  3818.      IF p = 0 THEN FName := FName + StdExt;
  3819.      {Cut long filename}
  3820.      FSplit(FName,dir,name,ext);
  3821.      FileName := dir + name + ext;
  3822.  
  3823.      SetStatusMessage(NLSTable[15]+FileName);
  3824.      IF (EditOptions AND EOD_CreateBackup) <> 0 THEN
  3825.      BEGIN
  3826.           p := pos('.',FileName);
  3827.           BackupName := copy(FileName,1,p-1) + '.BAK';
  3828.           Assign(utF,FileName);
  3829.           {$i-}
  3830.           Reset(utF);
  3831.           IoR := IoResult;
  3832.           Close(utF);
  3833.           {$i+}
  3834.           IF IoR = 0 THEN
  3835.           BEGIN
  3836.                Assign(eF,BackupName);
  3837.                {$i-}
  3838.                Erase(eF);
  3839.                Rename(utF,BackupName);
  3840.                {$i+}
  3841.           END;
  3842.      END;
  3843.      Assign(utF,FileName);
  3844.      {$i-}
  3845.      Rewrite(utF,1);
  3846.      {$i+}
  3847.      IF IoResult <> 0 THEN
  3848.      BEGIN
  3849.           SetErrorMessage(MB_ICONHAND,NLSTable[1],NLSTable[8]+FileName);
  3850.           SetStatusMessage('');
  3851.           exit;
  3852.      END;
  3853.      StartLinear := CopyLinesLinear(Len);
  3854.      IF Len > 2 THEN  {not only 1 empty line}
  3855.      BEGIN
  3856.           {$i-}
  3857.           BlockWrite(utF,StartLinear^,Len);
  3858.           {$i+}
  3859.           IF Ioresult<>0 THEN
  3860.           BEGIN
  3861.                SetErrorMessage(MB_ICONHAND,NLSTable[1],NLSTable[8]+FileName);
  3862.                FreeMem(StartLinear,Len);
  3863.                {$i-}
  3864.                Close(utF);
  3865.                {$i+}
  3866.                SetStatusMessage('');
  3867.                exit;
  3868.           END;
  3869.      END;
  3870.      FreeMem(StartLinear,Len);
  3871.      {$i-}
  3872.      Close(utF);
  3873.      {$i+}
  3874.      Untitled := FALSE;
  3875.      Modified := FALSE;
  3876.      SetStatusMessage('');
  3877.      SetWindowTitleText(FileName);
  3878.      UpdateEditorStatus;
  3879.      SaveFile := TRUE;
  3880. END;
  3881.  
  3882.  
  3883.  
  3884. PROCEDURE TEditorWindow.SaveAsFile;
  3885. VAR  p : WORD;
  3886.      Ext : STRING;
  3887.      FName : STRING;
  3888.      titel,text : STRING;
  3889.      resp : LONGWORD;
  3890.      F : FILE;
  3891. BEGIN
  3892.      p := pos('.',FileName);
  3893.      IF (p = 0) OR Untitled THEN Ext := StdExt
  3894.      ELSE Ext := copy(FileName,p,4);
  3895.      FileSaveDlgWildCards := '*' + Ext;
  3896.      FileSaveDlgTitle := NLSTable[7];
  3897.      FileSaveDlgOkname := NLSTable[28];
  3898.      IF NOT FileSaveDialog(Application^.MainWindow^.HWindow,FName) THEN exit;
  3899.      WinUpdateWindow(Application^.MainWindow^.HWindow);
  3900.  
  3901.      IF pos('.',FName) = 0 THEN FName := FName + Ext;
  3902.      Assign(F,FName);
  3903.      {$i-}
  3904.      Reset(F);
  3905.      {$i+}
  3906.      IF IoResult = 0 THEN
  3907.      BEGIN
  3908.           {$i-}
  3909.           Close(F);
  3910.           {$i+}
  3911.           text := NLSTable[12] + FName + NLSTable[13];
  3912.           titel := NLSTable[14];
  3913.           resp := SetQueryMessage(titel,text,MB_OKCANCEL OR MB_MOVEABLE OR
  3914.                                              MB_QUERY);
  3915.           IF resp = MBID_CANCEL THEN exit;
  3916.      END;
  3917.      FileName := FName;
  3918.      Untitled := FALSE;
  3919.      SaveFile;
  3920. END;
  3921.  
  3922.  
  3923.  
  3924. PROCEDURE TEditorWindow.CloseFile;
  3925. VAR  ptline : PLine;
  3926.      nextptline : PLine;
  3927.      i : WORD;
  3928. BEGIN
  3929.      IF WLactivated THEN _WriteWorkLine;
  3930.      ptline := FirstLine;
  3931.      WHILE ptline <> NIL DO
  3932.      BEGIN
  3933.          Freemem(ptline^.zk,length(ptline^.zk^)+1);
  3934.          nextptline := ptline^.next;
  3935.          dispose(ptline);
  3936.          ptline := nextptline;
  3937.      END;
  3938.      dispose(WorkLine);
  3939.      WinReleasePS(ResidentHPS);
  3940.  
  3941.      FOR i := 0 TO MaxUndoEvents-1 DO _DeleteUndoEvent(i);
  3942.      FOR i := 0 TO MaxRedoEvents-1 DO _DeleteRedoEvent(i);
  3943. END;
  3944.  
  3945.  
  3946.  
  3947. FUNCTION TEditorWindow.GetTextFromCursor:STRING;
  3948. VAR  FCX : WORD;
  3949.      count : WORD;
  3950. BEGIN
  3951.      IF WLactivated THEN _WriteWorkLine;
  3952.      FCX := FileCursorX;
  3953.      WHILE (ActLine^.zk^[FCX-1] IN NormalChars) AND (FCX > 1) DO dec(FCX);
  3954.      count := 0;
  3955.      WHILE (ActLine^.zk^[FCX+count] IN NormalChars) AND
  3956.            (FCX+count < StringLength) DO inc(count);
  3957.      GetTextFromCursor := copy(ActLine^.zk^,FCX,count);
  3958. END;
  3959.  
  3960.  
  3961.  
  3962. FUNCTION TEditorWindow.FindTextPos(s:STRING; w:WORD; VAR CY:LONGWORD;
  3963.                                    VAR CX:LONGWORD):BOOLEAN;
  3964. VAR  SForward : BOOLEAN;
  3965.      CaseSensitiv : BOOLEAN;
  3966.      FromCursor : BOOLEAN;
  3967.      WordsOnly : BOOLEAN;
  3968.      zeile : STRING;
  3969.      cutzeile : STRING;
  3970.      sl : STRING;
  3971.      P : WORD;
  3972.      ptline : PLine;
  3973. LABEL l1,l2,l3,l4;
  3974.  
  3975. FUNCTION IsFullWord:BOOLEAN;
  3976. VAR  locCX : LONGWORD;
  3977. BEGIN
  3978.      locCX := CX;
  3979.      IsFullWord := FALSE;
  3980.      IF locCX > 1 THEN
  3981.      BEGIN
  3982.           IF ptline^.zk^[locCX-1] IN NormalChars THEN exit;
  3983.      END;
  3984.      IF locCX+Length(sl)-1 < Length(ptline^.zk^) THEN
  3985.      BEGIN
  3986.           IF ptline^.zk^[locCX+Length(sl)] IN NormalChars THEN exit;
  3987.      END;
  3988.      IsFullWord := TRUE;
  3989. END;
  3990.  
  3991. BEGIN
  3992.      {evaluate the w flag}
  3993.      CaseSensitiv := w AND FRD_CaseSensitiv <> 0;
  3994.      FromCursor := w AND FRD_FromCursor <> 0;
  3995.      SForward := w AND FRD_Forward <> 0;
  3996.      WordsOnly := w AND FRD_WordsOnly <> 0;
  3997.  
  3998.      FindTextPos := FALSE;
  3999.      IF s = '' THEN exit;
  4000.      sl := s;
  4001.      IF NOT CaseSensitiv THEN UpcaseStr(s);
  4002.      IF WLactivated THEN _WriteWorkLine;
  4003.      IF SForward THEN
  4004.      BEGIN {Forward-Search}
  4005.           IF FromCursor THEN
  4006.           BEGIN
  4007.                ptline := ActLine;
  4008.                CY := FileCursorY;
  4009.           END
  4010.           ELSE
  4011.           BEGIN
  4012.                ptline := FirstLine;
  4013.                CY := 1;
  4014.           END;
  4015.  
  4016.           IF FromCursor THEN
  4017.           BEGIN
  4018.                zeile := copy(ptline^.zk^,FileCursorX,
  4019.                              Length(ptline^.zk^)-FileCursorX+1);
  4020.                IF NOT CaseSensitiv THEN UpcaseStr(zeile);
  4021. l1:
  4022.                CX := pos(s,zeile);
  4023.                IF CX <> 0 THEN
  4024.                BEGIN
  4025.                     FindTextPos := TRUE;
  4026.                     zeile[CX] := #0;
  4027.                     CX := CX + FileCursorX - 1;
  4028.                     IF NOT WordsOnly THEN exit;
  4029.                     IF IsFullWord THEN exit;
  4030.                     FindTextPos := FALSE;
  4031.                     goto l1;
  4032.                END;
  4033.                ptline := ptline^.next;
  4034.                inc(CY);
  4035.           END;
  4036.  
  4037.           WHILE ptline <> NIL DO
  4038.           BEGIN
  4039.                zeile := ptline^.zk^;
  4040.                IF NOT CaseSensitiv THEN UpcaseStr(zeile);
  4041. l2:
  4042.                CX := pos(s,zeile);
  4043.                IF CX <> 0 THEN
  4044.                BEGIN
  4045.                     FindTextPos := TRUE;
  4046.                     zeile[CX] := #0;
  4047.                     IF NOT WordsOnly THEN exit;
  4048.                     IF IsFullWord THEN exit;
  4049.                     FindTextPos := FALSE;
  4050.                     goto l2;
  4051.                END;
  4052.                ptline := ptline^.next;
  4053.                inc(CY);
  4054.           END;
  4055.      END
  4056.      ELSE {Backward-Search}
  4057.      BEGIN
  4058.           IF FromCursor THEN
  4059.           BEGIN
  4060.                ptline := ActLine;
  4061.                CY := FileCursorY;
  4062.           END
  4063.           ELSE
  4064.           BEGIN
  4065.                ptline := LastLine;
  4066.                CY := CountLines;
  4067.           END;
  4068.  
  4069.           IF FromCursor THEN
  4070.           BEGIN
  4071.                zeile := copy(ptline^.zk^,1,FileCursorX-1);
  4072.                IF NOT CaseSensitiv THEN UpcaseStr(zeile);
  4073. l3:
  4074.                CX := pos(s,zeile);
  4075.                IF CX <> 0 THEN
  4076.                BEGIN
  4077.                     FindTextPos := TRUE;
  4078.                     cutzeile := zeile;
  4079.                     REPEAT
  4080.                           cutzeile := copy(zeile,CX+1,Length(zeile)-CX);
  4081.                           IF NOT CaseSensitiv THEN UpcaseStr(cutzeile);
  4082.                           P := pos(s,cutzeile);
  4083.                           inc(CX,P);
  4084.                     UNTIL P = 0;
  4085.                     zeile[CX] := #0;
  4086.                     IF NOT WordsOnly THEN exit;
  4087.                     IF IsFullWord THEN exit;
  4088.                     FindTextPos := FALSE;
  4089.                     goto l3;
  4090.                END;
  4091.                ptline := ptline^.prev;
  4092.                dec(CY);
  4093.           END;
  4094.  
  4095.           WHILE ptline <> NIL DO
  4096.           BEGIN
  4097.                zeile := ptline^.zk^;
  4098.                IF NOT CaseSensitiv THEN UpcaseStr(zeile);
  4099. l4:
  4100.                CX := pos(s,zeile);
  4101.                IF CX <> 0 THEN
  4102.                BEGIN
  4103.                     FindTextPos := TRUE;
  4104.                     cutzeile := zeile;
  4105.                     REPEAT
  4106.                           cutzeile := copy(zeile,CX+1,Length(zeile)-CX);
  4107.                           IF NOT CaseSensitiv THEN UpcaseStr(cutzeile);
  4108.                           P := pos(s,cutzeile);
  4109.                           inc(CX,P);
  4110.                     UNTIL P = 0;
  4111.                     zeile[CX] := #0;
  4112.                     IF NOT WordsOnly THEN exit;
  4113.                     IF IsFullWord THEN exit;
  4114.                     FindTextPos := FALSE;
  4115.                     goto l4;
  4116.                END;
  4117.                ptline := ptline^.prev;
  4118.                dec(CY);
  4119.           END;
  4120.      END;
  4121. END;
  4122.  
  4123.  
  4124.  
  4125. PROCEDURE TEditorWindow.FindText(s:STRING; w:WORD); {Ctrl-Q F}
  4126. VAR  SForward : BOOLEAN;
  4127.      cy, cx : LONGWORD;
  4128.      dCursPos : WORD;
  4129.      ptline : PLine;
  4130. BEGIN
  4131.      SForward := w AND FRD_Forward <> 0;
  4132.      aSearchString := s;
  4133.      FindOptions := w;
  4134.  
  4135.      IF FindTextPos(s,w,cy,cx) THEN
  4136.      BEGIN
  4137.           IF SForward THEN dCursPos := Length(s)
  4138.           ELSE dCursPos := 0;
  4139.           OldICB := ICB;
  4140.           FindICB := TRUE;
  4141.           _ICBClearMark;
  4142.           ptline := _Long2PLine(cy);
  4143.           ICB.FirstLine := ptline;
  4144.           ICB.FirstX := cx;
  4145.           ICB.LastLine := ptline;
  4146.           ICB.LastX := cx+Length(s);
  4147.           _ICBSetMark;
  4148.           GotoLine(cy,cx+dCursPos);
  4149.      END
  4150.      ELSE SetErrorMessage(MB_ICONHAND,NLSTable[1],NLSTable[16]);
  4151.      LastFRD := FR_Find;
  4152. END;
  4153.  
  4154.  
  4155.  
  4156. PROCEDURE TEditorWindow.ReplaceText(s,s1:STRING; w:WORD); {Ctrl-Q A}
  4157. VAR  SForward : BOOLEAN;
  4158.      ReplaceAll : BOOLEAN;
  4159.      Confirm : BOOLEAN;
  4160.      Contin : BOOLEAN;
  4161.      Found : BOOLEAN;
  4162.      Repl : BOOLEAN;
  4163.      cy, cx : LONGWORD;
  4164.      resp : LONGWORD;
  4165.      dCursPos : WORD;
  4166.      ptline : PLine;
  4167.      foundmind1 : BOOLEAN;
  4168. BEGIN
  4169.      {evaluate w flag}
  4170.      SForward := w AND FRD_Forward <> 0;
  4171.      ReplaceAll := w AND FRD_ReplaceAll <> 0;
  4172.      Confirm := w AND FRD_Confirm <> 0;
  4173.  
  4174.      aSearchString := s;
  4175.      aReplaceString := s1;
  4176.      ReplOptions := w;
  4177.      Contin := TRUE;
  4178.      foundmind1 := FALSE;
  4179.  
  4180.      WHILE Contin DO
  4181.      BEGIN
  4182.           Found := FindTextPos(s,w,cy,cx);
  4183.           IF Found THEN
  4184.           BEGIN
  4185.                foundmind1 := TRUE;
  4186.                IF SForward THEN dCursPos := Length(s)
  4187.                ELSE dCursPos := 0;
  4188.                IF NOT FindICB THEN OldICB := ICB;
  4189.                FindICB := TRUE;
  4190.                _ICBClearMark;
  4191.                ptline := _Long2PLine(cy);
  4192.                ICB.FirstLine := ptline;
  4193.                ICB.FirstX := cx;
  4194.                ICB.LastLine := ptline;
  4195.                ICB.LastX := cx+Length(s);
  4196.                _ICBSetMark;
  4197.                GotoLine(cy,cx+dCursPos);
  4198.                IF Confirm THEN
  4199.                BEGIN
  4200.                     resp := SetQueryMessage(NLSTable[17],NLSTable[18],
  4201.                                             MB_YESNOCANCEL OR
  4202.                                             MB_MOVEABLE OR MB_QUERY);
  4203.                     Repl := FALSE;
  4204.                     CASE resp OF
  4205.                          MBID_YES    : Repl := TRUE;
  4206.                          MBID_CANCEL : Found := FALSE;
  4207.                     END;
  4208.                END
  4209.                ELSE Repl := TRUE;
  4210.                IF Repl THEN
  4211.                BEGIN
  4212.                     (*UNDO*)
  4213.                     _CopyUndoLines(ActLine,ActLine);
  4214.                     (*UNDO*)
  4215.                     _DeleteString(cx,Length(s));
  4216.                     IF NOT _InsertString(cx,s1) THEN beep(1000,10);
  4217.                     IF SForward THEN dCursPos := Length(s1)
  4218.                     ELSE dCursPos := 0;
  4219.                     ICB.LastX := cx+Length(s1);
  4220.                     _CheckICB;
  4221.  
  4222.                     FileCursorX := cx+dCursPos;
  4223.                     IF FileCursorX > WinSizeX THEN ScrCursorX := WinSizeX
  4224.                     ELSE ScrCursorX := FileCursorX;
  4225.                     IF _HorizMove THEN
  4226.                     BEGIN
  4227.                          UpdateLineColorFlag(ActLine);
  4228.                          InvalidateEditorWindow(1);
  4229.                     END
  4230.                     ELSE InvalidateSingleLine;
  4231.                     (*UNDO*)
  4232.                    _StoreUndoCursor;
  4233.                     (*UNDO*)
  4234.                END;
  4235.           END
  4236.           ELSE
  4237.           IF NOT foundmind1 THEN SetErrorMessage(MB_ICONHAND,
  4238.                                                  NLSTable[1],NLSTable[16]);
  4239.           w := w OR FRD_FromCursor;
  4240.           Contin := ReplaceAll AND Found;
  4241.      END;
  4242.      LastFRD := FR_Replace;
  4243. END;
  4244.  
  4245.  
  4246.  
  4247. PROCEDURE TEditorWindow.SearchTextAgain; {Ctrl-L}
  4248. VAR  OldOpt : WORD;
  4249. BEGIN
  4250.      IF LastFRD = FR_Replace THEN
  4251.      BEGIN
  4252.           IF WinReadOnly THEN exit;
  4253.           OldOpt := ReplOptions;
  4254.           TEditorWindow.ReplaceText(aSearchString,aReplaceString,
  4255.                                     ReplOptions OR FRD_FromCursor);
  4256.           ReplOptions := OldOpt;
  4257.      END;
  4258.  
  4259.      IF LastFRD = FR_Find THEN
  4260.      BEGIN
  4261.           OldOpt := FindOptions;
  4262.           TEditorWindow.FindText(aSearchString,FindOptions OR FRD_FromCursor);
  4263.           FindOptions := OldOpt;
  4264.      END;
  4265. END;
  4266.  
  4267.  
  4268.  
  4269. FUNCTION TEditorWindow.GotoLine(y,x:LONGWORD):BOOLEAN;
  4270. VAR  deltaY : LONGINT;
  4271.      i : LONGWORD;
  4272. BEGIN
  4273.      IF (y < 1) OR (y > CountLines) OR (x < 1) OR (x > Stringlength) THEN
  4274.      BEGIN
  4275.           GotoLine := FALSE;
  4276.           exit;
  4277.      END;
  4278.      IF WLactivated THEN _WriteWorkLine;
  4279.      (*UNDO*)
  4280.      IF LastUndoGroup <> UG_CursorMove THEN _StoreUndoCursor;
  4281.      (*UNDO*)
  4282.      IF x <= WinSizeX THEN ScrCursorX := x
  4283.      ELSE ScrCursorX := WinSizeX;
  4284.      FileCursorX := x;
  4285.      deltaY := y - FileCursorY;
  4286.      FileCursorY := y;
  4287.      IF (ScrCursorY + deltaY >= 1) AND (ScrCursorY + deltaY <= WinSizeY)
  4288.      THEN ScrCursorY := ScrCursorY + deltaY
  4289.      ELSE
  4290.      BEGIN
  4291.           ScrCursorY := WinSizeY DIV 2;
  4292.           IF ScrCursorY = 0 THEN ScrCursorY := 1;
  4293.           IF y < ScrCursorY THEN ScrCursorY := y;
  4294.      END;
  4295.      FirstScreenLine := _Long2PLine(y-ScrCursorY+1);
  4296.      InvalidateEditorWindow(1);
  4297.      ActLine := _Long2PLine(y);
  4298.      GotoLine := TRUE;
  4299.      (*UNDO*)
  4300.      LastUndoGroup := UG_CursorMove;
  4301.      (*UNDO*)
  4302. END;
  4303.  
  4304.  
  4305. { +++ Keyboard-Events ++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  4306.  
  4307.  
  4308. PROCEDURE TEditorWindow.DeleteChar;
  4309. VAR  newstring : STRING;
  4310.      lpl : WORD;
  4311.      lwl : WORD;
  4312.      P : BYTE;
  4313. BEGIN
  4314.      IF WinReadOnly THEN exit;
  4315.      IF NOT WLactivated THEN _ReadWorkLine;
  4316.      IF FileCursorX > Length(WorkLine^) THEN
  4317.      BEGIN
  4318.           IF ActLine^.next = NIL THEN exit;
  4319.           (*UNDO*)
  4320.           _CopyUndoLines(ActLine,ActLine^.next);
  4321.           UndoEvent[LastUndo].FrameEnd := _PLine2Long(ActLine^.next);
  4322.           IF NOT WLactivated THEN _ReadWorkLine;
  4323.           (*UNDO*)
  4324.           lpl := Length(ActLine^.next^.zk^);
  4325.           IF lpl + FileCursorX <= StringLength THEN
  4326.           BEGIN
  4327.                P := _ICBPos(ActLine^.next,0);
  4328.                IF P AND POS_FIRSTICBLINE <> 0 THEN
  4329.                BEGIN
  4330.                     ICB.FirstLine := ActLine;
  4331.                     inc(ICB.FirstX,FileCursorX-1);
  4332.                     IF ActLine^.next^.color AND CI_Selected <> 0
  4333.                     THEN ActLine^.color := ActLine^.color OR CI_Selected;
  4334.                END;
  4335.                IF P AND POS_LASTICBLINE <> 0 THEN
  4336.                BEGIN
  4337.                     ICB.LastLine := ActLine;
  4338.                     inc(ICB.LastX,FileCursorX-1);
  4339.                END;
  4340.                lwl := Length(WorkLine^);
  4341.                FillChar(WorkLine^[lwl+1],FileCursorX-lwl-1,32);
  4342.                newstring := _ReadString(ActLine^.next,1,lpl);
  4343.                _WriteString(FileCursorX,newstring);
  4344.                _DeleteLine(ActLine^.next);
  4345.           END
  4346.           ELSE SetErrorMessage(MB_ICONHAND,NLSTable[1],NLSTable[19]);
  4347.           SetSliderValues;
  4348.           UpdateLineColorFlag(ActLine);
  4349.           InvalidateEditorWindow(ScrCursorY);
  4350.           (*UNDO*)
  4351.           LastUndoGroup := UG_NoGroup;
  4352.           (*UNDO*)
  4353.      END
  4354.      ELSE
  4355.      BEGIN
  4356.           (*UNDO*)
  4357.           IF LastUndoGroup <> UG_DeleteChar
  4358.           THEN _CopyUndoLines(ActLine,ActLine);
  4359.           (*UNDO*)
  4360.           P := _ICBPos(ActLine,FileCursorX);
  4361.           IF P AND POS_BEFOREICBFIRST <> 0 THEN dec(ICB.FirstX);
  4362.           IF P AND POS_BEFOREICBLAST <> 0 THEN dec(ICB.LastX);
  4363.           _DeleteString(FileCursorX,1);
  4364.           InvalidateSingleLine;
  4365.           (*UNDO*)
  4366.           LastUndoGroup := UG_DeleteChar;
  4367.           (*UNDO*)
  4368.      END;
  4369.      _CheckICB;
  4370. END;
  4371.  
  4372.  
  4373.  
  4374. PROCEDURE TEditorWindow.BackSpace;
  4375. VAR  prevline : PLine;
  4376.      oldstring : STRING;
  4377.      lpl : WORD;
  4378.      P : BYTE;
  4379.      CountDel : WORD;
  4380.      FNT : WORD;
  4381.      ptline : PLine;
  4382. BEGIN
  4383.      IF WinReadOnly THEN exit;
  4384.      IF FileCursorX <= 1 THEN
  4385.      BEGIN
  4386.           IF ActLine^.prev = NIL THEN exit;
  4387.           (*UNDO*)
  4388.           _CopyUndoLines(ActLine^.prev,ActLine);
  4389.           UndoEvent[LastUndo].FrameEnd := _PLine2Long(ActLine);
  4390.           (*UNDO*)
  4391.           IF NOT WLactivated THEN _ReadWorkLine;
  4392.           oldstring := WorkLine^;
  4393.           prevline := ActLine^.prev;
  4394.           lpl := Length(prevline^.zk^);
  4395.           IF lpl + Length(WorkLine^) <= StringLength THEN
  4396.           BEGIN
  4397.                P := _ICBPos(ActLine,0);
  4398.                IF P AND POS_FIRSTICBLINE <> 0 THEN
  4399.                BEGIN
  4400.                     ICB.FirstLine := prevline;
  4401.                     inc(ICB.FirstX,lpl);
  4402.                     IF ActLine^.color AND CI_Selected <> 0
  4403.                     THEN prevline^.color := prevline^.color OR CI_Selected;
  4404.                END;
  4405.                IF P AND POS_LASTICBLINE <> 0 THEN
  4406.                BEGIN
  4407.                     ICB.LastLine := prevline;
  4408.                     inc(ICB.LastX,lpl);
  4409.                END;
  4410.                IF ScrCursorY > 1 THEN dec(ScrCursorY)
  4411.                ELSE FirstScreenLine := prevline;
  4412.                dec(FileCursorY);
  4413.                ActLine := prevline;
  4414.                _ReadWorkLine;
  4415.                IgnoreRedraw := TRUE;
  4416.                LastUndoGroup := UG_CursorMove; {ignore UNDO}
  4417.                CursorEnd;
  4418.                IgnoreRedraw := FALSE;
  4419.                _WriteString(FileCursorX,oldstring);
  4420.                _DeleteLine(ActLine^.next);
  4421.                UpdateLineColorFlag(ActLine);
  4422.                IF _HorizMove THEN InvalidateEditorWindow(1)
  4423.                ELSE InvalidateEditorWindow(ScrCursorY);
  4424.                SetSliderValues;
  4425.           END
  4426.           ELSE SetErrorMessage(MB_ICONHAND,NLSTable[1],NLSTable[19]);
  4427.           (*UNDO*)
  4428.           LastUndoGroup := UG_NoGroup;
  4429.           (*UNDO*)
  4430.      END
  4431.      ELSE
  4432.      BEGIN
  4433.           (*UNDO*)
  4434.           IF LastUndoGroup <> UG_BackspaceChar
  4435.           THEN _CopyUndoLines(ActLine,ActLine);
  4436.           (*UNDO*)
  4437.           IF WLactivated THEN _WriteWorkLine;
  4438.           IF EditOptions AND EOD_Unindent <> 0 THEN
  4439.           BEGIN
  4440.                IF (_FindNextTab(ActLine,1) >= FileCursorX) OR
  4441.                   (Length(ActLine^.zk^) = 0) THEN
  4442.                BEGIN
  4443.                     ptline := ActLine;
  4444.                     REPEAT
  4445.                           IF ptline^.prev <> NIL THEN
  4446.                           BEGIN
  4447.                                ptline := ptline^.prev;
  4448.                                FNT := _FindNextTab(ptline,1);
  4449.                           END
  4450.                           ELSE FNT := 1;
  4451.                     UNTIL FNT < FileCursorX;
  4452.                     CountDel := FileCursorX-FNT;
  4453.                END
  4454.                ELSE CountDel := 1;
  4455.           END
  4456.           ELSE CountDel := 1;
  4457.  
  4458.           dec(FileCursorX,CountDel);
  4459.           P := _ICBPos(ActLine,FileCursorX);
  4460.           IF P AND POS_BEFOREICBFIRST <> 0 THEN
  4461.           BEGIN
  4462.                IF ICB.FirstX-FileCursorX > CountDel
  4463.                THEN dec(ICB.FirstX,CountDel)
  4464.                ELSE ICB.FirstX := FileCursorX;
  4465.           END;
  4466.           IF P AND POS_BEFOREICBLAST <> 0 THEN
  4467.           BEGIN
  4468.                IF ICB.LastX-FileCursorX > CountDel
  4469.                THEN dec(ICB.LastX,CountDel)
  4470.                ELSE ICB.LastX := FileCursorX;
  4471.           END;
  4472.           _DeleteString(FileCursorX,CountDel);
  4473.           IF ScrCursorX <= CountDel THEN
  4474.           BEGIN
  4475.                ScrCursorX := 1;
  4476.                UpdateLineColorFlag(ActLine);
  4477.                InvalidateEditorWindow(1);
  4478.           END
  4479.           ELSE
  4480.           BEGIN
  4481.                dec(ScrCursorX,CountDel);
  4482.                InvalidateSingleLine;
  4483.           END;
  4484.           (*UNDO*)
  4485.           LastUndoGroup := UG_BackspaceChar;
  4486.           (*UNDO*)
  4487.      END;
  4488.      _CheckICB;
  4489. END;
  4490.  
  4491.  
  4492.  
  4493. FUNCTION TEditorWindow._FindNextTab(PL:PLine; CX:WORD):WORD;
  4494. VAR  tabvorbild : STRING;
  4495.      ptline : PLine;
  4496.      NormalTabSize : WORD;
  4497. BEGIN
  4498.      IF WLactivated THEN _WriteWorkLine;
  4499.      tabvorbild := '!';
  4500.      ptline := PL;
  4501.      WHILE ptline <> NIL DO
  4502.      BEGIN
  4503.           IF Length(ptline^.zk^) <> 0 THEN
  4504.           BEGIN
  4505.                tabvorbild := ptline^.zk^;
  4506.                ptline := NIL;
  4507.           END
  4508.           ELSE ptline := ptline^.prev;
  4509.      END;
  4510.  
  4511.      IF (CX = 1) AND (tabvorbild[1] <> ' ') THEN {for ENTER}
  4512.      BEGIN
  4513.           _FindNextTab := 1;
  4514.           exit;
  4515.      END;
  4516.  
  4517.      NormalTabSize := EditOptions DIV $1000000;
  4518.      IF NormalTabSize = 0 THEN NormalTabSize := 8;
  4519.      IF CX <= Length(tabvorbild) THEN
  4520.      BEGIN
  4521.           dec(CX);
  4522.           WHILE (tabvorbild[CX] <> ' ') AND (CX <= Length(tabvorbild))
  4523.             DO inc(CX);
  4524.           WHILE (tabvorbild[CX] = ' ') AND (CX <= Length(tabvorbild))
  4525.             DO inc(CX);
  4526.      END
  4527.      ELSE CX := ((CX DIV NormalTabSize)+1)*NormalTabSize + 1;
  4528.  
  4529.      IF CX > StringLength THEN CX := StringLength;
  4530.      _FindNextTab := CX;
  4531. END;
  4532.  
  4533.  
  4534.  
  4535. PROCEDURE TEditorWindow.Tabulator;
  4536. VAR  p : WORD;
  4537.      i : WORD;
  4538.      leerstring : STRING;
  4539.      B : BYTE;
  4540. BEGIN
  4541.      IF WinReadOnly THEN exit;
  4542.      (*UNDO*)
  4543.      _CopyUndoLines(ActLine,ActLine);
  4544.      (*UNDO*)
  4545.      p := _FindNextTab(ActLine^.prev,FileCursorX+1); {search from fcx+1}
  4546.      leerstring := '';
  4547.      FOR i := 1 TO p-FileCursorX DO leerstring := leerstring + ' ';
  4548.      IF NOT _InsertString(FileCursorX,leerstring) THEN beep(1000,10);
  4549.      B := _ICBPos(ActLine,FileCursorX);
  4550.      IF B AND POS_BEFOREICBFIRST <> 0  THEN inc(ICB.FirstX,p-FileCursorX);
  4551.      IF B AND POS_BEFOREICBLAST <> 0 THEN inc(ICB.LastX,p-FileCursorX);
  4552.      _CheckICB;
  4553.      FileCursorX := p;
  4554.      IF p > WinSizeX THEN ScrCursorX := WinSizeX
  4555.      ELSE ScrCursorX := p;
  4556.  
  4557.      IF _HorizMove THEN
  4558.      BEGIN
  4559.           UpdateLineColorFlag(ActLine);
  4560.           InvalidateEditorWindow(1);
  4561.      END
  4562.      ELSE InvalidateSingleLine;
  4563.      (*UNDO*)
  4564.      LastUndoGroup := UG_NoGroup;
  4565.      (*UNDO*)
  4566. END;
  4567.  
  4568.  
  4569.  
  4570. PROCEDURE TEditorWindow.CarriageReturn;
  4571. VAR  newstring : STRING;
  4572.      leerstring : STRING;
  4573.      i : WORD;
  4574.      FNT : WORD;
  4575.      NCX : WORD;
  4576.      P : BYTE;
  4577.      FCX : WORD;
  4578.      AL : PLine;
  4579. BEGIN
  4580.      IF WinReadOnly THEN exit;
  4581.      (*UNDO*)
  4582.      _CopyUndoLines(ActLine,ActLine);
  4583.      (*UNDO*)
  4584.      IF NOT WLactivated THEN _ReadWorkLine;
  4585.  
  4586.      IF FileCursorX <= Length(WorkLine^) THEN
  4587.      BEGIN
  4588.           newstring := copy(WorkLine^,FileCursorX,Length(WorkLine^)-FileCursorX+1);
  4589.           WorkLine^[0] := chr(FileCursorX-1);
  4590.      END
  4591.      ELSE newstring := '';
  4592.      _WriteWorkLine;
  4593.  
  4594.      _InsertLine(ActLine);
  4595.      P := _ICBPos(ActLine,FileCursorX);
  4596.      FCX := FileCursorX;
  4597.      AL := ActLine;
  4598.      ActLine := ActLine^.next;
  4599.      IF (EditOptions AND EOD_AutoIndentMode) <> 0 THEN
  4600.      BEGIN
  4601.           leerstring := '';
  4602.           IF Length(ActLine^.prev^.zk^) = 0 THEN FNT := FileCursorX
  4603.           ELSE
  4604.           BEGIN
  4605.                FNT := 1;
  4606.                WHILE (ActLine^.prev^.zk^[FNT] = ' ') AND
  4607.                      (FNT <= Length(ActLine^.prev^.zk^)) DO inc(FNT);
  4608.           END;
  4609.           FOR i := 1 TO FNT-1 DO leerstring := leerstring + ' ';
  4610.           WorkLine^ := leerstring + newstring;
  4611.           _WriteWorkLine;
  4612.  
  4613.           IF Length(ActLine^.prev^.zk^) = 0 THEN NCX := _FindNextTab(ActLine,1)
  4614.           ELSE NCX := _FindNextTab(ActLine^.prev,1);
  4615.           FileCursorX := NCX;
  4616.           ScrCursorX := NCX;
  4617.           IF ScrCursorX > WinSizeX THEN ScrCursorX := WinSizeX;
  4618.      END
  4619.      ELSE
  4620.      BEGIN
  4621.           FileCursorX := 1;
  4622.           ScrCursorX := 1;
  4623.           WorkLine^ := newstring;
  4624.           _WriteWorkLine;
  4625.           FNT := 1;
  4626.      END;
  4627.      {update ICB}
  4628.      IF P AND POS_BEFOREICBFIRST <> 0 THEN
  4629.      BEGIN
  4630.           AL^.next^.color := AL^.next^.color OR (AL^.color AND CI_Selected);
  4631.           AL^.color := AL^.color AND NOT CI_Selected;
  4632.           dec(ICB.FirstX,FCX-1);
  4633.           inc(ICB.FirstX,FNT-1);
  4634.           ICB.FirstLine := ICB.FirstLine^.next;
  4635.      END;
  4636.      IF P AND POS_BEFOREICBLAST <> 0 THEN
  4637.      BEGIN
  4638.           AL^.next^.color := AL^.next^.color OR (AL^.color AND CI_Selected);
  4639.           dec(ICB.LastX,FCX-1);
  4640.           inc(ICB.LastX,FNT-1);
  4641.           ICB.LastLine := ICB.LastLine^.next;
  4642.      END;
  4643.      IF (P AND POS_AFTERICBFIRST <> 0) OR (P AND POS_INICB <> 0)
  4644.      THEN AL^.next^.color := AL^.next^.color OR (AL^.color AND CI_Selected);
  4645.      IF P AND POS_AFTERICBLAST  <> 0
  4646.      THEN AL^.next^.color := AL^.next^.color AND NOT CI_Selected;
  4647.  
  4648.      inc(FileCursorY);
  4649.      SetLineColorFlag(ActLine^.prev,ActLine);
  4650.      IF ScrCursorY = WinSizeY THEN
  4651.      BEGIN
  4652.           FirstScreenLine := FirstScreenLine^.next;
  4653.           InvalidateEditorWindow(1);
  4654.      END
  4655.      ELSE
  4656.      BEGIN
  4657.           inc(ScrCursorY);
  4658.           IF _HorizMove THEN InvalidateEditorWindow(1)
  4659.           ELSE InvalidateEditorWindow(ScrCursorY-1);
  4660.      END;
  4661.      SetSliderValues;
  4662.      _CheckICB;
  4663.      (*UNDO*)
  4664.      UndoEvent[LastUndo].FrameEnd := _PLine2Long(ActLine^.next);
  4665.      LastUndoGroup := UG_NoGroup;
  4666.      (*UNDO*)
  4667. END;
  4668.  
  4669.  
  4670.  
  4671. PROCEDURE TEditorWindow.LineInsert; {Ctrl-N}
  4672. VAR  newstring : STRING;
  4673.      P : BYTE;
  4674.      FCX : WORD;
  4675.      AL : PLine;
  4676. BEGIN
  4677.      IF WinReadOnly THEN exit;
  4678.      (*UNDO*)
  4679.      _CopyUndoLines(ActLine,ActLine);
  4680.      (*UNDO*)
  4681.      IF NOT WLactivated THEN _ReadWorkLine;
  4682.  
  4683.      IF FileCursorX <= Length(WorkLine^)
  4684.      THEN newstring := copy(WorkLine^,FileCursorX,Length(WorkLine^)-FileCursorX+1)
  4685.      ELSE newstring := '';
  4686.      WorkLine^[0] := chr(FileCursorX-1);
  4687.      _WriteWorkLine;
  4688.  
  4689.      _InsertLine(ActLine);
  4690.      {update ICB}
  4691.      P := _ICBPos(ActLine,FileCursorX);
  4692.      FCX := FileCursorX;
  4693.      AL := ActLine;
  4694.      IF P AND POS_BEFOREICBFIRST <> 0 THEN
  4695.      BEGIN
  4696.           AL^.next^.color := AL^.next^.color OR (AL^.color AND CI_Selected);
  4697.           AL^.color := AL^.color AND NOT CI_Selected;
  4698.           dec(ICB.FirstX,FCX-1);
  4699.           ICB.FirstLine := ICB.FirstLine^.next;
  4700.      END;
  4701.      IF P AND POS_BEFOREICBLAST <> 0 THEN
  4702.      BEGIN
  4703.           AL^.next^.color := AL^.next^.color OR (AL^.color AND CI_Selected);
  4704.           dec(ICB.LastX,FCX-1);
  4705.           ICB.LastLine := ICB.LastLine^.next;
  4706.      END;
  4707.      IF (P AND POS_AFTERICBFIRST <> 0) OR (P AND POS_INICB <> 0)
  4708.      THEN AL^.next^.color := AL^.next^.color OR (AL^.color AND CI_Selected);
  4709.      IF P AND POS_AFTERICBLAST  <> 0
  4710.      THEN AL^.next^.color := AL^.next^.color AND NOT CI_Selected;
  4711.  
  4712.      ActLine := ActLine^.next;
  4713.      WorkLine^ := newstring;
  4714.      _WriteWorkLine;
  4715.  
  4716.      ActLine := ActLine^.prev;
  4717.      IF Length(newstring) = 0 THEN
  4718.      BEGIN
  4719.           LastUndoGroup := UG_CursorMove;
  4720.           CursorEnd;
  4721.      END;
  4722.  
  4723.      SetLineColorFlag(ActLine,ActLine^.next);
  4724.      IF (ScrCursorY = WinSizeY) AND (ScrCursorY > 1) THEN
  4725.      BEGIN
  4726.           dec(ScrCursorY);
  4727.           FirstScreenLine := FirstScreenLine^.next;
  4728.           InvalidateEditorWindow(1);
  4729.      END
  4730.      ELSE InvalidateEditorWindow(ScrCursorY);
  4731.      SetSliderValues;
  4732.      _CheckICB;
  4733.      (*UNDO*)
  4734.      UndoEvent[LastUndo].FrameEnd := _PLine2Long(ActLine^.next^.next);
  4735.      LastUndoGroup := UG_NoGroup;
  4736.      (*UNDO*)
  4737. END;
  4738.  
  4739.  
  4740.  
  4741. PROCEDURE TEditorWindow.DeleteLine;
  4742. VAR  nextline : PLine;
  4743.      prevline : PLine;
  4744.      P : BYTE;
  4745. BEGIN
  4746.      IF WinReadOnly THEN exit;
  4747.      IF NOT WLactivated THEN _ReadWorkLine;
  4748.      nextline := ActLine^.next;
  4749.  
  4750.      P := _ICBPos(ActLine,0);
  4751.  
  4752.      IF nextline <> NIL THEN
  4753.      BEGIN
  4754.           IF FirstScreenLine = ActLine THEN FirstScreenLine := nextline;
  4755.           prevline := ActLine^.prev;
  4756.           (*UNDO*)
  4757.           _MoveUndoLines(ActLine,ActLine);
  4758.           _Connect(prevline,nextline);
  4759.           UndoEvent[LastUndo].FrameEnd := _PLine2Long(nextline);
  4760.           dec(CountLines);
  4761.           (*UNDO*)
  4762.           SetSliderValues;
  4763.           ActLine := nextline;
  4764.           WLactivated := FALSE;
  4765.      END
  4766.      ELSE
  4767.      BEGIN
  4768.           (*UNDO*)
  4769.           _CopyUndoLines(ActLine,ActLine);
  4770.           IF NOT WLactivated THEN _ReadWorkLine;
  4771.           (*UNDO*)
  4772.           WorkLine^ := '';
  4773.      END;
  4774.  
  4775.      IF P AND POS_FIRSTICBLINE <> 0 THEN
  4776.      BEGIN
  4777.           IF nextline <> NIL THEN ICB.FirstLine := nextline;
  4778.           ICB.FirstX := 1;
  4779.      END;
  4780.      IF P AND POS_LASTICBLINE <> 0 THEN
  4781.      BEGIN
  4782.           IF nextline <> NIL THEN ICB.LastLine := nextline;
  4783.           ICB.LastX := 1;
  4784.      END;
  4785.  
  4786.      FileCursorX := 1;
  4787.      ScrCursorX := 1;
  4788.      Modified := TRUE;
  4789.      IF ActLine^.prev <> NIL THEN UpdateLineColorFlag(ActLine^.prev)
  4790.      ELSE UpdateLineColorFlag(ActLine);
  4791.      IF _HorizMove THEN InvalidateEditorWindow(1)
  4792.      ELSE InvalidateEditorWindow(ScrCursorY);
  4793.      _ICBSetMark;
  4794.      _CheckICB;
  4795.      (*UNDO*)
  4796.      LastUndoGroup := UG_NoGroup;
  4797.      (*UNDO*)
  4798. END;
  4799.  
  4800.  
  4801.  
  4802. PROCEDURE TEditorWindow.DeleteUntilEnd; {Ctrl-Q Y}
  4803. VAR  P : BYTE;
  4804. BEGIN
  4805.      IF WinReadOnly THEN exit;
  4806.      (*UNDO*)
  4807.      _CopyUndoLines(ActLine,ActLine);
  4808.      (*UNDO*)
  4809.      Modified := true;
  4810.      IF NOT WLactivated THEN _ReadWorkLine;
  4811.      WorkLine^[0] := chr(FileCursorX-1);
  4812.      _WriteWorkLine;
  4813.      P := _ICBPos(ActLine,FileCursorX);
  4814.      IF P AND POS_BEFOREICBFIRST <> 0 THEN ICB.FirstX := FileCursorX;
  4815.      IF P AND POS_BEFOREICBLAST <> 0 THEN ICB.LastX := FileCursorX;
  4816.      InvalidateSingleLine;
  4817.      _CheckICB;
  4818.      (*UNDO*)
  4819.      LastUndoGroup := UG_NoGroup;
  4820.      (*UNDO*)
  4821. END;
  4822.  
  4823.  
  4824.  
  4825. PROCEDURE TEditorWindow.DeleteRightWord; {Ctrl-T}
  4826. VAR  CX : WORD;
  4827.      newstring : STRING;
  4828.      P : BYTE;
  4829. BEGIN
  4830.      IF WinReadOnly THEN exit;
  4831.      IF NOT WLactivated THEN _ReadWorkLine;
  4832.      CX := 0;
  4833.      IF FileCursorX <= Length(WorkLine^) THEN
  4834.      BEGIN
  4835.           (*UNDO*)
  4836.           _CopyUndoLines(ActLine,ActLine);
  4837.           IF NOT WLactivated THEN _ReadWorkLine;
  4838.           (*UNDO*)
  4839.           WHILE (WorkLine^[FileCursorX+CX] IN NormalChars) AND
  4840.                 (FileCursorX+CX <= Length(WorkLine^)) DO inc(CX);
  4841.           IF CX = 0 THEN CX := 1;
  4842.           WHILE (WorkLine^[FileCursorX+CX] = ' ') AND
  4843.                 (FileCursorX+CX <= Length(WorkLine^)) DO inc(CX);
  4844.           _DeleteString(FileCursorX,CX);
  4845.           _WriteWorkLine;
  4846.           P := _ICBPos(ActLine,FileCursorX);
  4847.           IF P AND POS_BEFOREICBFIRST <> 0 THEN
  4848.           BEGIN
  4849.                IF ICB.FirstX-FileCursorX < CX THEN ICB.FirstX := FileCursorX
  4850.                ELSE dec(ICB.FirstX,CX);
  4851.           END;
  4852.           IF P AND POS_BEFOREICBLAST <> 0 THEN
  4853.           BEGIN
  4854.                IF ICB.LastX-FileCursorX < CX THEN ICB.LastX := FileCursorX
  4855.                ELSE dec(ICB.LastX,CX);
  4856.           END;
  4857.           InvalidateSingleLine;
  4858.      END
  4859.      ELSE
  4860.      BEGIN
  4861.           IF ActLine^.next = NIL THEN exit;
  4862.           (*UNDO*)
  4863.           _CopyUndoLines(ActLine,ActLine^.next);
  4864.           IF NOT WLactivated THEN _ReadWorkLine;
  4865.           UndoEvent[LastUndo].FrameEnd := _PLine2Long(ActLine^.next);
  4866.           (*UNDO*)
  4867.           IF FileCursorX + Length(ActLine^.next^.zk^) <= StringLength THEN
  4868.           BEGIN
  4869.                WorkLine^[0] := chr(FileCursorX-1);
  4870.                CX := 1;
  4871.                WHILE (ActLine^.next^.zk^[CX] = ' ') AND
  4872.                      (CX <= Length(ActLine^.next^.zk^)) DO inc(CX);
  4873.                newstring := _ReadString(ActLine^.next,CX,
  4874.                                         Length(ActLine^.next^.zk^)-CX+1);
  4875.                _WriteString(FileCursorX,newstring);
  4876.                P := _ICBPos(ActLine^.next,0);
  4877.                dec(CX);      {CX count of deletable ' '}
  4878.                IF P AND POS_FIRSTICBLINE <> 0 THEN
  4879.                BEGIN
  4880.                     ICB.FirstLine := ActLine;
  4881.                     inc(ICB.FirstX,FileCursorX-1);
  4882.                     IF ICB.FirstX-FileCursorX < CX
  4883.                     THEN ICB.FirstX := FileCursorX
  4884.                     ELSE dec(ICB.FirstX,CX);
  4885.                END;
  4886.                IF P AND POS_LASTICBLINE <> 0 THEN
  4887.                BEGIN
  4888.                     ICB.LastLine := ActLine;
  4889.                     inc(ICB.LastX,FileCursorX-1);
  4890.                     IF ICB.LastX-FileCursorX < CX
  4891.                     THEN ICB.LastX := FileCursorX
  4892.                     ELSE dec(ICB.LastX,CX);
  4893.                END;
  4894.                _DeleteLine(ActLine^.next);
  4895.                SetSliderValues;
  4896.           END
  4897.           ELSE SetErrorMessage(MB_ICONHAND,NLSTable[1],NLSTable[19]);
  4898.           UpdateLineColorFlag(ActLine);
  4899.           InvalidateEditorWindow(ScrCursorY);
  4900.      END;
  4901.      {_ICBSetMark;}
  4902.      _CheckICB;
  4903.      (*UNDO*)
  4904.      LastUndoGroup := UG_NoGroup;
  4905.      (*UNDO*)
  4906. END;
  4907.  
  4908.  
  4909.  
  4910. PROCEDURE TEditorWindow.ToggleInsertMode;
  4911. VAR  r:LONGWORD;
  4912.      cux,cuy:WORD;
  4913. BEGIN
  4914.      EditOptions := EditOptions XOR EOD_InsertMode;
  4915.      IF (EditOptions AND EOD_InsertMode) <> 0 THEN r := 2
  4916.      ELSE r:=CharHeight;
  4917.      WinDestroyCursor(HWindow);
  4918.      WinCreateCursor(HWindow,40,40,CharWidth,r,4,NIL);
  4919.      cux:=2+((ScrCursorX-1)*CharWidth);
  4920.      cuy:=WindowRect.yTop-(ScrCursorY*CharHeight);
  4921.      dec(cuy,CharBaseLine);
  4922.      WinCreateCursor(HWindow,cux,cuy,CharWidth,2,$8004,NIL);
  4923.      WinStartTimer(HInstance,HWindow,TID_CURSOR,CursorRate);
  4924.      WinShowCursor(HWindow,TRUE);
  4925.      UpdateEditorStatus;
  4926. END;
  4927.  
  4928.  
  4929.  
  4930. PROCEDURE TEditorWindow.ToggleICBVisibility;
  4931. BEGIN
  4932.      ICBVisible := NOT ICBVisible;
  4933.      IF ICBVisible THEN EnableCopyCut
  4934.      ELSE DisableCopyCut;
  4935.      InvalidateEditorWindow(1);
  4936. END;
  4937.  
  4938.  
  4939. { +++ CursorMove-Events ++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  4940.  
  4941.  
  4942. PROCEDURE TEditorWindow.CursorDown(rep:WORD);
  4943. VAR  t : WORD;
  4944.      ToScroll : WORD;
  4945.      maxrep : WORD;
  4946. BEGIN
  4947.      IF WinSizeY = 0 THEN exit;
  4948.      IF FileCursorY = CountLines THEN exit;
  4949.      IF WLactivated THEN _WriteWorkLine;
  4950.      (*UNDO*)
  4951.      IF LastUndoGroup <> UG_CursorMove THEN _StoreUndoCursor;
  4952.      (*UNDO*)
  4953.  
  4954.      maxrep := (WinSizeY SHR 1) + 1;
  4955.      IF rep > maxrep THEN rep := maxrep;
  4956.      IF FileCursorY + rep > CountLines THEN rep := CountLines - FileCursorY;
  4957.  
  4958.      inc(FileCursorY,rep);
  4959.      FOR t := 1 TO rep DO ActLine := ActLine^.next;
  4960.      IF ScrCursorY + rep > WinSizeY THEN {ScrollDown}
  4961.      BEGIN
  4962.           ToScroll := (ScrCursorY+rep) - WinSizeY;
  4963.           ScrCursorY := WinSizeY;
  4964.           FOR t := 1 TO ToScroll DO FirstScreenLine := FirstScreenLine^.next;
  4965.           InvalidateEditorWindow(1);
  4966.      END
  4967.      ELSE
  4968.      BEGIN
  4969.           inc(ScrCursorY,rep);
  4970.           SetCursorXY;
  4971.      END;
  4972.      (*UNDO*)
  4973.      LastUndoGroup := UG_CursorMove;
  4974.      (*UNDO*)
  4975. END;
  4976.  
  4977.  
  4978.  
  4979. PROCEDURE TEditorWindow.CursorUp(rep:WORD);
  4980. VAR  t : WORD;
  4981.      ToScroll : WORD;
  4982.      maxrep : WORD;
  4983. BEGIN
  4984.      IF WinSizeY = 0 THEN exit;
  4985.      IF FileCursorY = 1 THEN exit;
  4986.      IF WLactivated THEN _WriteWorkLine;
  4987.      (*UNDO*)
  4988.      IF LastUndoGroup <> UG_CursorMove THEN _StoreUndoCursor;
  4989.      (*UNDO*)
  4990.  
  4991.      maxrep := (WinSizeY SHR 1) + 1;
  4992.      IF rep > maxrep THEN rep := maxrep;
  4993.      IF FileCursorY <= rep THEN rep := FileCursorY-1;
  4994.  
  4995.      dec(FileCursorY,rep);
  4996.      FOR t := 1 TO rep DO ActLine := ActLine^.prev;
  4997.      IF rep >= ScrCursorY THEN {ScrollUp}
  4998.      BEGIN
  4999.           ToScroll := rep - ScrCursorY + 1;
  5000.           ScrCursorY := 1;
  5001.           FOR t := 1 TO ToScroll DO FirstScreenLine := FirstScreenLine^.prev;
  5002.           InvalidateEditorWindow(1);
  5003.      END
  5004.      ELSE
  5005.      BEGIN
  5006.           dec(ScrCursorY,rep);
  5007.           SetCursorXY;
  5008.      END;
  5009.      (*UNDO*)
  5010.      LastUndoGroup := UG_CursorMove;
  5011.      (*UNDO*)
  5012. END;
  5013.  
  5014.  
  5015.  
  5016. PROCEDURE TEditorWindow.CursorRight;
  5017. BEGIN
  5018.      IF FileCursorX < StringLength THEN
  5019.      BEGIN
  5020.           (*UNDO*)
  5021.           IF LastUndoGroup <> UG_CursorMove THEN _StoreUndoCursor;
  5022.           (*UNDO*)
  5023.           inc(FileCursorX);
  5024.           IF ScrCursorX < WinSizeX THEN
  5025.           BEGIN
  5026.                inc(ScrCursorX);
  5027.                SetCursorXY;
  5028.           END
  5029.           ELSE InvalidateEditorWindow(1);
  5030.           (*UNDO*)
  5031.           LastUndoGroup := UG_CursorMove;
  5032.           (*UNDO*)
  5033.      END;
  5034. END;
  5035.  
  5036.  
  5037.  
  5038. PROCEDURE TEditorWindow.CursorLeft;
  5039. BEGIN
  5040.      IF FileCursorX > 1 THEN
  5041.      BEGIN
  5042.           (*UNDO*)
  5043.           IF LastUndoGroup <> UG_CursorMove THEN _StoreUndoCursor;
  5044.           (*UNDO*)
  5045.           dec(FileCursorX);
  5046.           IF ScrCursorX > 1 THEN
  5047.           BEGIN
  5048.                dec(ScrCursorX);
  5049.                SetCursorXY;
  5050.           END
  5051.           ELSE InvalidateEditorWindow(1);
  5052.           (*UNDO*)
  5053.           LastUndoGroup := UG_CursorMove;
  5054.           (*UNDO*)
  5055.      END;
  5056. END;
  5057.  
  5058.  
  5059.  
  5060. PROCEDURE TEditorWindow.PageDown;
  5061. VAR  i : INTEGER;
  5062. BEGIN
  5063.      IF FileCursorY < CountLines THEN
  5064.      BEGIN
  5065.           (*UNDO*)
  5066.           IF LastUndoGroup <> UG_CursorMove THEN _StoreUndoCursor;
  5067.           (*UNDO*)
  5068.           IF WLactivated THEN _WriteWorkLine;
  5069.           FOR i := 1 TO WinSizeY-1 DO
  5070.           BEGIN
  5071.                IF ActLine^.next <> NIL THEN
  5072.                BEGIN
  5073.                     {SrollDown}
  5074.                     ActLine := ActLine^.next;
  5075.                     FirstScreenLine := FirstScreenLine^.next;
  5076.                     inc(FileCursorY);
  5077.                END;
  5078.           END;
  5079.           InvalidateEditorWindow(1);
  5080.           (*UNDO*)
  5081.           LastUndoGroup := UG_CursorMove;
  5082.           (*UNDO*)
  5083.      END;
  5084. END;
  5085.  
  5086.  
  5087.  
  5088. PROCEDURE TEditorWindow.PageUp;
  5089. VAR  i : INTEGER;
  5090. BEGIN
  5091.      IF FileCursorY > 1 THEN
  5092.      BEGIN
  5093.           (*UNDO*)
  5094.           IF LastUndoGroup <> UG_CursorMove THEN _StoreUndoCursor;
  5095.           (*UNDO*)
  5096.           IF WLactivated THEN _WriteWorkLine;
  5097.           FOR i := 1 TO WinSizeY-1 DO
  5098.           BEGIN
  5099.                IF FirstScreenLine^.prev <> NIL THEN
  5100.                BEGIN
  5101.                     {ScrollUp}
  5102.                     ActLine := ActLine^.prev;
  5103.                     FirstScreenLine := FirstScreenLine^.prev;
  5104.                     dec(FileCursorY);
  5105.                END
  5106.                ELSE
  5107.                BEGIN
  5108.                     IF ActLine^.prev <> NIL THEN
  5109.                     BEGIN
  5110.                          {JumpUp}
  5111.                          ActLine := ActLine^.prev;
  5112.                          dec(FileCursorY);
  5113.                          dec(ScrCursorY);
  5114.                     END;
  5115.                END;
  5116.           END;
  5117.           InvalidateEditorWindow(1);
  5118.           (*UNDO*)
  5119.           LastUndoGroup := UG_CursorMove;
  5120.           (*UNDO*)
  5121.      END;
  5122. END;
  5123.  
  5124.  
  5125.  
  5126. PROCEDURE TEditorWindow.RollUp; {Ctrl-W}
  5127. BEGIN
  5128.      IF WinSizeY = 0 THEN exit;
  5129.      IF WLactivated THEN _WriteWorkLine;
  5130.      IF FirstScreenLine^.Prev <> NIL THEN
  5131.      BEGIN
  5132.           (*UNDO*)
  5133.           IF LastUndoGroup <> UG_CursorMove THEN _StoreUndoCursor;
  5134.           (*UNDO*)
  5135.           FirstScreenLine := FirstScreenLine^.Prev;
  5136.           IF ScrCursorY >= WinSizeY THEN
  5137.           BEGIN
  5138.                ActLine := ActLine^.Prev;
  5139.                dec(FileCursorY);
  5140.           END
  5141.           ELSE inc(ScrCursorY);
  5142.           InvalidateEditorWindow(1);
  5143.           (*UNDO*)
  5144.           LastUndoGroup := UG_CursorMove;
  5145.           (*UNDO*)
  5146.      END;
  5147. END;
  5148.  
  5149.  
  5150.  
  5151. PROCEDURE TEditorWindow.RollDown; {Ctrl-Z}
  5152. BEGIN
  5153.      IF WinSizeY = 0 THEN exit;
  5154.      IF WLactivated THEN _WriteWorkLine;
  5155.      IF ActLine^.Next <> NIL THEN
  5156.      BEGIN
  5157.           (*UNDO*)
  5158.          IF LastUndoGroup <> UG_CursorMove THEN _StoreUndoCursor;
  5159.           (*UNDO*)
  5160.           FirstScreenLine := FirstScreenLine^.Next;
  5161.           IF ScrCursorY <= 1 THEN
  5162.           BEGIN
  5163.                ActLine := ActLine^.Next;
  5164.                inc(FileCursorY);
  5165.           END
  5166.           ELSE dec(ScrCursorY);
  5167.           InvalidateEditorWindow(1);
  5168.           (*UNDO*)
  5169.           LastUndoGroup := UG_CursorMove;
  5170.           (*UNDO*)
  5171.      END;
  5172. END;
  5173.  
  5174.  
  5175.  
  5176. PROCEDURE TEditorWindow.CursorPos1;
  5177. BEGIN
  5178.      (*UNDO*)
  5179.      IF LastUndoGroup <> UG_CursorMove THEN _StoreUndoCursor;
  5180.      (*UNDO*)
  5181.      FileCursorX := 1;
  5182.      ScrCursorX := 1;
  5183.      IF _HorizMove THEN InvalidateEditorWindow(1)
  5184.      ELSE SetCursorXY;
  5185.      (*UNDO*)
  5186.      LastUndoGroup := UG_CursorMove;
  5187.      (*UNDO*)
  5188. END;
  5189.  
  5190.  
  5191.  
  5192. PROCEDURE TEditorWindow.CursorEnd;
  5193. VAR  LastChar : WORD;
  5194. BEGIN
  5195.      (*UNDO*)
  5196.      IF LastUndoGroup <> UG_CursorMove THEN _StoreUndoCursor;
  5197.      (*UNDO*)
  5198.      IF WLactivated THEN _WriteWorkLine;
  5199.      LastChar := Length(ActLine^.zk^)+1;
  5200.      IF LastChar > StringLength THEN LastChar := StringLength;
  5201.  
  5202.      FileCursorX := LastChar;
  5203.      IF LastChar <= WinSizeX THEN ScrCursorX := LastChar
  5204.      ELSE ScrCursorX := WinSizeX;
  5205.  
  5206.      IF _HorizMove THEN InvalidateEditorWindow(1)
  5207.      ELSE SetCursorXY;
  5208.      (*UNDO*)
  5209.      LastUndoGroup := UG_CursorMove;
  5210.      (*UNDO*)
  5211. END;
  5212.  
  5213.  
  5214.  
  5215. PROCEDURE TEditorWindow.WordRight; {Ctrl-F}
  5216. VAR  ptline : PLine;
  5217.      scroll : BOOLEAN;
  5218.      i,dFCY : LONGWORD;
  5219.      FCX : WORD;
  5220.      CC : WORD;
  5221. BEGIN
  5222.      (*UNDO*)
  5223.      IF LastUndoGroup <> UG_CursorMove THEN _StoreUndoCursor;
  5224.      (*UNDO*)
  5225.      IF WLactivated THEN _WriteWorkLine;
  5226.      scroll := FALSE;
  5227.      IF FileCursorX > Length(ActLine^.zk^) THEN
  5228.      BEGIN
  5229.           ptline := ActLine^.next;
  5230.           IF ptline = NIL THEN
  5231.           BEGIN
  5232.                CursorEnd;
  5233.                exit;
  5234.           END;
  5235.           FileCursorX := 1;
  5236.           ScrCursorX := 1;
  5237.           dFCY := 0;
  5238.           CC := 0;
  5239.           WHILE (ptline <> NIL) AND (CC = 0) DO
  5240.           BEGIN
  5241.                inc(dFCY);
  5242.                IF Length(ptline^.zk^) = 0 THEN ptline := ptline^.next
  5243.                ELSE CC := 1; {line with <> '' found}
  5244.           END;
  5245.  
  5246.           FOR i := 1 TO dFCY DO
  5247.           BEGIN
  5248.                ActLine := ActLine^.next;
  5249.                inc(FileCursorY);
  5250.                IF ScrCursorY = WinSizeY THEN
  5251.                BEGIN
  5252.                     FirstScreenLine := FirstScreenLine^.next;
  5253.                     scroll := TRUE;
  5254.                END
  5255.                ELSE inc(ScrCursorY);
  5256.           END;
  5257.      END
  5258.      ELSE CC := 2;  {next word in the same line}
  5259.  
  5260.      FCX := 0;
  5261.      IF ((CC=1) AND NOT (ActLine^.zk^[1] IN NormalChars)) OR (CC = 2) THEN
  5262.      BEGIN
  5263.           WHILE (ActLine^.zk^[FileCursorX+FCX] IN NormalChars) AND
  5264.                 (FileCursorX+FCX <= Length(ActLine^.zk^)) DO inc(FCX);
  5265.           WHILE (NOT (ActLine^.zk^[FileCursorX+FCX] IN NormalChars)) AND
  5266.                 (FileCursorX+FCX <= Length(ActLine^.zk^)) DO inc(FCX);
  5267.      END;
  5268.  
  5269.      FileCursorX := FileCursorX+FCX;
  5270.      IF FileCursorX > StringLength THEN FileCursorX := StringLength;
  5271.      ScrCursorX := ScrCursorX+FCX;
  5272.      IF ScrCursorX > WinSizeX THEN ScrCursorX := WinSizeX;
  5273.  
  5274.      IF scroll OR _HorizMove THEN InvalidateEditorWindow(1)
  5275.      ELSE SetCursorXY;
  5276.      (*UNDO*)
  5277.      LastUndoGroup := UG_CursorMove;
  5278.      (*UNDO*)
  5279. END;
  5280.  
  5281.  
  5282.  
  5283. PROCEDURE TEditorWindow.WordLeft; {Ctrl-A}
  5284. VAR  ptline : PLine;
  5285.      scroll : BOOLEAN;
  5286.      i,dFCY : LONGWORD;
  5287.      FCX : WORD;
  5288.      CC : WORD;
  5289. BEGIN
  5290.      (*UNDO*)
  5291.      IF LastUndoGroup <> UG_CursorMove THEN _StoreUndoCursor;
  5292.      (*UNDO*)
  5293.      IF WLactivated THEN _WriteWorkLine;
  5294.      scroll := FALSE;
  5295.      IF FileCursorX > Length(ActLine^.zk^)+1 THEN CursorEnd;
  5296.      IF FileCursorX > 1 THEN
  5297.      BEGIN
  5298.           CC := 0;
  5299.           FCX := 1;
  5300.           IF NOT (ActLine^.zk^[FileCursorX-FCX] IN NormalChars) THEN
  5301.             WHILE (NOT (ActLine^.zk^[FileCursorX-FCX] IN NormalChars)) AND
  5302.                   (FileCursorX-FCX  > 0) DO inc(FCX);
  5303.           IF FileCursorX-FCX = 0 THEN CC := 1;
  5304.  
  5305.           WHILE (ActLine^.zk^[FileCursorX-FCX] IN NormalChars) AND
  5306.                 (FileCursorX-FCX > 0) DO inc(FCX);
  5307.  
  5308.           FileCursorX := FileCursorX-FCX+1;
  5309.           IF FCX > ScrCursorX THEN ScrCursorX := 1
  5310.           ELSE ScrCursorX := ScrCursorX-FCX+1;
  5311.      END
  5312.      ELSE CC := 1; {mind. 1 line up}
  5313.  
  5314.      IF CC = 1 THEN
  5315.      BEGIN
  5316.           ptline := ActLine^.prev;
  5317.           IF ptline = NIL THEN
  5318.           BEGIN
  5319.                CursorPos1;
  5320.                exit;
  5321.           END;
  5322.           dFCY := 0;
  5323.           WHILE (ptline <> NIL) DO
  5324.           BEGIN
  5325.                inc(dFCY);
  5326.                IF Length(ptline^.zk^) = 0 THEN ptline := ptline^.prev
  5327.                ELSE ptline := NIL; {line with <> '' found}
  5328.           END;
  5329.  
  5330.           FOR i := 1 TO dFCY DO
  5331.           BEGIN
  5332.                ActLine := ActLine^.prev;
  5333.                dec(FileCursorY);
  5334.                IF ScrCursorY = 1 THEN
  5335.                BEGIN
  5336.                     FirstScreenLine := FirstScreenLine^.prev;
  5337.                     scroll := TRUE;
  5338.                END
  5339.                ELSE dec(ScrCursorY);
  5340.           END;
  5341.           CursorEnd;
  5342.      END;
  5343.  
  5344.      IF scroll OR _HorizMove THEN InvalidateEditorWindow(1)
  5345.      ELSE SetCursorXY;
  5346.      (*UNDO*)
  5347.      LastUndoGroup := UG_CursorMove;
  5348.      (*UNDO*)
  5349. END;
  5350.  
  5351.  
  5352.  
  5353. PROCEDURE TEditorWindow.GotoBegin;
  5354. BEGIN
  5355.      GotoLine(1,1);
  5356. END;
  5357.  
  5358.  
  5359.  
  5360. PROCEDURE TEditorWindow.GotoEnd;
  5361. BEGIN
  5362.      GotoLine(CountLines,1);
  5363.      CursorEnd;
  5364. END;
  5365.  
  5366.  
  5367.  
  5368. PROCEDURE TEditorWindow.PageHome;
  5369. BEGIN
  5370.      GotoLine(FileCursorY-ScrCursorY+1,FileCursorX);
  5371. END;
  5372.  
  5373.  
  5374.  
  5375. PROCEDURE TEditorWindow.PageEnd;
  5376. BEGIN
  5377.      GotoLine(FileCursorY+WinSizeY-ScrCursorY,FileCursorX);
  5378. END;
  5379.  
  5380.  
  5381. { +++ CUA Procedures +++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  5382.  
  5383.  
  5384. FUNCTION TEditorWindow._CuaICBPresent:BOOLEAN;
  5385. BEGIN
  5386.      _CuaICBPresent := FALSE;
  5387.      IF (ICB.FirstLine = NIL) OR (ICB.LastLine = NIL) THEN exit;
  5388.      IF (ICB.FirstLine = ICB.LastLine) AND (ICB.FirstX = ICB.LastX)
  5389.      THEN exit;
  5390.      _CuaICBPresent := TRUE;
  5391. END;
  5392.  
  5393.  
  5394.  
  5395. PROCEDURE TEditorWindow._CuaClearMark;
  5396. BEGIN
  5397.      _ICBClearMark;
  5398.      ICB.FirstLine := NIL;
  5399.      ICB.LastLine := NIL;
  5400.      _CheckICB;
  5401. END;
  5402.  
  5403.  
  5404.  
  5405. PROCEDURE TEditorWindow._CuaOverWriteBlock;
  5406. VAR  FrameFirst : PLine;
  5407.      FrameLast  : PLine;
  5408.      firststring : STRING;
  5409.      laststring : STRING;
  5410.      cl : LONGWORD;
  5411. BEGIN
  5412.      IF WinReadOnly THEN exit;
  5413.      IgnoreRedraw := TRUE;
  5414.      ICBGotoBegin;
  5415.  
  5416.      firststring := _ReadString(ICB.FirstLine,1,ICB.FirstX-1);
  5417.      laststring := _ReadString(ICB.LastLine,ICB.LastX,
  5418.                                Length(ICB.LastLine^.zk^)-ICB.LastX+1);
  5419.  
  5420.      FrameFirst := ICB.FirstLine^.prev;
  5421.      FrameLast := ICB.LastLine^.next;
  5422.      (*UNDO*)
  5423.      cl := _MoveUndoLines(ICB.FirstLine,ICB.LastLine);
  5424.      (*UNDO*)
  5425.      _Connect(FrameFirst,FrameLast);
  5426.      dec(countlines,cl);
  5427.      Modified := TRUE;
  5428.  
  5429.      _InsertLine(FrameFirst);
  5430.      IF FrameFirst = NIL THEN ActLine := FirstLine
  5431.      ELSE ActLine := FrameFirst^.next;
  5432.      IF ScrCursorY = 1 THEN FirstScreenLine := ActLine;
  5433.      WorkLine^ := firststring + laststring;
  5434.      _WriteWorkLine;
  5435.  
  5436.      ICB.FirstLine := ActLine;
  5437.      ICB.FirstX := FileCursorX;
  5438.      ICB.LastLine := ActLine;
  5439.      ICB.LastX := FileCursorX;
  5440.      _CheckICB;
  5441.  
  5442.      IgnoreRedraw := FALSE;
  5443.      SetSliderValues;
  5444.      IF FrameFirst <> NIL THEN SetLineColorFlag(FrameFirst,ActLine)
  5445.      ELSE UpdateLineColorFlag(ActLine);
  5446.      (*UNDO*)
  5447.      UndoEvent[LastUndo].FrameEnd := _PLine2Long(FrameLast);
  5448.      LastUndoGroup := UG_NoGroup;
  5449.      (*UNDO*)
  5450.      ICB.FirstLine := NIL;
  5451.      ICB.LastLine := NIL;
  5452. END;
  5453.  
  5454.  
  5455.  
  5456. PROCEDURE TEditorWindow.CuaCursorDown(rep:WORD);
  5457. BEGIN
  5458.      IF _CuaICBPresent THEN
  5459.      BEGIN
  5460.           IgnoreRedraw := TRUE;
  5461.           CursorDown(rep);
  5462.           IgnoreRedraw := FALSE;
  5463.           _CuaClearMark;
  5464.           InvalidateEditorWindow(1);
  5465.      END
  5466.      ELSE CursorDown(rep);
  5467. END;
  5468.  
  5469.  
  5470.  
  5471. PROCEDURE TEditorWindow.CuaCursorUp(rep:WORD);
  5472. BEGIN
  5473.      IF _CuaICBPresent THEN
  5474.      BEGIN
  5475.           IgnoreRedraw := TRUE;
  5476.           CursorUp(rep);
  5477.           IgnoreRedraw := FALSE;
  5478.           _CuaClearMark;
  5479.           InvalidateEditorWindow(1);
  5480.      END
  5481.      ELSE CursorUp(rep);
  5482. END;
  5483.  
  5484.  
  5485.  
  5486. PROCEDURE TEditorWindow.CuaCursorRight;
  5487. BEGIN
  5488.      IF _CuaICBPresent THEN
  5489.      BEGIN
  5490.           IgnoreRedraw := TRUE;
  5491.           CursorRight;
  5492.           IgnoreRedraw := FALSE;
  5493.           _CuaClearMark;
  5494.           InvalidateEditorWindow(1);
  5495.      END
  5496.      ELSE CursorRight;
  5497. END;
  5498.  
  5499.  
  5500.  
  5501. PROCEDURE TEditorWindow.CuaCursorLeft;
  5502. BEGIN
  5503.      IF _CuaICBPresent THEN
  5504.      BEGIN
  5505.           IgnoreRedraw := TRUE;
  5506.           CursorLeft;
  5507.           IgnoreRedraw := FALSE;
  5508.           _CuaClearMark;
  5509.           InvalidateEditorWindow(1);
  5510.      END
  5511.      ELSE CursorLeft;
  5512. END;
  5513.  
  5514.  
  5515.  
  5516. PROCEDURE TEditorWindow.CuaPageDown;
  5517. BEGIN
  5518.      IF _CuaICBPresent THEN
  5519.      BEGIN
  5520.           IgnoreRedraw := TRUE;
  5521.           PageDown;
  5522.           IgnoreRedraw := FALSE;
  5523.           _CuaClearMark;
  5524.           InvalidateEditorWindow(1);
  5525.      END
  5526.      ELSE PageDown;
  5527. END;
  5528.  
  5529.  
  5530.  
  5531. PROCEDURE TEditorWindow.CuaPageUp;
  5532. BEGIN
  5533.      IF _CuaICBPresent THEN
  5534.      BEGIN
  5535.           IgnoreRedraw := TRUE;
  5536.           PageUp;
  5537.           IgnoreRedraw := FALSE;
  5538.           _CuaClearMark;
  5539.           InvalidateEditorWindow(1);
  5540.      END
  5541.      ELSE PageUp;
  5542. END;
  5543.  
  5544.  
  5545.  
  5546. PROCEDURE TEditorWindow.CuaCursorPos1;
  5547. BEGIN
  5548.      IF _CuaICBPresent THEN
  5549.      BEGIN
  5550.           IgnoreRedraw := TRUE;
  5551.           CursorPos1;
  5552.           IgnoreRedraw := FALSE;
  5553.           _CuaClearMark;
  5554.           InvalidateEditorWindow(1);
  5555.      END
  5556.      ELSE CursorPos1;
  5557. END;
  5558.  
  5559.  
  5560.  
  5561. PROCEDURE TEditorWindow.CuaCursorEnd;
  5562. BEGIN
  5563.      IF _CuaICBPresent THEN
  5564.      BEGIN
  5565.           IgnoreRedraw := TRUE;
  5566.           CursorEnd;
  5567.           IgnoreRedraw := FALSE;
  5568.           _CuaClearMark;
  5569.           InvalidateEditorWindow(1);
  5570.      END
  5571.      ELSE CursorEnd;
  5572. END;
  5573.  
  5574.  
  5575.  
  5576. PROCEDURE TEditorWindow.CuaWordRight;
  5577. BEGIN
  5578.      IF _CuaICBPresent THEN
  5579.      BEGIN
  5580.           IgnoreRedraw := TRUE;
  5581.           WordRight;
  5582.           IgnoreRedraw := FALSE;
  5583.           _CuaClearMark;
  5584.           InvalidateEditorWindow(1);
  5585.      END
  5586.      ELSE WordRight;
  5587. END;
  5588.  
  5589.  
  5590.  
  5591. PROCEDURE TEditorWindow.CuaWordLeft;
  5592. BEGIN
  5593.      IF _CuaICBPresent THEN
  5594.      BEGIN
  5595.           IgnoreRedraw := TRUE;
  5596.           WordLeft;
  5597.           IgnoreRedraw := FALSE;
  5598.           _CuaClearMark;
  5599.           InvalidateEditorWindow(1);
  5600.      END
  5601.      ELSE WordLeft;
  5602. END;
  5603.  
  5604.  
  5605.  
  5606. PROCEDURE TEditorWindow.CuaGotoBegin;
  5607. BEGIN
  5608.      IF _CuaICBPresent THEN
  5609.      BEGIN
  5610.           IgnoreRedraw := TRUE;
  5611.           GotoBegin;
  5612.           IgnoreRedraw := FALSE;
  5613.           _CuaClearMark;
  5614.           InvalidateEditorWindow(1);
  5615.      END
  5616.      ELSE GotoBegin;
  5617. END;
  5618.  
  5619.  
  5620.  
  5621. PROCEDURE TEditorWindow.CuaGotoEnd;
  5622. BEGIN
  5623.      IF _CuaICBPresent THEN
  5624.      BEGIN
  5625.           IgnoreRedraw := TRUE;
  5626.           GotoEnd;
  5627.           IgnoreRedraw := FALSE;
  5628.           _CuaClearMark;
  5629.           InvalidateEditorWindow(1);
  5630.      END
  5631.      ELSE GotoEnd;
  5632. END;
  5633.  
  5634.  
  5635.  
  5636. PROCEDURE TEditorWindow.CuaPageHome;
  5637. BEGIN
  5638.      IF _CuaICBPresent THEN
  5639.      BEGIN
  5640.           IgnoreRedraw := TRUE;
  5641.           PageHome;
  5642.           IgnoreRedraw := FALSE;
  5643.           _CuaClearMark;
  5644.           InvalidateEditorWindow(1);
  5645.      END
  5646.      ELSE PageHome;
  5647. END;
  5648.  
  5649.  
  5650.  
  5651. PROCEDURE TEditorWindow.CuaPageEnd;
  5652. BEGIN
  5653.      IF _CuaICBPresent THEN
  5654.      BEGIN
  5655.           IgnoreRedraw := TRUE;
  5656.           PageEnd;
  5657.           IgnoreRedraw := FALSE;
  5658.           _CuaClearMark;
  5659.           InvalidateEditorWindow(1);
  5660.      END
  5661.      ELSE PageEnd;
  5662. END;
  5663.  
  5664.  
  5665.  
  5666. PROCEDURE TEditorWindow.CuaDeleteChar;
  5667. BEGIN
  5668.      IF _CuaICBPresent THEN ICBDeleteBlock
  5669.      ELSE DeleteChar;
  5670. END;
  5671.  
  5672.  
  5673.  
  5674. PROCEDURE TEditorWindow.CuaBackSpace;
  5675. BEGIN
  5676.      IF _CuaICBPresent THEN ICBDeleteBlock
  5677.      ELSE BackSpace;
  5678. END;
  5679.  
  5680.  
  5681.  
  5682. PROCEDURE TEditorWindow.CuaRollUp;
  5683. BEGIN
  5684.      IF _CuaICBPresent THEN
  5685.      BEGIN
  5686.           IgnoreRedraw := TRUE;
  5687.           RollUp;
  5688.           IgnoreRedraw := FALSE;
  5689.           _CuaClearMark;
  5690.           InvalidateEditorWindow(1);
  5691.      END
  5692.      ELSE RollUp;
  5693. END;
  5694.  
  5695.  
  5696.  
  5697. PROCEDURE TEditorWindow.CuaRollDown;
  5698. BEGIN
  5699.      IF _CuaICBPresent THEN
  5700.      BEGIN
  5701.           IgnoreRedraw := TRUE;
  5702.           RollDown;
  5703.           IgnoreRedraw := FALSE;
  5704.           _CuaClearMark;
  5705.           InvalidateEditorWindow(1);
  5706.      END
  5707.      ELSE RollDown;
  5708. END;
  5709.  
  5710.  
  5711.  
  5712. PROCEDURE TEditorWindow.CuaTabulator;
  5713. BEGIN
  5714.      IF _CuaICBPresent THEN
  5715.      BEGIN
  5716.           IgnoreRedraw := TRUE;
  5717.           Tabulator;
  5718.           IgnoreRedraw := FALSE;
  5719.           _CuaClearMark;
  5720.           InvalidateEditorWindow(1);
  5721.      END
  5722.      ELSE Tabulator;
  5723. END;
  5724.  
  5725.  
  5726. PROCEDURE TEditorWindow.CuaCarriageReturn;
  5727. BEGIN
  5728.      IF _CuaICBPresent THEN
  5729.      BEGIN
  5730.           _CuaOverWriteBlock;
  5731.           IgnoreRedraw := TRUE;
  5732.           CarriageReturn;
  5733.           IgnoreRedraw := FALSE;
  5734.           InvalidateEditorWindow(1);
  5735.      END
  5736.      ELSE CarriageReturn;
  5737. END;
  5738.  
  5739.  
  5740.  
  5741. PROCEDURE TEditorWindow.CuaPasteFromClipBoard;
  5742. BEGIN
  5743.      IF _CuaICBPresent THEN
  5744.      BEGIN
  5745.           _CuaOverWriteBlock;
  5746.           IgnoreRedraw := TRUE;
  5747.           PasteFromClipBoard;
  5748.           IgnoreRedraw := FALSE;
  5749.           InvalidateEditorWindow(1);
  5750.      END
  5751.      ELSE PasteFromClipBoard;
  5752. END;
  5753.  
  5754.  
  5755.  
  5756. PROCEDURE TEditorWindow.CuaPasteFromFile(s:STRING);
  5757. BEGIN
  5758.      IF _CuaICBPresent THEN
  5759.      BEGIN
  5760.           _CuaOverWriteBlock;
  5761.           IgnoreRedraw := TRUE;
  5762.           PasteFromFile(s);
  5763.           IgnoreRedraw := FALSE;
  5764.           InvalidateEditorWindow(1);
  5765.      END
  5766.      ELSE PasteFromFile(s);
  5767. END;
  5768.  
  5769.  
  5770. { +++ Normal Keyboard-Events +++++++++++++++++++++++++++++++++++++++++++++++ }
  5771.  
  5772.  
  5773. PROCEDURE TEditorWindow.HandleCharEvent(Win:HWND;param,Rep:WORD);
  5774. VAR  P : BYTE;
  5775.      ch : CHAR;
  5776. BEGIN
  5777.      IF FindICB THEN
  5778.      BEGIN
  5779.           _ICBClearMark;
  5780.           ICB := OldICB;
  5781.           _ICBSetMark;
  5782.           InvalidateEditorWindow(1);
  5783.           FindICB := FALSE;
  5784.      END;
  5785.  
  5786.      IF IsWindowMinimized(HWindowFrame) THEN exit;
  5787.      ch := chr(Lo(param));
  5788.      IF PreCtrl > 0 THEN
  5789.      BEGIN
  5790.           param := ord(upcase(ch));
  5791.           HandleScanEvent(Win,param,Rep);
  5792.           exit;
  5793.      END;
  5794.      IF WinReadOnly THEN exit;
  5795.  
  5796.      IF (EditOptions AND EOD_UseCUA <> 0) AND _CuaICBPresent THEN
  5797.      BEGIN
  5798.           _CuaOverWriteBlock;
  5799.           InvalidateEditorWindow(1);
  5800.      END;
  5801.      IF (EditOptions AND EOD_InsertMode) <> 0 THEN
  5802.      BEGIN
  5803.           (*UNDO*)
  5804.           IF LastUndoGroup <> UG_InsertChar
  5805.           THEN _CopyUndoLines(ActLine,ActLine);
  5806.           LastUndoGroup := UG_InsertChar;
  5807.           (*UNDO*)
  5808.           IF NOT _InsertString(FileCursorX,ch) THEN beep(1000,10);
  5809.           P := _ICBPos(ActLine,FileCursorX);
  5810.           IF P AND POS_BEFOREICBFIRST <> 0 THEN inc(ICB.FirstX);
  5811.           IF P AND POS_BEFOREICBLAST <> 0 THEN inc(ICB.LastX);
  5812.           _CheckICB;
  5813.      END
  5814.      ELSE
  5815.      BEGIN
  5816.           (*UNDO*)
  5817.           IF LastUndoGroup <> UG_OverwriteChar
  5818.           THEN _CopyUndoLines(ActLine,ActLine);
  5819.           LastUndoGroup := UG_OverwriteChar;
  5820.           (*UNDO*)
  5821.           IF NOT _WriteString(FileCursorX,ch) THEN beep(1000,10);
  5822.      END;
  5823.  
  5824.      {Cursor Right}
  5825.      IF FileCursorX < StringLength THEN inc(FileCursorX);
  5826.      IF ScrCursorX < WinSizeX THEN
  5827.      BEGIN
  5828.           inc(ScrCursorX);
  5829.           InvalidateSingleLine;
  5830.      END
  5831.      ELSE
  5832.      BEGIN
  5833.           UpdateLineColorFlag(ActLine);
  5834.           InvalidateEditorWindow(1);
  5835.      END;
  5836. END;
  5837.  
  5838.  
  5839. { +++ special Keyboard-Events ++++++++++++++++++++++++++++++++++++++++++++++ }
  5840.  
  5841.  
  5842. PROCEDURE TEditorWindow.HandleScanEvent(Win:HWND;param,Rep:WORD);
  5843. VAR  Scan : LONGWORD;
  5844. LABEL l;
  5845. BEGIN
  5846.      IF FindICB THEN
  5847.      BEGIN
  5848.           _ICBClearMark;
  5849.           ICB := OldICB;
  5850.           _ICBSetMark;
  5851.           InvalidateEditorWindow(1);
  5852.           FindICB := FALSE;
  5853.      END;
  5854.  
  5855.      IF IsWindowMinimized(HWindowFrame) THEN
  5856.      BEGIN
  5857.           IF param IN [kbCR,kbEnter]
  5858.           THEN WinSetWindowPos(HWindowFrame,HWND_TOP,0,0,0,0,
  5859.                                SWP_RESTORE OR SWP_ACTIVATE OR SWP_SHOW);
  5860.           exit;
  5861.      END;
  5862.  
  5863.      Scan := PreCtrl OR param;
  5864.      IF (param <> kbCtrl) AND (param <> kbShift) THEN PreCtrl := 0;
  5865.  
  5866.      IF EditOptions AND EOD_UseCUA <> 0 THEN
  5867.      BEGIN
  5868.           CASE Scan OF
  5869.               kbCUp                 : CuaCursorUp(Rep);
  5870.               kbCDown               : CuaCursorDown(Rep);
  5871.               kbCLeft               : CuaCursorLeft;
  5872.               kbCRight              : CuaCursorRight;
  5873.               kbPageUp              : CuaPageUp;
  5874.               kbPageDown            : CuaPageDown;
  5875.               kbPos1                : CuaCursorPos1;
  5876.               kbEnd                 : CuaCursorEnd;
  5877.               kbCtrlCRight          : CuaWordRight;
  5878.               kbCtrlCLeft           : CuaWordLeft;
  5879.               kbCtrlPageUp          : CuaPageHome;
  5880.               kbCtrlPageDown        : CuaPageEnd;
  5881.               kbCtrlPos1            : CuaGotoBegin;
  5882.               kbCtrlEnd             : CuaGotoEnd;
  5883.  
  5884.               kbBS                  : CuaBackSpace;
  5885.               kbDel                 : CuaDeleteChar;
  5886.               kbTab                 : CuaTabulator;
  5887.               kbCR, kbEnter         : CuaCarriageReturn;
  5888.  
  5889.               kbCtrlS               : FindText(aSearchString,FRD_Forward);
  5890.               kbCtrlR               : ReplaceText(aSearchString,aReplaceString,
  5891.                                                   FRD_Forward);
  5892.               kbCtrlN               : SearchTextAgain;
  5893.  
  5894.               kbShiftInsert         : CuaPasteFromClipBoard;
  5895.               kbCtrlBS              : DeleteLine;
  5896.               kbCtrlF7              : ICBMoveLeft;
  5897.               kbCtrlF8              : ICBMoveRight;
  5898.               ELSE goto l;
  5899.           END;
  5900.      END
  5901.      ELSE
  5902.      BEGIN
  5903.           CASE Scan OF
  5904.               kbCUp, kbCtrlE        : CursorUp(Rep);
  5905.               kbCDown, kbCtrlX      : CursorDown(Rep);
  5906.               kbCLeft, kbCtrlS      : CursorLeft;
  5907.               kbCRight, kbCtrlD     : CursorRight;
  5908.               kbPageUp, kbCtrlR     : PageUp;
  5909.               kbPageDown, kbCtrlC   : PageDown;
  5910.               kbCtrlW               : RollUp;
  5911.               kbCtrlZ               : RollDown;
  5912.               kbPos1, kbCtrlQS      : CursorPos1;
  5913.               kbEnd, kbCtrlQD       : CursorEnd;
  5914.               kbCtrlCRight, kbCtrlF : WordRight;
  5915.               kbCtrlCLeft, kbCtrlA  : WordLeft;
  5916.               kbCtrlPageUp,kbCtrlQR : GotoBegin;
  5917.               kbCtrlPageDown,
  5918.               kbCtrlQC              : GotoEnd;
  5919.               kbCtrlPos1,kbCtrlQE   : PageHome;
  5920.               kbCtrlEnd,kbCtrlQX    : PageEnd;
  5921.  
  5922.               kbCtrlV       : ToggleInsertMode;
  5923.               kbCtrlOI      : EditOptions := EditOptions XOR EOD_AutoIndentMode;
  5924.               kbBS, kbCtrlH : BackSpace;
  5925.               kbDel,kbCtrlG : DeleteChar;
  5926.               kbtab,kbCtrlI : Tabulator;
  5927.               kbCR, kbEnter : CarriageReturn;
  5928.               kbCtrlY       : DeleteLine;
  5929.               kbCtrlN       : LineInsert;
  5930.               kbCtrlQY      : DeleteUntilEnd;
  5931.               kbCtrlT       : DeleteRightWord;
  5932.  
  5933.               kbCtrlQF      : FindText(aSearchString,FRD_Forward);
  5934.               kbCtrlQA      : ReplaceText(aSearchString,aReplaceString,
  5935.                                           FRD_Forward);
  5936.               kbCtrlL       : SearchTextAgain;
  5937.  
  5938.               kbCtrlKB      : ICBSetBegin;
  5939.               kbCtrlKK      : ICBSetEnd;
  5940.               kbCtrlKT      : ICBSelectWord;
  5941.               kbCtrlKL      : ICBSelectLine;
  5942.               kbCtrlQB      : ICBGotoBegin;
  5943.               kbCtrlQK      : ICBGotoEnd;
  5944.               kbCtrlKC      : ICBCopyBlock;
  5945.               kbCtrlKV      : ICBMoveBlock;
  5946.               kbCtrlKY      : ICBDeleteBlock;
  5947.               kbCtrlKR      : ICBReadBlock;
  5948.               kbCtrlKW      : ICBWriteBlock;
  5949.               kbCtrlKU      : ICBMoveLeft;
  5950.               kbCtrlKI      : ICBMoveRight;
  5951.               kbCtrlShiftPageUp  : ICBExtFileBegin;
  5952.               kbCtrlShiftPageDown: ICBExtFileEnd;
  5953.  
  5954.               kbCtrlKS      : SaveFile;
  5955.               kbCtrlKH      : ToggleICBVisibility;
  5956.               kbShiftInsert : PasteFromClipBoard;
  5957.               ELSE goto l;
  5958.           END;
  5959.      END;
  5960.      exit;
  5961. l:
  5962.      CASE Scan OF
  5963.          kbCtrlDel          : ICBDeleteBlock;
  5964.          kbCtrlInsert       : CopyToClipBoard;
  5965.          kbShiftDel         : CutToClipBoard;
  5966.  
  5967.          kbShiftCLeft       : ICBExtLeft;
  5968.          kbShiftCRight      : ICBExtRight;
  5969.          kbShiftCUp         : ICBExtUp;
  5970.          kbShiftCDown       : ICBExtDown;
  5971.          kbShiftPageUp      : ICBExtPageUp;
  5972.          kbShiftPageDown    : ICBExtPageDown;
  5973.          kbShiftPos1        : ICBExtPos1;
  5974.          kbShiftEnd         : ICBExtEnd;
  5975.          kbCtrlShiftCLeft   : ICBExtWordLeft;
  5976.          kbCtrlShiftCRight  : ICBExtWordRight;
  5977.          kbCtrlShiftPos1    : ICBExtFileBegin;
  5978.          kbCtrlShiftEnd     : ICBExtFileEnd;
  5979.  
  5980.          kbInsert           : ToggleInsertMode;
  5981.          kbF2               : SaveFile;
  5982.          kbAltBS            : Undo;
  5983.          kbShiftAltBS       : Redo;
  5984.  
  5985.          kbCtrlSlash        : ICBSelectAll;
  5986.          kbCtrlBackSlash    : ICBDeselectAll;
  5987.  
  5988.          kbCtrlK0..kbCtrlK9 : SetBookMark(Scan);
  5989.          kbCtrlQ0..kbCtrlQ9 : GotoBookMark(Scan);
  5990.          kbCtrlU0..kbCtrlU9 : DeleteBookMark(Scan);
  5991.          kbCtrlUU           : DeleteAllBookMarks;
  5992.  
  5993.          kbCtrlK            : PreCtrl := kbPreCtrlK;
  5994.          kbCtrlQ            : PreCtrl := kbPreCtrlQ;
  5995.          kbCtrlO            : PreCtrl := kbPreCtrlO;
  5996.          kbCtrlB            : PreCtrl := kbPreCtrlB;
  5997.          kbCtrlU            : PreCtrl := kbPreCtrlU;
  5998.      END;
  5999. END;
  6000.  
  6001.  
  6002. { +++ BookMark Events ++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  6003.  
  6004.  
  6005. FUNCTION TEditorWindow._FindBookMark(BM:WORD):PLine;
  6006. VAR  ptline : PLine;
  6007.      w : WORD;
  6008. BEGIN
  6009.      ptline := FirstLine;
  6010.      WHILE ptline <> NIL DO
  6011.      BEGIN
  6012.           w := ptline^.color AND Mask4MSB;  {mask 4 MSB}
  6013.           IF w = BM THEN
  6014.           BEGIN
  6015.                _FindBookMark := ptline;
  6016.                exit;
  6017.           END;
  6018.           ptline := ptline^.next;
  6019.      END;
  6020.      _FindBookMark := NIL;
  6021. END;
  6022.  
  6023.  
  6024. PROCEDURE TEditorWindow.GotoBookMark(Scan:LONGWORD);
  6025. VAR  ptline : PLine;
  6026.      BM,Nr : WORD;
  6027.      cy : LONGWORD;
  6028. BEGIN
  6029.      Nr := (Scan AND 255) - 47;
  6030.      BM := Nr * BM_0;
  6031.      ptline := _FindBookMark(BM);
  6032.      IF ptline = NIL THEN exit;
  6033.      cy := _PLine2Long(ptline);
  6034.      GotoLine(cy,BookMarkColumn[Nr]);
  6035. END;
  6036.  
  6037.  
  6038. PROCEDURE TEditorWindow.SetBookMark(Scan:LONGWORD);
  6039. VAR  ptline : PLine;
  6040.      BM,Nr : WORD;
  6041. BEGIN
  6042.      Nr := (Scan AND 255) - 47;
  6043.      BM := Nr * BM_0;
  6044.      ptline := _FindBookMark(BM);
  6045.      IF ptline <> NIL THEN ptline^.color := ptline^.color AND (BM_0 - 1);
  6046.      Actline^.color := Actline^.color AND (BM_0 - 1);
  6047.      ActLine^.color := ActLine^.color OR BM;
  6048.      IF Nr < 10 THEN BookMarkColumn[Nr] := FileCursorX;
  6049.      InvalidateEditorWindow(1);
  6050. END;
  6051.  
  6052.  
  6053. PROCEDURE TEditorWindow.DeleteBookMark(Scan:LONGWORD);
  6054. VAR  ptline : PLine;
  6055.      BM,Nr : WORD;
  6056. BEGIN
  6057.      Nr := (Scan AND 255) - 47;
  6058.      BM := Nr * BM_0;
  6059.      ptline := _FindBookMark(BM);
  6060.      IF ptline = NIL THEN exit;
  6061.      ptline^.color := ptline^.color AND (BM_0 - 1);
  6062.      InvalidateEditorWindow(1);
  6063. END;
  6064.  
  6065.  
  6066. PROCEDURE TEditorWindow.DeleteAllBookMarks;
  6067. VAR  ptline : PLine;
  6068. BEGIN
  6069.      ptline := FirstLine;
  6070.      WHILE ptline <> NIL DO
  6071.      BEGIN
  6072.           ptline^.color := ptline^.color AND (BM_0 - 1);
  6073.           ptline := ptline^.next;
  6074.      END;
  6075.      InvalidateEditorWindow(1);
  6076. END;
  6077.  
  6078.  
  6079. { +++ Mouse-Events +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  6080.  
  6081.  
  6082. PROCEDURE GetPosFromMaus(pt:POINTS; WinRect:RECTL; VAR ret:POINTS);
  6083. BEGIN
  6084.      pt.x := pt.x DIV CharWidth;
  6085.      pt.y := (WinRect.yTop - pt.y - CharBaseLine) DIV CharHeight;
  6086.      inc(pt.x);
  6087.      inc(pt.y);
  6088.      ret := pt;
  6089. END;
  6090.  
  6091.  
  6092.  
  6093. PROCEDURE TEditorWindow.SetEditorPtr(id,res:LONGWORD);
  6094. VAR  Ptr:LONGWORD;
  6095. BEGIN
  6096.      Ptr:=WinLoadPointer(HWND_DESKTOP,res,id);
  6097.      IF Ptr<>0 THEN NewEditorPtr:=Ptr;
  6098. END;
  6099.  
  6100.  
  6101.  
  6102. PROCEDURE TEditorWindow.WMSetFocus(VAR Msg:TMessage); {Set Input focus}
  6103. VAR  r : LONGWORD;
  6104.      SRE : WORD;
  6105. BEGIN
  6106.      IF (EditOptions AND EOD_InsertMode) <> 0 THEN r := 2
  6107.      ELSE r := CharHeight;
  6108.      IF Msg.Param2 <> 0 THEN {Window is becoming focus}
  6109.      BEGIN
  6110.           WinCreateCursor(Msg.Receiver,40,40,CharWidth,r,4,NIL);
  6111.           WinStartTimer(HInstance,HWindow,TID_CURSOR,CursorRate);
  6112.           WinShowCursor(Msg.Receiver,TRUE);
  6113.           SRE := RedoEvents;
  6114.           SetCursorXY;
  6115.           RedoEvents := SRE;
  6116.           _CheckICB;
  6117.           IF WinOpenClipBrd(AppHandle) THEN
  6118.           BEGIN
  6119.                IF WinQueryClipBrdData(AppHandle,CF_TEXT) = 0
  6120.                THEN DisablePaste
  6121.                ELSE EnablePaste;
  6122.                WinCloseClipBrd(AppHandle);
  6123.           END
  6124.           ELSE DisablePaste;
  6125.           IF UndoEvents = 0 THEN DisableUndo
  6126.           ELSE EnableUndo;
  6127.           IF RedoEvents = 0 THEN DisableRedo
  6128.           ELSE EnableRedo;
  6129.           PreCtrl := 0;
  6130.      END
  6131.      ELSE {Window is loosing focus}
  6132.      BEGIN
  6133.           WinDestroyCursor(Msg.Receiver);
  6134.      END;
  6135.      Msg.Handled:=TRUE;
  6136.      Msg.result:=0;
  6137. END;
  6138.  
  6139.  
  6140.  
  6141. PROCEDURE TEditorWindow.WMButton1DBLCLK(VAR Msg:TMessage);
  6142. BEGIN
  6143.      ICBSelectLine;
  6144. END;
  6145.  
  6146.  
  6147.  
  6148. PROCEDURE TEditorWindow.WMMouseMove(VAR Msg:TMessage);
  6149. BEGIN
  6150.      Inherited.WMMouseMove(Msg);
  6151.      IF NewEditorPtr <> 0 THEN WinSetPointer(HWND_DESKTOP,NewEditorPtr);
  6152.      Msg.Handled := TRUE;
  6153.      Msg.result := 0;
  6154. END;
  6155.  
  6156.  
  6157.  
  6158. PROCEDURE TEditorWindow.WMButton1Down(VAR Msg:TMessage);
  6159. VAR  pt : POINTS;
  6160.      lpt : POINTS;
  6161.      t : WORD;
  6162.      FCX : WORD;
  6163. BEGIN
  6164.      Inherited.WMButton1Down(Msg);
  6165.      Capture(FALSE);
  6166.      IF WinQueryFocus(HWND_DESKTOP) <> HWindow THEN
  6167.      BEGIN
  6168.           WindowToTop;
  6169.           Focus;
  6170.           Enable;
  6171.           WindowGetFocus := TRUE;
  6172.           exit;
  6173.      END
  6174.      ELSE WindowGetFocus := FALSE;
  6175.  
  6176.      FindICB := FALSE;
  6177.  
  6178.      (*UNDO*)
  6179.      IF LastUndoGroup <> UG_CursorMove THEN _StoreUndoCursor;
  6180.      LastUndoGroup := UG_CursorMove;
  6181.      (*UNDO*)
  6182.  
  6183.      IF WLactivated THEN _WriteWorkLine;
  6184.      pt := POINTS(Msg.Param1);
  6185.      GetPosFromMaus(pt,WindowRect,lpt);
  6186.  
  6187.      IF lpt.x < 1 THEN lpt.x := 1;
  6188.      IF lpt.x > WinSizeX THEN lpt.x := WinSizeX;
  6189.      IF lpt.y < 1 then lpt.y := 1;
  6190.      IF lpt.y > WinSizeY THEN lpt.y := WinSizeY;
  6191.  
  6192.      IF lpt.x > ScrCursorX THEN inc(FileCursorX,lpt.x-ScrCursorX)
  6193.      ELSE dec(FileCursorX,ScrCursorX-lpt.x);
  6194.      ScrCursorX := lpt.x;
  6195.  
  6196.      IF (FileCursorY+lpt.y)-ScrCursorY > CountLines THEN
  6197.         lpt.y := Countlines-FileCursorY+ScrCursorY;
  6198.  
  6199.      IF lpt.y > ScrCursorY THEN
  6200.      BEGIN
  6201.          inc(FileCursorY,lpt.y-ScrCursorY);
  6202.          FOR t := 1 TO lpt.y-ScrCursorY DO Actline := ActLine^.Next;
  6203.          ScrCursorY := lpt.y;
  6204.      END
  6205.      ELSE
  6206.      BEGIN
  6207.           dec(FileCursorY,ScrCursorY-lpt.y);
  6208.           FOR t := 1 TO ScrCursorY-lpt.y DO Actline := ActLine^.Prev;
  6209.           ScrCursorY := lpt.y;
  6210.      END;
  6211.      Enable;
  6212.      Focus;
  6213.      SetCursorXY;
  6214.  
  6215.      _ICBExtSetICB;
  6216.      _ICBSetMark;
  6217.  
  6218.      IF Length(ActLine^.zk^) < FileCursorX
  6219.      THEN FCX := Length(ActLine^.zk^)+1
  6220.      ELSE FCX := FileCursorX;
  6221.      IF FCX > StringLength THEN FCX := StringLength;
  6222.  
  6223.      IF (ActLine = ICB.LastLine) AND (FCX = ICB.LastX) THEN
  6224.      BEGIN
  6225.           DragStaticY := _PLine2Long(ICB.FirstLine);
  6226.           DragStaticX := ICB.FirstX;
  6227.           DragStaticLine := ICB.FirstLine;
  6228.      END
  6229.      ELSE
  6230.      BEGIN
  6231.           DragStaticY := _PLine2Long(ICB.LastLine);
  6232.           DragStaticX := ICB.LastX;
  6233.           DragStaticLine := ICB.LastLine;
  6234.      END;
  6235.  
  6236.      WinShowCursor(HWindow,FALSE);
  6237.      Msg.Handled := TRUE;
  6238.      Msg.result := 0;
  6239. END;
  6240.  
  6241.  
  6242.  
  6243. PROCEDURE TEditorWindow.WMButton1Up(VAR Msg:TMessage);
  6244. BEGIN
  6245.      Inherited.WMButton1Up(Msg);
  6246.      Capture(TRUE);
  6247.      IF NOT WindowGetFocus THEN
  6248.      BEGIN
  6249.           _CheckICB;
  6250.           WinShowCursor(HWindow,TRUE);
  6251.      END;
  6252.      WindowGetFocus := FALSE;
  6253.      Msg.Handled := TRUE;
  6254.      Msg.result := 0;
  6255. END;
  6256.  
  6257.  
  6258.  
  6259. PROCEDURE TEditorWindow.WMMouseDrag1(VAR Msg:TMessage);
  6260. VAR  pt : POINTS;
  6261.      lpt : POINTS;
  6262.      newY : LONGINT;
  6263.      newX : INTEGER;
  6264.      von,bis,cl,i : INTEGER;
  6265.      ptline : PLine;
  6266.  
  6267. FUNCTION BeforeDragStatic:BOOLEAN;
  6268. BEGIN
  6269.      BeforeDragStatic := FALSE;
  6270.      IF newY > DragStaticY THEN exit;
  6271.      IF newY = DragStaticY THEN
  6272.        IF newX >= DragStaticX THEN exit;
  6273.      BeforeDragStatic := TRUE;
  6274. END;
  6275.  
  6276. BEGIN
  6277.      IF WindowGetFocus THEN exit;
  6278.      Capture(FALSE); {!!}
  6279.  
  6280.      pt := POINTS(Msg.Param1);
  6281.      GetPosFromMaus(pt,WindowRect,lpt);
  6282.  
  6283.      IF lpt.x < 1 THEN
  6284.      BEGIN
  6285.           dec(FileCursorX,ScrCursorX - 1);
  6286.           ScrCursorX := 1;
  6287.           IF FileCursorX <= 1 THEN newX := 1
  6288.           ELSE newX := FileCursorX - 1;
  6289.      END;
  6290.  
  6291.      IF lpt.x > WinSizeX THEN
  6292.      BEGIN
  6293.           inc(FileCursorX,WinSizeX - ScrCursorX);
  6294.           ScrCursorX := WinSizeX;
  6295.           IF FileCursorX >= StringLength THEN newX := StringLength
  6296.           ELSE newX := FileCursorX + 1;
  6297.      END;
  6298.  
  6299.      IF (lpt.x >= 1) AND (lpt.x <= WinSizeX) THEN
  6300.      BEGIN
  6301.           FileCursorX := FileCursorX - ScrCursorX + lpt.x;
  6302.           ScrCursorX := lpt.x;
  6303.           newX := FileCursorX;
  6304.      END;
  6305.  
  6306.  
  6307.      cl := abs(lpt.y - ScrCursorY);
  6308.      IF cl >= WinSizeY THEN cl := WinSizeY-1;
  6309.  
  6310.      newY := FileCursorY;
  6311.  
  6312.      IF lpt.y > ScrCursorY THEN
  6313.      BEGIN
  6314.           IF FileCursorY + cl > CountLines
  6315.           THEN cl := CountLines - FileCursorY;
  6316.           newY := FileCursorY + cl;
  6317.           von := ScrCursorY;
  6318.           bis := ScrCursorY + cl;
  6319.           IF bis > WinSizeY THEN bis := WinSizeY;
  6320.      END;
  6321.  
  6322.      IF lpt.y < ScrCursorY THEN
  6323.      BEGIN
  6324.           IF FileCursorY < 1 + cl
  6325.           THEN cl := FileCursorY - 1;
  6326.           newY := FileCursorY - cl;
  6327.           von := ScrCursorY - cl;
  6328.           IF von < 1 THEN von := 1;
  6329.           bis := ScrCursorY;
  6330.      END;
  6331.  
  6332.  
  6333.      _ICBClearMark;
  6334.      IF BeforeDragStatic THEN
  6335.      BEGIN
  6336.           ICB.FirstLine := _Long2PLine(newY);
  6337.           ICB.FirstX := newX;
  6338.           ICB.LastLine := DragStaticLine;
  6339.           ICB.LastX := DragStaticX;
  6340.      END
  6341.      ELSE
  6342.      BEGIN
  6343.           ICB.FirstLine := DragStaticLine;
  6344.           ICB.FirstX := DragStaticX;
  6345.           ICB.LastLine := _Long2PLine(newY);
  6346.           ICB.LastX := newX;
  6347.      END;
  6348.  
  6349.      IF Length(ICB.FirstLine^.zk^) < ICB.FirstX
  6350.      THEN ICB.FirstX := Length(ICB.FirstLine^.zk^)+1;
  6351.      IF Length(ICB.LastLine^.zk^) < ICB.LastX
  6352.      THEN ICB.LastX := Length(ICB.LastLine^.zk^)+1;
  6353.      _ICBSetMark;
  6354.  
  6355.  
  6356.      IF lpt.x < 1 THEN CursorLeft
  6357.      ELSE IF lpt.x > WinSizeX THEN CursorRight
  6358.           ELSE InvalidateSingleLine;
  6359.  
  6360.  
  6361.      ptline := ActLine;
  6362.      IF lpt.y > ScrCursorY THEN
  6363.      BEGIN
  6364.           FOR i := von TO bis DO
  6365.           BEGIN
  6366.                InvalidateEditorLine(ptline,i);
  6367.                ptline := ptline^.next;
  6368.           END;
  6369.           CursorDown(cl);
  6370.      END
  6371.      ELSE
  6372.      IF lpt.y < ScrCursorY THEN
  6373.      BEGIN
  6374.           FOR i := bis DOWNTO von DO
  6375.           BEGIN
  6376.                InvalidateEditorLine(ptline,i);
  6377.                ptline := ptline^.prev;
  6378.           END;
  6379.           CursorUp(cl);
  6380.      END;
  6381.  
  6382.      Msg.Handled := TRUE;
  6383.      Msg.result := 0;
  6384. END;
  6385.  
  6386.  
  6387. { +++ Scrollbar-Events +++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  6388.  
  6389.  
  6390. PROCEDURE TEditorWindow.SetSliderValues;
  6391. VAR  ww1,ww2:WORD;
  6392.      p:LONGWORD;
  6393.      ScrollWin,FrameWin:HWND;
  6394. BEGIN
  6395.      FrameWin:=WinQueryWindow(HWindow,QW_PARENT);
  6396.  
  6397.      {init horicontal ScrollWindow}
  6398.      ScrollWin:=WinWindowFromID(FrameWin,FID_HORZSCROLL);
  6399.      HSlider.scrollbottom:=1;
  6400.      HSlider.scrolltop:=StringLength;
  6401.      HSlider.viewarea:=WinSizeX;
  6402.  
  6403.      {define horizontal Scroll intervall}
  6404.      ww1:=HSlider.scrollbottom;
  6405.      ww2:=(HSlider.scrolltop-HSlider.scrollbottom)-HSlider.viewarea+2;
  6406.      p:=MPFROM2SHORT(ww1,ww2);
  6407.      WinSendMsg(ScrollWin,SBM_SETSCROLLBAR,1,p);
  6408.  
  6409.      {Set horizontal slider size}
  6410.      ww1:=HSlider.viewarea;
  6411.      ww2:=HSlider.scrolltop-HSlider.scrollbottom+1;
  6412.      p:=MPFROM2SHORT(ww1,ww2);
  6413.      WinSendmsg(ScrollWin,SBM_SETTHUMBSIZE,p,0);
  6414.  
  6415.      {init vertical ScrollWindow}
  6416.      ScrollWin:=WinWindowFromID(FrameWin,FID_VERTSCROLL);
  6417.      VSlider.scrollbottom:=1;
  6418.      VSlider.scrolltop:=CountLines;
  6419.      VSlider.viewarea:=WinSizeY;
  6420.  
  6421.      {define vertical Scroll intervall}
  6422.      ww1:=VSlider.scrollbottom;
  6423.      ww2:=(VSlider.scrolltop-VSlider.scrollbottom)-VSlider.viewarea+2;
  6424.      p:=MPFROM2SHORT(ww1,ww2);
  6425.      WinSendMsg(ScrollWin,SBM_SETSCROLLBAR,1,p);
  6426.  
  6427.      {Set vertical slider size}
  6428.      ww1:=VSlider.viewarea;
  6429.      ww2:=VSlider.scrolltop-VSlider.scrollbottom+1;
  6430.      p:=MPFROM2SHORT(ww1,ww2);
  6431.      WinSendmsg(ScrollWin,SBM_SETTHUMBSIZE,p,0);
  6432.  
  6433.      SetSliderPosition;
  6434. END;
  6435.  
  6436.  
  6437.  
  6438. PROCEDURE TEditorWindow.SetSliderPosition;
  6439. VAR  ScrollWin : HWND;
  6440.      FrameWin : HWND;
  6441.      w : WORD;
  6442.      p : ULONG;
  6443. BEGIN
  6444.      HSlider.acvalue := FileCursorX-ScrCursorX+1;
  6445.      VSlider.acvalue := FileCursorY-ScrCursorY+1;
  6446.      FrameWin:=WinQueryWindow(HWindow,QW_PARENT);
  6447.  
  6448.      ScrollWin:=WinWindowFromID(FrameWin,FID_HORZSCROLL);
  6449.      w:=HSlider.acvalue;
  6450.      p:=MPFROMSHORT(w);
  6451.      WinSendMsg(ScrollWin,SBM_SETPOS,p,0);
  6452.  
  6453.      ScrollWin:=WinWindowFromID(FrameWin,FID_VERTSCROLL);
  6454.      w:=VSlider.acvalue;
  6455.      p:=MPFROMSHORT(w);
  6456.      WinSendMsg(ScrollWin,SBM_SETPOS,p,0);
  6457. END;
  6458.  
  6459.  
  6460.  
  6461. PROCEDURE TEditorWindow.WMHScroll(VAR Msg:TMessage);
  6462. VAR  w : Word;
  6463.      l : LONGWORD;
  6464.      ScrollWin : HWND;
  6465.      FrameWin : HWND;
  6466.      SliderID : LONGWORD;
  6467.      Win : HWND;
  6468.      acval : WORD;
  6469. BEGIN
  6470.      (*UNDO*)
  6471.      IF LastUndoGroup <> UG_CursorMove THEN _StoreUndoCursor;
  6472.      LastUndoGroup := UG_CursorMove;
  6473.      (*UNDO*)
  6474.      Msg.Handled:=TRUE;
  6475.      Msg.Result:=0;
  6476.      Win:=Msg.Receiver;
  6477.  
  6478.      l:=Msg.param2;
  6479.      SliderID:=Msg.param1;
  6480.      SliderID:=Lo(SliderID);
  6481.      w:=hi(l);
  6482.      FrameWin:=WinQueryWindow(Win,QW_PARENT);
  6483.      ScrollWin:=WinWindowFromID(FrameWin,SliderID);
  6484.      CASE w OF
  6485.          SB_LINELEFT:
  6486.          BEGIN
  6487.               IF HSlider.acvalue > 1 THEN
  6488.               BEGIN
  6489.                    dec(FileCursorX);
  6490.                    IF EditOptions AND EOD_UseCUA <> 0 THEN _CuaClearMark;
  6491.                    InvalidateEditorWindow(1);
  6492.               END;
  6493.          END;
  6494.          SB_LINERIGHT:
  6495.          BEGIN
  6496.               IF HSlider.acvalue+WinSizeX <= StringLength THEN
  6497.               BEGIN
  6498.                    inc(FileCursorX);
  6499.                    IF EditOptions AND EOD_UseCUA <> 0 THEN _CuaClearMark;
  6500.                    InvalidateEditorWindow(1);
  6501.               END;
  6502.          END;
  6503.          SB_PAGELEFT:
  6504.          BEGIN
  6505.               IF HSlider.acvalue > WinSizeX THEN
  6506.               BEGIN
  6507.                    dec(FileCursorX,WinSizeX);
  6508.                    IF EditOptions AND EOD_UseCUA <> 0 THEN _CuaClearMark;
  6509.                    InvalidateEditorWindow(1);
  6510.               END
  6511.               ELSE
  6512.               BEGIN
  6513.                    dec(FileCursorX,HSlider.acvalue-1);
  6514.                    IF EditOptions AND EOD_UseCUA <> 0 THEN _CuaClearMark;
  6515.                    InvalidateEditorWindow(1);
  6516.               END;
  6517.          END;
  6518.          SB_PAGERIGHT:
  6519.          BEGIN
  6520.               IF HSlider.acvalue+WinSizeX+WinSizeX <= StringLength THEN
  6521.               BEGIN
  6522.                    inc(FileCursorX,WinSizeX);
  6523.                    IF EditOptions AND EOD_UseCUA <> 0 THEN _CuaClearMark;
  6524.                    InvalidateEditorWindow(1);
  6525.               END
  6526.               ELSE
  6527.               BEGIN
  6528.                    FileCursorX := StringLength-(WinSizeX-ScrCursorX);
  6529.                    IF EditOptions AND EOD_UseCUA <> 0 THEN _CuaClearMark;
  6530.                    InvalidateEditorWindow(1);
  6531.               END;
  6532.          END;
  6533.          SB_SLIDERTRACK,SB_SLIDERPOSITION:
  6534.          BEGIN
  6535.               acval := lo(l);
  6536.               IF acval=HSlider.acvalue THEN exit;
  6537.  
  6538.               IF acval > HSlider.acvalue THEN
  6539.               BEGIN  {to the right}
  6540.                    dec(acval,HSlider.acvalue);
  6541.                    inc(FileCursorX,acval);
  6542.               END
  6543.               ELSE
  6544.               BEGIN {to the left}
  6545.                    acval:=HSlider.acvalue-acval;
  6546.                    dec(FileCursorX,acval);
  6547.               END;
  6548.               IF EditOptions AND EOD_UseCUA <> 0 THEN _CuaClearMark;
  6549.               InvalidateEditorWindow(1);
  6550.          END;
  6551.          ELSE exit;
  6552.      END; {Case}
  6553. END;
  6554.  
  6555.  
  6556.  
  6557. PROCEDURE TEditorWindow.WMVScroll(VAR Msg:TMessage);
  6558. VAR  w : Word;
  6559.      l : LONGWORD;
  6560.      ScrollWin : HWND;
  6561.      FrameWin : HWND;
  6562.      SliderID : LONGWORD;
  6563.      acval : WORD;
  6564.      Win : HWND;
  6565. BEGIN
  6566.      IF WLactivated THEN _WriteWorkLine;
  6567.      (*UNDO*)
  6568.      IF LastUndoGroup <> UG_CursorMove THEN _StoreUndoCursor;
  6569.      LastUndoGroup := UG_CursorMove;
  6570.      (*UNDO*)
  6571.      Msg.Handled:=TRUE;
  6572.      Msg.result:=0;
  6573.      Win:=Msg.receiver;
  6574.  
  6575.      l:=msg.param2;
  6576.      SliderID:=msg.param1;
  6577.      SliderID:=lo(SliderID);
  6578.      w:=hi(l);
  6579.      FrameWin:=WinQueryWindow(Win,QW_PARENT);
  6580.      ScrollWin:=WinWindowFromID(FrameWin,SliderID);
  6581.  
  6582.      CASE w OF
  6583.          SB_LINEUP:
  6584.          BEGIN
  6585.               IF EditOptions AND EOD_UseCUA <> 0 THEN CuaRollUp
  6586.               ELSE RollUp;
  6587.          END;
  6588.          SB_LINEDOWN:
  6589.          BEGIN
  6590.               IF EditOptions AND EOD_UseCUA <> 0 THEN CuaRollDown
  6591.               ELSE RollDown;
  6592.          END;
  6593.          SB_PAGEUP:
  6594.          BEGIN
  6595.               IF EditOptions AND EOD_UseCUA <> 0 THEN CuaPageUp
  6596.               ELSE PageUp;
  6597.          END;
  6598.          SB_PAGEDOWN:
  6599.          BEGIN
  6600.               IF EditOptions AND EOD_UseCUA <> 0 THEN CuaPageDown
  6601.               ELSE PageDown;
  6602.          END;
  6603.          SB_SLIDERTRACK,SB_SLIDERPOSITION:
  6604.          BEGIN
  6605.               acval := lo(l);
  6606.               IF acval=VSlider.acvalue THEN exit;
  6607.  
  6608.               IF acval>VSlider.acvalue THEN  {downward}
  6609.               BEGIN
  6610.                    dec(acval,VSlider.acvalue);
  6611.                    FOR l:=1 TO acval DO
  6612.                    BEGIN
  6613.                          IF ActLine^.Next<>NIL THEN
  6614.                          BEGIN
  6615.                               inc(FileCursorY);
  6616.                               ActLine:=ActLine^.Next;
  6617.                               FirstScreenLine:=FirstScreenLine^.Next;
  6618.                          END;
  6619.                    END;
  6620.               END
  6621.               ELSE
  6622.               BEGIN   {upward}
  6623.                    acval:=VSlider.acvalue-acval;
  6624.                    FOR l:=1 TO acval DO
  6625.                    BEGIN
  6626.                          IF FirstScreenLine^.Prev<>NIL THEN
  6627.                          BEGIN
  6628.                               dec(FileCursorY);
  6629.                               ActLine:=ActLine^.Prev;
  6630.                               FirstScreenLine:=FirstScreenLine^.Prev;
  6631.                          END;
  6632.                    END;
  6633.               END;
  6634.               IF EditOptions AND EOD_UseCUA <> 0 THEN _CuaClearMark;
  6635.               InvalidateEditorWindow(1);
  6636.          END;
  6637.      END; {Case}
  6638. END;
  6639.  
  6640.  
  6641. {*** Printing **************************************************************}
  6642.  
  6643.  
  6644. FUNCTION TEditorWindow.GetPrinterDevice(VAR dopPrinter:DEVOPENSTRUC):BOOLEAN;
  6645. VAR  ppuffer : PPRQINFO3;
  6646.      LengthInByte : LONGWORD;
  6647.      pspool : PPRQINFO3;
  6648.      szTemp : CSTRING;
  6649.      pszApp : CSTRING;
  6650.      pszKey : CSTRING;
  6651.      pszDefault : CSTRING;
  6652.      szPrinter : CSTRING;
  6653.      lSize : LONGWORD;
  6654.      s : STRING;
  6655.      p : BYTE;
  6656. BEGIN
  6657.      GetPrinterDevice := FALSE;
  6658.  
  6659.      {Query the default printer}
  6660.      pszApp := 'PM_SPOOLER';
  6661.      pszKey := 'QUEUE';
  6662.      pszDefault := '';
  6663.      IF PrfQueryProfileString(HINI_PROFILE,
  6664.                               pszApp,pszKey,pszDefault,szTemp,255) = 0 THEN
  6665.      BEGIN
  6666.           SetErrorMessage(MB_ICONHAND, NLSTable[1],NLSTable[20]);
  6667.           exit;
  6668.      END;
  6669.  
  6670.      {Remove Semicolon}
  6671.      s := szTemp;
  6672.      p := pos(';',s);
  6673.      IF p <> 0 THEN
  6674.      BEGIN
  6675.           s[p] := #0;
  6676.           s[0] := chr(p-1);
  6677.      END;
  6678.      szTemp := s;
  6679.  
  6680.      SplQueryQueue(NIL,szTemp,3,NIL,0,LengthInByte);
  6681.      IF LengthInByte = 0 THEN
  6682.      BEGIN
  6683.           SetErrorMessage(MB_ICONHAND, NLSTable[1],NLSTable[21]);
  6684.           exit;
  6685.      END;
  6686.  
  6687.      GetMem(ppuffer,LengthInByte);
  6688.      SplQueryQueue(NIL,szTemp,3,ppuffer^,LengthInByte,LengthInByte);
  6689.  
  6690.      pspool := PPRQINFO3(ppuffer);
  6691.      IF pspool = NIL THEN
  6692.      BEGIN
  6693.           SetErrorMessage(MB_ICONHAND, NLSTable[1],NLSTable[21]);
  6694.           exit;
  6695.      END;
  6696.  
  6697.      {Fill Structure with SpoolerInfo}
  6698.      s := pspool^.pszDriverName^;
  6699.      p := pos('.',s);
  6700.      IF p <> 0 THEN
  6701.      BEGIN
  6702.           s[p] := #0;
  6703.           s[0] := chr(p-1);
  6704.      END;
  6705.      szDriverName := s;
  6706.      szLogAddress := pspool^.pszName^;
  6707.      szDeviceName := pspool^.pDriverData^.szDeviceName;
  6708.      szPrinter    := pspool^.pszPrinters^;
  6709.      szDataType   := 'PM_Q_STD';
  6710.  
  6711.      lSize := DevPostDeviceModes(HInstance,
  6712.                                  NIL,
  6713.                                  szDriverName,
  6714.                                  szDeviceName,
  6715.                                  szPrinter,
  6716.                                  DPDM_POSTJOBPROP);
  6717.  
  6718.      GetMem(dopPrinter.pDriv,lSize);
  6719.  
  6720.      move(pspool^.pDriverData^, dopPrinter.pDriv^, pspool^.pDriverData^.cb);
  6721.      dopPrinter.pszDriverName := @szDriverName;
  6722.      dopPrinter.pszLogAddress := @szLogAddress;
  6723.      dopPrinter.pszDataType := @szDataType;
  6724.  
  6725.      FreeMem(ppuffer,LengthInByte);
  6726.  
  6727.      GetPrinterDevice := TRUE;
  6728. END;
  6729.  
  6730.  
  6731.  
  6732. PROCEDURE Printing(pPI:PPrintInfo);CDECL;
  6733. VAR  pkt : POINTL;
  6734.      s : STRING;
  6735.      P : POINTER;
  6736.      Len : LONGWORD;
  6737. BEGIN
  6738.      DevEscape(pPI^.PrinterDC, DEVESC_STARTDOC, 0, NIL, NIL, NIL);
  6739.      pkt.x := pPI^.OffsX;
  6740.      pkt.y := pPI^.OffsFL;
  6741.      P := pPI^.Text;
  6742.      Len := pPI^.TextLen;
  6743.  
  6744.      WHILE Len > 0 DO
  6745.      BEGIN
  6746.           dec(pkt.y, pPI^.PRN_LineDist);
  6747.           IF pkt.y < pPI^.OffsY THEN
  6748.           BEGIN
  6749.                pkt.y := pPI^.OffsFL - pPI^.PRN_LineDist;
  6750.                DevEscape(pPI^.PrinterDC, DEVESC_NEWFRAME, 0, NIL, NIL, NIL);
  6751.           END;
  6752.           ASM
  6753.              CLD
  6754.              LEA EDI,$s
  6755.              MOV ESI,$P
  6756.              INC EDI
  6757.              XOR ECX,ECX
  6758. !pr1:
  6759.              CMPD $Len,0
  6760.              JE !pr6
  6761.              LODSB
  6762.              DECD $Len
  6763.              CMP AL,13
  6764.              JE !pr3
  6765.              STOSB
  6766.              INC ECX
  6767.              JMP !pr1
  6768. !pr3:
  6769.              LODSB
  6770.              DECD $Len
  6771. !pr6:
  6772.              MOV $P,ESI
  6773.              MOVB [EDI],0     // terminal 0
  6774.              MOV $s,CL
  6775.           END;
  6776.           IF Length(s) > 0
  6777.           THEN GpiCharStringAt(pPI^.PrinterPS, pkt, Length(s), s[1]);
  6778.      END;
  6779.      DevEscape(pPI^.PrinterDC, DEVESC_ENDDOC, 0, NIL, NIL, NIL);
  6780.  
  6781.      DosEnterCritSec;
  6782.      IF pPI^.Status = 1 THEN      {Job is active}
  6783.      BEGIN
  6784.           pPI^.Status := 2;       {Job Killing initiated}
  6785.           DosExitCritSec;
  6786.           GpiAssociate(pPI^.PrinterPS,0);
  6787.           GpiDestroyPS(pPI^.PrinterPS);
  6788.           DevCloseDC(pPI^.PrinterDC);
  6789.           FreeMem(pPI^.Text,pPI^.TextLen);
  6790.           IF pPI^.AbortHwnd <> 0 THEN WinPostMsg(pPI^.AbortHwnd,WM_DISMISS,0,0);
  6791.           pPI^.Status := 0;       {Job finished}
  6792.      END
  6793.      ELSE DosExitCritSec;
  6794. END;
  6795.  
  6796.  
  6797.  
  6798. PROCEDURE TEditorWindow.PrintFile;
  6799. CONST g : SIZEL = (cx:0; cy:0);
  6800. VAR  dopPrinter : DEVOPENSTRUC;
  6801.      InfoDC : HDC;
  6802.      InfoPS : HPS;
  6803.      PrinterDC : HDC;
  6804.      PrinterPS : HPS;
  6805.      ptl : POINTL;
  6806.      ptlRes : POINTL;
  6807.      lSizeHC : LONGWORD;
  6808.      pHCInfo : ^HCINFO;
  6809.      pHCI : ^HCINFO;
  6810.      physPageSize : SIZEL;
  6811.      PrintArea : SIZEL;
  6812.      PrintOffset : SIZEL;
  6813.      Len : LONGWORD;
  6814.      i : WORD;
  6815. BEGIN
  6816.      IF WLactivated THEN _WriteWorkLine;
  6817.      IF PrintInfo.Status <> 0 THEN exit;
  6818.      PrintInfo.PRN_LeftIndent := 100;
  6819.      PrintInfo.PRN_UpperIndent := 100;
  6820.      PrintInfo.PRN_LowerIndent := 150;
  6821.      PrintInfo.PRN_LineDist := 45;
  6822.      {Get Printer Device Open Structure}
  6823.      FillChar(dopPrinter,SizeOf(dopPrinter),0);
  6824.      IF NOT GetPrinterDevice(dopPrinter) THEN exit; {Canceled or Error}
  6825.  
  6826.      {Open Info DC}
  6827.      InfoDC := DevOpenDC(HInstance, OD_INFO, '*', 4, dopPrinter, 0);
  6828.      IF InfoDC = 0 THEN
  6829.      BEGIN
  6830.           SetErrorMessage(MB_ICONHAND, NLSTable[1],NLSTable[22]);
  6831.           exit;
  6832.      END;
  6833.      InfoPS := GpiCreatePS(HInstance, InfoDC, g,
  6834.                             PU_LOMETRIC OR GPIT_MICRO OR GPIA_ASSOC);
  6835.      IF InfoPS = 0 THEN
  6836.      BEGIN
  6837.           SetErrorMessage(MB_ICONHAND, NLSTable[1],NLSTable[23]);
  6838.           exit;
  6839.      END;
  6840.  
  6841.      GpiQueryPS(InfoPS,PrintArea);
  6842.  
  6843.      lSizeHC := DevQueryHardcopyCaps(InfoDC,0,0,NIL);
  6844.      IF lSizeHC = 0 THEN
  6845.      BEGIN
  6846.           SetErrorMessage(MB_ICONHAND, NLSTable[1],NLSTable[24]);
  6847.           exit;
  6848.      END;
  6849.  
  6850.      GetMem(pHCInfo,lSizeHC*SizeOf(HCINFO));
  6851.      DevQueryHardcopyCaps(InfoDC,0,lSizeHC,pHCInfo^);
  6852.  
  6853.      pHCI := pHCInfo;
  6854.      FOR i := 0 TO lSizeHC-1 DO
  6855.      BEGIN
  6856.           IF pHCI^.flAttributes AND HCAPS_CURRENT <> 0 THEN
  6857.           BEGIN
  6858.                /* Get Resolution */
  6859.                DevQueryCaps (InfoDC,CAPS_HORIZONTAL_RESOLUTION,1,ptlRes.x);
  6860.                DevQueryCaps (InfoDC,CAPS_VERTICAL_RESOLUTION,1,ptlRes.y);
  6861.  
  6862.                /* Calculate the physical page size */
  6863.                physPageSize.cx := round((ptlRes.x * pHCI^.cx) / 1000);
  6864.                physPageSize.cy := round((ptlRes.y * pHCI^.cy) / 1000);
  6865.                /* Convert from device to world coordinate space */
  6866.                GpiConvert(InfoPS,CVTC_DEVICE,CVTC_WORLD,1,POINTL(physPageSize));
  6867.  
  6868.                /* Calculate Print Offset */
  6869.                PrintOffset.cx := round((ptlRes.x * pHCI^.xLeftClip) / 1000);
  6870.                PrintOffset.cy := round((ptlRes.y * pHCI^.yBottomClip) / 1000);
  6871.                /* Convert from device to world coordinate space */
  6872.                GpiConvert(InfoPS,CVTC_DEVICE,CVTC_WORLD,1,POINTL(PrintOffset));
  6873.  
  6874.                /* Correct Print Offset if necessary */
  6875.                DevQueryCaps (InfoDC,CAPS_WIDTH,1,ptl.x);
  6876.                DevQueryCaps (InfoDC,CAPS_HEIGHT,1,ptl.y);
  6877.                /* Convert from device to world coordinate space */
  6878.                GpiConvert(InfoPS,CVTC_DEVICE,CVTC_WORLD,1,ptl);
  6879.                IF PrintOffset.cx = 0
  6880.                THEN PrintOffset.cx := (physPageSize.cx - ptl.x) DIV 2;
  6881.                IF PrintOffset.cy = 0
  6882.                THEN PrintOffset.cy := (physPageSize.cy - ptl.y) DIV 2;
  6883.            END;
  6884.            inc(pHCI,SizeOf(HCINFO));
  6885.      END;
  6886.      FreeMem(pHCInfo,lSizeHC*SizeOf(HCINFO));
  6887.      GpiAssociate(InfoPS,0);
  6888.      GpiDestroyPS(InfoPS);
  6889.      DevCloseDC(InfoDC);
  6890.  
  6891.  
  6892.      {Open Printer DC}
  6893.      PrinterDC := DevOpenDC(HInstance, OD_QUEUED, '*', 4, dopPrinter, 0);
  6894.      IF PrinterDC = 0 THEN
  6895.      BEGIN
  6896.           SetErrorMessage(MB_ICONHAND, NLSTable[1],NLSTable[25]);
  6897.           exit;
  6898.      END;
  6899.      {Set DeviceContext and PresentationSpace}
  6900.      PrinterPS := GpiCreatePS(HInstance, PrinterDC, g,
  6901.                          PU_LOMETRIC OR GPIT_MICRO OR GPIA_ASSOC);
  6902.      IF PrinterPS = 0 THEN
  6903.      BEGIN
  6904.           SetErrorMessage(MB_ICONHAND, NLSTable[1],NLSTable[26]);
  6905.           DevCloseDC(PrinterDC);
  6906.           exit;
  6907.      END;
  6908.  
  6909.      {Release Memory allocated in the GetPrinterDevice-Function}
  6910.      IF dopPrinter.pDriv <> NIL THEN FreeMem(dopPrinter.pDriv,dopPrinter.pDriv^.cb);
  6911.  
  6912.      {Calculate PrintOffset within the Presentation space}
  6913.      IF PrintOffset.cx < PrintInfo.PRN_LeftIndent
  6914.      THEN PrintInfo.OffsX := PrintInfo.PRN_LeftIndent-PrintOffset.cx
  6915.      ELSE PrintInfo.OffsX := 0;
  6916.  
  6917.      IF PrintOffset.cy < PrintInfo.PRN_LowerIndent
  6918.      THEN PrintInfo.OffsY := PrintInfo.PRN_LowerIndent-PrintOffset.cy
  6919.      ELSE PrintInfo.OffsY := 0;
  6920.  
  6921.      PrintInfo.OffsFL := physPageSize.cy-PrintOffset.cy-PrintInfo.PRN_UpperIndent;
  6922.      IF PrintInfo.OffsFL > PrintArea.cy THEN PrintInfo.OffsFL := PrintArea.cy;
  6923.  
  6924.      PrintInfo.PrinterDC := PrinterDC;
  6925.      PrintInfo.PrinterPS := PrinterPS;
  6926.      PrintInfo.Text := CopyLinesLinear(Len);
  6927.      PrintInfo.TextLen := Len;
  6928.      PrintInfo.AbortHwnd := 0;
  6929.      PrintInfo.Status := 1;
  6930.  
  6931.      InitializePrinting;
  6932. END;
  6933.  
  6934.  
  6935.  
  6936. PROCEDURE TEditorWindow.InitializePrinting;
  6937. BEGIN
  6938.      DosCreateThread(PrintInfo.PTid,@Printing,@PrintInfo,0,32768);
  6939. END;
  6940.  
  6941.  
  6942.  
  6943.  
  6944.  
  6945. BEGIN
  6946.      EditOptions := EOD_CreateBackup OR EOD_InsertMode OR EOD_AutoIndentMode
  6947.                     OR $8000000;
  6948.      ReplOptions := FRD_Forward;
  6949.      FindOptions := FRD_Forward;
  6950.      aSearchString := '';
  6951.      aReplaceString := '';
  6952.      LastFRD := 0;
  6953.      PreCtrl := 0;
  6954.      FaceName := 'System VIO';
  6955.      CharHeight := 16;
  6956.      CharWidth := 8;
  6957.      CharBaseLine := 4;
  6958.      WinReadOnly := FALSE;
  6959.      AvailFontCount := 0;
  6960.      CursorRate := 500;
  6961.  
  6962.      NLSTable[1] := 'Error';
  6963.      NLSTable[2] := 'Could not copy text.';
  6964.      NLSTable[3] := 'Could not access clipboard.';
  6965.      NLSTable[4] := 'Read block from file';
  6966.      NLSTable[5] := 'Open a file';
  6967.      NLSTable[6] := 'Write block to file';
  6968.      NLSTable[7] := 'Save file as';
  6969.      NLSTable[8] := 'Error writing: ';
  6970.      NLSTable[9] := ' was modified. Save?';
  6971.      NLSTable[10] := 'Information';
  6972.      NLSTable[11] := 'Loading...';
  6973.      NLSTable[12] := 'File ';
  6974.      NLSTable[13] := ' already exist. Overwrite?';
  6975.      NLSTable[14] := 'Warning';
  6976.      NLSTable[15] := 'Saving...';
  6977.      NLSTable[16] := 'Search string not found.';
  6978.      NLSTable[17] := 'Confirm';
  6979.      NLSTable[18] := 'Replace this string?';
  6980.      NLSTable[19] := 'Line would be to long.';
  6981.      NLSTable[20] := 'Default Printer not found.';
  6982.      NLSTable[21] := 'Default Spooler Queue not found.';
  6983.      NLSTable[22] := 'Cannot create Information Device Context.';
  6984.      NLSTable[23] := 'Cannot create Information Presentation Space.';
  6985.      NLSTable[24] := 'Cannot acces to Hardcopy capabilities.';
  6986.      NLSTable[25] := 'Cannot create Printer Device Context.';
  6987.      NLSTable[26] := 'Cannot create Printer Presentation Space.';
  6988.      NLSTable[27] := 'Open';
  6989.      NLSTable[28] := 'Save';
  6990.      NLSTable[29] := ' not found.';
  6991. END.
  6992.