This repository is a mirror!

;    - 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 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 = 32       ; set breakpoint in debug mode.



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

  .fold_level   dd  ?
  .debugdata    dd  ?   ; pointer to debug data, associated to this line

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


  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
modeOverwrite = 1

; selection modes

selmChar = 0
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.


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

  ._pLines          dd  ?   ; pointer to TArray of TEditorLine items.

  ._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  ?   ; pointer to TBackBuffer object.
  ._fShadowValid    dd  ?   ;

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

; view change fields


  ._LeftColumn      dd  ?   ; the column of the text at the leftmost side of the window.

  ._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  ?        ; NOTE: on selmBlock, the word wrap should be OFF
  ._InsMode         dd  ?
  ._TabStop         dd  ?

; end change fields

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

  ._prevCaretChar   dd  ?
  ._prevCaretLine   dd  ?

  ._prevxDelta      dd  ?
  ._prevyDelta      dd  ?

  ._prevSelMode     dd  ?
  ._prevInsMode     dd  ?

; end backup fields

  ._DragButton      dd  ?



  ._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. read only
  param .Text           ; whole text; read/write
  param .MaxLineLen

; Commands

  method .Clear

  method .Left
  method .Right
  method .Up
  method .Down

  method .LineBegin
  method .LineEnd


  method .FileBegin
  method .FileEnd



  method .PageUp
  method .PageDown



  method .InsertString, .hString




;


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


; Coordinates convertions






  method .PixelToCaret, .xPixel, .yPixel
  method .CaretToPixel, .iRow, .xChar

; themes methods

  method LoadTheme, .configdb, .directory

endobj













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    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], 4




        mov     [ebx+TFreshEdit._DragButton], -1

        stdcall CreateArray, sizeof.TEditorLine
        mov     [ebx+TFreshEdit._pLines], 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
        clc
        return
endp



;_________________________________________________________________________________________


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

; free all text data
        execute ebx, TFreshEdit.Clear

; 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:


        mov     ecx, [.pobj]





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





                                         [ecx+TFreshEdit._ySelection], [ecx+TFreshEdit._xSelection], [ecx+TFreshEdit._SelMode]

        clc

        return









;................................................................
.gettext:
        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 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 TFreshEdit.__AddFormatLine, ebx, [esi+TEditorLine.flags]

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

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

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

.currentline:


        mov     ecx, [.pobj]
        stdcall GetArrayItem, [ecx+TFreshEdit._pLines], [ecx+TFreshEdit._yCaret]


        jnc     .endgcl






        xor     eax, eax

.endgcl:














        clc

        return

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

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

;_________________________________________________________________________________________


proc TFreshEdit.Set, .pobj, .paramID, .value
begin




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

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

        stc



        return

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

        pop     edx eax esi
        clc
        return

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

.settext:

locals
.pLine    dd ?

endl
        push    eax ebx edx esi edi

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

        stdcall StrPtr, [.value]
        mov     esi, eax

.lineloop:









        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     [.pLine], eax

        mov     [eax+TEditorLine.Data], ebx
        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


        stdcall StrPtr, ebx
        stdcall TFreshEdit.__DecodeFormatLine, eax
        jc      .format_ok

        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

; 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
        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.InsertString
        je      .insert_string

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

        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     ecx, [.self]
        mov     [ecx+TFreshEdit._fShadowValid], 0
        stc
        return


















































































































































































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

        push    edx esi
        mov     esi, [.self]

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

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

        shr     eax, TEditorLine.shift







        stdcall StrDel, [ecx+TEditorLine.Data]
        stdcall TFreshEdit.__FixLength, esi, -1, [ecx+TEditorLine.width]





        stdcall DeleteArrayItems, edx, eax, 1








        mov     [esi+TFreshEdit._pLines], edx






; delete the wrapped line (if any)









.end_del_line:
        clc
        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

        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

        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:
; have the same arguments and local variables as .get_text













        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      .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 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 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


.addspc:

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

.catit:


        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     eax, [.indexFrom]
        mov     ecx, [.indexTo]
        sub     ecx, eax


        inc     eax

        stdcall DeleteArrayItems, [esi+TFreshEdit._pLines], eax, ecx




        mov     [esi+TFreshEdit._pLines], edx

.finish_delete:


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








;.........................................................................................
; delete the selection
.delete_selection:
        mov     ecx, [.self]





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





                                            [ecx+TFreshEdit._ySelection], [ecx+TFreshEdit._xSelection], [ecx+TFreshEdit._SelMode]





        clc
        return

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

.insert_line:
virtual at ebx
  .ins_index dd ?
end virtual
        push    edx esi






        mov     esi, [.self]



        mov     edx, [esi+TFreshEdit._pLines]






        mov     ecx, [.ins_index]






















        cmp     ecx, -1
        jne     @f

        mov     ecx, [esi+TFreshEdit._yCaret]









        inc     ecx

@@:


        cmp     ecx, [edx+TArray.count]
        jb      @f
        mov     ecx, [edx+TArray.count]
@@:






        stdcall InsertArrayItems, edx, ecx, 1
        mov     [esi+TFreshEdit._pLines], edx
        jc      .err_ins_line
        mov     ebx, eax


        stdcall StrNew

        mov     [ebx+TEditorLine.Data], eax
        xor     eax, 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


        stdcall TFreshEdit.__FixLength, esi, 0, -1

        mov     eax, ebx

.finish_ins_line:
        pop     esi edx
        clc
        return

.err_ins_line:
        xor     eax, eax
        jmp     .finish_ins_line


;.........................................................................................
.del_char:
locals
  .del_char_to_line dd ?

  .del_char_to_char dd ?
endl
        push    eax ecx edx esi

        mov     esi, [.self]
        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]


        stdcall GetArrayItem, [esi+TFreshEdit._pLines], ecx
        jc      .do_del_char

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

        mov     [.del_char_to_char], 0

        inc     [.del_char_to_line]


.do_del_char:






        execute esi, TFreshEdit.DeleteText, [esi+TFreshEdit._yCaret], [esi+TFreshEdit._xCaret], [.del_char_to_line], [.del_char_to_char], selmChar















        pop     esi edx ecx eax
        clc
        return









































































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



















































































.insert_string:

virtual at ebx
  .hstring dd ?
end virtual

        push    eax edx


        mov     ecx, [.self]




        execute ecx, TFreshEdit.InsertText, [ecx+TFreshEdit._yCaret], [ecx+TFreshEdit._xCaret], [.hstring], [ecx+TFreshEdit._InsMode]


        mov     [ecx+TFreshEdit._yCaret], eax

        mov     [ecx+TFreshEdit._xCaret], edx




        pop     edx eax

















        clc

        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    edx esi edi
        mov     esi, [.self]

        stdcall TFreshEdit.__FitCaretInWindow, esi
        jnz     .endle





        stdcall GetArrayItem, [esi+TFreshEdit._pLines], [esi+TFreshEdit._yCaret]
        jnc     .inline



        mov     [esi+TFreshEdit._xCaret], 0









        jmp     .endle

.inline:

        mov     eax, [eax+TEditorLine.width]
        mov     [esi+TFreshEdit._xCaret], eax

.endle:
        pop     edi esi edx
        clc
        return


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

        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


        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, [.count]
        add     [esi+TFreshEdit._xCaret], ecx
        jns     .xcaretok


        mov     [esi+TFreshEdit._xCaret], 0

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

        mov     ecx, [.count]
        add     [esi+TFreshEdit._LeftColumn], ecx
        jns     .leftcolok


        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, [.count]
        add     [esi+TFreshEdit._yCaret], ecx
        jns     .ycaretok


        mov     [esi+TFreshEdit._yCaret], 0

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


        mov     ecx, [.count]





        add     [esi+TFreshEdit._TopLine], ecx
        jns     .toplineok






        mov     [esi+TFreshEdit._TopLine], 0

.toplineok:

        mov     ecx, [esi+TFreshEdit._yCaret]
        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._pLines]
        stdcall FreeMem, [ebx+TFreshEdit._pLengths]




        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 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 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.__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.__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
        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


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

        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 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

        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
        jmp     .end_del



.havesel:
        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 enough patience to fix it just now.....
.handler_backspc:
        cmp     [esi+TFreshEdit._fReadOnly], froReadWrite
        jne     .refresh

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



        dec     ecx

        jns     .posok

        dec     edx
        stdcall GetArrayItem, [esi+TFreshEdit._pLines], edx

        jc      .refresh

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


.posok:
        execute esi, TFreshEdit.DeleteText, edx, ecx, [esi+TFreshEdit._yCaret], [esi+TFreshEdit._xCaret]
        mov     [esi+TFreshEdit._yCaret], eax
        mov     [esi+TFreshEdit._xCaret], edx
        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

        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._prevCaretChar]
        jne     .caretmoved
        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._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.__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:

        mov     ebx, [esi+TFreshEdit._pLines]


        mov     edx, [esi+TFreshEdit._TopLine]












        xor     ecx, ecx


; so draw the lines.
.lineloop:



        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.

        mov     eax, [esi+TFreshEdit.__LeftMargin]

        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, .iLine, .y



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











begin
        pushad

        mov     esi, [.editor]




        mov     eax, [.iLine]






























        mov     edi, [esi+TFreshEdit._pLines]







        shl     eax, TEditorLine.shift

        lea     edi, [edi+TArray.array+eax]






























































; now draw transparent selection

; selection bounds.
        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     [esi+TFreshEdit._SelMode], selmChar
        jne     @f
        xchg    eax, ebx
@@:
        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, [.iLine]
        cmp     eax, [.ysel0]
        jl      .end_sel
        cmp     eax, [.ysel1]
        jg      .end_sel

        mov     eax, [esi+TFreshEdit._SelMode]

        cmp     eax, selmChar
        je      .selchar

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

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

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

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

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

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

        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, [esi+TFreshEdit._LeftColumn]
        test    ecx, ecx
        jns     .lastok
        xor     ecx, ecx

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

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

;        stdcall SetDrawMode, [.context], [FreshEditTheme.clSelMode]

        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














endp





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

.x         dd ?

.width     dd ?
.height    dd ?

.maxptr    dd ?

.ytext     dd ?
.yicons    dd ?

.unfold    dd ?  ; is the line folded?

.pNext     dd ?  ; pointer to the next line.

.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



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


        mov     ecx, [.pLine]


        sub     ecx, sizeof.TEditorLine
        cmp     ecx, [esi+TFreshEdit._pLines]



        ja      @f
        xor     ecx, ecx


@@:


        mov     [.pPrev], ecx




        mov     ecx, [.pLine]
        add     ecx, sizeof.TEditorLine
        mov     [.pNext], ecx


        mov     [.unfold], 0
        mov     edx, [.pLine]





; determine the bounds of the drawing


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

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

        xor     eax, eax
        mov     [.x], eax

        mov     eax, [.y]




        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   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+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

        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


; Line number draw
.borderok:
        test    [FreshEditTheme.Options], eoLineNumbers
        jz      .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
        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, [.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, [.pLine]

; first, determine, what icon should be set for fold/unfold icon:
        xor     ecx, ecx

        mov     eax, [.pNext]
        cmp     eax, [.maxptr]
        jae     @f


        mov     ecx, eax

@@:
        cmp     [.pPrev], 0
        je      .fold_fold

        mov     eax, [.pPrev]
        mov     eax, [edx-sizeof.TEditorLine+TEditorLine.fold_level]
        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




.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]


        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._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






















; Arguments:




;
; Returns:
; CF=0
;    eax - number of the line
;    edx - offset inside the line
; CF=1



;    the pixel is outside the client area.



;



proc TFreshEdit.__PixelToCaretPos, .editor, .x, .y


begin


        push    ebx ecx esi edi




        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]



        push    eax
; y

        mov     eax, [.y]
        cdq




        idiv    [esi+TFreshEdit._fontheight]












        add     eax, [esi+TFreshEdit._TopLine]
        pop     edx
        clc

.finish:
        pop     edi esi ecx ebx
        return


.nomove:
        stc
































        jmp     .finish

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

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












































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

        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

        jecxz   .eol

        cmp     al, ';'


        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:








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








endmodule

include "FreshEditThemes.asm"
include "LineProcessors.asm"


ObjectClass FreshEdit,                   \
            ScrollWindow,                \
            TFreshEdit.Create,           \
            TFreshEdit.Destroy,          \
            TFreshEdit.Get,              \
            TFreshEdit.Set,              \
            TFreshEdit.ExecCmd,          \
            TFreshEdit.SysEventHandler


; values for ._EditorMode field
femSelBlock   = 1
femOverwrite  = 2



object TFreshEdit, TScrollWindow

; system font sizes (used for additional texts and line numbers)
  ._Font2           dd  ?   ; Supplementary font.

  ._fontwidth2      dd  ?   ; in pixels.
  ._fontheight2     dd  ?   ; in pixels.
  ._fontdescent2    dd  ?   ; in pixels.


; Shadow object for double buffered paint and other paint related fields.

  ._pShadow         dd  ?   ; pointer to TBackBuffer object.
  ._fShadowValid    dd  ?   ; the shadow buffer is valid and should not be repainted.

; Text related data structures.

  ._pLines          dd  ?   ; TArray of dword pointers to TEditorLine structures.
  ._pLengths        dd  ?   ; TArray with count of the lines of given width (in pixels).
                            ; It is needed for horizontal scrollbar adjustment.

; when non textual lines are selected, the entire lines should be selected actually.
  ._CaretLine       dd  ?   ; index of the line where caret resides.
  ._CaretChar       dd  ?   ; char of the line where caret resides. It can be bigger than the line length.

  ._SelLine         dd  ?   ; index of the line where selection starts.
  ._SelChar         dd  ?   ; char of the line where selection starts.

  ._WrapX           dd  ?   ; X coordinate (in pixels) where the lines should be word wraped.


  .__LeftMargin     dd  ?   ; width of the left margin field.
  .__NumberMargin   dd  ?

; Syntax highlighter

  ._procSyntax      dd  ?   ; procedure for syntax highlighting.


; params of TFreshEdit

; methods of TFreshEdit

; internal methods

  method .__DrawShadow
  method .__ComputeLeftMargin

; public methods
  method .Clear    ; clears the text of the editor.

  method .AppendLine, .hText    ; appends the line at the end of the text.
  method .LoadFromFile, .hFilename

endobj




; TEditorLine.flags

lfBookmark    = 1        ; the line have bookmark set.
lfProtected   = 2        ; the line can not be edited.
lfWordWrap    = 4        ; the line must be word wrapped.
lfBreakpoint  = 8        ; set breakpoint in debug mode.

lfFormatted   = $10

struct TEditorLine
  .pProcessor   dd  ?   ; pointer to TLineProcessor structure, that will process this line.

  .pData        dd  ?   ; internal representation of the line data.
                        ; Can differs for different types of lines.
                        ; the canonical content of this field is a handle of string with the text
                        ; of the line in UTF-8 encoding. All editors must understand this type
                        ; and to convert back to it.

  .LineY        dd  ?   ; Y coordinate of the line in pixels inside the document.
  .LineH        dd  ?   ; Height of the line in pixels.

  .flags        dd  ?

  .syn_context  dd  ?
  .debug_data   dd  ?

  .pRenderInfo  dd  ?   ; pointer to some internal rendering info for this line.
                        ; this array must exists only when the line is inside the
                        ; visible window.
ends




;_______________________________________________________________________________________________

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

        mov     [ebx+TFreshEdit._cursor], mcText
        mov     [ebx+TFreshEdit._WrapX], 640

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

        execute ebx, TFreshEdit.Clear


        clc
        return
endp



;_______________________________________________________________________________________________



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

        execute ebx, TFreshEdit.Clear

; destroy arrays.
        stdcall FreeMem, [ebx+TFreshEdit._pLines]
        stdcall FreeMem, [ebx+TFreshEdit._pLengths]

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

        clc
        return
endp



;_______________________________________________________________________________________________



dproc TFreshEdit.Get, .pobj, .paramID
begin
        mov     ecx, [.pobj]

        dispatch [.paramID]
        stc
        return
enddp



;_______________________________________________________________________________________________




dproc TFreshEdit.Set, .pobj, .paramID, .value
begin
        pushad

        mov     esi, [.pobj]
        mov     ebx, [.value]

        dispatch [.paramID]

.continue:
        stc
        popad
        return

enddp



;_______________________________________________________________________________________________



dproc TFreshEdit.ExecCmd, .self, .method
begin
        pushad
        mov     esi, [.self]

        dispatch [.method]
        stc
        popad
        return

oncase TFreshEdit.LoadFromFile
virtual at ebx
  .hFilename dd ?
end virtual
        execute esi, TFreshEdit.Clear

        stdcall FileOpen, [.hFilename]
        jc      .error

        mov     edx, eax

.load_loop:
        stdcall FileReadLine, edx
        jc      .error_close

        test    eax, eax
        jz      .end_of_file

        push    eax
        execute esi, TFreshEdit.AppendLine, eax
        stdcall StrDel ; from the stack.
        jmp     .load_loop

.end_of_file:
        stdcall FileClose, edx
        mov     [esi+TFreshEdit._fShadowValid], 0

        popad
        xor     eax, eax
        clc
        return

.error_close:
        stdcall FileClose, edx
        mov     [esi+TFreshEdit._fShadowValid], 0

.error:
        mov     [esp+4*regEAX], eax
        popad
        clc
        return

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

oncase TFreshEdit.AppendLine
virtual at ebx
  .hText dd ?
end virtual

        stdcall GetMem, sizeof.TEditorLine
        mov     edi, eax

; append the line to the text...
        stdcall AddArrayItems, [esi+TFreshEdit._pLines], 1
        mov     [esi+TFreshEdit._pLines], edx
        mov     [eax], edi

        mov     [edi+TEditorLine.pProcessor], lprTextLine

        stdcall textLineCreate, edi, [.hText]

        xor     edx, edx

        mov     ebx, [esi+TFreshEdit._pLines]
        mov     eax, [ebx+TArray.count]
        cmp     eax, 1
        je      .coor_ok

        mov     eax, [ebx+TArray.array+4*eax-8]
        mov     edx, [eax+TEditorLine.LineY]
        add     edx, [eax+TEditorLine.LineH]

.coor_ok:
        mov     [edi+TEditorLine.LineY], edx
        mov     [edi+TEditorLine.LineH], 16

        stdcall TFreshEdit.__UpdateScrollbars

        clc
        popad
        return

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


oncase TFreshEdit.Clear

        mov     ebx, [esi+TFreshEdit._pLines]
        test    ebx, ebx
        jz      .endclr1

        mov     ecx, [ebx+TArray.count]

.clrloop:
        dec     ecx
        js      .endclr

        mov     edi, [ebx+TArray.array+4*ecx]

        mov     edx, [edi+TEditorLine.pProcessor]
        test    edx, edx
        jz      .line_ok
        stdcall [edx+TLineProcessor.__Free], edi
.line_ok:
        stdcall FreeMem, edi
        mov     [ebx+TArray.array+4*ecx], 0
        jmp     .clrloop

.endclr:
        stdcall FreeMem, ebx

.endclr1:
        mov     eax, [esi+TFreshEdit._pLengths]
        test    eax, eax
        jz      .all_cleared
        stdcall FreeMem, eax

.all_cleared:
        stdcall CreateArray, 4
        mov     [esi+TFreshEdit._pLines], eax

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

        xor     eax, eax
        mov     [esi+TFreshEdit._fShadowValid], eax
        mov     [esi+TFreshEdit._CaretLine], eax
        mov     [esi+TFreshEdit._CaretChar], eax
        mov     [esi+TFreshEdit._SelLine], eax
        mov     [esi+TFreshEdit._SelChar], eax

        clc
        popad
        return


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


oncase TFreshEdit.__ComputeLeftMargin

        xor     ebx, ebx
        mov     [esi+TFreshEdit.__NumberMargin], ebx

        test    [FreshEditTheme.Options], eoLeftMargin
        jz      .marginok

        test    [FreshEditTheme.Options], eoLineNumbers
        jz      .marginok1

        mov     eax, [esi+TFreshEdit._pLines]
        mov     eax, [eax+TArray.count]
        test    eax, eax
        jz      .marginok1
        mov     ecx, 10

.digits:
        add     ebx, [esi+TFreshEdit._fontwidth2]
        cdq
        div     ecx
        test    eax, eax
        jnz     .digits

        mov     [esi+TFreshEdit.__NumberMargin], ebx

.marginok1:
        add     ebx, 17+11+3+1 ; 17px breakpoints and other icons; 11px fold tree; 3px word-wrap cut; 1px whitespace at the begining of the line.

.marginok:
        xchg    [esi+TFreshEdit.__LeftMargin], ebx
        cmp     ebx, [esi+TFreshEdit.__LeftMargin]
        je      .end_clm


.end_clm:
        clc
        popad
        return

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



oncase TFreshEdit.__DrawShadow
locals
  .context dd ?
  .clip    TBounds
  .line    dd ?
endl
        execute esi, TFreshEdit.__ComputeLeftMargin

        mov     edi, [esi+TFreshEdit._pShadow]
        stdcall AllocateContext, [edi+TBackBuffer.raster]
        mov     [.context], eax

        mov     eax, [edi+TBackBuffer.width]
        sub     eax, [esi+TFreshEdit.__LeftMargin]
        mov     [.clip.width], eax
;        stdcall DrawFillRect, [.context], [esi+TFreshEdit.__LeftMargin], 0, eax, [edi+TBackBuffer.height], [FreshEditTheme.clBackground]

        mov     ecx, [esi+TFreshEdit.__LeftMargin]
        mov     edx, [edi+TBackBuffer.height]
        mov     [.clip.x], ecx
        mov     [.clip.height], edx
        mov     [.clip.y], 0

        lea     eax, [.clip]
        stdcall SetClipRectangle, [.context], eax

        mov     ebx, [esi+TFreshEdit._pLines]
        mov     edx, [esi+TFreshEdit._VScroller.Pos]

; search the first line

        stdcall __SearchLine, ebx, edx
        jc      .end_draw_lines

; ecx - index of the line.
; edx - offset inside the line.
        neg    edx

.line_loop:

        mov     eax, [FreshEditTheme.clBackground]
        test    [FreshEditTheme.Options], eoStripedBackground
        jz      .color_ok
        test    ecx, 1
        jz      .color_ok
        mov     eax, [FreshEditTheme.clAltBack]
.color_ok:
        push    eax

        mov     eax, [ebx+TArray.array+4*ecx]
        stdcall DrawFillRect, [.context], 0, edx, [edi+TBackBuffer.width], [eax+TEditorLine.LineH] ; color from the stack

        add     [.clip.x], 2
        sub     [.clip.width], 2
        lea     eax, [.clip]
        stdcall SetClipRectangle, [.context], eax

        push    edx             ; Y

        mov     eax, [esi+TFreshEdit._HScroller.Pos]
        neg     eax
        add     eax, [esi+TFreshEdit.__LeftMargin]
        add     eax, 2
        push    eax             ; X

        mov     eax, [ebx+TArray.array+4*ecx]
        push    eax

        mov     [.line], eax

        mov     eax, [eax+TEditorLine.pProcessor]
        stdcall [eax+TLineProcessor.Draw], [.context] ; remaining parameters from the stack...

        mov     eax, [.line]
        add     edx, [eax+TEditorLine.LineH]    ; the Draw procedure can changes the line height
                                                ; that is why the change of the Y coordinate
                                                ; should be after draw call.

        sub     [.clip.x], 2
        add     [.clip.width], 2
        lea     eax, [.clip]
        stdcall SetClipRectangle, [.context], eax

        cmp     edx, [edi+TBackBuffer.height]
        jae     .end_draw_lines

        inc     ecx
        cmp     ecx, [ebx+TArray.count]
        jb      .line_loop

; clear to the end of the screen...

        mov     eax, [edi+TBackBuffer.height]
        sub     eax, edx

        stdcall DrawFillRect, [.context], 0,edx, [edi+TBackBuffer.width], eax, [FreshEditTheme.clAfterBackground]

.end_draw_lines:
        mov     eax, [esi+TFreshEdit._WrapX]
        sub     eax, [esi+TFreshEdit._HScroller.Pos]
        add     eax, [esi+TFreshEdit.__LeftMargin]
        add     eax, 2

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

        xor     eax, eax
        xchg    eax, [.clip.x]
        test    eax, eax
        jz      .left_ok

        mov     [.clip.width], eax

        lea     eax, [.clip]
        stdcall SetClipRectangle, [.context], eax

        stdcall DrawFillRect, [.context], 0, 0, [esi+TFreshEdit.__LeftMargin], [edi+TBackBuffer.height], [FreshEditTheme.clLeftMargin]

        stdcall SetSimpleLine, [.context], [FreshEditTheme.clLeftMarginBorder]
        mov     eax, [esi+TFreshEdit.__LeftMargin]
        dec     eax
        stdcall DrawLine, [.context], eax, 0, eax, [edi+TBackBuffer.height]

.left_ok:
        stdcall ReleaseContext, [.context]

        clc
        popad
        return
enddp



;_______________________________________________________________________________________________




dproc TFreshEdit.SysEventHandler, .pobj, .pEvent
begin
        pushad

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

        dispatch [ebx+TSysEvent.event]

.continue:
        stc
        popad
        return

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

oncase sePaint

        xor     eax, eax
        cmp     [esi+TFreshEdit._pShadow], eax
        je      .continue

        cmp     [esi+TFreshEdit._fShadowValid], 0
        jne     @f
        execute esi, TFreshEdit.__DrawShadow
@@:
        stdcall SetClipRectangle, [ebx+TPaintEvent.context], 0

        stdcall TScrollWindow.SysEventHandler, esi, [.pEvent]

        stdcall DrawBackBuffer, [ebx+TPaintEvent.context], [esi+TFreshEdit._pShadow], 0, 0
        clc
        popad
        return

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

oncase seScroll
        cmp     [ebx+TScrollEvent.ScrollBar], scrollX
        je      .xscroll

; yscroll
        xor     edx, edx
        mov     ecx, [ebx+TScrollEvent.Value]
        cmp     [ebx+TScrollEvent.ScrollCmd], scTrack
        je      .track

        cmp     [ebx+TScrollEvent.ScrollCmd], scWheelUp
        je      .scrollwheelup
        cmp     [ebx+TScrollEvent.ScrollCmd], scWheelDn
        je      .scrollwheeldn

        cmp     [ebx+TScrollEvent.ScrollCmd], scUp
        je      .scrollup
        cmp     [ebx+TScrollEvent.ScrollCmd], scDown
        je      .scrolldn

        jmp     .continue

; scroll down
.scrollwheelup:
        neg     ecx

.scrollwheeldn:
        imul    ecx, [FreshEditTheme.MouseWheel]

.scrolldn:
.scrollup:
        mov     eax, [esi+TFreshEdit._VScroller.Pos]
        add     eax, ecx
        jns     .vsignok
        xor     eax, eax
.vsignok:
        cmp     eax, [esi+TFreshEdit._VScroller.Max]
        jbe     .vmaxok
        mov     eax, [esi+TFreshEdit._VScroller.Max]
.vmaxok:
        mov     [esi+TFreshEdit._VScroller.Pos], eax
        jmp     .refresh

.track:
;        mov     [esi+TFreshEdit._VScroller.Pos], ecx
        jmp     .refresh

.xscroll:
        jmp     .refresh


.refresh:
        mov     [esi+TFreshEdit._fShadowValid], 0
        execute esi, TWindow.Refresh
        clc
        popad
        return


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

oncase seMoveResize

        stdcall TScrollWindow.SysEventHandler, esi, [.pEvent]

        cmp     [esi+TFreshEdit._pShadow], 0
        je      @f
        stdcall DestroyBackBuffer, [esi+TFreshEdit._pShadow]
@@:
        stdcall Get, esi, TScrollWindow.FreeArea        ; compute the free area.
        mov     ecx, [eax+TBounds.width]
        mov     edx, [eax+TBounds.height]

        stdcall CreateBackBuffer, [esi+TFreshEdit.handle], ecx, edx
        mov     [esi+TFreshEdit._pShadow], eax
        mov     [esi+TFreshEdit._fShadowValid], 0

        stdcall TFreshEdit.__UpdateScrollbars

        clc
        popad
        return

enddp









proc TFreshEdit.__UpdateScrollbars
begin
        push    eax ebx ecx edx

; vertical

        mov     ebx, [esi+TFreshEdit._pLines]
        mov     ecx, [ebx+TArray.count]
        test    ecx, ecx
        jz      .yok

        dec     ecx
        mov     eax, [ebx+TArray.array+4*ecx]

        mov     ecx, [eax+TEditorLine.LineY]
        add     ecx, [eax+TEditorLine.LineH]

.yok:
        mov     edx, [esi+TFreshEdit._pShadow]
        mov     edx, [edx+TBackBuffer.height]
        sub     ecx, edx
        jns     .yok2
        xor     ecx, ecx
.yok2:

        mov     [esi+TFreshEdit._VScroller.Max], ecx
        mov     [esi+TFreshEdit._VScroller.Page], edx
        cmp     [esi+TFreshEdit._VScroller.Pos], ecx
        jbe     .pos_ok
        mov     [esi+TFreshEdit._VScroller.Pos], ecx
        mov     [esi+TFreshEdit._fShadowValid], 0
.pos_ok:

; horizontal

        mov     ebx, [esi+TFreshEdit._pLengths]
        mov     eax, [ebx+TArray.count]
        mov     edx, [esi+TFreshEdit._pShadow]
        mov     edx, [edx+TBackBuffer.width]
        sub     edx, [esi+TFreshEdit.__LeftMargin]
        sub     eax, edx

        mov     eax, 1000   ; TEST ONLY!!!


        mov     [esi+TFreshEdit._HScroller.Max], eax
        mov     [esi+TFreshEdit._HScroller.Page], edx
        cmp     [esi+TFreshEdit._HScroller.Pos], eax
        jbe     @f
        mov     [esi+TFreshEdit._HScroller.Pos], eax
        mov     [esi+TFreshEdit._fShadowValid], 0
@@:
        pop     edx ecx ebx eax
        return
endp










; Computes the wrap positions for the given line of text and returns (possibly reallocated)
; array with the line wrap positions. If the line does not need wrapping - returns 0 and
; frees passed in [.pSublines] array.
;
; Arguments:
;     .Data - the string with the line text.
;     .pSublines - previously created dword array with wrap positions.
;                  the subroutine tries to use it and it is not possible, resize it accordingly.
;     .RigthMargin - width of the sublines.
;

proc __CreateSublines, .hText, .pSublines, .RightMargin
begin
        pushad

        stdcall StrPtr, [.hText]
        mov     esi, eax

        xor     edi, edi        ; count of the lines...

.outer_loop:
        xor     ebx, ebx        ; the last wrap position.
        xor     ecx, ecx        ; current x position.

.loop:
        stdcall DecodeUtf8, [esi]
        inc     ecx
        test    eax, eax
        jz      .end_string

        cmp     eax, ' '
        jne     .not_space

        lea     ebx, [esi+edx]
.next:
        add     esi, edx
        jmp     .loop

.not_space:
        cmp     ecx, [.RightMargin]
        jbe     .next

        test    ebx, ebx
        jnz     .wraphere

        mov     ebx, esi

.wraphere:
        push    ebx
        mov     esi, ebx
        inc     edi
        jmp     .outer_loop

.end_string:
        mov     esi, [.pSublines]
        test    edi, edi
        jnz     .fill_sublines

        test    esi, esi
        jz      .exit_empty

        stdcall FreeMem, esi

.exit_empty:
        popad
        xor     eax, eax
        return                          ; there is no need for pSublines


.fill_sublines:
        test    esi, esi
        jz      .allocate

        cmp     edi, [esi]
        jbe     .array_ok

        stdcall FreeMem, esi

.allocate:
        lea     eax, [4*edi+4]
        stdcall GetMem, eax
        mov     esi, eax

.array_ok:
        mov     [esi], edi

        stdcall StrPtr, [.hText]

.fill:
        popd    [esi+4*edi]
        sub     [esi+4*edi], eax
        dec     edi
        jnz     .fill

        mov     [esp+4*regEAX], esi
        popad
        return
endp





proc __SearchLine, .pLines, .y
begin
        pushad

        mov     esi, [.pLines]
        xor     ecx, ecx
        mov     edx, [esi+TArray.count]
        dec     edx

.loop:
        cmp     ecx, edx
        jg      .not_found

        lea     ebx, [ecx+edx]
        shr     ebx, 1

        mov     edi, [esi+TArray.array+4*ebx]
        mov     eax, [edi+TEditorLine.LineY]

        cmp     [.y], eax
        jl      .less

        add     eax, [edi+TEditorLine.LineH]
        cmp     [.y], eax
        jge     .more

.found:
        mov     eax, [.y]
        sub     eax, [edi+TEditorLine.LineY]
        mov     [esp+4*regECX], ebx     ; index of the line.
        mov     [esp+4*regEDX], eax     ; offset of the line.
        clc
        popad
        return

.less:
        lea     edx, [ebx-1]
        jmp     .loop

.more:
        lea     ecx, [ebx+1]
        jmp     .loop

.not_found:
        stc
        popad
        return
endp

include "%lib%/freshlib.inc"

@BinaryType GUI

options.DebugMode = 0

include '%lib%/freshlib.asm'

include 'FreshEdit2.asm'
include "fasm_syntax.asm"

iglobal
frmMainForm:
        ObjTemplate  tfParent or tfEnd, Form, frmMain, \
                     x, 100,        \
                     y, 50,         \
                     width, 640,    \
                     height, 480,   \
                     borderKind, borderFull,    \
                     Visible, TRUE, \
                     Caption, 'FreshEdit test application.'

        ObjTemplate  tfParent, Form, Toolbar,           \
                     x, 0, y, 0,                        \
                     width, 100, height, 20,            \
                     Align, waBottom,                   \
                     borderKind, borderNone,         \
                     Visible, TRUE

        ObjTemplate  tfChild, Button, btnOpen,  \
                     x, 112, y, 2,                        \
                     width, 64, height, 21,            \
                     Align, waLeft,                     \
                     Caption, 'Open',                   \
                     TextAlign, dtfAlignCenter or dtfAlignMiddle,       \
                     OnClick, OnOpenFile,         \
                     Visible, TRUE

        ObjTemplate  tfChild, Button, btnSave,  \
                     x, 180, y, 2,                     \
                     width, 64, height, 21,            \
                     Align, waLeft,                     \
                     Caption, 'Save',                   \
                     TextAlign, dtfAlignCenter or dtfAlignMiddle,       \
                     OnClick, OnSaveFile,         \
                     Visible, TRUE

        ObjTemplate  tfChild, Button, btnNumbers,  \
                     x, 180, y, 2,                     \
                     width, 21, height, 21,            \
                     Align, waLeft,                     \
                     Caption, '#',                  \
                     TextAlign, dtfAlignCenter or dtfAlignMiddle,       \
                     OnClick, OnNumbers,         \
                     Visible, TRUE

        ObjTemplate  tfChild, Button, btnZebra,  \
                     x, 180, y, 2,                     \
                     width, 21, height, 21,            \
                     Align, waLeft,                     \
                     Caption, 'Z',                  \
                     TextAlign, dtfAlignCenter or dtfAlignMiddle,       \
                     OnClick, OnZebra,         \
                     Visible, TRUE

        ObjTemplate  tfChild, Button, btnTheme,  \
                     x, 180, y, 2,                     \
                     width, 21, height, 21,            \
                     Align, waLeft,                     \
                     Caption, 'T',                  \
                     TextAlign, dtfAlignCenter or dtfAlignMiddle,       \
                     OnClick, OnTheme,         \
                     Visible, TRUE

        ObjTemplate  tfEnd, Edit, FilenameEdit,         \
                     x, 2, y, 2,                        \
                     width, 100, height, 21,            \
                     Align, waClient,                     \
                     Visible, TRUE

        ObjTemplate tfEnd, FreshEdit, Editor,   \
                    Visible, TRUE,              \
                    x, 8, y, 8,                 \
                    width, 624, height, 464,    \
                    Align, waClient

  SampleText file 'unicode_test.txt'
             dd   0

endg


;--------------------------------------------------------------------------

start:
        InitializeAll

; TEST CODE - to be removed later ---------------------------------------
        stdcall Output, '00000000001111111111222222222233333333334444444444555555555566666666667777777777'
        stdcall Output, <'01234567890123456789012345678901234567890123456789012345678901234567890123456789',13, 10>

        stdcall PrintWrappedLine, cTestString, 25
        stdcall PrintWrappedLine, cTestString2, 25
        stdcall PrintWrappedLine, cTestString2, 60

; END OF THE TEST CODE ---------------------------------------------------


        stdcall Create, CApplication
        jc      .start_error
        mov     [pApplication], ebx

        stdcall [lprTextLine.Initialize]

        stdcall CreateFromTemplate, frmMainForm, 0
        mov     ecx, [pApplication]
        mov     [ecx+TApplication.MainWindow], frmMain

        execute [Editor], TFreshEdit.LoadFromFile, 'unicode_test.txt'

        execute [Editor], TFreshEdit.AppendLine, 'This is Test line'
        execute [Editor], TFreshEdit.AppendLine, 'This is Test line number 2'
        execute [Editor], TFreshEdit.AppendLine, 'This is the third test line.'

        stdcall Set, [Editor], TFreshEdit._procSyntax, SyntaxFASM
;        stdcall Set, [Editor], TFreshEdit.OnControlKey, procKeyPress
;        stdcall Set, [Editor], TFreshEdit.Text, SampleText


; TEST CODE - to be removed later ---------------------------------------
        stdcall SaveTheme, 'test.cfg', FreshEditTheme, pThemePath1
        stdcall TFETheme.SetDefaultThemeClassic, FreshEditTheme
        stdcall SaveTheme, 'test.cfg', FreshEditTheme, pThemePath2

iglobal
  pThemePath1 dd 'EThm', 'tWin', 0
  pThemePath2 dd 'EThm', 'tCls', 0
endg
; END OF THE TEST CODE ---------------------------------------------------


        stdcall Run

.terminate:
        stdcall [lprTextLine.Finalize]

        FinalizeAll
        stdcall Terminate, 0

.start_error:
        DebugMsg "Can't create application object."
        jmp      .terminate



var FreshEditSetTheme = TFETheme.SetDefaultThemeWindows


proc OnTheme, .self, .mousebtn
begin
        xor     [FreshEditSetTheme], TFETheme.SetDefaultThemeWindows xor TFETheme.SetDefaultThemeClassic
        stdcall [FreshEditSetTheme], FreshEditTheme
        xor     [SynTheme], fasm_colors_classic xor fasm_colors_windows
        execute [Editor], TFreshEdit.Refresh
        return
endp


proc OnZebra, .self, .mousebtn
begin
        xor     [FreshEditTheme.Options], eoStripedBackground
        execute [Editor], TFreshEdit.Refresh
        return
endp


proc OnNumbers, .self, .mousebtn
begin
        xor     [FreshEditTheme.Options], eoLineNumbers
        execute [Editor], TFreshEdit.Refresh
        return
endp


cErrorTitleOpen text "Error open file."
cErrorTitleSave text "Error save file."

proc OnSaveFile, .self, .mousebtn
begin
        pushad

;        stdcall Get, [FilenameEdit], TEdit.Text
;        push    eax
;        stdcall StrPtr, eax
;        mov     edi, eax
;
;        stdcall Get, [Editor], TFreshEdit.Text
;        jc      .finish
;
;        push    eax
;        stdcall StrPtr, eax
;
;        stdcall SaveBinaryFile, edi, eax, [eax+string.len]
;        jnc     .end_save
;
;        stdcall GetErrorString, eax
;        mov     esi, eax
;        stdcall ShowMessage, [frmMain], smiError, cErrorTitleSave, esi, smbOK
;        stdcall FreeErrorString, esi
;
;.end_save:
;        stdcall StrDel ; from the stack
;.finish:
;        stdcall StrDel ; from the stack
        popad
        return
endp


proc OnOpenFile, .self, .mousebtn
begin
        pushad
; Load test file
;        stdcall Get, [FilenameEdit], TEdit.Text
;        push    eax
;
;        stdcall StrPtr, eax
;        stdcall LoadBinaryFile, eax
;        jnc     .loaded
;
;        stdcall GetErrorString, eax
;        mov     esi, eax
;        stdcall ShowMessage, [frmMain], smiError, cErrorTitleOpen, esi, smbOK
;        stdcall FreeErrorString, esi
;        jmp     .exit
;
;.loaded:
;        push    eax
;        stdcall Set, [Editor], TFreshEdit.Text, eax
;        stdcall FreeMem ; from the stack
;
;.exit:
;        stdcall StrDel ; from the stack
;
;        mov     eax, [Editor]
;        mov     [eax+TFreshEdit._xCaret], 0
;        mov     [eax+TFreshEdit._yCaret], 0
;        mov     [eax+TFreshEdit._xSelection], 0
;        mov     [eax+TFreshEdit._ySelection], 0
;
;;        stdcall ParseFolding, [eax+TFreshEdit._pLines]
;
;        execute [Editor], TFreshEdit.Refresh
;        execute [Editor], TFreshEdit.Focus
        popad
        return
endp




proc procKeyPress, .self, .keyevent
begin

        return
;        mov     ebx, [.keyevent]
;
;        mov     eax, [ebx+TKeyboardEvent.key]
;
;        cmp     eax, $03        ; ctrl+C
;        je      .copy
;        cmp     eax, $16        ; ctrl+V
;        je      .paste
;        cmp     eax, 12 ; ctrl+L
;        je      .length_list
;        cmp     eax, 18 ; ctrl+R
;        je      .clipright
;        cmp     eax, 19 ; ctrl+S == save
;        je      .save
;        cmp     eax, 20 ; ctrl+T
;        je      .test_something
;
;        cmp     [ebx+TKeyboardEvent.scancode], keyF2
;        je      .toggle_breakpoint
;
;.finish:
;        mov     eax, chgfNoClearSelection
;.exit:
;        return
;
;.copy:
;        stdcall Get, [.self], TFreshEdit.Selection
;        test    eax, eax
;        jz      .end_copy
;        stdcall ClipboardWrite, eax
;        stdcall StrDel, eax
;.end_copy:
;        mov     eax, chgfNoClearSelection
;        return
;
;.paste:
;        stdcall ClipboardRead
;        test    eax, eax
;        jz      .end_paste
;
;        stdcall Set, [.self], TFreshEdit.Selection, eax
;        stdcall StrDel, eax
;
;        mov     eax, chgfNeedRefresh
;.end_paste:
;        return
;
;
;.save:
;        stdcall OnSaveFile, [.self], 0
;        xor     eax, eax
;        return
;
;.length_list:
;        xor     eax, eax
;        return
;
;.clipright:
;        stdcall Get, esi, TFreshEdit.CurrentLine
;        jc      .finish
;        stdcall StrClipSpacesR, [eax+TEditorLine.Data]
;        mov     eax, chgfNeedRefresh
;        return
;
;.test_something:
;        mov     eax, chgfNeedRefresh
;        return
;
;
;.toggle_breakpoint:
;        cmp     [esi+TFreshEdit._fReadOnly], froReadWrite
;        jne     .finish
;
;        stdcall Get, esi, TFreshEdit.CurrentLine
;        jc      .finish
;
;        xor     [eax+TEditorLine.flags], lfBreakpoint
;        mov     eax, chgfNeedRefresh or chgfNoClearSelection
;        return
;
;
;. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

endp





proc PrintWrappedLine, .hString, .width
begin
        pushad

        stdcall StrPtr, [.hString]
        mov     ebx, eax

        stdcall __CreateSublines, ebx, 0, [.width]
        mov     edi, eax
        push    eax

        xor     esi, esi
        mov     ecx, [edi]
        add     edi, 4

.loop1:
        mov     eax, [edi]
        sub     eax, esi
        lea     edx, [esi+ebx]
        stdcall FileWrite, [STDOUT], edx, eax
        stdcall FileWrite, [STDOUT], cCRLF, 2
        mov     esi, [edi]
        add     edi, 4
        dec     ecx
        jnz     .loop1

        lea     edx, [esi+ebx]
        stdcall StrLen, edx
        stdcall FileWrite, [STDOUT], edx, eax
        stdcall FileWrite, [STDOUT], cCRLF, 2
        stdcall FileWrite, [STDOUT], cCRLF, 2

        stdcall FreeMem ; from the stack

        popad
        return
endp


cTestString text 'This is test string that has to be word wrapped on some position as a test ', \
                 'for the word wrap formatting procedure. This procedure creates an array ',    \
                 'with offsets to the begining of the sublines where the string has to be wrap.'
cTestString2 text 'This_is_test_string_that_has_to_be_word_wrapped_on_some_position_as_a_test_', \
                 'for_the_word_wrap_formatting_procedure._This_procedure_creates_an_array_',    \
                 'with_offsets_to_the_begining_of_the_sublines_where_the_string_has_to_be_wrap.'
cCRLF       text 13, 10


@AllImportSection
@AllDataSection

struct TShortcut
  .key        dd  ?     ; if .key is <> 0 the scancode and .kbdStatus are not used.
  .scancode   dd  ?
  .kbdStatus  dd  ?
  .maskStatus dd  ?     ; what bits from the kbdStatus to be compared
ends


macro Shortcut .key, .scancode, .kbdstatus, .maskstatus {
        dd  .key
        dd  .scancode
        dd  .kbdstatus
        dd  .maskstatus
}


ffBold       = 1
ffItalic     = 2
ffUnderlined = 4
ffStrikeOut  = 8


struct TThemeFont
  .ptrFace    dd ?       ; pointer to the font face string.
  .size       db ?       ; in pixels height.
  .flags      db ?       ; flag - normal, bold, italic, etc.
  .family     db ?       ; fixed, proportional
  .reserved   db ?

  .handle     dd ?      ; created on the first use.
ends


eoAutoIndents       = 1
eoSaveWithTabs      = 2
eoVerticalCaret     = 4
eoStripedBackground = 8
eoLeftMargin        = 16
eoLineNumbers       = 32


struct TFETheme
; colors
  .clAfterBackground  dd  ?       ; the background after the end of the text.
  .clBackground       dd  ?       ; background color of the editor field.
  .clAltBack          dd  ?       ; althernative background (when eoStripedBackground is true)



  .clSelBack          dd  ?       ; background color for selections
  .clSelAltBack       dd  ?       ; althernative background for selections (when eoStripedBackground is true)

  .clLeftMargin       dd  ?       ; the color of the left margin field.
  .clLeftMarginBorder dd  ?       ; left margin border color.
  .clLeftMarginText   dd  ?
  .clLeftMarginTree   dd  ?

  .clBookmarkBack     dd  ?       ; background of the left margin when the bookmark is set.
  .clWrapColumn       dd  ?       ; color of the line that marks word wrap column.

  .clSyntax           rd  32      ; 32 syntax colors - more than needed, but...

  .FontsSyntax        TThemeFont  ; 32 syntax fonts - more than needed, but... (640K are enough for everyone)
                      rb  31*sizeof.TThemeFont

; options and behavior
  .Options            dd  ?       ; flags eoXXXXX (see above).
  .MouseWheel         dd  ?       ; the count of the pixels, one mouse wheel event scrolls.
  .WrapPos            dd  ?       ; word wrap position for the lines that have lfWordWrap flag set.
  .UndoLevels         dd  ?       ; how many levels of undo/redo to be remembered.

; keyboard shortcuts:

; navigation
  .shortcuts:
  .keyUp             TShortcut
  .keyDown           TShortcut

; Control
  .ToggleInsMode     TShortcut
  .ToggleSelMode     TShortcut
  .shortcuts.count = ($ - .shortcuts)/sizeof.TShortcut
ends


struct TCfgInfo
  .key    dd ?
  .offset dw ?
  .type   dw ?
ends


macro cfginfo  offset, key, type {
      dd key
      dw offset
      dw type
}

cfgInteger = 0
cfgFont    = 1
cfgShortcut = 2

iglobal
  if used FreshEditThemeKeys
    FreshEditThemeKeys:
        ; colors
          cfginfo    TFETheme.clAfterBackground,     'cAFB', cfgInteger
          cfginfo    TFETheme.clBackground,          'cBKG', cfgInteger
          cfginfo    TFETheme.clAltBack,             'cABK', cfgInteger


          cfginfo    TFETheme.clSelBack,             'cSBK', cfgInteger
          cfginfo    TFETheme.clSelAltBack,          'cSAB', cfgInteger
          cfginfo    TFETheme.clLeftMargin,          'cMrg', cfgInteger
          cfginfo    TFETheme.clLeftMarginBorder,    'cMBr', cfgInteger
          cfginfo    TFETheme.clLeftMarginText,      'cMTx', cfgInteger
          cfginfo    TFETheme.clLeftMarginTree,      'cMTr', cfgInteger
          cfginfo    TFETheme.clBookmarkBack,        'cBMB', cfgInteger
          cfginfo    TFETheme.clWrapColumn,          'cWrC', cfgInteger

          cfginfo    TFETheme.clSyntax,              'cS00', cfgInteger
          cfginfo    TFETheme.clSyntax+4,            'cS01', cfgInteger
          cfginfo    TFETheme.clSyntax+8,            'cS02', cfgInteger
          cfginfo    TFETheme.clSyntax+12,           'cS03', cfgInteger
          cfginfo    TFETheme.clSyntax+16,           'cS04', cfgInteger
          cfginfo    TFETheme.clSyntax+20,           'cS05', cfgInteger
          cfginfo    TFETheme.clSyntax+24,           'cS06', cfgInteger
          cfginfo    TFETheme.clSyntax+28,           'cS07', cfgInteger
          cfginfo    TFETheme.clSyntax+32,           'cS08', cfgInteger
          cfginfo    TFETheme.clSyntax+36,           'cS09', cfgInteger
          cfginfo    TFETheme.clSyntax+40,           'cS10', cfgInteger
          cfginfo    TFETheme.clSyntax+44,           'cS11', cfgInteger
          cfginfo    TFETheme.clSyntax+48,           'cS12', cfgInteger
          cfginfo    TFETheme.clSyntax+52,           'cS13', cfgInteger
          cfginfo    TFETheme.clSyntax+56,           'cS14', cfgInteger
          cfginfo    TFETheme.clSyntax+60,           'cS15', cfgInteger
          cfginfo    TFETheme.clSyntax+64,           'cS16', cfgInteger
          cfginfo    TFETheme.clSyntax+68,           'cS17', cfgInteger
          cfginfo    TFETheme.clSyntax+72,           'cS18', cfgInteger
          cfginfo    TFETheme.clSyntax+76,           'cS19', cfgInteger
          cfginfo    TFETheme.clSyntax+80,           'cS20', cfgInteger
          cfginfo    TFETheme.clSyntax+84,           'cS21', cfgInteger
          cfginfo    TFETheme.clSyntax+88,           'cS22', cfgInteger
          cfginfo    TFETheme.clSyntax+92,           'cS23', cfgInteger
          cfginfo    TFETheme.clSyntax+96,           'cS24', cfgInteger
          cfginfo    TFETheme.clSyntax+100,          'cS25', cfgInteger
          cfginfo    TFETheme.clSyntax+104,          'cS26', cfgInteger
          cfginfo    TFETheme.clSyntax+108,          'cS27', cfgInteger
          cfginfo    TFETheme.clSyntax+112,          'cS28', cfgInteger
          cfginfo    TFETheme.clSyntax+116,          'cS29', cfgInteger
          cfginfo    TFETheme.clSyntax+120,          'cS30', cfgInteger
          cfginfo    TFETheme.clSyntax+124,          'cS31', cfgInteger

          cfginfo    TFETheme.FontsSyntax+0*sizeof.TThemeFont,    'fS00', cfgFont
          cfginfo    TFETheme.FontsSyntax+1*sizeof.TThemeFont,    'fS01', cfgFont
          cfginfo    TFETheme.FontsSyntax+2*sizeof.TThemeFont,    'fS02', cfgFont
          cfginfo    TFETheme.FontsSyntax+3*sizeof.TThemeFont,    'fS03', cfgFont
          cfginfo    TFETheme.FontsSyntax+4*sizeof.TThemeFont,    'fS04', cfgFont
          cfginfo    TFETheme.FontsSyntax+5*sizeof.TThemeFont,    'fS05', cfgFont
          cfginfo    TFETheme.FontsSyntax+6*sizeof.TThemeFont,    'fS06', cfgFont
          cfginfo    TFETheme.FontsSyntax+7*sizeof.TThemeFont,    'fS07', cfgFont
          cfginfo    TFETheme.FontsSyntax+8*sizeof.TThemeFont,    'fS08', cfgFont
          cfginfo    TFETheme.FontsSyntax+9*sizeof.TThemeFont,    'fS09', cfgFont
          cfginfo    TFETheme.FontsSyntax+10*sizeof.TThemeFont,   'fS10', cfgFont
          cfginfo    TFETheme.FontsSyntax+11*sizeof.TThemeFont,   'fS11', cfgFont
          cfginfo    TFETheme.FontsSyntax+12*sizeof.TThemeFont,   'fS12', cfgFont
          cfginfo    TFETheme.FontsSyntax+13*sizeof.TThemeFont,   'fS13', cfgFont
          cfginfo    TFETheme.FontsSyntax+14*sizeof.TThemeFont,   'fS14', cfgFont
          cfginfo    TFETheme.FontsSyntax+15*sizeof.TThemeFont,   'fS15', cfgFont
          cfginfo    TFETheme.FontsSyntax+16*sizeof.TThemeFont,   'fS16', cfgFont
          cfginfo    TFETheme.FontsSyntax+17*sizeof.TThemeFont,   'fS17', cfgFont
          cfginfo    TFETheme.FontsSyntax+18*sizeof.TThemeFont,   'fS18', cfgFont
          cfginfo    TFETheme.FontsSyntax+19*sizeof.TThemeFont,   'fS19', cfgFont
          cfginfo    TFETheme.FontsSyntax+20*sizeof.TThemeFont,   'fS20', cfgFont
          cfginfo    TFETheme.FontsSyntax+21*sizeof.TThemeFont,   'fS21', cfgFont
          cfginfo    TFETheme.FontsSyntax+22*sizeof.TThemeFont,   'fS22', cfgFont
          cfginfo    TFETheme.FontsSyntax+23*sizeof.TThemeFont,   'fS23', cfgFont
          cfginfo    TFETheme.FontsSyntax+24*sizeof.TThemeFont,   'fS24', cfgFont
          cfginfo    TFETheme.FontsSyntax+25*sizeof.TThemeFont,   'fS25', cfgFont
          cfginfo    TFETheme.FontsSyntax+26*sizeof.TThemeFont,   'fS26', cfgFont
          cfginfo    TFETheme.FontsSyntax+27*sizeof.TThemeFont,   'fS27', cfgFont
          cfginfo    TFETheme.FontsSyntax+28*sizeof.TThemeFont,   'fS28', cfgFont
          cfginfo    TFETheme.FontsSyntax+29*sizeof.TThemeFont,   'fS29', cfgFont
          cfginfo    TFETheme.FontsSyntax+30*sizeof.TThemeFont,   'fS30', cfgFont
          cfginfo    TFETheme.FontsSyntax+31*sizeof.TThemeFont,   'fS31', cfgFont

          cfginfo    TFETheme.Options,               'Opts', cfgInteger
          cfginfo    TFETheme.MouseWheel,            'nWhl', cfgInteger
          cfginfo    TFETheme.WrapPos,               'WrPs', cfgInteger
          cfginfo    TFETheme.UndoLevels,            'UdLv', cfgInteger

        ; keyboard shortcuts:
        ; navigation
          cfginfo    TFETheme.keyUp,                 'kkUp', cfgShortcut
          cfginfo    TFETheme.keyDown,               'kkDn', cfgShortcut
          cfginfo    TFETheme.keyLeft,               'kLft', cfgShortcut
          cfginfo    TFETheme.keyRight,              'kRgt', cfgShortcut
          cfginfo    TFETheme.keyPgUp,               'kPUp', cfgShortcut
          cfginfo    TFETheme.keyPgDn,               'kPDn', cfgShortcut
          cfginfo    TFETheme.keyHome,               'kHom', cfgShortcut
          cfginfo    TFETheme.keyEnd,                'kEnd', cfgShortcut
          cfginfo    TFETheme.keyPageBegin,          'kPgB', cfgShortcut
          cfginfo    TFETheme.keyPageEnd,            'kPgE', cfgShortcut
          cfginfo    TFETheme.keyTextBegin,          'kTxB', cfgShortcut
          cfginfo    TFETheme.keyTextEnd,            'kTxE', cfgShortcut
          cfginfo    TFETheme.keyWordLeft,           'kWdL', cfgShortcut
          cfginfo    TFETheme.keyWordRight,          'kWdR', cfgShortcut

        ; Edit
          cfginfo    TFETheme.Delete,                'kDel', cfgShortcut
          cfginfo    TFETheme.DelLine,               'kDLn', cfgShortcut
          cfginfo    TFETheme.Backspace,             'kBkS', cfgShortcut

        ; Formating
          cfginfo    TFETheme.ToggleWordWrap,        'kWWr', cfgShortcut
          cfginfo    TFETheme.ToggleBookmark,        'kBkm', cfgShortcut
          cfginfo    TFETheme.ToggleInsMode,         'kIMd', cfgShortcut
          cfginfo    TFETheme.ToggleSelMode,         'kSMd', cfgShortcut
          dd    0
  end if
endg



iglobal

proc TFETheme.SetDefaultThemeWindows, .ptrTheme
begin
        push    ebx ecx esi edi
        mov     ebx, [.ptrTheme]

; colors

        mov     [ebx+TFETheme.clAfterBackground], $d0d0d0
        mov     [ebx+TFETheme.clBackground], $ffffff
        mov     [ebx+TFETheme.clAltBack],    $e8e8e8




        mov     [ebx+TFETheme.clSelBack], $000080
        mov     [ebx+TFETheme.clSelAltBack], $000090

        mov     [ebx+TFETheme.clLeftMargin],       $d0d0d8
        mov     [ebx+TFETheme.clLeftMarginBorder], $606060
        mov     [ebx+TFETheme.clLeftMarginText],   $000000
        mov     [ebx+TFETheme.clLeftMarginTree],   $9000ff
        mov     [ebx+TFETheme.clBookmarkBack],     $ffd000

        mov     [ebx+TFETheme.clSyntax], $000000
        mov     [ebx+TFETheme.clSyntax+4], $808080

        mov     [ebx+TFETheme.clWrapColumn], $c0c0ff
        mov     [ebx+TFETheme.Options], eoLineNumbers or eoLeftMargin

        mov     [ebx+TFETheme.WrapPos], 70
        mov     [ebx+TFETheme.MouseWheel], 16

        mov     esi, TFETheme.DefaultShortcuts
        lea     edi, [ebx+TFETheme.shortcuts]
        mov     ecx, TFETheme.DefaultShortcuts.size
        rep movsd

        pop     edi esi ecx ebx
        return
endp




proc TFETheme.SetDefaultThemeClassic, .ptrTheme
begin
        push    ebx ecx esi edi
        mov     ebx, [.ptrTheme]

; colors
        mov     [ebx+TFETheme.clAfterBackground], $000040
        mov     [ebx+TFETheme.clBackground], $000080
        mov     [ebx+TFETheme.clAltBack],    $000090




        mov     [ebx+TFETheme.clSelBack], $c0c0c0
        mov     [ebx+TFETheme.clSelAltBack], $a0a0a0

        mov     [ebx+TFETheme.clLeftMargin],      $c0c0c0
        mov     [ebx+TFETheme.clLeftMarginBorder], $ffffff
        mov     [ebx+TFETheme.clLeftMarginText],  $000000
        mov     [ebx+TFETheme.clLeftMarginTree],  $ff0000
        mov     [ebx+TFETheme.clBookmarkBack],    $ffd000

        mov     [ebx+TFETheme.clSyntax], $ffffff
        mov     [ebx+TFETheme.clSyntax+4], $a0a000

        mov     [ebx+TFETheme.clWrapColumn], $0000ff
        mov     [ebx+TFETheme.Options], eoLineNumbers or eoLeftMargin

        mov     [ebx+TFETheme.WrapPos], 70
        mov     [ebx+TFETheme.MouseWheel], 16

        mov     esi, TFETheme.DefaultShortcuts
        lea     edi, [ebx+TFETheme.shortcuts]
        mov     ecx, TFETheme.DefaultShortcuts.size
        rep movsd

        pop     edi esi ecx ebx
        return
endp




proc SaveTheme, .ptrConfigFile, .ptrTheme, .ptrPath
.ptrDB dd ?
.newpath dd ?
begin
        pushad

        xor     esi, esi
        mov     ebx, 'THTM'

        stdcall LoadBinaryFile, [.ptrConfigFile]
        jc      .file_ok

        mov     esi, eax
        mov     ebx, -1

.file_ok:
        stdcall LoadConfigDB, esi, ebx
        mov     [.ptrDB], eax

        test    esi, esi
        jz      @f
        stdcall FreeMem, esi
@@:

        mov     esi, [.ptrTheme]
        mov     ebx, FreshEditThemeKeys

.loop:
        cmp     [ebx+TCfgInfo.key], 0
        je      .end_of_keys

        cmp     [ebx+TCfgInfo.type], cfgFont
        je      .save_font

        cmp     [ebx+TCfgInfo.type], cfgShortcut
        je      .save_shortcut

; save integer

        lea     eax, [.ptrDB]
        movzx   ecx, [ebx+TCfgInfo.offset]
        stdcall SetConfigParam, eax, [.ptrPath], [ebx+TCfgInfo.key], cdtInteger, [esi+ecx], 4

.next:
        add     ebx, sizeof.TCfgInfo
        jmp     .loop

.save_font:
        lea     eax, [.ptrDB]
        movzx   ecx, [ebx+TCfgInfo.offset]
        stdcall SetConfigParam, eax, [.ptrPath], [ebx+TCfgInfo.key], cdtConfig, eax, eax

        stdcall __CreateNewPath, [.ptrPath], [ebx+TCfgInfo.key]
        mov     [.newpath], eax

        lea     eax, [.ptrDB]
        mov     edx, [esi+ecx+TThemeFont.ptrFace]
        test    edx, edx
        jnz     @f
        mov     edx, cDefaultEditorFont
@@:
        stdcall SetConfigParam, eax, [.newpath], 'face', cdtString, edx, 0

        movzx   edx, [esi+ecx+TThemeFont.size]
        stdcall SetConfigParam, eax, [.newpath], 'size', cdtInteger, edx, 0

        movzx   edx, [esi+ecx+TThemeFont.flags]
        stdcall SetConfigParam, eax, [.newpath], 'flgs', cdtInteger, edx, 0

        movzx   edx, [esi+ecx+TThemeFont.family]
        stdcall SetConfigParam, eax, [.newpath], 'fmly', cdtInteger, edx, 0

        stdcall FreeMem, [.newpath]
        jmp     .next

.save_shortcut:
        lea     eax, [.ptrDB]
        movzx   ecx, [ebx+TCfgInfo.offset]
        stdcall SetConfigParam, eax, [.ptrPath], [ebx+TCfgInfo.key], cdtConfig, eax, eax

        stdcall __CreateNewPath, [.ptrPath], [ebx+TCfgInfo.key]
        mov     edx, eax

        lea     eax, [.ptrDB]
        stdcall SetConfigParam, eax, edx, 'ckey', cdtInteger, [esi+ecx+TShortcut.key], 0
        stdcall SetConfigParam, eax, edx, 'scan', cdtInteger, [esi+ecx+TShortcut.scancode], 0
        stdcall SetConfigParam, eax, edx, 'stat', cdtInteger, [esi+ecx+TShortcut.kbdStatus], 0
        stdcall SetConfigParam, eax, edx, 'mask', cdtInteger, [esi+ecx+TShortcut.maskStatus], 0

        stdcall FreeMem, edx
        jmp     .next


.end_of_keys:
        mov     eax, [.ptrDB]
        stdcall SaveConfigFile, [.ptrDB], [eax+TArray.lparam]
        mov     esi, eax

        mov     ecx, [esi+TArray.count]
        lea     eax, [esi+TArray.array]
        shl     ecx, 2
        stdcall SaveBinaryFile, [.ptrConfigFile], eax, ecx

        stdcall FreeMem, esi
        stdcall FreeConfigDB, [.ptrDB]
        popad
        return
endp



proc __CreateNewPath, .ptrPath, .newdir
begin
        pushad
        mov     esi, [.ptrPath]
        xor     ecx, ecx
        test    esi, esi
        jz      .end_found

.loop:
        cmp     dword [esi], 0
        je      .end_found
        add     esi, 4
        jmp     .loop

.end_found:
        sub     esi, [.ptrPath]
        mov     ecx, esi
        lea     eax, [ecx+8]

        stdcall GetMem, eax
        mov     edi, eax
        mov     ebx, eax

        shr     ecx, 2

        mov     esi, [.ptrPath]
        test    esi, esi
        jz      .root_ok

        rep movsd

.root_ok:
        mov     eax, [.newdir]
        stosd
        xor     eax, eax
        stosd

        mov     [esp+4*regEAX], ebx
        popad
        return
endp



endmodule

; the fields of this structure point to a set of procedures that
; handles one type of editor line. It can be text line or other type of line.
; The editor itself will call this procedures when some processing of the line is needed.

; some of these procedures can be NULL when not needed.

struc TLineProcessor [arg] {
common
  local offs, start
  offs = 0
  start = $

  .__Create     dd ?    ; creates line from given text.
  .__Free       dd ?    ; frees all allocated in the file resources.

  .Draw         dd ?    ; draws the line on the shadow buffer.
  .KeyEvent     dd ?    ; process keyboard events when the caret is in the line.
  .MouseEvent   dd ?    ; process mouse events on the line.

  .ToText       dd ?    ; Converts the line to cannonical type. The editing is disabled if not possible.
  .FromText     dd ?    ; Converts the line to internal representation suitable for editing.

  .Format       dd ?    ; prepares the row for painting and computes needed data structures and indexes.

  .Initialize   dd ?    ; should be called once in order to initialize this line type.
  .Finalize     dd ?    ; should be called once in order to finalize this line type.
forward
  if ~arg eq
    store dword arg at start+offs
    offs = offs + 4
  end if
}

virtual at 0
  TLineProcessor TLineProcessor
end virtual




include "TextLineProcessor.asm"

lprTextLine TLineProcessor   textLineCreate,            \
                             textLineFree,              \
                             textLineDraw,              \
                             textLineKeyEvent,          \
                             textLineMouseEvent,        \
                             textLineToText,            \
                             textLineFromText,          \
                             textLineFormat,            \
                             textLineInit,              \
                             textLineFinish


; Rendering character information for .pRenderInfo array.
struct TCharInfo
  .x   dd ?     ; x coordinate relative to the upper left edge of the line.
  .y   dd ?     ; y coordinate relative to the upper left edge of the line.
  .w   dw ?     ; width of the character.
  .h   dw ?     ; height of the character.
  .b   dw ?     ; base offset of the character.
  .c   db ?     ; color of the character as an index in the syntax colors.
  .f   db ?     ; font of the character as an index in the syntax fonts.
ends



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



proc textLineCreate, .pLine, .hString
begin
        push    eax esi

        mov     esi, [.pLine]
        stdcall StrDup, [.hString]
        mov     [esi+TEditorLine.pData], eax

        pop     esi eax
        return
endp



proc textLineFree, .pLine
begin
        push    eax
        mov     eax, [.pLine]
        stdcall StrDel, [eax+TEditorLine.pData]
        mov     [eax+TEditorLine.pData], 0
        pop     eax
        return
endp



proc textLineDraw, .context, .pEditor, .pLine, .x, .y
begin
        pushad

        add     [.y], 12        ; font base line;

        mov     esi, [.pLine]

        test    [esi+TEditorLine.flags], lfFormatted
        jnz     .so_draw_it

        stdcall textLineFormat, [.context], [.pEditor], esi

.so_draw_it:
        stdcall StrLen, [esi+TEditorLine.pData]
        mov     ecx, eax
        stdcall StrPtr, [esi+TEditorLine.pData]
        mov     edi, eax
        mov     ebx, [esi+TEditorLine.pRenderInfo]      ; pointer to TArray of TCharInfo
        lea     ebx, [ebx+TArray.array]

.draw_loop:
        stdcall DecodeUtf8, [edi]
        add     edi, edx

        test    eax, eax
        jz      .end_of_string

        movzx   eax, [ebx+TCharInfo.c]
        movzx   ecx, [ebx+TCharInfo.f]
        mov     eax, [FreshEditTheme.clSyntax+4*eax]
        mov     ecx, [FreshEditTheme.FontsSyntax+4*ecx]

        push    eax ecx         ; color and font

        mov     eax, [.x]
        mov     ecx, [.y]
        add     eax, [ebx+TCharInfo.x]
        add     ecx, [ebx+TCharInfo.y]

        stdcall DrawString, [.context], edi, edx, eax, ecx ; remaining from the stack.

        add     ebx, sizeof.TCharInfo
        jmp     .draw_loop

.end_of_string:
        popad
        return
endp



proc textLineKeyEvent, .pLine, .pEvent
begin

        return
endp


proc textLineMouseEvent,.pLine, .pEvent
begin
        return
endp



proc textLineToText, .pLine
begin
        return
endp



proc textLineFromText, .pLine
begin
        return
endp



proc textLineFormat, .context, .pEditor, .pLine
  .x    dd ?  ; current X coordinate.
  .y    dd ?  ; current Y coordinate.
  .maxh dd ?  ; maximal height of the subline.

  .wrap dd ?
begin
        pushad

        mov     ebx, [.pLine]
        cmp     [ebx+TEditorLine.pRenderInfo], 0
        je      .info_ok
        stdcall FreeMem, [ebx+TEditorLine.pRenderInfo]

.info_ok:
        stdcall CreateArray, sizeof.TCharInfo
        mov     [ebx+TEditorLine.pRenderInfo], eax

        stdcall StrLenUtf8, [ebx+TEditorLine.pData]
        mov     ecx, eax

        stdcall AddArrayItems, [ebx+TEditorLine.pRenderInfo], ecx
        mov     [ebx+TEditorLine.pRenderInfo], edx

        mov     eax, [.pEditor]
        stdcall [eax+TFreshEdit._procSyntax], [ebx+TEditorLine.pData], edx, [ebx+TEditorLine.syn_context]
        mov     [ebx+TEditorLine.syn_context], eax

        stdcall StrPtr, [ebx+TEditorLine.pData]
        mov     esi, eax
        mov     edi, [ebx+TEditorLine.pRenderInfo]
        lea     edi, [edi+TArray.array]

.render_loop:
        stdcall DecodeUtf8, [esi]
        add     esi, edx

        test    eax, eax
        jz      .end_of_string

        mov     eax, [.x]
        mov     edx, [.y]
        mov     [edi+TCharInfo.x], eax
        mov     [edi+TCharInfo.y], edx

        movzx   eax, [edi+TCharInfo.f]
        stdcall GetTextBounds, [.context], esi, edx, [FreshEditTheme.FontsSyntax+4*eax]

        mov     [edi+TCharInfo.w], ax
        mov     [edi+TCharInfo.h], dx

        cmp     [.maxh], edx
        jae     @f
        mov     [.maxh], edx
@@:
        add     eax, [.x]
        test    [ebx+TEditorLine.flags], lfWordWrap
        jz      .wrap_ok

        cmp     eax, [.wrap]
        jb      .wrap_ok

        mov     eax, [.maxh]
        add     [.y], eax
        xor     eax, eax
        mov     [.maxh], eax

.wrap_ok:
        mov     [.x], eax


        jmp     .render_loop

.end_of_string:
        popad
        return
endp



proc textLineInit
begin
; Main Font settings.
;        stdcall FontCreate, cDefaultEditorFont, 0, 0, ffMonospaced
;        mov     [hTextFont], eax
        return
endp



proc textLineFinish
begin
;        stdcall FontDestroy, [hTextFont]
;        mov     [hTextFont], 0
        return
endp

module "FASM syntax highlighter"

ttText = 0
ttRem  = 1
ttStr  = 2
ttNum  = 3
ttChar = 4
ttNewLine = $80000000


iglobal

  var SynTheme = fasm_colors_windows

; Windows theme.

; Returns:
;       eax - output context of the highligher.
;
proc SyntaxFASM, .hString, .pAttr, .SynContext
.Quo rb 4
.start dd ?
begin
        pushad

        test    [.SynContext], ttNewLine
        jz      @f
        mov     [.SynContext], ttText
@@:
        and     dword [.SynContext], ttNewLine-1

        mov     edi, [.pAttr]
        mov     ebx, [SynTheme]

        stdcall StrPtr, [.hString]
        mov     esi, eax
        mov     [.start], eax