This repository is a mirror!

; _______________________________________________________________________________________
;|                                                                                       |
;| ..::FreshLib::..  Free, open source. Licensed under "Fresh artistic license."         |
;|_______________________________________________________________________________________|
;
;  Description: ForthScript standard word library.
;
;  Target OS: Any
;
;  Dependencies:
;
;  Notes:
;_________________________________________________________________________________________

macro ForthBlock blockname {
  forth@block equ blockname
  forth@block@size equ blockname#.size

  label blockname byte

  macro forthword name \{
    \local nnnn

    macro endfw \\{
    \\local ..footer
      endp
      label ..footer byte
      db   name
      db   16-($-..footer) dup 0
      dd   nnnn - blockname
      \\purge endfw
    \\}
    \proc nnnn
  \}
}

macro EndForthBlock {
  forth@block@size = $ - forth@block
  restore forth@block, forth@block@size
  purge forthword
}



ForthBlock ForthStandardLib

; "->" word.
forthword '->'
begin
        or      [ebx+TForthContext.Status], forthAssignMode
        clc
        retn
endfw


forthword '+'
begin
        mov     eax, [ebx+TForthContext.pAStack]
        mov     ecx, [eax+TArray.count]
        cmp     ecx, 2
        jb      .error

        dec     ecx
        imul    ecx, [eax+TArray.itemsize]
        lea     ecx, [eax+TArray.array+ecx]

        mov     edx, [ecx+TFStackCell.value]
        sub     ecx, [eax+TArray.itemsize]
        add     [ecx+TFStackCell.value], edx
        mov     [ecx+TFStackCell.type], ftypeNumber

        mov     ecx, [eax+TArray.count]
        dec     ecx
        stdcall DeleteArrayItem, [ebx+TForthContext.pAStack], ecx
        mov     [ebx+TForthContext.pAStack], edx
        clc
        return

.error:
        stc
        return
endfw


forthword '-'
begin
        mov     eax, [ebx+TForthContext.pAStack]
        mov     ecx, [eax+TArray.count]
        cmp     ecx, 2
        jb      .error

        dec     ecx
        imul    ecx, [eax+TArray.itemsize]
        lea     ecx, [eax+TArray.array+ecx]

        mov     edx, [ecx+TFStackCell.value]
        sub     ecx, [eax+TArray.itemsize]
        sub     [ecx+TFStackCell.value], edx
        mov     [ecx+TFStackCell.type], ftypeNumber

        mov     ecx, [eax+TArray.count]
        dec     ecx
        stdcall DeleteArrayItem, [ebx+TForthContext.pAStack], ecx
        mov     [ebx+TForthContext.pAStack], edx
        clc
        return

.error:
        stc
        return
endfw



forthword '*'
begin
        mov     eax, [ebx+TForthContext.pAStack]
        mov     ecx, [eax+TArray.count]
        cmp     ecx, 2
        jb      .error

        dec     ecx
        imul    ecx, [eax+TArray.itemsize]
        lea     ecx, [eax+TArray.array+ecx]

        mov     edx, [ecx+TFStackCell.value]
        sub     ecx, [eax+TArray.itemsize]
        imul    edx, [ecx+TFStackCell.value]
        mov     [ecx+TFStackCell.value], edx
        mov     [ecx+TFStackCell.type], ftypeNumber

        mov     ecx, [eax+TArray.count]
        dec     ecx
        stdcall DeleteArrayItem, [ebx+TForthContext.pAStack], ecx
        mov     [ebx+TForthContext.pAStack], edx
        clc
        return

.error:
        stc
        return
endfw



forthword '/'
begin
        mov     eax, [ebx+TForthContext.pAStack]
        mov     ecx, [eax+TArray.count]
        cmp     ecx, 2
        jb      .error

        dec     ecx
        imul    ecx, [eax+TArray.itemsize]
        lea     ecx, [eax+TArray.array+ecx]

        mov     edx, [ecx+TFStackCell.value]
        sub     ecx, [eax+TArray.itemsize]

        push    eax
        mov     eax, edx
        cdq
        idiv    [ecx+TFStackCell.value]
        mov     [ecx+TFStackCell.value], eax
        mov     [ecx+TFStackCell.type], ftypeNumber
        pop     eax

        mov     ecx, [eax+TArray.count]
        dec     ecx
        stdcall DeleteArrayItem, [ebx+TForthContext.pAStack], ecx
        mov     [ebx+TForthContext.pAStack], edx
        clc
        return

.error:
        stc
        return
endfw


forthword '%'
begin
        mov     eax, [ebx+TForthContext.pAStack]
        mov     ecx, [eax+TArray.count]
        cmp     ecx, 2
        jb      .error

        dec     ecx
        shl     ecx, 3
        lea     ecx, [eax+TArray.array+ecx]

        mov     edx, [ecx+TFStackCell.value]
        sub     ecx, [eax+TArray.itemsize]

        push    eax
        mov     eax, edx
        cdq
        idiv    [ecx+TFStackCell.value]
        mov     [ecx+TFStackCell.value], eax
        mov     [ecx+TFStackCell.type], ftypeNumber
        pop     eax

        mov     ecx, [eax+TArray.count]
        dec     ecx
        stdcall DeleteArrayItem, [ebx+TForthContext.pAStack], ecx
        mov     [ebx+TForthContext.pAStack], edx
        clc
        return

.error:
        stc
        return
endfw




forthword 'swap'
begin
        mov     eax, [ebx+TForthContext.pAStack]
        mov     ecx, [eax+TArray.count]
        cmp     ecx, 2
        jb      .finish         ; jb == jc

        shl     ecx, 3
        add     ecx, [ebx+TForthContext.pAStack]
;        lea     ecx, [ecx+TArray.array-2*sizeof.TFStackCell] TArray.array = 2*sizeof.TFStackCell

        mov     eax, [ecx+TFStackCell.value]
        mov     edx, dword [ecx+TFStackCell.type]
        xchg    eax, [ecx+sizeof.TFStackCell+TFStackCell.value]
        xchg    edx, dword [ecx+sizeof.TFStackCell+TFStackCell.type]
        mov     [ecx+TFStackCell.value], ecx
        mov     dword [ecx+TFStackCell.type], edx

        clc
.finish:
        return
endfw



forthword 'dup'
begin
        mov     eax, [ebx+TForthContext.pAStack]
        mov     ecx, [eax+TArray.count]
        cmp     ecx, 1
        jb      .finish         ; jb == jc

        shl     ecx, 3
        add     ecx, [ebx+TForthContext.pAStack]
        lea     ecx, [ecx+TArray.array-sizeof.TFStackCell]

        stdcall AddArrayItem, [ebx+TForthContext.pAStack]
        mov     [ebx+TForthContext.pAStack], edx
        jc      .finish

        pushd   [ecx+TFStackCell.value] dword [ecx+TFStackCell.type]
        popd    dword [eax+TFStackCell.type] [eax+TFStackCell.value]

        clc
.finish:
        return
endfw



forthword 'label'
begin


endfw




forthword 'jump'
begin


endfw




forthword '?branch'
begin


endfw



; : if +1 ?branch ;
forthword 'if'
begin


endfw



; : else label not +1 ?branch ;
forthword 'else'
begin


endfw


; : then label ;
forthword 'then'
begin


endfw





; : do label ;
forthword 'do'
begin


endfw


; : loop -1 ?branch ;
forthword 'loop'




forthword '.'
begin
        mov     eax, [ebx+TForthContext.pAStack]
        mov     ecx, [eax+TArray.count]
        jecxz   .exit

        dec     ecx
        mov     edx, ecx

        imul    ecx, [eax+TArray.itemsize]
        lea     ecx, [eax+TArray.array+ecx]

        cmp     [ecx+TFStackCell.type], ftypeNumber
        jne     .printstring

        stdcall NumToStr, [ecx+TFStackCell.value], ntsSigned or ntsDec
        mov     [ecx+TFStackCell.value], eax
        mov     [ecx+TFStackCell.type], ftypeStringFree

.printstring:
        stdcall StrPtr, [ecx+TFStackCell.value]
        stdcall Output, eax

        cmp     [ecx+TFStackCell.type], ftypeStringFree
        jne     .popit

        stdcall StrDel, [ecx+TFStackCell.value]

.popit:
        stdcall DeleteArrayItem, [ebx+TForthContext.pAStack], edx
        mov     [ebx+TForthContext.pAStack], edx

.exit:
        clc
        return

endfw



forthword 'crlf'
begin
        stdcall Output, sCRLF
        clc
        return
endfw



EndForthBlock



sCRLF db 13, 10, 0, 0

; _______________________________________________________________________________________
;|                                                                                       |
;| ..::FreshLib::..  Free, open source. Licensed under "Fresh artistic license."         |
;|_______________________________________________________________________________________|
;
;  Description: ForthScript engine.
;
;  Target OS: Any
;
;  Dependencies:
;
;  Notes:
;_________________________________________________________________________________________
module "Forth script compiler"

include 'ForthLib.asm'

; NOTE: E8    is the opcode for relative call
;       B8    is the opcode for mov eax, dword const
;       BA    is the opcode for mov edx, dword const
;       FF D0 is the opcode for call eax
;       C3    is the opcode for retn
;       e9    is the opcode for jmp long offset



ftypeNumber  = 0
ftypeString  = 1
ftypeStringFree = 2      ; this string should be destroyed after use.

struct TFStackCell
  .value dd ?           ; number or handle of the string.
  .type  db ?           ; number/string
  align 4
ends


struct TFLoopStackCell
ends



struct TFWordFooter
  .name    rb 16        ; max 12 bytes name paded with 0
  .entry   dd ?         ; offset to the code of the word  [.entry]-4 points to the footer of the previous word.
ends


; values for the Status flags.

forthCompileMode =  1   ; if set the script is compiled instead of interpreted
forthNextNewName =  2   ; if set the next extracted word should be interpreted as a new name.
forthAssignMode  =  4   ; if set the next variable word must pop value from the stack, instead of push.



struct TForthContext
  .pAStack     dd  ?     ; pointer to the aritmetic stack TArray.
  .pLStack     dd  ?     ; pointer to the loop stack TArray.
  .pWords      dd  ?     ; pointer to the words memory.
  .iWords      dd  ?     ; offset to the first free byte in the words memory.
  .iLastWord   dd  ?     ; offset to the end of the last word defined.
  .sizeWords   dd  ?     ; size of the words memory.

  .Status      dd ?

  .pUserWords  dd  ?     ; pointer to the user words memory.
  .iUserWords  dd  ?     ; offset of the end of the user word memory.
  .pUser       dd  ?     ; pointer to the user provided object for example TFreshEdit or other.
ends


ForthInitWordsMemory = 1024


proc ForthCreateContext
begin
        push    edi

        stdcall GetMem, sizeof.TForthContext
        mov     edi, eax

        stdcall CreateArray, sizeof.TFStackCell
        mov     [edi+TForthContext.pAStack], eax

        stdcall CreateArray, sizeof.TFLoopStackCell
        mov     [edi+TForthContext.pLStack], eax

        mov     [edi+TForthContext.sizeWords], ForthInitWordsMemory
        stdcall GetMem, [edi+TForthContext.sizeWords]
        mov     [edi+TForthContext.pWords], eax

        mov     eax, edi
        pop     edi
        return
endp


proc ForthFreeContext, .forth_context
begin


        return
endp



ferrSyntaxError = 1
ferrUnknownWord = 2
ferrOutOfMemory = 3
ferrInvalidNumber = 4
ferrInvalidString = 5
ferrMissingBracket = 6

ferrMaxError = 6

dmsgEndWithoutBegin db  'Syntax error', 0
dmsgUnknownWord     db  'Unknown word', 0
dmsgOutOfMemory     db  'Out of memory', 0
dmsgInvalidNumber   db  'Invalid number', 0
dmsgInvalidString   db  'Invalid string', 0
dmsgMissingBracket  db  'Missing ")"', 0
dmsgUnknownError    db  'Unknown error. Probably bug.', 0



ForthErrorMessages  dd  0
                    dd dmsgEndWithoutBegin
                    dd dmsgUnknownWord
                    dd dmsgOutOfMemory
                    dd dmsgInvalidNumber
                    dd dmsgInvalidString
                    dd dmsgMissingBracket
; this should be last.
                    dd dmsgUnknownError


proc GetForthErrorMsg, .errcode
begin
        mov     eax, [.errcode]
        cmp     eax, ferrMaxError
        jbe     @f
        mov     eax, ferrMaxError+1
@@:
        mov     eax, [ForthErrorMessages+4*eax]
        return
endp



proc ForthExecScript, .pcontext, .psource
.word     rb 16
.newword  rb 16
.entry    dd ?  ; the entry point of the currently compiled word.
.ofs_error dd ?
.sign      dd ?
begin
        push    ebx ecx esi edi

        mov     ebx, [.pcontext]
        mov     esi, [.psource]

.script_loop:

        xor     eax, eax
        mov     dword [.word], eax
        mov     dword [.word+4], eax
        mov     dword [.word+8], eax
        mov     dword [.word+12], eax
        xor     ecx, ecx

        dec     esi

.start_scan:

        inc     esi
        mov     al, [esi]

; offset for the error message, if any
        mov     edx, esi
        sub     edx, [.psource]
        mov     [.ofs_error], edx

        test    al, al
        jz      .end_of_script

        cmp     al, '+'
        je      .maybe_number
        cmp     al, '-'
        je      .maybe_number

        cmp     al, '0'
        jb      .nan
        cmp     al, '9'
        jbe     .extract_number

.nan:
        cmp     al, '"'
        je      .extract_string
        cmp     al, "'"
        je      .extract_string

        cmp     al, ' '
        jbe     .start_scan

        cmp     al, ':'
        jne     @f

        test    [ebx+TForthContext.Status], forthCompileMode
        jnz     .syntax_error

        or      [ebx+TForthContext.Status], forthCompileMode or forthNextNewName
        mov     eax, [ebx+TForthContext.iWords]
        mov     [.entry], eax
        jmp     .start_scan

@@:
        cmp     al, ';'
        jne     @f

        test    [ebx+TForthContext.Status], forthCompileMode
        jz      .syntax_error

; finalize the compilation of a word.

        mov     eax, sizeof.TFWordFooter+1
        call    .allocate_bytes
        jc      .err_out_of_memory

        sub     eax, sizeof.TFWordFooter
        mov     byte [eax+edx-1], $c3   ; retn

        pushd   dword [.newword] dword [.newword+4] dword [.newword+8] dword [.newword+12]
        popd    [eax+edx+12] [eax+edx+8] [eax+edx+4] [eax+edx]

        push    [.entry]
        pop     [eax+edx+TFWordFooter.entry]

        push    [ebx+TForthContext.iWords]
        pop     [ebx+TForthContext.iLastWord]

        and    [ebx+TForthContext.Status], not forthCompileMode

        jmp     .start_scan

@@:
        cmp     al, '('
        jne     @f

; comment ()
.comment_loop:
        inc     esi
        mov     al, [esi]
        test    al, al
        jz      .err_missing_bracket

        cmp     al, ')'
        jne     .comment_loop
        inc     esi
        jmp     .script_loop

@@:
        cmp     al, '\'
        jne     .extract_word

; one line comment
.comment_loop2:
        inc     esi
        mov     al, [esi]
        cmp     al, ' '
        jae     .comment_loop2
        jmp     .script_loop

.extract_word:
        mov     [.word+ecx], al
        inc     ecx
        and     ecx, $0f
        inc     esi
        mov     al, [esi]
        cmp     al, ' '
        ja      .extract_word

;.word_ok:
        test    [ebx+TForthContext.Status], forthNextNewName
        jz      .process_word

; copy the word as a new word name to be placed at the end of the word definition.
        mov     eax, dword [.word]
        mov     ecx, dword [.word+4]
        mov     dword [.newword], eax
        mov     dword [.newword+4], ecx

        mov     eax, dword [.word+8]
        mov     ecx, dword [.word+12]
        mov     dword [.newword+8], eax
        mov     dword [.newword+12], ecx

        and     [ebx+TForthContext.Status], not forthNextNewName
        jmp     .script_loop


.process_word:
        call    .search_word    ; eax offset relative to [TForthContext.pWords]
        jc      .err_unknown_word

        test    [ebx+TForthContext.Status], forthCompileMode
        jnz     .compile_the_word

        push    esi

        mov     esi, [ebx+TForthContext.pUser]
        add     eax, [ebx+TForthContext.pWords]
        call    eax

        pop     esi
        jmp     .script_loop

.compile_the_word:
        mov     ecx, eax        ; offset of the word entry

        cmp     eax, [ebx+TForthContext.iWords]
        jb      .internal_call

;.external_call:
        add     ecx, [ebx+TForthContext.pWords]         ; absolute address

        mov     eax, 7
        call    .allocate_bytes
        jc      .err_out_of_memory

        mov     byte [edx+eax-7], $b8   ; mov eax, const
        mov     [edx+eax-6], ecx
        mov     word [edx+eax-2], $d0ff

        jmp     .script_loop


.internal_call:
        mov     eax, 5
        call    .allocate_bytes ; return new offset in eax and pointer to the memory block in edx
        jc      .err_out_of_memory

; relative call to the word entry point.
        sub     ecx, eax
        mov     byte [edx+eax-5], $e8    ; call instruction opcode.
        mov     [edx+eax-4], ecx

        jmp     .script_loop


.maybe_number:
        cmp     byte [esi+1], '0'
        jb      .extract_word
        cmp     byte [esi+1], '9'
        ja      .extract_word

.extract_number:
        xor     edx, edx
        movzx   eax, al

        mov     byte [.sign], al
        cmp     al, '-'
        je      .next
        cmp     al, '+'
        je      .next

.num_loop:
        cmp     al, ' '
        jbe     .number_ok

        cmp     al, '0'
        jb      .err_invalid_number
        cmp     al, '9'
        ja      .err_invalid_number

        sub     al, '0'
        imul    edx, 10
        add     edx, eax

.next:
        inc     esi
        mov     al, [esi]
        jmp     .num_loop

.number_ok:
        cmp     byte [.sign], '-'
        jne     @f
        neg     edx
@@:
        test    [ebx+TForthContext.Status], forthCompileMode
        jnz     .compile_number

        call    forth_push_number
        jmp     .script_loop


.compile_number: ; $b8 forth_push_number $ba number $ff $d0
        mov     ecx, edx

        mov     eax, 12
        call    .allocate_bytes
        jc      .err_out_of_memory

        mov     byte  [edx+eax-12], $b8   ; mov eax, const
        mov     dword [edx+eax-11], forth_push_number
        mov     byte  [edx+eax-7], $ba    ; mov edx, const
        mov     dword [edx+eax-6], ecx
        mov     word  [edx+eax-2], $d0ff

        jmp     .script_loop


.extract_string:
        mov     ah, al          ; end character.
        xor     ecx, ecx        ; length of the string
        lea     edi, [esi+1]

.str_loop:
        inc     esi
        mov     al, [esi]
        test    al, al
        jz      .err_invalid_string

        cmp     al, ah
        je      .string_ok

        inc     ecx
        jmp     .str_loop

.string_ok:
        mov     ecx, esi
        sub     ecx, edi

        inc     esi

        test    [ebx+TForthContext.Status], forthCompileMode
        jnz     .compile_string

        stdcall StrNew
        mov     edx, eax

        stdcall StrCopyPart, edx, edi, 0, ecx

        push    edx
        stdcall AddArrayItem, [ebx+TForthContext.pAStack]
        mov     [ebx+TForthContext.pAStack], edx
        mov     [eax+TFStackCell.type], ftypeStringFree
        pop     [eax+TFStackCell.value]

        jmp     .script_loop

.compile_string:
        push    esi
        mov     esi, edi
        mov     edi, [ebx+TForthContext.iWords]

        lea     eax, [ecx+1+17]
        stdcall .allocate_bytes
        jc      .err_out_of_memory

        lea     eax, [edi+17]
        add     edi, [ebx+TForthContext.pWords]

        mov     byte [edi], $ba                ; mov edx, offset of string
        mov     dword [edi+1], eax             ; offset of string
        mov     byte [edi+5], $b8              ; mov eax, forth_push_string
        mov     dword [edi+6], forth_push_string
        mov     word [edi+10], $d0ff           ; call eax
        lea     eax, [ecx+1]
        mov     byte [edi+12], $e9             ; jmp  end
        mov     dword [edi+13], eax            ;

        add     edi, 17

        rep movsb
        mov     al, 0
        stosb

        pop     esi
        jmp     .script_loop


.end_of_script:
        mov     ecx, [ebx+TForthContext.pAStack]
        mov     eax, [ecx+TArray.count]
        test    eax, eax
        jz      @f

        lea     eax, [ecx+TArray.array+8*eax-8]
        mov     eax, [eax+TFStackCell.value]
        dec     [ecx+TArray.count]

@@:
        clc
        jmp     .finish

; error handlers
.err_missing_bracket:
        mov     eax, ferrMissingBracket
        jmp     .error

.err_invalid_string:
        mov     eax, ferrInvalidString
        jmp     .error

.err_invalid_number:
        mov     eax, ferrInvalidNumber
        jmp     .error

.err_out_of_memory:
        mov     eax, ferrOutOfMemory
        jmp     .error

.err_unknown_word:
        mov     eax, ferrUnknownWord
        jmp     .error

.syntax_error:
        mov     eax, ferrSyntaxError

.error:
        mov     edx, [.ofs_error]
        stc

.finish:
        pop     edi esi ecx ebx
        return


; internal subroutines


; returns:
; CF=0 - word found.
; eax - offset of word entry point in pWords memory.
;
; CF=1 - word not found.
.search_word:
        push    edx esi

; search in the compiled words
        mov     edx, [ebx+TForthContext.pWords]
        mov     esi, [ebx+TForthContext.iLastWord]
        call    .search_list
        jnc     .word_found

; if not found, search in the user provided words, if any.
        mov     edx, [ebx+TForthContext.pUserWords]
        test    edx, edx
        jz      .check_std

        mov     esi, [ebx+TForthContext.iUserWords]
        call    .search_list
        jnc     .word_found

.check_std:
        mov     edx, ForthStandardLib
        mov     esi, ForthStandardLib.size
        call    .search_list
        jnc     .word_found

        stc
        pop     esi edx
        retn

.word_found:
        clc
        pop     esi edx
        retn



; arguments:
;   esi - offset of the end of the word area.
;   edx - pointer to the begin of the word area.
; returns:
;   CF=0; eax=offset of the word entry in the word area.
;   CF=1 - not found
.search_list:
        add     esi, edx

.search_loop:
        sub     esi, sizeof.TFWordFooter
        cmp     esi, edx
        jb      .notfound

        mov     eax, dword [esi+TFWordFooter.name]
        cmp     eax, dword [.word]
        jne     .prev_word

        mov     eax, dword [esi+TFWordFooter.name+4]
        cmp     eax, dword [.word+4]
        jne     .prev_word

        mov     eax, dword [esi+TFWordFooter.name+8]
        cmp     eax, dword [.word+8]
        jne     .prev_word

        mov     eax, dword [esi+TFWordFooter.name+12]
        cmp     eax, dword [.word+12]
        je      .found

.prev_word:
        mov     esi, [esi+TFWordFooter.entry]
        add     esi, edx
        jmp     .search_loop

.found:
        mov     eax, [esi+TFWordFooter.entry]
        add     eax, edx
        sub     eax, [ebx+TForthContext.pWords]         ; relatively to TForthContext.pWords
        clc
        retn

.notfound:
        stc
        retn


; argument: eax - count of bytes to allocate.
; returns:
;   eax - offset in pWords of the new end ( iWords )
;   edx - pointer of pWords memory.

.allocate_bytes:
        push    ecx

        mov     edx, [ebx+TForthContext.iWords]
        add     edx, eax
        cmp     edx, [ebx+TForthContext.sizeWords]
        jb      .sizeok

        mov     ecx, [ebx+TForthContext.sizeWords]
        call    [ResizeIt]
        mov     [ebx+TForthContext.sizeWords], ecx

        stdcall ResizeMem, [ebx+TForthContext.pWords], ecx
        jc      .end_alloc
        mov     [ebx+TForthContext.pWords], eax

.sizeok:
        mov     [ebx+TForthContext.iWords], edx
        mov     eax, edx
        mov     edx, [ebx+TForthContext.pWords]
        clc

.end_alloc:
        pop     ecx
        retn

endp

; arguments:
;    ebx - TForthContext
;    edx - number to be pushed
; returns
;
forth_push_number:
        push    edx
        stdcall AddArrayItem, [ebx+TForthContext.pAStack]
        mov     [ebx+TForthContext.pAStack], edx
        mov     [eax+TFStackCell.type], ftypeNumber
        pop     [eax+TFStackCell.value]
        retn


; arguments:
;    ebx - TForthContext
; returns
;    eax - value from the top of the stack
proc forth_pop_number
begin
        mov     edx, [ebx+TForthContext.pAStack]
        mov     eax, [edx+TArray.count]
        dec     eax
        js      .empty_stack

        push    eax

        imul    eax, [edx+TArray.itemsize]
        mov     eax, [edx+TArray.array+edx+TFStackCell.value]

        stdcall DeleteArrayItem, edx ; from the stack
        clc
        return

.empty_stack:
        xor     eax, eax
        stc
        return
endp



; arguments:
;    ebx - TForthContext
;    edx - offset to the string related to pWords memory.
; returns
;
proc forth_push_string
begin
        add     edx, [ebx+TForthContext.pWords]
        push    edx
        stdcall AddArrayItem, [ebx+TForthContext.pAStack]
        mov     [ebx+TForthContext.pAStack], edx
        mov     [eax+TFStackCell.type], ftypeString
        pop     [eax+TFStackCell.value]
        return
endp






endmodule

;    - Word wrap
;    - Code folding
;    - Associated debug information
;    - save with format information (bookmarks and breakpoints)
;    - Read-only lines
;    - Undo and Redo functions.
;    - Adjustable colors, keyboard and behavior.
;    - Char, Block and Line selections.
;    - Char and Block selections.
;    - Syntax highlighters interface for different languages.
;    - Interface to visual programming tools and auto source generators.
;_________________________________________________________________________________________
include "FreshEditThemes.asm"

module "TFreshEdit library"

; Line flags

lfBookmark   = 1        ; the line have bookmark set.
lfFocused    = 2        ; the line is focused until the user press some key.
lfProtected  = 4        ; the line can not be edited.
lfWordWrap   = 8        ; the line must be word wrapped. After changes, the format have to be updated.
lfHidden     = 16       ; this line is hidden
lfBreakpoint = 16       ; set breakpoint in debug mode.
lfBreakpoint = 32       ; set breakpoint in debug mode.
lfFoldHeader = 32       ; this is the first line of foldable part of the text.


struct TEditorLine
  .Data         dd  ?   ; pointer to line data.
  .flags        dd  ?   ; line flags
  .syn_context  dd  ?   ; flags about current syntax highlighter context after processing line.

  .syn_context  dd  ?   ; flags about current syntax highlighter context.
  .fold_level   dd  ?
  .debugdata    dd  ?   ; pointer to debug data, associated to this line
  .fold_level   dd  ?   ; the level of folding.

  .subcount     dd  ?   ; count of wrapped sublines
  .pSublines    dd  ?   ; pointer to array containing offsets to the sublines inside the line.

  .width        dd  ?   ; width of the line text in chars. It is the length of the string for non wrapped lines and maximal subline for wrapped.
  align 32
  .shift = 5
ends


struct TScreenLine
  .IndexLine dd ?
  .Subline   dd ?
ends


undoInsertText     = 0
undoDeleteText     = 1


struct TUndoInfo
  .operation   db ?       ; what was changed???
  .selMode     db ?
  align 4
  .caretX      dd ?
  .caretY      dd ?

chgfNoClearSelection = 1
chgfNeedRefresh      = 2
chgfFinished         = 4

; insert modes

modeInsert = 0
modeInsert    = 0
modeOverwrite = 1

; selection modes

selmChar = 0
selmBlock = 1
selmBlock = 1      ; when the editor is in block selection mode, the word wrap
                   ; feature must be switched OFF, because it is not possible
                   ; to select rectangular region, on word wrapped lines.

; flag ReadOnly values
froReadWrite          = 0
froReadOnlyWithCaret  = 1
froReadOnlyNoCaret    = 2


object TFreshEdit, TScrollWindow

  ._Font            dd  ?   ; font of the editor.

; main editor font sizes
  ._fontheight      dd  ?   ; in pixels.
  ._fontwidth       dd  ?   ; in pixels.
  ._fontdescent     dd  ?   ; in pixels.

; system font sizes (used for additional texts and line numbers)
  ._fontheight2     dd  ?   ; in pixels.
  ._fontwidth2      dd  ?   ; in pixels.
  ._fontdescent2    dd  ?   ; in pixels.

  .__LeftMargin     dd  ?   ; width of the left margin field. Auto computed.
  .__NumberMargin   dd  ?   ; width of the field for the line number. Auto computed.
  ._ExtraFont       dd  ?   ;

  ._cols            dd  ?   ; width of the window in text columns.
  ._rows            dd  ?   ; height of the window in text rows.
                            ; must to be update on resize and on font change.
                            ; must be updated on resize and on font change.

  ._pLines          dd  ?   ; pointer to TArray of TEditorLine items.
  ._pIndex          dd  ?   ; pointer to TArray of dword that contains numbers of TEditorLine for the screen.
  ._pLengths        dd  ?   ; pointer to TArray with counts of the lines with given length.

  ._pUndoList       dd  ?   ; pointer to TArray of TUndoInfo
  ._pRedoList       dd  ?   ; pointer to TArray of TUndoInfo

  ._pShadow         dd  ?   ; double buffer pointer to TBackBuffer object.
  ._pShadow         dd  ?   ; pointer to TBackBuffer object.
  ._fShadowValid    dd  ?   ;

  .pScreenIndex     dd  ?   ; pointer to array of TScreenLine structures, containing

; view change fields

  ._TopLine         dd  ?   ; number of the line that is at the topmost line of the window.
  ._LeftColumn      dd  ?   ; the column of the text at the leftmost side of the window.

  ._xCaret          dd  ?   ; horizontal position of the caret inside the current line.
  ._yCaret          dd  ?   ; vertical position of the caret inside the text.
  ._xCaret          dd  ?   ; the number of the char the caret resides.
  ._yCaret          dd  ?   ; the index of the line the caret resides.

  ._xSelection      dd  ?
  ._ySelection      dd  ?

  ._fReadOnly       dd  ?
  ._SelMode         dd  ?
  ._SelMode         dd  ?        ; NOTE: on selmBlock, the word wrap should be OFF
  ._InsMode         dd  ?
  ._TabStop         dd  ?

; end change fields

  ._prevTopLine     dd  ?
  ._prevTopOffset   dd  ?
  ._prevLeftColumn  dd  ?

  ._prevxCaret      dd  ?
  ._prevyCaret      dd  ?
  ._prevCaretChar   dd  ?
  ._prevCaretLine   dd  ?

  ._prevxDelta      dd  ?
  ._prevyDelta      dd  ?

  ._prevSelMode     dd  ?
  ._prevInsMode     dd  ?

; end backup fields

  ._DragButton      dd  ?

;  ._Theme           TFETheme

  ._procSyntax      dd  ?   ; syntax highlighter procedure.

; icons and masks for the left margin
  ._iconBreakpointA dd  ?       ; active breakpoint icon.
  ._iconBreakpointI dd  ?       ; inactive breakpoint icon.
  ._iconDebugInfo   dd  ?
  ._maskBreakpointA dd  ?
  ._maskBreakpointI dd  ?
  ._maskDebugInfo   dd  ?


  ._iconUnfold      dd  ?
  ._iconFold        dd  ?

  ._maskUnfold      dd  ?

; Event handlers

  .OnControlKey     dd  ?

; Parameters
  param .Selection      ; selected text read/write

  param .CurrentLine    ; TEditorLine where caret resides.
  param .Text
  param .CurrentLine    ; TEditorLine where caret resides. read only
  param .Text           ; whole text; read/write
  param .MaxLineLen

; Methods
; Commands

  method .Clear          ; clears the text in the editor.
  method .Clear

; navigation methods

  method .Move, .direction, .count, .force      ; moves the caret
  method .Left
  method .Right
  method .Up
  method .Down

  method .LineBegin
  method .LineEnd
  method .ScreenBegin

  method .ScreenEnd
  method .FileBegin
  method .FileEnd

; editing methods

  method .DeleteSel
  method .InsertLine, .index    ; index = -1 inserts at current position of the caret.
  method .PageUp
  method .PageDown
                                ; index = -2 appends the line at the end of the text.
  method .DeleteLine, .index    ; index = -1 deletes the line on the current position of the caret.

; block processing methods.
  method .InsertString, .hString
  method .DeleteText, .indexFrom, .charFrom, .indexTo, .charTo
  method .GetText, .indexFrom, .charFrom, .indexTo, .charTo

; Undo/Redo functions.

;
  method .RegisterForUndo, .operation, .data

  method .Undo
  method .Redo
  method .GetText, .LineFrom, .CharFrom, .LineTo, .CharTo
  method .DeleteSel

  method .ClearUndo

; Coordinates convertions
; these two methods are flexible, but very slow. .Text parameter seting is fastest way to change whole text of the editor.
  method .InsertChar, .char
  method .InsertString, .hstring    ; inserts a string at the caret position.
                                    ; If the string contains formating chars they are processed properly.
  method .DelChar      ; deletes the char under the caret.

; appearance methods
  method .FormatLine, .index
  method .PixelToCaret, .xPixel, .yPixel
  method .CaretToPixel, .iRow, .xChar

; themes methods

  method LoadTheme, .configdb, .directory

endobj


; about .pIndex field:
;
;  This array contains the number of text lines that have to be displayed on the
;  respective screen lines.
;  Not every text line have screen line representation - it means the count of items of [pIntex]
;  can be smaller than count of items of [pLines]. This case is when some lines are folded and not visible.
;  On the other hand, another variant is also possible - several items of [pIndex] to point to
;  one line in [pLines] - when the text line is wraped and displayed on several lines of the screen.
;
;_________________________________________________________________________________________

cDefaultEditorFont text 'Fixedsys Excelsior 3.01'
;cDefaultEditorFont text 'Droid sans mono'


; left margin icons.
;iglobal
    getfile iconBreakpointA, 'images/breakpoint.gif'
    getfile iconBreakpointI, 'images/breakpoint_inactive.gif'
    getfile maskBreakpointA, 'images/breakpoint_mask.gif'
    getfile maskBreakpointI, 'images/breakpoint_mask_inactive.gif'
    getfile iconDebugInfo,   'images/debug_icon.gif'
    getfile maskDebugInfo,   'images/debug_mask.gif'
    getfile iconUnfold,      'images/unfold.gif'
    getfile iconFold,        'images/fold.gif'
    getfile maskUnfold,      'images/unfold_mask.gif'
;endg



proc TFreshEdit.Create, .pobj
begin
        push    eax edx
        push    edx

        mov     ebx, [.pobj]

; Main Font settings.
        stdcall FontCreate, cDefaultEditorFont, 0, 0, ffMonospaced
        mov     [ebx+TFreshEdit._Font], eax

        mov     [ebx+TFreshEdit._cursor], mcText

        stdcall FontGetCharSize, [ebx+TFreshEdit.handle], [ebx+TFreshEdit._Font], __HeightProbeString
        test    edx, edx
        jnz     @f
        inc     edx
@@:

        stdcall CreateImageGIF, iconFold, iconFold.size
        mov     [ebx+TFreshEdit._iconFold], eax

        stdcall CreateImageGIF, maskUnfold, maskUnfold.size
        mov     [ebx+TFreshEdit._maskUnfold], eax

; Init some values.
        mov     [ebx+TFreshEdit._TabStop], 8
        mov     [ebx+TFreshEdit._TabStop], 4

        mov     [eax+TFETheme.WrapPos], 80
        mov     [eax+TFETheme.UndoLevels], 20

        mov     [ebx+TFreshEdit._DragButton], -1

        stdcall CreateArray, sizeof.TEditorLine
        mov     [ebx+TFreshEdit._pLines], eax

        stdcall CreateArray, 4
        mov     [ebx+TFreshEdit._pIndex], eax

        stdcall CreateArray, 4
        mov     [ebx+TFreshEdit._pLengths], eax

        stdcall CreateArray, sizeof.TUndoInfo
        mov     [ebx+TFreshEdit._pUndoList], eax

        stdcall CreateArray, sizeof.TUndoInfo
        mov     [ebx+TFreshEdit._pRedoList], eax

        stdcall CreateBackBuffer, [ebx+TFreshEdit.handle], 1, 1
        mov     [ebx+TFreshEdit._pShadow], eax

        pop     edx eax
        pop     edx
        clc
        return
endp



;_________________________________________________________________________________________


proc TFreshEdit.Destroy, .pobj
begin
        mov     ebx, [.pobj]

; free all text data
        execute ebx, TFreshEdit.Clear
        stdcall FreeMem, [ebx+TFreshEdit._pLines]
        stdcall FreeMem, [ebx+TFreshEdit._pIndex]

; free the allocated buffers
        stdcall FreeMem, [ebx+TFreshEdit._pLines]
        stdcall FreeMem, [ebx+TFreshEdit._pLengths]
        stdcall FreeMem, [ebx+TFreshEdit._pUndoList]
        stdcall FreeMem, [ebx+TFreshEdit._pRedoList]

; destroy the shadow buffer.
        stdcall DestroyBackBuffer, [ebx+TFreshEdit._pShadow]

; destroy icon images.
        stdcall DestroyImage, [ebx+TFreshEdit._iconBreakpointA]
        stdcall DestroyImage, [ebx+TFreshEdit._iconBreakpointI]
        stdcall DestroyImage, [ebx+TFreshEdit._iconDebugInfo]
        stdcall DestroyImage, [ebx+TFreshEdit._maskBreakpointA]
        stdcall DestroyImage, [ebx+TFreshEdit._maskBreakpointI]
        stdcall DestroyImage, [ebx+TFreshEdit._maskDebugInfo]
        stdcall DestroyImage, [ebx+TFreshEdit._iconUnfold]
        stdcall DestroyImage, [ebx+TFreshEdit._iconFold]

        stdcall DestroyImage, [ebx+TFreshEdit._maskUnfold]
        clc
        return
endp


;_________________________________________________________________________________________

        stc
.exit:
        return

;................................................................
.get_selection:
        push    esi

        mov     esi, [.pobj]
        mov     ecx, [.pobj]
        mov     eax, [esi+TFreshEdit._SelMode]
        cmp     eax, selmChar
        je      .get_sel_char
        cmp     eax, selmBlock
        je      .get_sel_block

        execute ecx, TFreshEdit.GetText, [ecx+TFreshEdit._yCaret], [ecx+TFreshEdit._xCaret],      \
        stc
        return

.get_sel_char:
        execute esi, TFreshEdit.GetText, [esi+TFreshEdit._yCaret], [esi+TFreshEdit._xCaret],      \
                                         [esi+TFreshEdit._ySelection], [esi+TFreshEdit._xSelection]
                                         [ecx+TFreshEdit._ySelection], [ecx+TFreshEdit._xSelection], [ecx+TFreshEdit._SelMode]

        clc
        pop     esi
        return


.get_sel_block:
        xor     eax, eax
        clc
        pop     esi
        return


;................................................................
.gettext:
        push    ebx ecx edx esi edi
        push    ebx edx esi edi


        stdcall StrNew
        mov     ebx, eax
        mov     edi, [.pobj]

        mov     esi, [edi+TFreshEdit._pLines]
        mov     ecx, [esi+TArray.count]

        jecxz   .text_ready
        lea     esi, [esi+TArray.array]

.line_loop:
        stdcall TFreshEdit.__AddFormatLine, ebx, [esi+TEditorLine.flags]

        stdcall StrDup, [esi+TEditorLine.Data]
        push    eax
        push    eax
        push    eax
        stdcall StrLen, eax
        mov     edx, eax
        stdcall StrPtr ; from the stack

        inc     eax
        dec     edx
        jnz     .loop_char

.line_ready:
        stdcall StrCat, ebx ; from the stack.
        stdcall StrDel      ; from the stack
        stdcall StrCharCat, ebx, $0a0d
        stdcall TFreshEdit.__AddFormatLine, ebx, [esi+TEditorLine.flags]

.next_line:
        add     esi, sizeof.TEditorLine
        loop    .line_loop

.text_ready:
        mov     eax, ebx
        pop     edi esi edx ecx ebx
        pop     edi esi edx ebx
        clc
        return

;................................................................

.currentline:
        push    ebx edx edi

        mov     edi, [.pobj]
        mov     eax, [edi+TFreshEdit._yCaret]
        mov     ecx, [.pobj]
        stdcall GetArrayItem, [ecx+TFreshEdit._pLines], [ecx+TFreshEdit._yCaret]
        mov     ebx, [edi+TFreshEdit._pIndex]
        cmp     eax, [ebx+TArray.count]
        jae     .errorcl
        jnc     .endgcl

.lineloop:
        mov     edx, [ebx+TArray.array+4*eax]
        cmp     edx, -1
        jne     .found

        dec     eax
        xor     eax, eax
        jns     .lineloop

.endgcl:
.errorcl:
        stc
        pop     edi edx ebx
        return

; edx is the number of string in the lines array.
.found:
        mov     ebx, [edi+TFreshEdit._pLines]
        cmp     edx, [ebx+TArray.count]
        jae     .errorcl

        shl     edx, TEditorLine.shift
        lea     eax, [ebx+TArray.array+edx]

        clc
        pop     edi edx ebx
        return

;................................................................

.maxlinelen:
        mov     eax, [.pobj]
        mov     eax, [eax+TFreshEdit._pLengths]

;_________________________________________________________________________________________


proc TFreshEdit.Set, .pobj, .paramID, .value
begin
        push    eax ebx edx esi edi
        mov     edi, [.pobj]

        mov     eax, [.paramID]
        cmp     eax, TFreshEdit.Text
        cmp     [.paramID], TFreshEdit.Text
        je      .settext

        cmp     eax, TFreshEdit.Selection
        cmp     [.paramID], TFreshEdit.Selection
        je      .set_selection

        stc

.finish:
        pop     edi esi edx ebx eax
        return

;.........................................................................................
.set_selection:
; delete the old selection
        push    esi eax edx
        mov     esi, [.pobj]

        pop     edx eax esi
        clc
        return

;.........................................................................................

.settext:

locals
.pLine    dd ?
.flags    dd ?
endl
        push    eax ebx edx esi edi

        mov     edi, [.pobj]
        execute edi, TFreshEdit.Clear

        stdcall StrPtr, [.value]
        mov     esi, eax

.lineloop:
        mov     [.flags], 0

        stdcall TFreshEdit.__DecodeFormatLine, esi
        jc      .line_begin

        mov     [.flags], eax
        add     esi, ecx

.line_begin:
        push    esi

.char:
        lodsb
        test    al, al
        jz      .end_of_line

                        ; because the memory reallocation returns not zero filled memory.
        stosb

        pop     edi esi ecx

; insert text line.
        stdcall AddArrayItems, [edi+TFreshEdit._pLines], 1
        jc      .end_set_text

        mov     [edi+TFreshEdit._pLines], edx
        mov     ecx, [edx+TArray.count]
        mov     [.pLine], eax

        mov     [eax+TEditorLine.Data], ebx
        push    [.flags]
        pop     [eax+TEditorLine.flags]
        mov     [eax+TEditorLine.syn_context], 0
        mov     [eax+TEditorLine.debugdata], 0
        mov     [eax+TEditorLine.width], -1
        xor     ecx, ecx
        mov     [eax+TEditorLine.flags], ecx
        mov     [eax+TEditorLine.syn_context], ecx
        mov     [eax+TEditorLine.debugdata], ecx
        mov     [eax+TEditorLine.fold_level], ecx
        dec     ecx
;        mov     [eax+TEditorLine.width], ecx

; insert index line.
        stdcall AddArrayItems, [edi+TFreshEdit._pIndex], 1
        mov     [edi+TFreshEdit._pIndex], edx
        stdcall StrPtr, ebx
        stdcall TFreshEdit.__DecodeFormatLine, eax
        jc      .format_ok

        dec     ecx
        mov     [eax], ecx
        mov     edx, [.pLine]
        mov     [edx+TEditorLine.flags], eax
        stdcall StrCopyPart, ebx, ebx, 0, ecx

.format_ok:

; format the line
        mov     ecx, [edx+TArray.count]
        dec     ecx

        execute edi, TFreshEdit.FormatLine, ecx
;        execute edi, TFreshEdit.FormatLine, ecx

; goto next line.
        cmp     byte [esi], 0
        jne     .lineloop

        mov     [edi+TFreshEdit._TopLine], 0
        mov     [edi+TFreshEdit._yCaret], 0

        mov     eax, [edi+TFreshEdit._pLengths]

        stdcall TFreshEdit.__UpdateScrollBars, edi
        mov     [edi+TFreshEdit._fShadowValid], 0

.end_set_text:
        clc
        jmp     .finish
        pop     edi esi edx ebx eax
        return
endp



;_________________________________________________________________________________________

; move commands
mvcMoveX   = 1
mvcMoveY   = 2

        je      .movecaret

        cmp     [.method], TFreshEdit.LineBegin
        je      .linebegin

        cmp     [.method], TFreshEdit.LineEnd
        je      .lineend

        cmp     [.method], TFreshEdit.FileBegin
        je      .filebegin

        cmp     [.method], TFreshEdit.FileEnd
        je      .fileend

        cmp     [.method], TFreshEdit.ScreenBegin
        je      .pagebegin

        cmp     [.method], TFreshEdit.ScreenEnd
        je      .pageend

        cmp     [.method], TFreshEdit.DeleteSel
        je      .delete_selection

        cmp     [.method], TFreshEdit.DeleteText
        je      .delete_text

        cmp     [.method], TFreshEdit.GetText
        je      .get_text

        cmp     [.method], TFreshEdit.InsertText
        je      .insert_text

        cmp     [.method], TFreshEdit.DeleteLine
        je      .delete_line

        cmp     [.method], TFreshEdit.InsertChar
        je      .insert_char

        cmp     [.method], TFreshEdit.InsertString
        je      .insert_string

        cmp     [.method], TFreshEdit.InsertLine
        je      .insert_line

        cmp     [.method], TFreshEdit.FormatLine
        je      .format_line
        cmp     [.method], TFreshEdit.DelChar
        je      .del_char

        cmp     [.method], TFreshEdit.DelChar
        je      .del_char
        cmp     [.method], TFreshEdit.PixelToCaret
        je      .pixel_to_caret

        cmp     [.method], TFreshEdit.CaretToPixel
        je      .caret_to_pixel

        stc
        return

;.........................................................................................
.refresh:
        mov     eax, [.self]
        mov     [eax+TFreshEdit._fShadowValid], 0
        mov     ecx, [.self]
        mov     [ecx+TFreshEdit._fShadowValid], 0
        stc
        return

;.........................................................................................
; formats some line of the text, depending on the flags. Also, fix the index items for
; this line.
.format_line:
virtual at ebx
  .index dd ?
end virtual

; first get the line pointer
locals
  .imin  dd  ?
  .imax  dd  ?
  .start_count dd ?
  .rows        dd ?

  .caret_ofs dd ?
  .wrap_here dd ?

  .retval dd ?   ; correction count on tab-expansion
endl
        push    ecx esi edi

        mov     esi, [.self]
        mov     edi, [esi+TFreshEdit._pIndex]

        mov     ecx, [.index]
        cmp     ecx, [edi+TArray.count]
        jae     .error_format

.loop_end:
        inc     ecx
        cmp     ecx, [edi+TArray.count]
        jae     .end_found
        cmp     [edi+TArray.array+4*ecx], -1
        je      .loop_end

.end_found:
        dec     ecx
        mov     [.imax], ecx

        mov     ecx, [.index]
        inc     ecx

.loop_start:
        dec     ecx
        js      .error_format

        cmp     [edi+TArray.array+4*ecx], -1
        je      .loop_start

        mov     [.imin], ecx
        mov     [.rows], 1    ; how many lines are withit the line

        mov     ecx, [edi+TArray.array+4*ecx]   ; index in _pLines array.
        shl     ecx, TEditorLine.shift
        add     ecx, [esi+TFreshEdit._pLines]
        lea     edi, [ecx+TArray.array]         ; edi points to TEditorLine structure.

; begin of formating
        stdcall StrClipSpacesR, [edi+TEditorLine.Data]
        stdcall ExpandTabs, [edi+TEditorLine.Data], [esi+TFreshEdit._TabStop]
        mov     [.retval], eax
        stdcall StrLen, [edi+TEditorLine.Data]
        mov     ecx, eax
        mov     [.start_count], eax
        jecxz   .wrap_ok

        stdcall StrPtr, [edi+TEditorLine.Data]
        mov     edx, eax

; first replace $01 with $20 (wrap char to space)
        push    edx ecx
.spc_loop:
        cmp     byte [edx], $01
        jne     @f
        mov     byte [edx], $20
@@:
        inc     edx
        loop    .spc_loop
        pop     ecx edx

; word wrap?
        test    [edi+TEditorLine.flags], lfWordWrap
        jz      .wrap_ok

        push    edi

        mov     edi, edx
.wrap_outer:
        mov     ecx, [FreshEditTheme.WrapPos]
        inc     ecx
        mov     [.wrap_here], -1
        xor     edx, edx

.wrap_loop:
        add     edi, edx
        stdcall DecodeUtf8, [edi]
        test    eax, eax
        jz      .wrap_ready

        cmp     eax, ' '
        jne     @f
        mov     [.wrap_here], edi
@@:
        loop    .wrap_loop

        cmp     [.wrap_here], -1
        jne     .do_wrap

.forward:
        add     edi, edx
        stdcall DecodeUtf8, [edi]
        test    eax, eax
        jz      .wrap_ready

        cmp     eax, ' '
        jne     .forward

        mov     [.wrap_here], edi

.do_wrap:
        mov     edi, [.wrap_here]
        mov     byte [edi], $01         ; wrap the line.
        inc     edi
        inc     [.rows]
        jmp     .wrap_outer


.wrap_ready:
; ready, so fix the index.
        pop     edi

.wrap_ok:
        mov     eax, [.imin]
        inc     eax

        mov     ecx, [.imax]
        sub     ecx, [.imin]
        inc     ecx
        sub     ecx, [.rows]    ; ecx>0 means some rows from the index must be deleted
                                ; ecx<0 means some rows must be added.
                                ; ecx=0 means the index is ok
        jz      .index_ok
        js      .add_more_index

        stdcall DeleteArrayItems, [esi+TFreshEdit._pIndex], eax, ecx
        mov     [esi+TFreshEdit._pIndex], edx
        jmp     .index_ok

.add_more_index:
        neg     ecx
        stdcall InsertArrayItems, [esi+TFreshEdit._pIndex], eax, ecx
        mov     [esi+TFreshEdit._pIndex], edx

.fill_new_items:
        mov     dword [eax], -1
        lea     eax, [eax+4]
        loop    .fill_new_items

.index_ok:
        stdcall TFreshEdit.__LineWidth, [edi+TEditorLine.Data]
        xchg    eax, [edi+TEditorLine.width]
        stdcall TFreshEdit.__FixLength, esi, [edi+TEditorLine.width], eax

        clc
        mov     eax, [.retval]
        mov     edx, [.imin]
        pop     edi esi ecx
        return

.error_format:
        int3
        mov     eax, -1
        clc
        pop     edi esi ecx
        return

;.........................................................................................
.delete_line:
virtual at ebx
  .del_index dd ?
  .del_index  dd  ?
end virtual

        push    edx esi edi
        push    edx esi
        mov     esi, [.self]

        mov     eax, [.del_index]
        cmp     eax, -1
        jne     @f
        mov     eax, [esi+TFreshEdit._yCaret]
@@:
        mov     edi, [esi+TFreshEdit._pIndex]
        cmp     eax, [edi+TArray.count]
        mov     edx, [esi+TFreshEdit._pLines]
        cmp     eax, [edx+TArray.count]
        jae     .end_del_line

.beg_search:
        cmp     [edi+TArray.array+4*eax], -1    ; word wrap
        shl     eax, TEditorLine.shift
        lea     ecx, [edx+TArray.array+eax]
        jne     .do_del
        dec     eax
        shr     eax, TEditorLine.shift
        jnz     .beg_search

.do_del:
        mov     ecx, [edi+TArray.array+4*eax]
        shl     ecx, TEditorLine.shift
        add     ecx, TArray.array
        add     ecx, [esi+TFreshEdit._pLines]
        stdcall StrDel, [ecx+TEditorLine.Data]
        stdcall TFreshEdit.__FixLength, esi, -1, [ecx+TEditorLine.width]

        stdcall DeleteArrayItems, [esi+TFreshEdit._pLines], [edi+TArray.array+4*eax], 1
        mov     [esi+TFreshEdit._pLines], edx

.del_index2:
        stdcall DeleteArrayItems, edi, eax, 1
        stdcall DeleteArrayItems, edx, eax, 1
        mov     edi, edx
        cmp     eax, [edi+TArray.count]
        jae     .end_del_index2

        cmp     [edi+TArray.array+4*eax], -1
        je      .del_index2

.end_del_index2:
        mov     [esi+TFreshEdit._pIndex], edi
        mov     [esi+TFreshEdit._pLines], edx
        push    eax

; fix the index to the end:
.fix_index_del:
        cmp     eax, [edi+TArray.count]
        jae     .end_fix_index

; delete the wrapped line (if any)
        cmp     [edi+TArray.array+4*eax], -1
        je      @f
        dec     [edi+TArray.array+4*eax]
@@:
        inc     eax
        jmp     .fix_index_del

.end_fix_index:
        pop     eax
.end_del_line:
        clc
        pop     edi esi edx
        pop     esi edx
        return

;.........................................................................................
.get_text:
; have the same arguments and local variables as .delete_text
virtual at ebx  ; arguments
  .indexFrom dd ?
  .charFrom  dd ?
  .indexTo   dd ?
  .charTo    dd ?
  .BlockKind dd ?
end virtual
locals
  .final_str   dd ?
  .final_flags dd ?
  .final_level dd ?
  .fromline    dd ?
  .toline      dd ?
  .ret_str     dd ?
endl

        pushad

        mov     [.ret_str], 0

; sort the "from" and "To" in order to have "From" < "To"
        mov     eax, [.indexFrom]
        mov     ecx, [.charFrom]
        cmp     eax, [.indexTo]
        jne     @f
        cmp     ecx, [.charTo]
@@:
        je      .finish_get    ; from == to so nothing to return
        jb      @f
        xchg    eax, [.indexTo]
        xchg    ecx, [.charTo]
        mov     [.indexFrom], eax
        mov     [.charFrom], ecx
@@:
        mov     esi, [.self]

; last line processing
        stdcall GetArrayItem, [esi+TFreshEdit._pLines], [.indexTo]
        jc      .error_get
        stdcall TFreshEdit.__PosToPointer, [.self], [.charTo], [.indexTo]
        mov     [.toline], edx

        stdcall StrExtract, [edx+TEditorLine.Data], 0, eax

        mov     [.toline], eax
        mov     edx, eax
        stdcall StrOffsUtf8, [edx+TEditorLine.Data], [.charTo]
        stdcall StrExtract,  [edx+TEditorLine.Data], 0, eax
        mov     [.final_str], eax

; first line processing
        stdcall GetArrayItem, [esi+TFreshEdit._pLines], [.indexFrom]
        jc      .error_get
        stdcall TFreshEdit.__PosToPointer, [.self], [.charFrom], [.indexFrom]
        mov     [.fromline], edx

        mov     [.fromline], eax
        mov     edx, eax
        stdcall StrOffsUtf8, [edx+TEditorLine.Data], [.charFrom]

        mov     edi, [edx+TEditorLine.Data]
        cmp     edx, [.toline]
        jne     .dup_first
        mov     edi, [.final_str]

.dup_first:
        push    eax
        stdcall StrDup, edi
        mov     edi, eax
        pop     eax

        jecxz   .get_splitit

.finish_get:
        clc
        popad
        mov     eax, [.ret_str]
        return

.error_get:
        clc
        popad
        xor     eax, eax
        return

;.........................................................................................
;  method .InsertText, .lineFrom, .charFrom, .hString, .fInsert
.insert_text:
virtual at ebx
  .lineFrom2 dd ?
  .charFrom2 dd ?
  .hString2  dd ?
  .fInsert   dd ?
end virtual

locals
  .suffix       dd ?
  .end_ptr      dd ?
  .current_line dd ?
  .current_char dd ?
  .ptr_line     dd ?
  .char_count   dd ?
endl
        pushad

        mov     esi, [.self]

.search_line:
        stdcall GetArrayItem, [esi+TFreshEdit._pLines], [.lineFrom2]
        jnc     .linefound

        execute esi, TFreshEdit.InsertLine, -2
        jmp     .search_line

.linefound:
        mov     edi, eax
        mov     eax, [.lineFrom2]
        mov     [.current_line], eax

        mov     [.suffix], 0

        stdcall StrOffsUtf8, [edi+TEditorLine.Data], [.charFrom2]
        test    ecx, ecx
        jnz     .add_spaces

        stdcall StrSplit, [edi+TEditorLine.Data], eax
        mov     [.suffix], eax
        jmp     .do_insertion

.add_spaces:
        stdcall StrCharCat, [edi+TEditorLine.Data], ' '
        dec     ecx
        jnz     .add_spaces

.do_insertion:
        stdcall StrPtr, [.hString2]
        mov     esi, eax
        stdcall StrLen, [.hString2]
        lea     eax, [esi+eax]
        mov     [.end_ptr], eax

        stdcall StrLen, [edi+TEditorLine.Data]
        mov     ecx, eax
        stdcall StrLen, [.hString2]
        add     ecx, eax

.loop_lines:
        mov     [.ptr_line], edi

        stdcall StrSetCapacity, [edi+TEditorLine.Data], ecx
        mov     edi, eax
        lea     ecx, [edi+string.len]
        add     edi, [ecx]   ; append the string to the end...
        mov     [.char_count], 0

.append_loop:
        stdcall DecodeUtf8, [esi]
        test    eax, eax
        jz      .end_of_string

        cmp     eax, $0d
        je      .new_line
        cmp     eax, $0a
        je      .new_line

        mov     eax, [esi]
        mov     [edi], eax
        add     esi, edx
        add     edi, edx

        add     [ecx], edx
        inc     [.char_count]
        jmp    .append_loop

.new_line:
        xor     al, $0d xor $0a
        inc     esi
        cmp     [esi], al
        jne     @f
        inc     esi
@@:
        call    .finish_current_line

        inc     [.current_line]
        execute [.self], TFreshEdit.InsertLine, [.current_line]
        mov     edi, eax

        mov     ecx, [.end_ptr]
        sub     ecx, esi
        jmp     .loop_lines


.finish_current_line:
        xor     eax, eax
        stosd

        cmp     [.fInsert], modeInsert
        je      .overwrite_ok

        cmp     [.suffix], 0
        je      .overwrite_ok

        stdcall StrOffsUtf8, [.suffix], [.char_count]
        jecxz   .split_suffix

        stdcall StrDel, [.suffix]
        mov     [.suffix], 0
        retn

.split_suffix:
        stdcall StrSplit, [.suffix], eax
        xchg    [.suffix], eax
        stdcall StrDel, eax

.overwrite_ok:
        retn


.end_of_string:
        call    .finish_current_line

        mov     edi, [.ptr_line]

        stdcall StrLenUtf8, [edi+TEditorLine.Data], -1
        mov     [.current_char], eax

        cmp     [.suffix], 0
        je      .last_ok

        stdcall StrCat, [edi+TEditorLine.Data], [.suffix]
        stdcall StrDel, [.suffix]

.last_ok:

.finish_ins_text:
        popad
        mov     eax, [.current_line]
        mov     edx, [.current_char]
        clc
        return

;.........................................................................................
.delete_text:
virtual at ebx  ; arguments
; have the same arguments and local variables as .get_text
  .indexFrom dd ?
  .charFrom  dd ?
  .indexTo   dd ?
  .charTo    dd ?
end virtual
locals
  .final_str   dd ?
  .final_flags dd ?
  .final_level dd ?
  .fromline    dd ?
  .toline      dd ?
  .ret_str     dd ?
endl
        pushad

; sort the "from" and "To" in order to have "From" < "To"
        mov     eax, [.indexFrom]
        mov     ecx, [.charFrom]
        cmp     eax, [.indexTo]
        jne     @f
        cmp     ecx, [.charTo]
@@:
        je      .nothing_to_delete    ; from == to so nothing to delete.
        je      .finish_delete    ; from == to so nothing to delete.
        jb      @f
        xchg    eax, [.indexTo]
        xchg    ecx, [.charTo]
        mov     [.indexFrom], eax
        mov     [.charFrom], ecx
@@:

        mov     esi, [.self]
; last line processing
        stdcall TFreshEdit.__PosToPointer, [.self], [.charTo], [.indexTo]
        stdcall GetArrayItem, [esi+TFreshEdit._pLines], [.indexTo]
        jc      .finish_delete

        mov     edx, eax
        stdcall StrOffsUtf8, [edx+TEditorLine.Data], [.charTo]
        stdcall StrSplit, [edx+TEditorLine.Data], eax
        mov     [.final_str], eax

        mov     eax, [edx+TEditorLine.flags]
        mov     ecx, [edx+TEditorLine.fold_level]
        mov     [.final_flags], eax
        mov     [.final_level], ecx

; first line processing
        stdcall TFreshEdit.__PosToPointer, [.self], [.charFrom], [.indexFrom]
        mov     [.fromline], edx
        stdcall GetArrayItem, [esi+TFreshEdit._pLines], [.indexFrom]
        jc      .finish_delete
        mov     edx, eax
        mov     [.fromline], eax

        stdcall StrOffsUtf8, [edx+TEditorLine.Data], [.charFrom]
        stdcall StrTrim, [edx+TEditorLine.Data], eax
        jecxz   .splitit

        add     eax, ecx
.addspc:
        stdcall StrCharCat, [edx+TEditorLine.Data], ' '
        dec     ecx
        js      .catit
        stdcall StrCharCat, [edx+TEditorLine.Data], ' ', eax
        jnz     .addspc
        jmp     .addspc

.splitit:
.catit:
        stdcall StrSplit, [edx+TEditorLine.Data], eax
        stdcall StrDel, eax
        stdcall StrCat, [edx+TEditorLine.Data], [.final_str]
        stdcall StrDel, [.final_str]
        mov     eax, [.final_level]
        mov     ecx, [.final_flags]
        mov     [edx+TEditorLine.fold_level], eax
        or      [edx+TEditorLine.flags], ecx

; now delete all lines except the first.

        mov     edi, [.indexTo]

        mov     eax, [.indexFrom]
        mov     ecx, [.indexTo]
        sub     ecx, eax
.del_loop:
        stdcall TFreshEdit.__PosToPointer, [.self], -1, edi
        cmp     edx, [.fromline]
        inc     eax
        je      .delete_ok

        stdcall DeleteArrayItems, [esi+TFreshEdit._pLines], eax, ecx
        execute [.self], TFreshEdit.DeleteLine, edi
        mov     edi, eax
        dec     edi
        jmp     .del_loop

        mov     [esi+TFreshEdit._pLines], edx

.delete_ok:
.finish_delete:
        execute [.self], TFreshEdit.FormatLine, [.indexFrom]

        clc
        popad
        mov     eax, [.indexFrom]
        mov     edx, [.charFrom]
        return

.nothing_to_delete:
        clc
        popad
        xor     eax, eax
        dec     eax
        return

;.........................................................................................
; delete the selection
.delete_selection:
        mov     esi, [.self]
        mov     ecx, [.self]
        mov     eax, [esi+TFreshEdit._SelMode]
        cmp     eax, selmChar
        je      .del_sel_char
        cmp     eax, selmBlock
        je      .del_sel_block

        execute ecx, TFreshEdit.DeleteText, [ecx+TFreshEdit._yCaret], [ecx+TFreshEdit._xCaret],      \
        stc
        return

.del_sel_char:
        execute esi, TFreshEdit.DeleteText, [esi+TFreshEdit._yCaret], [esi+TFreshEdit._xCaret],      \
                                            [esi+TFreshEdit._ySelection], [esi+TFreshEdit._xSelection]
                                            [ecx+TFreshEdit._ySelection], [ecx+TFreshEdit._xSelection], [ecx+TFreshEdit._SelMode]
        clc
        return


.del_sel_block:
        clc
        return

;.........................................................................................

.insert_line:
virtual at ebx
  .ins_index dd ?
end virtual
        push    esi edi
        push    edx esi
        mov     esi, [.self]

; first where to search. The next line is OK, but if the line is wrapped...
        cmp     [.ins_index], -1
        jne     @f
        mov     eax, [esi+TFreshEdit._yCaret]
        mov     [.ins_index], eax
        mov     esi, [.self]
@@:

        mov     edi, [esi+TFreshEdit._pIndex]
        mov     edx, [.ins_index]
        mov     edx, [esi+TFreshEdit._pLines]

        cmp     edx, [edi+TArray.count]
        jb      .search_begin

; insert as a last line
        mov     edx, [edi+TArray.count]
        mov     ecx, -1
        mov     ecx, [.ins_index]
        jmp     .ins_here

; if the line is wrapped, search for the begin.
.search_begin:
        mov     ecx, [edi+TArray.array+4*edx]
        cmp     ecx, -1                         ; wrapped line?
        jne     .ins_here
        dec     edx
        jns     .search_begin
        jmp     .err_ins_line

; ...insert index item.
; edx contains the index in _pIndex where the new line have to be inserted.
; ecx contains the index in _pLines where the new line have to be inserted.
.ins_here:
        push    edx
        stdcall InsertArrayItems, [esi+TFreshEdit._pIndex], edx, 1
        mov     [esi+TFreshEdit._pIndex], edx
        mov     edi, edx
        pop     edx
        jc      .err_ins_line

        cmp     ecx, -1
        jne     .storeline
        jne     @f

        mov     ecx, [esi+TFreshEdit._pLines]
        mov     ecx, [esi+TFreshEdit._yCaret]
        mov     ecx, [ecx+TArray.count]

.storeline:
        mov     [eax], ecx

; ...then fix the index to the end.

        sub     edx, [edi+TArray.count]
        neg     edx
        dec     edx
        inc     ecx
        jle     .index_fixed

@@:
.inc_index:
        lea     eax, [eax+4]
        cmp     dword [eax], -1
        je      @f
        inc     dword [eax]
        cmp     ecx, [edx+TArray.count]
        jb      @f
        mov     ecx, [edx+TArray.count]
@@:
        dec     edx
        jnz     .inc_index


.index_fixed:
; then insert new line
        stdcall InsertArrayItems, [esi+TFreshEdit._pLines], ecx, 1
        stdcall InsertArrayItems, edx, ecx, 1
        mov     [esi+TFreshEdit._pLines], edx
        jc      .err_ins_line
        mov     ebx, eax

        mov     edx, eax
        stdcall StrNew

        mov     [edx+TEditorLine.Data], eax
        mov     [ebx+TEditorLine.Data], eax
        xor     eax, eax
        mov     [edx+TEditorLine.flags], eax
        mov     [edx+TEditorLine.syn_context], eax
        mov     [edx+TEditorLine.debugdata], eax
        mov     [edx+TEditorLine.width], eax
        mov     [ebx+TEditorLine.flags], eax
        mov     [ebx+TEditorLine.syn_context], eax
        mov     [ebx+TEditorLine.debugdata], eax
        mov     [ebx+TEditorLine.fold_level], eax
        mov     [ebx+TEditorLine.width], eax
        mov     eax, edx

        stdcall TFreshEdit.__FixLength, esi, 0, -1

        mov     eax, ebx

.finish_ins_line:
        pop     edi esi
        pop     esi edx
        clc
        return

.err_ins_line:
        pop     edi esi
        stc
        xor     eax, eax
        jmp     .finish_ins_line
        return

;.........................................................................................
.del_char:
locals
  .del_char_line dd ?
  .del_char_to_line dd ?
  .del_line_index dd ?
  .byte_offs dd ?
  .del_char_to_char dd ?
endl
        push    ecx edx esi edi
        push    eax ecx edx esi

        mov     esi, [.self]
        stdcall TFreshEdit.__PosToPointer, esi, [esi+TFreshEdit._xCaret], [esi+TFreshEdit._yCaret]
        jc      .end_del_char
        mov     eax, [esi+TFreshEdit._xCaret]
        mov     ecx, [esi+TFreshEdit._yCaret]
        mov     [.del_char_to_char], eax
        mov     [.del_char_to_line], ecx
        inc     [.del_char_to_char]

        test    [edx+TEditorLine.flags], lfProtected
        jnz     .end_del_char
        stdcall GetArrayItem, [esi+TFreshEdit._pLines], ecx
        jc      .do_del_char

        stdcall StrOffsUtf8, [eax+TEditorLine.Data], [.del_char_to_char]
        jecxz   .do_del_char

.del_pad_spc:
        mov     [.del_char_to_char], 0
        stdcall StrCharInsert, [edx+TEditorLine.Data], ' ', eax
        inc     eax
        inc     [.del_char_to_line]
        loop    .del_pad_spc

.do_del_char:
        mov     [.byte_offs], eax
        mov     [.del_char_line], edx
        mov     ebx, eax
        stdcall StrLen, [edx+TEditorLine.Data]
        cmp     ebx, eax
        je      .join_next_line

        execute esi, TFreshEdit.DeleteText, [esi+TFreshEdit._yCaret], [esi+TFreshEdit._xCaret], [.del_char_to_line], [.del_char_to_char], selmChar
        mov     ecx, eax
        sub     ecx, ebx

        stdcall StrPtr, [edx+TEditorLine.Data]
        mov     edi, eax
        stdcall DecodeUtf8, [edi+ebx]
        lea     esi, [edi+edx]
        sub     [edi+string.len], edx
        add     esi, ebx
        add     edi, ebx
        cld
        rep movsb

.end_del_char:
        mov     eax, [.byte_offs]
        pop     edi esi edx ecx
        pop     esi edx ecx eax
        clc
        return

.join_next_line:
        mov     eax, [.del_char_line]
        mov     edx, [esi+TFreshEdit._pLines]
        sub     eax, edx
        sub     eax, TArray.array
        shr     eax, TEditorLine.shift
        inc     eax
        cmp     eax, [edx+TArray.count]
        jae     .end_del_char

        mov     [.del_line_index], eax

        mov     edx, [.del_char_line]
        mov     ebx, edx
        add     edx, sizeof.TEditorLine
        test    [edx+TEditorLine.flags], lfProtected
        jz      .do_join

        stdcall StrLen, [ebx+TEditorLine.Data]
        test    eax, eax
        jnz     .end_del_char

.do_join:
        stdcall StrCat, [ebx+TEditorLine.Data], [edx+TEditorLine.Data]
        mov     eax, [edx+TEditorLine.flags]
        or      [ebx+TEditorLine.flags], eax

; now delete the line
        stdcall TFreshEdit.__FixLength, esi, -1, [edx+TEditorLine.width]
        stdcall StrDel, [edx+TEditorLine.Data]
        stdcall DeleteArrayItems, [esi+TFreshEdit._pLines], [.del_line_index], 1
        mov     [esi+TFreshEdit._pLines], edx

; then fix the index.
        mov     edi, [esi+TFreshEdit._pIndex]
        mov     eax, [esi+TFreshEdit._yCaret]
        mov     edx, [.del_line_index]
        inc     eax

.char_fix_index:
        cmp     eax, [edi+TArray.count]
        jae     .end_del_char

        cmp     [edi+TArray.array+4*eax], -1
        je      .next_line_fix
        cmp     [edi+TArray.array+4*eax], edx
        je      .del_index_elements

        dec     [edi+TArray.array+4*eax]

.next_line_fix:
        inc     eax
        jmp     .char_fix_index

.del_index_elements:
        mov     ecx, eax

.char_scan_loop:
        inc     ecx
        cmp     ecx, [edi+TArray.count]
        jae     .end_char_scan
        cmp     [edi+TArray.array+4*ecx], -1
        je      .char_scan_loop

.end_char_scan:
        sub     ecx, eax
        stdcall DeleteArrayItems, edi, eax, ecx
        mov     [esi+TFreshEdit._pIndex], edx
        mov     edi, edx
        mov     edx, [.del_line_index]
        jmp     .char_fix_index

;.........................................................................................
.insert_char:
; arguments
virtual at ebx
  .ins_char dd ?
end virtual

        push    ecx edx esi edi

        mov     esi, [.self]
.ins_loop:
        stdcall TFreshEdit.__PosToPointer, esi, [esi+TFreshEdit._xCaret], [esi+TFreshEdit._yCaret]
        jnc     .line_found

        execute [.self], TFreshEdit.InsertLine, -2
        jnc     .ins_loop                               ; possible hang!

        xor     edx, edx
        jmp     .end_ins_char

.line_found:
        test    [edx+TEditorLine.flags], lfProtected
        jz      .not_protected

        lea     edx, [eax+ecx]
        jmp     .end_ins_char

.not_protected:
        cmp     [.ins_char], $0d
        je      .split_here
        cmp     [.ins_char], $0a
        je      .split_here

        jecxz   .spaces_ok

.addspc2:
        stdcall StrCharInsert, [edx+TEditorLine.Data], ' ', eax
        inc     eax
        loop    .addspc2

.spaces_ok:
.do_ins_char:
        stdcall StrCharInsert, [edx+TEditorLine.Data], [.ins_char], eax
        mov     esi, eax
        stdcall DecodeUtf8, [.ins_char]
        add     edx, esi
        jmp     .end_ins_char

.split_here:
        push    eax edx

        mov     eax, [esi+TFreshEdit._yCaret]
        inc     eax
        execute [.self], TFreshEdit.InsertLine, eax
        mov     edi, eax

        pop     edx eax
        stdcall StrSplit, [edx+TEditorLine.Data], eax

        stdcall StrDel, [edi+TEditorLine.Data]
        mov     [edi+TEditorLine.Data], eax

        mov     eax, [esi+TFreshEdit._yCaret]
        inc     eax
        execute esi, TFreshEdit.FormatLine, eax
        execute esi, TFreshEdit.FormatLine, [esi+TFreshEdit._yCaret]

.split_ok:
        execute esi, TFreshEdit.LineBegin
        execute esi, TFreshEdit.Move, mvcMoveY, 1, TRUE
        xor     edx, edx

.end_ins_char:
        push    edx
        mov     esi, [.self]
        stdcall TFreshEdit.__PointerToPos, [.self], [esi+TFreshEdit._yCaret], edx
        mov     [esi+TFreshEdit._xCaret], edx
        mov     [esi+TFreshEdit._yCaret], eax
        pop     eax
        clc
        pop     edi esi edx ecx
        return
;.........................................................................................

.insert_string:
; arguments
virtual at ebx
  .hstring dd ?
end virtual

        push    ecx edx esi
        push    eax edx

        stdcall StrPtr, [.hstring]
        mov     esi, eax
        mov     ecx, [.self]

.char_loop:
        stdcall DecodeUtf8, [esi]
        jc      .end_ins_str

        execute ecx, TFreshEdit.InsertText, [ecx+TFreshEdit._yCaret], [ecx+TFreshEdit._xCaret], [.hstring], [ecx+TFreshEdit._InsMode]
        mov     eax, [esi]
        add     esi, edx

        mov     [ecx+TFreshEdit._yCaret], eax
        lea     ecx, [8*edx]
        mov     edx, 1
        mov     [ecx+TFreshEdit._xCaret], edx
        shl     edx, cl
        dec     edx
        and     eax, edx

        cmp     eax, 0
        pop     edx eax
        je      .end_ins_str

        cmp     eax, $0d
        je      .ins_cr
        cmp     eax, $0a
        jne     .ins_it

.ins_cr:
        xor     al, $0d xor $0a
        cmp     al, [esi]
        je      .char_loop

.ins_it:
        execute [.self], TFreshEdit.InsertChar, eax
        jmp     .char_loop

.end_ins_str:
        clc
        pop     esi edx ecx
        return

;.........................................................................................
.linebegin:
        stdcall TFreshEdit.__FitCaretInWindow, [.self]
        jnz     .endlb

        mov     eax, [.self]
        mov     [eax+TFreshEdit._xCaret], 0
        mov     [eax+TFreshEdit._LeftColumn], 0

.endlb:
        clc
        return

;.........................................................................................
.lineend:
        push    ecx edx esi edi
        push    edx esi edi
        mov     esi, [.self]

        stdcall TFreshEdit.__FitCaretInWindow, esi
        jnz     .endle

        mov     esi, [.self]
        mov     ecx, [esi+TFreshEdit._yCaret]
        mov     ebx, [esi+TFreshEdit._pIndex]

        stdcall TFreshEdit.__PosToPointer, esi, [esi+TFreshEdit._xCaret], [esi+TFreshEdit._yCaret]
        mov     ebx, eax
        stdcall GetArrayItem, [esi+TFreshEdit._pLines], [esi+TFreshEdit._yCaret]
        jnc     .inline

        stdcall StrPtr, [edx+TEditorLine.Data]
        mov     edi, eax

        mov     [esi+TFreshEdit._xCaret], 0
; search the end of the current line
.el_loop:
        stdcall DecodeUtf8, [edi+ebx]
        test    eax, eax
        jz      .el_found
        cmp     eax, $01
        je      .el_found

        add     ebx, edx
        jmp     .el_loop
        jmp     .endle

.el_found:
.inline:
        stdcall TFreshEdit.__PointerToPos, esi, [esi+TFreshEdit._yCaret], ebx
        mov     [esi+TFreshEdit._yCaret], eax
        mov     [esi+TFreshEdit._xCaret], edx
        mov     eax, [eax+TEditorLine.width]
        mov     [esi+TFreshEdit._xCaret], eax

.endle:
        pop     edi esi edx
        clc
        return


;.........................................................................................
.filebegin:
        mov     ecx, [.self]

        stdcall TFreshEdit.__FitCaretInWindow, esi
        pop     edi esi edx ecx
        stdcall TFreshEdit.__FitCaretInWindow, ecx
        jnz     .endfb

        mov     [ecx+TFreshEdit._TopLine], 0
        mov     [ecx+TFreshEdit._yCaret], 0
        mov     [ecx+TFreshEdit._ySelection], 0

.endfb:
        clc
        return

;.........................................................................................
.fileend:
        mov     ecx, [.self]

        stdcall TFreshEdit.__FitCaretInWindow, ecx
        jnz     .endfe

        mov     eax, [ecx+TFreshEdit._pLines]
        mov     eax, [eax+TArray.count]
        dec     eax
        jns     @f
        inc     eax
@@:
        mov     [ecx+TFreshEdit._yCaret], eax
        mov     [ecx+TFreshEdit._ySelection], eax

        inc     eax
        sub     eax, [ecx+TFreshEdit._rows]
        jns     @f
        xor     eax, eax
@@:
        mov     [ecx+TFreshEdit._TopLine], eax

.endfe:
        clc
        return

;.........................................................................................
.pagebegin:
        mov     ecx, [.self]
        stdcall TFreshEdit.__FitCaretInWindow, ecx
        jnz     .endpb

        mov     eax, [ecx+TFreshEdit._TopLine]
        mov     [ecx+TFreshEdit._yCaret], eax
        mov     [ecx+TFreshEdit._ySelection], eax

.endpb:
        clc
        return

;.........................................................................................
.pageend:
        push    edx

        mov     ecx, [.self]
        stdcall TFreshEdit.__FitCaretInWindow, ecx
        jnz     .endpe

        mov     eax, [ecx+TFreshEdit._TopLine]
        add     eax, [ecx+TFreshEdit._rows]
        dec     eax
        jns     @f
        xor     eax, eax
@@:
        mov     edx, [ecx+TFreshEdit._pLines]
        cmp     eax, [edx+TArray.count]
        jb      @f
        mov     eax, [edx+TArray.count]
        dec     eax
@@:
        mov     [ecx+TFreshEdit._yCaret], eax
        mov     [ecx+TFreshEdit._ySelection], eax

.endpe:
        pop     edx
        clc
        return


;.........................................................................................
; The method TFreshEdit.Move moves the caret towards given direction and on
; the given count of steps.
;
.movecaret:
virtual at ebx

        test    [.direction], mvcMoveX or mvcMoveY
        jz      .fitok

        cmp     [.force], 0
        jne     .fitok

        stdcall TFreshEdit.__FitCaretInWindow, esi

        test    eax, eax
        jnz     .endmove

.fitok:
        test    [.direction], mvcMoveX or mvcMoveY or mvcScrollX or mvcScrollY
        jz      .endmove

        test    [.direction], mvcMoveX or mvcScrollX
        jnz     .move_horizontal

        test    [.direction], mvcMoveY or mvcScrollY
        jnz     .move_vertical

.endmove:
        clc
        pop     edi esi edx
        return


.move_horizontal:
        test    [.direction], mvcMoveX
        jz      .xcaretok

        mov     ecx, [esi+TFreshEdit._xCaret]
        add     ecx, [.count]
        jns     @f
        mov     ecx, [.count]
        add     [esi+TFreshEdit._xCaret], ecx
        jns     .xcaretok
        xor     ecx, ecx
@@:
        mov     [esi+TFreshEdit._xCaret], ecx
        mov     [esi+TFreshEdit._xCaret], 0

.xcaretok:
        test    [.direction], mvcScrollX
        jz      .leftcolok

        mov     ecx, [esi+TFreshEdit._LeftColumn]
        add     ecx, [.count]
        jns     @f
        mov     ecx, [.count]
        add     [esi+TFreshEdit._LeftColumn], ecx
        jns     .leftcolok
        xor     ecx, ecx
@@:
        mov     [esi+TFreshEdit._LeftColumn], ecx
        mov     [esi+TFreshEdit._LeftColumn], 0

.leftcolok:

        mov     ecx, [esi+TFreshEdit._xCaret]
        mov     edx, [esi+TFreshEdit._LeftColumn]
        cmp     ecx, edx
        jb      .hscroll

        add     edx, [esi+TFreshEdit._cols]
        cmp     ecx, edx
        jb      .endmove

.hscroll:
        mov     ecx, [esi+TFreshEdit._cols]
        mov     eax, [.count]

;. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

.move_vertical:
        test    [.direction], mvcMoveY
        jz      .ycaretok

        mov     ecx, [esi+TFreshEdit._yCaret]
        add     ecx, [.count]
        jns     @f
        mov     ecx, [.count]
        add     [esi+TFreshEdit._yCaret], ecx
        jns     .ycaretok
        xor     ecx, ecx
@@:
        mov     [esi+TFreshEdit._yCaret], ecx
        mov     [esi+TFreshEdit._yCaret], 0

.ycaretok:
        test    [.direction], mvcScrollY
        jz      .toplineok

        mov     ecx, [esi+TFreshEdit._TopLine]
        add     ecx, [.count]
        mov     ecx, [.count]
        jns     @f
        xor     ecx, ecx
@@:
        mov     edx, [esi+TFreshEdit._pIndex]
        mov     edx, [edx+TArray.count]
        sub     edx, [esi+TFreshEdit._rows]
        jns     @f
        add     [esi+TFreshEdit._TopLine], ecx
        jns     .toplineok
        xor     edx, edx
@@:
        cmp     ecx, edx
        jl      @f
        mov     ecx, edx
@@:
        mov     [esi+TFreshEdit._TopLine], ecx
        mov     [esi+TFreshEdit._TopLine], 0

.toplineok:

        mov     ecx, [esi+TFreshEdit._yCaret]
        mov     eax, [esi+TFreshEdit._pIndex]
        mov     eax, [esi+TFreshEdit._pLines]
        mov     eax, [eax+TArray.count]
        cmp     ecx, eax
        jb      @f
        lea     ecx, [eax-1]
@@:
        mov     [esi+TFreshEdit._yCaret], ecx

        mov     edx, [esi+TFreshEdit._TopLine]
        cmp     ecx, edx
        jb      .vscroll
        add     edx, [esi+TFreshEdit._rows]
        cmp     edx, eax
        jae     .vscroll

        cmp     ecx, edx
        jb      .endmove

.vscroll:
        test    [.direction], mvcMoveX or mvcMoveY
        jz      .endmove                             ; it is only scroll, so don't care about caret.

        mov     [ebx+TEditorLine.Data], 0
        add     ebx, sizeof.TEditorLine
        dec     ecx
        jmp     .clrloop

.endclr:
        mov     ebx, [.self]
        stdcall FreeMem, [ebx+TFreshEdit._pIndex]
        stdcall FreeMem, [ebx+TFreshEdit._pLines]
        stdcall FreeMem, [ebx+TFreshEdit._pLengths]

        stdcall CreateArray, 4
        mov     [ebx+TFreshEdit._pIndex], eax

        stdcall CreateArray, sizeof.TEditorLine
        mov     [ebx+TFreshEdit._pLines], eax

        stdcall CreateArray, 4
        mov     [ebx+TFreshEdit._pLengths], eax

        xor     eax, eax

        mov     [ebx+TFreshEdit._fShadowValid], eax
        mov     [ebx+TFreshEdit._xCaret], eax
        mov     [ebx+TFreshEdit._yCaret], eax
        mov     [ebx+TFreshEdit._xSelection], eax
        mov     [ebx+TFreshEdit._ySelection], eax

        execute ebx, TFreshEdit.Refresh
        stdcall TFreshEdit.__UpdateScrollBars, ebx

        clc
        return


;.........................................................................................
;  method .PixelToCaret, .xPixel, .yPixel
;    .xPixel, .yPixel - coordinates of pixel related to the editor window.
;  Returns:
;    eax - index of the text line in TFreshEdit._pLines array.
;    edx - character in the line.
.pixel_to_caret:
virtual at ebx
  .xPixel dd ?
  .yPixel dd ?
end virtual

        mov     esi, [.self]

        mov     ecx, [.xPixel]
        mov     eax, [.yPixel]

        mov     edi, [esi+TFreshEdit._FreeArea.x]
        mov     edx, [esi+TFreshEdit._FreeArea.y]

        cmp     ecx, edi
        jl      .pixel_outside
        cmp     eax, edx
        jl      .pixel_outside

        add     edi, [esi+TFreshEdit._FreeArea.width]
        add     edx, [esi+TFreshEdit._FreeArea.height]

        cmp     ecx, edi
        jge     .pixel_outside
        cmp     eax, edx
        jge     .pixel_outside

        sub     ecx, [esi+TFreshEdit.__LeftMargin]
        jge     @f
        xor     ecx, ecx
@@:
        cdq
        idiv    [esi+TFreshEdit._fontheight]
        add     eax, [esi+TFreshEdit._TopOffset]
        mov     [.yPixel], eax

        mov     eax, ecx
        cdq
        idiv    [esi+TFreshEdit._fontwidth]
        add     eax, [esi+TFreshEdit._LeftColumn]
        mov     [.xPixel], eax

; search the line and char

; first the line:
        mov     edi, [esi+TFreshEdit._TopLine]
        stdcall GetArrayItem, [esi+TFreshEdit._pLines], edi

        test    [eax+TEditorLine.flags], lfWordWrap





        mov     edx, [.xPixel]
        mov     eax, [.yPixel]
        clc
        return

.pixel_outside:
        xor     eax, eax
        dec     eax
        clc
        return

;.........................................................................................
;  method .CaretToPixel, .iRow, .xChar
.caret_to_pixel:





endp



;_________________________________________________________________________________________



proc TFreshEdit.SysEventHandler, .pobj, .pEvent
.changes dd ?
begin
        push    eax ebx ecx edx esi edi
        push    eax ebx edx esi edi

        mov     [.changes], 0
        mov     ebx, [.pEvent]
        mov     esi, [.pobj]

        mov     eax, [ebx+TSysEvent.event]

        cmp     [ebx+TSysEvent.event], seMouseBtnRelease
        je      .mousebtnrelease

        cmp     [ebx+TSysEvent.event], seMouseMove
        je      .mousemove


.continue:
        stc
.finish:
        pop     edi esi edx ecx ebx eax
        pop     edi esi edx ebx eax
        return

;.........................................................................................
.mousemove:
        mov     ecx, mcText
        mov     eax, [ebx+TMouseMoveEvent.x]
        cmp     eax, [esi+TFreshEdit.__LeftMargin]
        ja      @f
        mov     ecx, mcArrow
@@:
        mov     [esi+TFreshEdit._cursor], ecx

        cmp     [esi+TFreshEdit._DragButton], mbLeft
        jne     .continue

        stdcall TFreshEdit.__MoveCaretToPixel, esi, [ebx+TMouseMoveEvent.x], [ebx+TMouseMoveEvent.y]
        stdcall TFreshEdit.__PixelToCaretPos, esi, [ebx+TMouseMoveEvent.x], [ebx+TMouseMoveEvent.y]
        jc      .continue

        mov     [esi+TFreshEdit._yCaret], eax
        mov     [esi+TFreshEdit._xCaret], edx

        jmp     .refresh

;.........................................................................................
.mousebtnrelease:
        mov     eax, [ebx+TMouseButtonEvent.Button]
        cmp     eax, [esi+TFreshEdit._DragButton]
        jne     .continue

        stdcall MouseCapture, [esi+TWindow.handle]
        mov     eax, [ebx+TMouseButtonEvent.Button]
        mov     [esi+TFreshEdit._DragButton], eax

        cmp     [ebx+TMouseButtonEvent.Button], mbLeft
        jne     .continue

        stdcall TFreshEdit.__MoveCaretToPixel, esi, [ebx+TMouseButtonEvent.x], [ebx+TMouseButtonEvent.y]
        stdcall TFreshEdit.__PixelToCaretPos, esi, [ebx+TMouseButtonEvent.x], [ebx+TMouseButtonEvent.y]
        jc      .continue

        mov     [esi+TFreshEdit._yCaret], eax
        mov     [esi+TFreshEdit._xCaret], edx
        jmp     .refresh

.left_margin_process:
        sub     edx, 16
        cmp     ecx, edx
        jl      .continue       ; number or breakpoint click

; Fold/unfold click
; check for the fold/unfold icon under the cursor
        xor     edx, edx
        div     [esi+TFreshEdit._fontheight]
        add     eax, [esi+TFreshEdit._TopLine]

        mov     edx, [esi+TFreshEdit._pIndex]
        cmp     eax, [edx+TArray.count]
        jae     .continue

        mov     ecx, [edx+TArray.array+4*eax]
        cmp     ecx, -1
        je      .continue       ; it is not fold icon row.

        shl     ecx, TEditorLine.shift
        add     ecx, [esi+TFreshEdit._pLines]
        add     ecx, TArray.array                       ; pointer to TEditorLine

        test    [ecx+TEditorLine.flags], lfFoldHeader
        jz      .continue

; determine what is the current state folded or expanded
locals
  .current dd ?
  .next    dd ?
endl
        mov     [.current], eax        ; current line index
        mov     ecx, [edx+TArray.array+4*eax]
        inc     ecx

.next_loop:
        inc     eax
        cmp     eax, [edx+TArray.count]
        jae     .folded

        cmp     [edx+TArray.array+4*eax], -1
        je      .next_loop

        mov     [.next], eax
        cmp     ecx, [edx+TArray.array+4*eax]         ; the next index == current+1 -> expanded
        jne     .folded

; so, fold it...
        stdcall TFreshEdit.__FoldZoneLen, esi, [.current]

        mov     ecx, [.next]
        sub     ecx, [.current]
        inc     ecx

        cmp     eax, ecx
        jbe     .continue       ; nothing to fold

        sub     eax, ecx
        stdcall DeleteArrayItems, [esi+TFreshEdit._pIndex], [.next], eax
        mov     [esi+TFreshEdit._pIndex], edx

        stdcall TFreshEdit.__UpdateScrollBars, esi
        or      [.changes], chgfNeedRefresh
        jmp     .refresh

.folded:
; the zone is folded, so restore the index items.
        stdcall TFreshEdit.__RestoreIndex, esi, [.current], [.next]
        stdcall TFreshEdit.__UpdateScrollBars, esi
        or      [.changes], chgfNeedRefresh
;        sub     edx, 16
;        cmp     ecx, edx
;        jl      .continue       ; number or breakpoint click
;
;; Fold/unfold click
;; check for the fold/unfold icon under the cursor
;        xor     edx, edx
;        div     [esi+TFreshEdit._fontheight]
;        add     eax, [esi+TFreshEdit._TopLine]
;
;        mov     edx, [esi+TFreshEdit._pIndex]
;        cmp     eax, [edx+TArray.count]
;        jae     .continue
;
;        mov     ecx, [edx+TArray.array+4*eax]
;        cmp     ecx, -1
;        je      .continue       ; it is not fold icon row.
;
;        shl     ecx, TEditorLine.shift
;        add     ecx, [esi+TFreshEdit._pLines]
;        add     ecx, TArray.array                       ; pointer to TEditorLine
;
;        test    [ecx+TEditorLine.flags], lfFoldHeader
;        jz      .continue
;
;; determine what is the current state folded or expanded
;locals
;  .current dd ?
;  .next    dd ?
;endl
;        mov     [.current], eax        ; current line index
;        mov     ecx, [edx+TArray.array+4*eax]
;        inc     ecx
;
;.next_loop:
;        inc     eax
;        cmp     eax, [edx+TArray.count]
;        jae     .folded
;
;        cmp     [edx+TArray.array+4*eax], -1
;        je      .next_loop
;
;        mov     [.next], eax
;        cmp     ecx, [edx+TArray.array+4*eax]         ; the next index == current+1 -> expanded
;        jne     .folded
;
;; so, fold it...
;        stdcall TFreshEdit.__FoldZoneLen, esi, [.current]
;
;        mov     ecx, [.next]
;        sub     ecx, [.current]
;        inc     ecx
;
;        cmp     eax, ecx
;        jbe     .continue       ; nothing to fold
;
;        sub     eax, ecx
;        stdcall DeleteArrayItems, [esi+TFreshEdit._pIndex], [.next], eax
;        mov     [esi+TFreshEdit._pIndex], edx
;
;        stdcall TFreshEdit.__UpdateScrollBars, esi
;        or      [.changes], chgfNeedRefresh
;        jmp     .refresh
;
;.folded:
;; the zone is folded, so restore the index items.
;        stdcall TFreshEdit.__RestoreIndex, esi, [.current], [.next]
;        stdcall TFreshEdit.__UpdateScrollBars, esi
;        or      [.changes], chgfNeedRefresh
        jmp     .refresh

;.........................................................................................
.scroll:
        cmp     [ebx+TScrollEvent.ScrollBar], scrollX
        je      .xscroll

locals
  .byte_offs dd ?
endl
        cmp     [esi+TFreshEdit._fReadOnly], froReadWrite
        jne     .refresh

        execute esi, TFreshEdit.DeleteSel
        test    eax, eax
        js      @f
        mov     [esi+TFreshEdit._yCaret], eax
        mov     [esi+TFreshEdit._xCaret], edx
@@:
        execute esi, TFreshEdit.InsertChar, [ebx+TKeyboardEvent.key]
        mov     [.byte_offs], eax

        stdcall StrNew
        push    eax

        stdcall StrCharCat, eax, [ebx+TKeyboardEvent.key]

        execute esi, TFreshEdit.InsertString, eax

        stdcall StrDel ; from the stack

        mov     [.byte_offs], 0

; is it necessary???
        execute esi, TFreshEdit.FormatLine, [esi+TFreshEdit._yCaret]
        add     [.byte_offs], eax

        stdcall TFreshEdit.__PointerToPos, esi, [esi+TFreshEdit._yCaret], [.byte_offs]

        mov     [esi+TFreshEdit._yCaret], eax
        mov     [esi+TFreshEdit._xCaret], edx
;        execute esi, TFreshEdit.FormatLine, [esi+TFreshEdit._yCaret]
;        add     [.byte_offs], eax
;
;        stdcall GetArrayItem, [esi+TFreshEdit._pLines], [esi+TFreshEdit._yCaret]
;
;        stdcall StrCharUtf8, [eax+TEditorLine.Data], [.byte_offs]
;        mov     [esi+TFreshEdit._xCaret], eax

        stdcall TFreshEdit.__UpdateScrollBars, esi
        stdcall TFreshEdit.__FitCaretInWindow, esi

        or     [.changes], chgfNeedRefresh
        jmp    .refresh

.handler_pgdn:
        mov     eax, [esi+TFreshEdit._rows]
        dec     eax
        mov     ecx, mvcMoveY or mvcScrollY
        jmp     .moveit


.moveit:
        test    [ebx+TKeyboardEvent.kbdStatus], maskScrLk
        jnz     .scroll_override

        cmp     [esi+TFreshEdit._fReadOnly], froReadOnlyNoCaret
        jne     .scroll_override_ok

.handler_end:
        execute esi, TFreshEdit.LineEnd
        jmp     .refresh

;. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

.handler_pgbeg:
        execute esi, TFreshEdit.ScreenBegin
        jmp     .refresh

;. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

.handler_pgend:
        execute esi, TFreshEdit.ScreenEnd
        jmp     .refresh

;. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

.handler_txtbeg:
        execute esi, TFreshEdit.FileBegin
        jmp     .refresh

;. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

.handler_txtend:
        execute esi, TFreshEdit.FileEnd
        jmp     .refresh

;. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

.handler_wordleft:
        jmp     .refresh

;. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

.handler_wordright:
        jmp     .refresh

;. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
.handler_delete:
locals
  .byte_offs2 dd ?
endl
        cmp     [esi+TFreshEdit._fReadOnly], froReadWrite
        jne     .refresh

        execute esi, TFreshEdit.DeleteSel
        test    eax, eax
        jns     .deleted
        mov     eax, [esi+TFreshEdit._yCaret]
        mov     ecx, [esi+TFreshEdit._xCaret]
        cmp     eax, [esi+TFreshEdit._ySelection]
        jne     .havesel
        cmp     ecx, [esi+TFreshEdit._xSelection]
        jne     .havesel

        execute esi, TFreshEdit.DelChar
        mov     [.byte_offs2], eax
        jmp     .end_del
        execute esi, TFreshEdit.FormatLine, [esi+TFreshEdit._yCaret]
        stdcall TFreshEdit.__PointerToPos, esi, edx, [.byte_offs2]

.havesel:
.deleted:
        execute esi, TFreshEdit.DeleteSel
        mov     [esi+TFreshEdit._yCaret], eax
        mov     [esi+TFreshEdit._xCaret], edx

.end_del:
        stdcall TFreshEdit.__FitCaretInWindow, esi
        stdcall TFreshEdit.__UpdateScrollBars, esi
        or      [.changes], chgfNeedRefresh
        jmp     .refresh

;. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
; BUG:  it does not works as expected, but I don't have anough patience to fix it just now.....
; BUG:  it does not works as expected, but I don't have enough patience to fix it just now.....
.handler_backspc:
        cmp     [esi+TFreshEdit._fReadOnly], froReadWrite
        jne     .refresh

        push    [esi+TFreshEdit._xCaret] [esi+TFreshEdit._yCaret]
        execute esi, TFreshEdit.Move, mvcMoveX, -1, FALSE
        mov     edx, [esi+TFreshEdit._yCaret]
        mov     ecx, [esi+TFreshEdit._xCaret]
        pop     edx eax

        cmp     eax, [esi+TFreshEdit._xCaret]
        jne     .do_del
        dec     ecx
        cmp     edx, [esi+TFreshEdit._yCaret]
        je      .refresh
        jns     .posok

.do_del:
        stdcall TFreshEdit.__PosToPointer, esi, [esi+TFreshEdit._xCaret], [esi+TFreshEdit._yCaret]
        dec     edx
        stdcall GetArrayItem, [esi+TFreshEdit._pLines], edx
        test    ecx, ecx
        jnz     .refresh
        jc      .refresh

        stdcall StrLen, [edx+TEditorLine.Data]
        cmp     ecx, eax
        stdcall StrLenUtf8, [eax+TEditorLine.Data], -1
        mov     ecx, eax
        jae     .refresh

.posok:
        execute esi, TFreshEdit.DeleteText, edx, ecx, [esi+TFreshEdit._yCaret], [esi+TFreshEdit._xCaret]
        mov     [esi+TFreshEdit._yCaret], eax
        mov     [esi+TFreshEdit._xCaret], edx
        jmp     .handler_delete
        jmp     .end_del


;. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
.handler_linedel:
        cmp     [esi+TFreshEdit._fReadOnly], froReadWrite
        jne     .refresh

        execute esi, TFreshEdit.DeleteLine, [esi+TFreshEdit._yCaret]

        cmp     [esi+TFreshEdit._fReadOnly], froReadWrite
        jne     .refresh

        stdcall Get, esi, TFreshEdit.CurrentLine
        jc      .refresh

        xor     [eax+TEditorLine.flags], lfWordWrap
        execute esi, TFreshEdit.FormatLine, [esi+TFreshEdit._yCaret]
        stdcall TFreshEdit.__UpdateScrollBars, esi
        or      [.changes], chgfNeedRefresh
        jmp     .refresh

;. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

.handler_bookmark:

        or      [.changes], chgfNeedRefresh
        jmp     .caretmoved

.scrollerok:
        mov     eax, [esi+TFreshEdit._xCaret]
        mov     ecx, [esi+TFreshEdit._yCaret]
        mov     edx, [esi+TFreshEdit._InsMode]
        cmp     eax, [esi+TFreshEdit._prevxCaret]
        cmp     eax, [esi+TFreshEdit._prevCaretChar]
        jne     .caretmoved
        cmp     ecx, [esi+TFreshEdit._prevyCaret]
        cmp     ecx, [esi+TFreshEdit._prevCaretLine]
        jne     .caretmoved
        cmp     edx, [esi+TFreshEdit._prevInsMode]
        je      .caretposok

.caretmoved:
        stdcall TFreshEdit.__UpdateCaretPosition, esi

        mov     ecx, [esi+TFreshEdit._LeftColumn]
        mov     [esi+TFreshEdit._prevTopLine], eax
        mov     [esi+TFreshEdit._prevLeftColumn], ecx

        mov     eax, [esi+TFreshEdit._xCaret]
        mov     ecx, [esi+TFreshEdit._yCaret]
        mov     edx, [esi+TFreshEdit._InsMode]
        mov     [esi+TFreshEdit._prevxCaret], eax
        mov     [esi+TFreshEdit._prevyCaret], ecx
        mov     [esi+TFreshEdit._prevCaretChar], eax
        mov     [esi+TFreshEdit._prevCaretLine], ecx
        mov     [esi+TFreshEdit._prevInsMode], edx

        mov     eax, [esi+TFreshEdit._xSelection]
        mov     ecx, [esi+TFreshEdit._ySelection]
        sub     eax, [esi+TFreshEdit._xCaret]
        sub     ecx, [esi+TFreshEdit._yCaret]
        mov     edx, [esi+TFreshEdit._SelMode]

.finish_event:
        test    [.changes], chgfFinished
        jz      .continue
        clc
        jmp     .finish

;.........................................................................................
uglobal
  Prevtime dd ?
endg

.paint:

      if defined options.DebugMode and options.DebugMode
        stdcall GetTimestamp
        xchg    eax, [Prevtime]
        sub     eax, [Prevtime]
        neg     eax
        OutputRegister regEAX, 10
      end if

        cmp     [esi+TFreshEdit._fShadowValid], 0
        jne     @f
        stdcall TFreshEdit.__DrawShadow, esi
@@:
        stdcall SetClipRectangle, [ebx+TPaintEvent.context], 0
        stdcall TScrollWindow.SysEventHandler, [.pobj], [.pEvent]
        stdcall DrawBackBuffer, [ebx+TPaintEvent.context], [esi+TFreshEdit._pShadow], 0, 0

; debug mode of autoscroll with maximal speed.
;        execute esi, TFreshEdit.Move, mvcMoveY or mvcScrollY, 2, TRUE
;        execute esi, TFreshEdit.Refresh
;        stdcall TFreshEdit.__UpdateScrollBars, esi

        clc
        jmp     .finish

;.........................................................................................

.moveresize:
        stdcall Get, esi, TFreshEdit.FreeArea

        mov     [esi+TFreshEdit._fShadowValid], 0
        jmp     .continue
endp



;_________________________________________________________________________________________



proc TFreshEdit.__MoveCaretToPixel, .editor, .x, .y
begin
        push    ecx edx esi

        xor     ecx, ecx
        mov     esi, [.editor]

; x
        mov     eax, [.y]
        mov     edx, [esi+TFreshEdit._FreeArea.y]
        cmp     eax, edx
        jl      .nomove

        add     edx, [esi+TFreshEdit._FreeArea.height]
        cmp     eax, edx
        jge     .nomove

        mov     eax, [.x]
        mov     edx, [esi+TFreshEdit._FreeArea.x]
        cmp     eax, edx
        jl      .nomove

        add     edx, [esi+TFreshEdit._FreeArea.width]
        cmp     eax, edx
        jge     .nomove

        sub     eax, [esi+TFreshEdit.__LeftMargin]
        jge     @f
        xor     eax, eax
@@:
        cdq
        idiv    [esi+TFreshEdit._fontwidth]
        add     eax, [esi+TFreshEdit._LeftColumn]

        cmp     [esi+TFreshEdit._xCaret], eax
        je      @f

        test    eax, eax
        js      @f

        mov     [esi+TFreshEdit._xCaret], eax
@@:
; y
        mov     eax, [.y]
        cdq
        idiv    [esi+TFreshEdit._fontheight]
        add     eax, [esi+TFreshEdit._TopLine]

        cmp     [esi+TFreshEdit._yCaret], eax
        je      @f

        test    eax, eax
        js      @f
        mov     [esi+TFreshEdit._yCaret], eax
@@:
        mov     eax, ecx
        clc

.finish:
        pop     esi edx ecx
        return

.nomove:
        stc
        jmp     .finish
endp




proc TFreshEdit.__DrawShadow, .editor
  .context  dd  ?
  .latest   dd  ?
  .color     dd ?

        cmp     eax, [edi+TBackBuffer.width]
        jge     .wrapok

        stdcall SetSimpleLine, [.context], [FreshEditTheme.clWrapColumn]
        stdcall DrawLine, [.context], eax, 0, eax, [edi+TBackBuffer.height]

.wrapok:
; ebx is pointer to the index array.
        mov     ebx, [esi+TFreshEdit._pIndex]
        mov     ebx, [esi+TFreshEdit._pLines]

; edx is the number of the line in [pIndex]
        mov     edx, [esi+TFreshEdit._TopLine]

; ecx is the y coordinate of the line.
        mov     ecx, [esi+TFreshEdit._fontheight]
        sub     ecx, [esi+TFreshEdit._fontdescent]
;        sub     ecx, 3                                  ; this is not good.

; check the first line
.searchbegin:
        cmp     [ebx+TArray.array+4*edx], -1
        jne     .lineloop

        sub     ecx, [esi+TFreshEdit._fontheight]
        dec     edx
        xor     ecx, ecx
        jnz     .searchbegin

; so draw the lines.
.lineloop:
        mov     eax, ecx
        sub     eax, [esi+TFreshEdit._fontheight]
        add     eax, [esi+TFreshEdit._fontdescent]
        cmp     eax, [edi+TBackBuffer.height]
        cmp     ecx, [edi+TBackBuffer.height]
        jge     .endlines

        cmp     edx, [ebx+TArray.count]
        jae     .endlines

; call the TFreshEditLineType.procDraw for the current line type.
        stdcall TFreshEdit.__DrawLine, esi, [.context], edx, ecx
        add     ecx, [esi+TFreshEdit._fontheight]

        inc     edx
        jmp     .lineloop

.endlines:
; fix the left line border to the end of the windows.
        add     ecx, [esi+TFreshEdit._fontdescent]
        mov     eax, [esi+TFreshEdit.__LeftMargin]
        sub     ecx, [esi+TFreshEdit._fontheight]
        sub     eax, 2
        stdcall SetSimpleLine, [.context], [FreshEditTheme.clLeftMarginBorder]
        stdcall DrawLine, [.context], eax, ecx, eax, [edi+TBackBuffer.height]
        stdcall SetSimpleLine, [.context], [FreshEditTheme.clLeftMargin]
        dec     eax
        stdcall DrawLine, [.context], eax, ecx, eax, [edi+TBackBuffer.height]
        dec     eax
        stdcall DrawLine, [.context], eax, ecx, eax, [edi+TBackBuffer.height]

        stdcall ReleaseContext, [.context]

.finish:
        mov     [esi+TFreshEdit._fShadowValid], 1

        popad
        return
endp


; y is the coordinate of the top of the line!
; returns the height of the line in characters.
; if the line is not drawn (because is hidden) returns 0

proc TFreshEdit.__DrawLine, .editor, .context, .indexLine, .y
proc TFreshEdit.__DrawLine, .editor, .context, .iLine, .y
  .line   dd  ?
  .last_line dd ?

  .attr   dd  ?
  .ysel0  dd  ?
  .xsel0  dd  ?
  .ysel1  dd  ?
  .xsel1  dd  ?

  .unfold dd  ?

  .next   dd  ?
  .markh  dd  ?

  .linenumber dd ?

  .fold_icon dd ?
  .fold_line dd ?

begin
        pushad

        mov     edi, [.editor]
        mov     esi, [.editor]

        mov     [.line], -1
        mov     [.unfold], 0

        mov     eax, [.indexLine]
        mov     eax, [.iLine]
        lea     ecx, [eax+1]
        mov     edx, [edi+TFreshEdit._pIndex]

.nextloop:
        cmp     ecx, [edx+TArray.count]
        jae     .unfoldok
        cmp     [edx+TArray.array+4*ecx], -1
        jne     @f
        inc     ecx
        jmp     .nextloop
@@:
        push    ecx
        mov     ecx, [edx+TArray.array+4*ecx]
        dec     ecx
        cmp     ecx, [edx+TArray.array+4*eax]
        pop     ecx
        je      .unfoldok

        mov     [.unfold], 1

.unfoldok:
        mov     [.next], ecx

; if the line is part of the word-wrapped line, don't draw the text, because it is already OK.
        mov     edx, [edx+TArray.array+4*eax]     ; index in pLines
        mov     [.linenumber], edx
        inc     [.linenumber]           ; count it from 1
        cmp     edx, -1
        je      .end_draw_text       ; wrapped line.

        mov     eax, [edi+TFreshEdit._pLines]
        mov     edi, [esi+TFreshEdit._pLines]
        mov     [.last_line], 0
        mov     eax, [eax+TArray.count]
        dec     eax
        cmp     eax, edx
        jne     @f
        inc     [.last_line]    ; flag that this line is the last line.
@@:
        shl     edx, TEditorLine.shift
        shl     eax, TEditorLine.shift
        add     edx, [edi+TFreshEdit._pLines]
        add     edx, TArray.array
        lea     edi, [edi+TArray.array+eax]
        mov     [.line], edx                      ; pointer to TEditorLines

; draw the text of the line
;. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
        stdcall StrLen, [edx+TEditorLine.Data]
        test    eax, eax
        jz      .empty_string

        mov     ecx, eax
        shl     eax, 4          ; sizeof.TCharAttr =  16

        stdcall GetMem, eax     ; attr array.
        mov     [.attr], eax
        mov     esi, eax

        mov     ebx, [FreshEditTheme.clSimpleText]
        test    [edx+TEditorLine.flags], lfProtected
        jz      @f
        mov     ebx, [FreshEditTheme.clProtectedText]
@@:
        mov     edx, [edi+TFreshEdit._Font]

; fill the attribute array with the default values.
.attrloop:
        mov     [esi+TCharAttr.color], ebx
        mov     [esi+TCharAttr.font], edx
        lea     esi, [esi+sizeof.TCharAttr]
        loop    .attrloop

        mov     edx, [.line]
        test    [edx+TEditorLine.flags], lfProtected
        jnz     .syntaxok

; Call the syntax highlighter if any:
        xor     ecx, ecx
        cmp     [.indexLine], ecx
        je      @f
        mov     ecx, [edx-sizeof.TEditorLine+TEditorLine.syn_context]
@@:
        cmp     [edi+TFreshEdit._procSyntax], 0
        je      .syntaxok

        push    edi edx
        stdcall [edi+TFreshEdit._procSyntax], [edx+TEditorLine.Data], [.attr], ecx
        pop     edx edi
        mov     [edx+TEditorLine.syn_context], eax

.syntaxok:
        stdcall StrPtr, [edx+TEditorLine.Data]
        cmp     byte [eax], 0
        je      .end_draw_text

        stdcall DrawColoredString, [.context], eax, [.attr], [eax+string.len], [edi+TFreshEdit.__LeftMargin],     \
                                   [.y], [edi+TFreshEdit._LeftColumn], [edi+TFreshEdit._fontwidth], [edi+TFreshEdit._fontheight]

        stdcall FreeMem, [.attr]

.end_draw_text:

; draw left margin graphics:
        stdcall TFreshEdit.__DrawLeftMargin, edi, [.context], [.indexLine]

; now draw transparent selection

; selection bounds.
        mov     eax, [edi+TFreshEdit._xSelection]
        mov     ecx, [edi+TFreshEdit._ySelection]
        mov     ebx, [edi+TFreshEdit._xCaret]
        mov     edx, [edi+TFreshEdit._yCaret]
        mov     eax, [esi+TFreshEdit._xSelection]
        mov     ecx, [esi+TFreshEdit._ySelection]
        mov     ebx, [esi+TFreshEdit._xCaret]
        mov     edx, [esi+TFreshEdit._yCaret]

        cmp     ecx, edx
        jl      @f
        je      .sortx
        xchg    ecx, edx
        cmp     [edi+TFreshEdit._SelMode], selmChar
        cmp     [esi+TFreshEdit._SelMode], selmChar
        jne     @f
        xchg    eax, ebx
@@:
        cmp     [edi+TFreshEdit._SelMode], selmChar
        cmp     [esi+TFreshEdit._SelMode], selmChar
        je      .endsort

.sortx:
        cmp     eax, ebx
        jle     @f
        xchg    eax, ebx
@@:

.endsort:
        mov     [.xsel0], eax
        mov     [.ysel0], ecx
        mov     [.xsel1], ebx
        mov     [.ysel1], edx

        mov     eax, [.indexLine]
        mov     eax, [.iLine]
        cmp     eax, [.ysel0]
        jl      .end_sel
        cmp     eax, [.ysel1]
        jg      .end_sel

        mov     eax, [edi+TFreshEdit._SelMode]
        mov     eax, [esi+TFreshEdit._SelMode]

        cmp     eax, selmChar
        je      .selchar

; sel block
        mov     eax, [.xsel0]
        cmp     eax, [.xsel1]
        je      .end_sel

        sub     eax, [edi+TFreshEdit._LeftColumn]
        sub     eax, [esi+TFreshEdit._LeftColumn]
        jge     @f
        xor     eax, eax
@@:
        imul    eax, [edi+TFreshEdit._fontwidth]
        add     eax, [edi+TFreshEdit.__LeftMargin]
        imul    eax, [esi+TFreshEdit._fontwidth]
        add     eax, [esi+TFreshEdit.__LeftMargin]

        mov     ecx, [.xsel1]
        sub     ecx, [edi+TFreshEdit._LeftColumn]
        sub     ecx, [esi+TFreshEdit._LeftColumn]
        jge     @f
        xor     ecx, ecx
@@:
        imul    ecx, [edi+TFreshEdit._fontwidth]
        add     ecx, [edi+TFreshEdit.__LeftMargin]
        imul    ecx, [esi+TFreshEdit._fontwidth]
        add     ecx, [esi+TFreshEdit.__LeftMargin]
        sub     ecx, eax
        jmp     .drawsel

.selchar:
        xor     eax, eax
        mov     edx, [.indexLine]
        mov     edx, [.iLine]
        cmp     edx, [.ysel0]
        jne     .firstok

        mov     eax, [.xsel0]
        sub     eax, [edi+TFreshEdit._LeftColumn]
        sub     eax, [esi+TFreshEdit._LeftColumn]
        jge     .firstok
        xor     eax, eax

.firstok:
        imul    eax, [edi+TFreshEdit._fontwidth]
        add     eax, [edi+TFreshEdit.__LeftMargin]
        imul    eax, [esi+TFreshEdit._fontwidth]
        add     eax, [esi+TFreshEdit.__LeftMargin]

        mov     ecx, [edi+TFreshEdit._cols]    ; selection is to the end of the line, for the intermediate lines.
        mov     ecx, [esi+TFreshEdit._cols]    ; selection is to the end of the line, for the intermediate lines.
        inc     ecx

        cmp     edx, [.ysel1]
        jne     .lastok

        mov     ecx, [.xsel1]
        sub     ecx, [edi+TFreshEdit._LeftColumn]
        sub     ecx, [esi+TFreshEdit._LeftColumn]
        test    ecx, ecx
        jns     .lastok
        xor     ecx, ecx

.lastok:
        imul    ecx, [edi+TFreshEdit._fontwidth]
        add     ecx, [edi+TFreshEdit.__LeftMargin]
        imul    ecx, [esi+TFreshEdit._fontwidth]
        add     ecx, [esi+TFreshEdit.__LeftMargin]
        sub     ecx, eax

.drawsel:
        mov     edx, [.y]
        sub     edx, [edi+TFreshEdit._fontheight]
        add     edx, 3
;        sub     edx, [esi+TFreshEdit._fontheight]
;        add     edx, 3

        stdcall SetDrawMode, [.context], [FreshEditTheme.clSelMode]
;        stdcall SetDrawMode, [.context], [FreshEditTheme.clSelMode]
        stdcall DrawFillRect, [.context], eax, edx, ecx, [edi+TFreshEdit._fontheight], [FreshEditTheme.clSelBack]
        stdcall SetDrawMode, [.context], cmCopy
        stdcall DrawFillRect, [.context], eax, edx, ecx, [esi+TFreshEdit._fontheight], [FreshEditTheme.clSelBack]

.end_sel:
        mov     eax, [.iLine]
        mov     edi, [esi+TFreshEdit._pLines]
        shl     eax, TEditorLine.shift
        lea     edi, [edi+TArray.array+eax]

; draw the text of the line

; allocate memory for the color data.
        stdcall StrLen, [edi+TEditorLine.Data]
        test    eax, eax
        jz      .end_draw_text

        mov     ecx, eax
        shl     eax, 4          ; sizeof.TCharAttr =  16

        stdcall GetMem, eax     ; attr array.
        mov     [.attr], eax
        mov     edx, eax

        mov     ebx, [FreshEditTheme.clSimpleText]
        test    [edi+TEditorLine.flags], lfProtected
        jz      @f
        mov     ebx, [FreshEditTheme.clProtectedText]
@@:
        mov     eax, [esi+TFreshEdit._Font]

; fill the attribute array with the default values.
.attrloop:
        mov     [edx+TCharAttr.color], ebx
        mov     [edx+TCharAttr.font], eax
        lea     edx, [edx+sizeof.TCharAttr]
        loop    .attrloop

.attrok:
; Call the syntax highlighter if any:
        cmp     [esi+TFreshEdit._procSyntax], 0
        je      .syntaxok

; get the syntax context of the previous line:
        xor     ecx, ecx
        cmp     [.iLine], ecx
        je      .prev_ok                ; there is no previous line

        lea     edx, [edi-sizeof.TEditorLine]

        mov     ecx, [edx+TEditorLine.syn_context]
        or      ecx, ttNewLine

; ecx contains the syntax context:
.prev_ok:
        stdcall [esi+TFreshEdit._procSyntax], [edi+TEditorLine.Data], [.attr], ecx
        mov     [edi+TEditorLine.syn_context], eax

.syntaxok:
        stdcall StrPtr, [edi+TEditorLine.Data]
        mov     ecx, [.y]
        add     ecx, [esi+TFreshEdit._fontheight]
        sub     ecx, [esi+TFreshEdit._fontdescent]
        stdcall DrawColoredString, [.context], eax, [.attr], [eax+string.len], [esi+TFreshEdit.__LeftMargin],     \
                                   ecx, [esi+TFreshEdit._LeftColumn], [esi+TFreshEdit._fontwidth], [esi+TFreshEdit._fontheight]

        stdcall FreeMem, [.attr]

.end_draw_text:

        stdcall TFreshEdit.__DrawLeftMargin, esi, [.context], edi, [.y]



.finish_draw_line:
        popad
        return

.empty_string:
        mov     eax, [.indexLine]
        mov     ecx, [FreshEditTheme.clBackground]
        cmp     eax, [.ysel0]
        jb      .setback
        cmp     eax, [.ysel1]
        jae     .setback

        mov     ecx, [FreshEditTheme.clSelBack]

.setback:
        jmp     .end_draw_text

endp





proc TFreshEdit.__DrawLeftMargin, .editor, .context, .indexLine
proc TFreshEdit.__DrawLeftMargin, .editor, .context, .pLine, .y

.x         dd ?
.y         dd ?
.width     dd ?
.height    dd ?

.maxptr    dd ?

.ytext     dd ?
.yicons    dd ?

.unfold    dd ?  ; is the line folded?
.indexNext dd ?  ; the index of the next line in TFreshEdit._pIndex

.pNext     dd ?  ; pointer to the next line.
.ipLines   dd ?  ; the index of the current line in pLines array.
.ptrLine   dd ?  ; pointer of the current TEditorLine.
.pPrev     dd ?  ; pointer to the previous line.

.fold_icon dd ?
.fold_line dd ?

begin
        pushad

        mov     esi, [.editor]

        test    [FreshEditTheme.Options], eoLeftMargin
        jz      .finish

        stdcall SetDrawMode, [.context], cmCopy

; search for the next line index;
        mov     ecx, [.indexLine]
        mov     edx, [esi+TFreshEdit._pIndex]
        cmp     [edx+TArray.array+4*ecx], -1
        je      .finish

        mov     [.unfold], 0
        mov     edx, [esi+TFreshEdit._pLines]
        mov     ecx, [edx+TArray.count]
        shl     ecx, TEditorLine.shift
        lea     ecx, [edx+TArray.array+ecx]
        mov     [.maxptr], ecx

        xor     eax, eax
        dec     eax
        mov     ecx, [.pLine]

.nextloop:
        inc     ecx
        cmp     ecx, [edx+TArray.count]
        sub     ecx, sizeof.TEditorLine
        cmp     ecx, [esi+TFreshEdit._pLines]
        jae     .found_next

        cmp     [edx+TArray.array+4*ecx], eax
        je      .nextloop

        ja      @f
        xor     ecx, ecx
.found_next:
        mov     [.indexNext], ecx

@@:
        mov     eax, [.indexLine]
        mov     eax, [edx+TArray.array+4*eax]   ; current line - index in pLines
        mov     [.ipLines], eax
        mov     [.pPrev], ecx

        cmp     ecx, [edx+TArray.count]
        jae     .unfoldok

        mov     ecx, [edx+TArray.array+4*ecx]   ; next line index in pLines
        dec     ecx
        cmp     ecx, eax
        mov     ecx, [.pLine]
        add     ecx, sizeof.TEditorLine
        mov     [.pNext], ecx
        setne   byte [.unfold]

.unfoldok:
        mov     edx, eax
        mov     [.unfold], 0
        mov     edx, [.pLine]
        shl     edx, TEditorLine.shift
        add     edx, TArray.array
        add     edx, [esi+TFreshEdit._pLines]
        mov     [.ptrLine], edx

; determine the bounds of the drawing
        mov     ecx, [.indexNext]

        sub     ecx, [.indexLine]
        mov     eax, [esi+TFreshEdit.__LeftMargin]
        imul    ecx, [esi+TFreshEdit._fontheight]
        mov     ecx, [esi+TFreshEdit._fontheight]

        mov     [.width], eax
        mov     [.height], ecx

        xor     eax, eax
        mov     [.x], eax

        mov     eax, [.indexLine]
        mov     eax, [.y]
        sub     eax, [esi+TFreshEdit._TopLine]
        imul    eax, [esi+TFreshEdit._fontheight]
        mov     [.y], eax                               ; it can be negative for the word wrapped lines, partially displayed.

        add     eax, [esi+TFreshEdit._fontheight]
        sub     eax, [esi+TFreshEdit._fontdescent]
        mov     [.ytext], eax

        mov     ecx, [esi+TFreshEdit._iconBreakpointA]
        mov     eax, [esi+TFreshEdit._fontheight]
        sub     eax, [ecx+TImage.height]
        sar     eax, 1
        adc     eax, [.y]
        mov     [.yicons], eax

; draw the bookmark background.

        test    [edx+TEditorLine.flags], lfBookmark
        jz      .bookmarkok
        mov     eax, [.width]
        sub     eax, 4
        stdcall DrawFillRect, [.context], [.x], [.y], eax, [.height], [FreshEditTheme.clBookmarkBack]
.bookmarkok:

        dec     eax
        stdcall DrawLine, [.context], eax, [.y], eax, ecx
        jmp     .borderok

.wrap_border:
        dec     ecx

        push    ecx  eax [.y] eax [.context]       ; vertical
        push    [.y] eax [.y] eax [.context]       ; upper edge
        push    ecx  eax [.y] eax [.context]       ; vertical   ye x ys x
        push    [.y] eax [.y] eax [.context]       ; upper edge ys
        push    ecx  eax ecx  eax [.context]       ; down edge

; down edge
        mov     ebx, [.pNext]
        sub     dword [esp+4], 2
        sub     dword [esp+12], 2
        sub     dword [esp+16], 2
        stdcall DrawLine

        sub     dword [esp+12], 2
        sub     dword [esp+4], 2
        add     dword [esp+16], 2
        sub     dword [esp+12], 2
        stdcall DrawLine

        sub     dword [esp+4], 2
        add     dword [esp+8], 2
        sub     dword [esp+12], 2
        sub     dword [esp+16], 1
        stdcall DrawLine

        mov     ebx, [FreshEditTheme.clLeftMargin]
        test    [edx+TEditorLine.flags], lfBookmark
        jz      @f
        mov     ebx, [FreshEditTheme.clBookmarkBack]
@@:
        stdcall SetSimpleLine, [.context], ebx

        push    [.y] eax [.y] eax [.context]       ; upper edge
        push    [.y] eax [.y] eax [.context]       ; upper edge
        push    ecx  eax ecx  eax [.context]       ; down corner pixels
        push    ecx  eax ecx  eax [.context]       ; down corner pixels
        mov     ebx, [.pNext]

        push    ecx  eax ecx  eax [.context]       ; down edge
        push    ecx  eax ecx  eax [.context]       ; down edge

        sub     dword [esp+4], 2
        stdcall DrawLine

        sub     dword [esp+4], 2
        sub     dword [esp+8], 1
        sub     dword [esp+12], 2
        stdcall DrawLine

        push    [.y] eax [.y] eax [.context]       ; upper edge
        push    [.y] eax [.y] eax [.context]       ; upper edge

        sub     dword [esp+4], 2
        stdcall DrawLine

        sub     dword [esp+4], 2
        add     dword [esp+8], 1
        sub     dword [esp+12], 2
        stdcall DrawLine

.borderok:
; Line number draw
.borderok:
        test    [FreshEditTheme.Options], eoLineNumbers
        jz      .line_numbers_ok

        mov     ecx, [.ipLines]
        test    ecx, ecx
        jl      .line_numbers_ok

        mov     ecx, [.pLine]
        sub     ecx, [esi+TFreshEdit._pLines]
        sub     ecx, TArray.array
        shr     ecx, TEditorLine.shift
        inc     ecx

        stdcall NumToStr, ecx, ntsDec or ntsUnsigned
        push    eax eax
        stdcall StrLen, eax
        mov     ecx, eax
        stdcall StrPtr ; from the stack
        mov     ebx, eax

        stdcall GetTextBounds, [.context], eax, ecx, 0 ; [edi+TFreshEdit._Font]
        stdcall GetTextBounds, [.context], eax, ecx, 0
        sub     eax, [esi+TFreshEdit.__NumberMargin]
        neg     eax
        stdcall DrawString, [.context], ebx, ecx, eax, [.ytext], 0, [FreshEditTheme.clLeftMarginText]
        stdcall StrDel ; from the stack

.line_numbers_ok:
; draw icons in the middle

; icon breakpoint
        mov     edx, [.ptrLine]
        mov     edx, [.pLine]
        test    [edx+TEditorLine.flags], lfBreakpoint
        jnz     .draw_breakpoint

        cmp     [edx+TEditorLine.debugdata], 0
        je      .breakpoint_ok

.draw_breakpoint:

        mov     ecx, [esi+TFreshEdit._iconBreakpointI]
@@:
        stdcall DrawMaskedImage, [.context], eax, ecx

.breakpoint_ok:

; draw fold tree.

        mov     edx, [.ptrLine]
        mov     edx, [.pLine]

; first, determine, what icon should be set for fold/unfold icon:
        xor     ecx, ecx
        mov     ebx, [esi+TFreshEdit._pIndex]
        mov     eax, [.indexNext]
        cmp     eax, [ebx+TArray.count]
        mov     eax, [.pNext]
        cmp     eax, [.maxptr]
        jae     @f
        mov     eax, [ebx+TArray.array+4*eax]   ; index in pLines of the next visible line.
        shl     eax, TEditorLine.shift
        mov     ecx, [esi+TFreshEdit._pLines]
        mov     ecx, eax
        lea     ecx, [ecx+TArray.array+eax]
@@:
        cmp     [.pPrev], 0
        je      .fold_fold

        mov     eax, [.pPrev]
        mov     eax, [edx-sizeof.TEditorLine+TEditorLine.fold_level]
        test    [edx+TEditorLine.flags], lfFoldHeader
        jnz     .fold_fold
        cmp     eax, [edx+TEditorLine.fold_level]
        jb      .fold_fold

        jecxz   .fold_end

        mov     eax, [ecx+TEditorLine.fold_level]
        cmp     eax, [edx+TEditorLine.fold_level]
        ja      .fold_continue
        jb      .fold_end

        test    [ecx+TEditorLine.flags], lfFoldHeader
        jz      .fold_continue

.fold_end:
        xor     eax, eax
        mov     ecx, 2          ; 2 means corner up/right
        jmp     .fold_ok

.fold_fold:
        mov     ecx, 1          ; 1 means half vertical down
        mov     eax, [esi+TFreshEdit._iconUnfold]
        cmp     [.unfold], 0

        jne     .fold_ok
        mov     eax, [esi+TFreshEdit._iconFold]
        jmp     .fold_ok

.fold_continue:
        xor     eax, eax
        xor     ecx, ecx        ; 0 means full vertical line

.height dd ?
.offset dd ?
begin
        push    eax ebx edx

        mov     ebx, [.editor]


        mov     eax, [ebx+TFreshEdit._fontheight]
        mov     edx, [ebx+TFreshEdit._fontwidth]

        mov     [.offset], 0

        cmp     [ebx+TFreshEdit._InsMode], modeInsert
        jne     .sizeok

proc TFreshEdit.__UpdateScrollBars, .editor
begin
        push    eax ebx ecx edx

        mov     ebx, [.editor]

; V scroller
        mov     eax, [ebx+TFreshEdit._pIndex]
        mov     eax, [ebx+TFreshEdit._pLines]
        mov     eax, [eax+TArray.count]
        sub     eax, [ebx+TFreshEdit._rows]
        mov     [ebx+TFreshEdit._VScroller.Max], eax

        mov     eax, [ebx+TFreshEdit._TopLine]
        mov     [ebx+TFreshEdit._VScroller.Pos], eax

.endset:
        test    eax, eax
        pop     esi edx ecx ebx
        return
endp

; Converts x,y position in the text to memory parameters
; arguments:
;   .x, .y - x and y coordinates of the position.
; returns:
; edx - pointer to the TEditorLine
; eax - byte offset inside the string that corresponds with the given position.
; ecx - count of the spaces that have to be inserted on offset eax in the string
;       in order to reach the .x coordinate (when the position is beyond the end of the line)
proc TFreshEdit.__PosToPointer, .editor, .x, .y
.pline dd ?
.start dd ?
begin
        push    ebx esi edi

        mov     edi, [.editor]
        mov     eax, [.y]
        mov     ebx, [edi+TFreshEdit._pIndex]
        cmp     eax, [ebx+TArray.count]
        jae     .error

        xor     ecx, ecx

; Arguments:
.lineloop:
        mov     edx, [ebx+TArray.array+4*eax]
        cmp     edx, -1
        jne     .found

        inc     ecx
        dec     eax
        jns     .lineloop

;
; Returns:
; CF=0
;    eax - number of the line
;    edx - offset inside the line
; CF=1
.error:
        stc
        jmp     .finish

;    the pixel is outside the client area.
.crash_error:
        int3
        jmp     .error

;
; ecx is the wrapped line count.
; edx is the number of string in the lines array.
.found:
        mov     ebx, [edi+TFreshEdit._pLines]
proc TFreshEdit.__PixelToCaretPos, .editor, .x, .y
        cmp     edx, [ebx+TArray.count]
        jae     .crash_error

begin
        shl     edx, TEditorLine.shift
        lea     eax, [ebx+TArray.array+edx]

        push    ebx ecx esi edi
        mov     [.pline], eax        ; handle of the string.

        cmp     [.x], -1
        je      .only_line

        xor     ecx, ecx
        stdcall StrPtr, [eax+TEditorLine.Data]
        mov     esi, eax
        mov     esi, [.editor]
        mov     [.start], eax
        jecxz   .wrapok

.wraploop:
        stdcall DecodeUtf8, dword [esi]
        add     esi, edx

; x
        test    eax, eax
        jz      .crash_error

        cmp     eax, $01        ; line wrap char
        jne     .wraploop

        dec     ecx
        jnz     .wraploop

.wrapok:
        mov     ecx, [.x]
        mov     eax, [.y]
        jecxz   .endofstring

        mov     edx, [esi+TFreshEdit._FreeArea.y]
.charloop:
        stdcall DecodeUtf8, dword [esi]
        test    eax, eax
        jz      .endofstring
        cmp     eax, $01
        je      .endofstring
        cmp     eax, edx
        jl      .nomove

        add     esi, edx
        dec     ecx
        jnz     .charloop
        add     edx, [esi+TFreshEdit._FreeArea.height]
        cmp     eax, edx
        jge     .nomove

.endofstring:
        sub     esi, [.start]
        mov     eax, esi
        mov     eax, [.x]

.only_line:
        mov     edx, [.pline]
        mov     edx, [esi+TFreshEdit._FreeArea.x]

        clc

.finish:
        pop     edi esi ebx
        cmp     eax, edx
        return
endp

        jl      .nomove

; Converts the pointer parameters to caret coordinate.
; arguments:
;   .index - index of the line
;   .offset - byte offset inside the string.
; returns:
;   eax - y coordinate of the caret
;   edx - x coordinate of the caret
;   ecx - pointer to the current TEditorLine

proc TFreshEdit.__PointerToPos, .editor, .index, .offset
.base dd ?
.x    dd ?
begin
        push    esi edi

        mov     esi, [.editor]
        mov     edi, [esi+TFreshEdit._pIndex]
        mov     ecx, [.index]
        add     edx, [esi+TFreshEdit._FreeArea.width]
        cmp     eax, edx
        jge     .nomove

.line_loop:
        cmp     [edi+TArray.array+4*ecx], -1
        jne     .found
        dec     ecx
        sub     eax, [esi+TFreshEdit.__LeftMargin]
        jge     @f
        xor     eax, eax
        jns     .line_loop

@@:
.error:
        stc
        cdq
        jmp     .finish

        idiv    [esi+TFreshEdit._fontwidth]
.found:
        mov     [.base], ecx                ; base index
        mov     [.x], 0

        mov     ecx, [edi+TArray.array+4*ecx] ; index in pLines
        shl     ecx, TEditorLine.shift
        add     ecx, [esi+TFreshEdit._pLines]
        add     eax, [esi+TFreshEdit._LeftColumn]
        add     ecx, TArray.array

        cmp     [.offset], 0
        je      .ready

        push    eax
; y
        stdcall StrPtr, [ecx+TEditorLine.Data]
        mov     esi, eax

        mov     eax, [.y]
        cdq
.char_loop:
        stdcall DecodeUtf8, [esi]
        jc      .error
        add     esi, edx

        idiv    [esi+TFreshEdit._fontheight]
        cmp     eax, 1  ; wrap char
        jne     .no_wrap

        inc     [.base]
        mov     [.x], -1

.no_wrap:
        inc     [.x]
        sub     [.offset], edx
        ja      .char_loop

.ready:
        mov     eax, [.base]
        mov     edx, [.x]
        add     eax, [esi+TFreshEdit._TopLine]
        pop     edx
        clc

.finish:
        pop     edi esi
        pop     edi esi ecx ebx
        return
endp



.nomove:
        stc
; .hString - the string containing the line.
;
; returns:
;   eax - the width of the line in chars.
;         if the line contains wrapped sublines,
;         the maximal length will be returned.

proc TFreshEdit.__LineWidth, .hString
.maxlen dd ?
begin
        push    esi ecx edx

        mov     [.maxlen], 0
        stdcall StrPtr, [.hString]
        mov     esi, eax

.outer:
        xor     ecx, ecx

.loop:
        stdcall DecodeUtf8, [esi]
        jc      .error

        add     esi, edx

        test    eax, eax
        jz      .endofline

        cmp     eax, $01        ; wrap char
        je      .endofline

        inc     ecx
        jmp     .loop
        jmp     .finish

.endofline:
endp
        cmp     ecx, [.maxlen]
        jbe     .maxok
        mov     [.maxlen], ecx
.maxok:
        test    eax, eax
        jnz     .outer

        mov     eax, [.maxlen]
        clc

.error:
        pop     edx ecx esi
        return
endp




proc TFreshEdit.__FixLength, .editor, .newlen, .oldlen
begin
        push    eax ecx edx esi edi

        mov     [esi+TFreshEdit._pLengths], edx

        pop     edi esi edx ecx eax
        return
endp




proc TFreshEdit.__ComputeLeftMargin, .editor
begin
        pushad
        mov     esi, [.editor]
        xor     ebx, ebx
        mov     [esi+TFreshEdit.__NumberMargin], ebx

proc TFreshEdit.__FoldZoneLen, .editor, .index
.result dd ?
begin
        pushad

        mov     [.result], 0

        mov     esi, [.editor]
        mov     edi, [esi+TFreshEdit._pLines]
        mov     edx, [esi+TFreshEdit._pIndex]

        mov     eax, [.index]
        cmp     eax, [edx+TArray.count]
        jae     .finish

        mov     ecx, [edx+TArray.array+4*eax]   ; index of the first element.
        shl     ecx, TEditorLine.shift
        mov     ebx, [edi+TArray.array+ecx+TEditorLine.fold_level]

.loop:
        inc     [.result]
        inc     eax
        cmp     eax, [edx+TArray.count]
        je      .finish

        mov     ecx, [edx+TArray.array+4*eax]
        cmp     ecx, -1
        je      .loop

        shl     ecx, TEditorLine.shift

        cmp     [edi+TArray.array+ecx+TEditorLine.fold_level], ebx
        jb      .finish
        ja      .loop

        test    [edi+TArray.array+ecx+TEditorLine.flags], lfFoldHeader
        jz      .loop
;        mov     esi, [.editor]
;        mov     edi, [esi+TFreshEdit._pLines]
;        mov     edx, [esi+TFreshEdit._pIndex]
;
;        mov     eax, [.index]
;        cmp     eax, [edx+TArray.count]
;        jae     .finish
;
;        mov     ecx, [edx+TArray.array+4*eax]   ; index of the first element.
;        shl     ecx, TEditorLine.shift
;        mov     ebx, [edi+TArray.array+ecx+TEditorLine.fold_level]
;
;.loop:
;        inc     [.result]
;        inc     eax
;        cmp     eax, [edx+TArray.count]
;        je      .finish
;
;        mov     ecx, [edx+TArray.array+4*eax]
;        cmp     ecx, -1
;        je      .loop
;
;        shl     ecx, TEditorLine.shift
;
;        cmp     [edi+TArray.array+ecx+TEditorLine.fold_level], ebx
;        jb      .finish
;        ja      .loop
;
;        test    [edi+TArray.array+ecx+TEditorLine.flags], lfFoldHeader
;        jz      .loop

.finish:
        popad
        mov     eax, [.result]
        return
endp


proc TFreshEdit.__RestoreIndex, .editor, .start_index, .end_index
begin
        pushad

        mov     esi, [.editor]
        mov     edi, [esi+TFreshEdit._pIndex]

        mov     eax, [.start_index]
        mov     edx, [.end_index]

        mov     ebx, [edi+TArray.array+4*edx]
        mov     ecx, [edi+TArray.array+4*eax]   ; index of the first element
        sub     ebx, ecx
        dec     ebx
        jz      .finish

        stdcall InsertArrayItems, [esi+TFreshEdit._pIndex], edx, ebx
        mov     [esi+TFreshEdit._pIndex], edx

        add     [.end_index], ebx

.fill_loop:
        inc     ecx
        mov     [eax], ecx
        add     eax, 4
        dec     ebx
        jnz     .fill_loop

        mov     ecx, [.end_index]

.format_loop:
        execute esi, TFreshEdit.FormatLine, ecx
        dec     ecx
        cmp     ecx, [.start_index]
        jne     .format_loop

.finish:
        popad
        return
endp


proc TFreshEdit.__AddFormatLine, .hstring, .format
begin
        test    [.format], lfBookmark or lfWordWrap or lfProtected
        jz      .format_ok

        stdcall StrCharCat, [.hstring], ';#F:'
        stdcall StrCharCat, [.hstring], ';'

        test    [.format], lfBookmark
        jz      @f
        stdcall StrCharCat, [.hstring], 'b'    ; ctrl-B == Bookmark
@@:
        test    [.format], lfWordWrap
        jz      @f
        stdcall StrCharCat, [.hstring], 'w'   ; ctrl-A == Word wrap
@@:
        test    [.format], lfProtected
        jz      @f
        stdcall StrCharCat, [.hstring], 'p'   ; ctrl-D == Protected
@@:
        stdcall StrCharCat, [.hstring], ':F#;'
        stdcall StrCharCat, [.hstring], $0a0d

.format_ok:
        return
endp


; decodes format line (begining with ';#F:')
; returns:
;       CF=0 if the line contains format information.
;            eax - format flags
;            ecx - format line length;
;

; decodes format line (ending with ':F#;')
; returns:
;       CF=0 if the line contains format information.
;            eax - format flags
;            ecx - format line length;
;

proc TFreshEdit.__DecodeFormatLine, .pString
begin
        push    ebx esi

        std

        mov     esi, [.pString]
        mov     ecx, [esi+string.len]
        jecxz   .not_format

        lea     esi, [esi+ecx-1]

        lodsb
        cmp     al, ';'
        jne     .not_format
        lodsb
        cmp     al, '#'
        jne     .not_format
        lodsb
        cmp     al, 'F'
        jne     .not_format
        lodsb
        cmp     al, ':'
        jne     .not_format

        xor     ebx, ebx

.format_loop:
        lodsb
        test    al, al
        jz      .not_format
        jecxz   .eol

        cmp     al, $0d
        cmp     al, ';'
        je      .eol
        cmp     al, $0a
        je      .eol

        cmp     al, 'b'
        jne     @f
        or      ebx, lfBookmark
        jmp     .format_loop
@@:

        jmp     .format_loop
@@:

.not_format:
        xor     eax, eax
        pop     esi ebx
        stc
        cld
        return

.eol:
        mov     ah, al
        xor     ah, $0a xor $0d
        lodsb
        cmp     al, ah
        je      .format_ok
        dec     esi

.format_ok:
        sub     esi, [.pString]
        mov     ecx, esi
        mov     eax, ebx
        pop     esi ebx
        clc
        cld
        return
endp








endmodule