This repository is a mirror!

                        ;
  .             TText
ends



struct TTextChunk
  .len   dw ?   ; the length of the text chunk in BYTES (in Utf-8 chars???)
  .color db ?   ; the high order nibble encode the background, low order nibble encodes the text color.
  .len   dw ?   ; the length of the text chunk in UTF-8 characters.
  .color db ?   ; byte, index of the color/background of the text chunk.
  .flags db ?   ; the text formatting flags. not used, reserved. For example underlining, bold, etc...
ends



object TAsmEdit, TWindow

  method .Redo


; Text editing methods

  method .InsertNewLine, .LineNum
  method .DeleteLine, .LineNum
  method .DeleteChars, .LineNum, .From, .To
  method .DeleteChar

  method .JoinNextLine, .LineNum
  method .JoinNextLine, .LineNum        ; if .LineNum < 0; joins the current caret line

  method .DeleteSelection
  method .ReplaceSelection, .text

  method .InsertString, .text

; OS event handlers

.ins_mask_ok:
        xor     eax, edx
        set     esi, TAsmEdit:Options, eax
        jmp     .endselect

.delkey:
        exec    esi, TAsmEdit:DeleteSelection
        jnc     .del_ok
        jnc     .del_refresh

        DebugMsg "No selection - delete the char under the caret."

        exec    esi, TAsmEdit:TextLine, [esi+TAsmEdit._caretPos.y]
        exec    esi, TAsmEdit:DeleteChar
        jc      .finish

        mov     ebx, eax        ; TTextLine

        OutputValue "TTextLine length = ", [ebx+TTextLine.ch_len], 16, 8
        OutputValue "_caretPos.x = ", [esi+TAsmEdit._caretPos.x], 16, 8

        mov     eax, [esi+TAsmEdit._caretPos.x]
        inc     eax
        cmp     eax, [ebx+TTextLine.ch_len]
        jbe     .del_char
        jnc     .del_refresh

        DebugMsg "Join the next line."

        exec    esi, TAsmEdit:JoinNextLine, [esi+TAsmEdit._caretPos.y]
        exec    esi, TAsmEdit:JoinNextLine, -1
        jmp     .del_refresh

.del_char:
        OutputValue "Delete char on line: ", [esi+TAsmEdit._caretPos.y], 10, -1
        exec    esi, TAsmEdit:DeleteChars, [esi+TAsmEdit._caretPos.y], [esi+TAsmEdit._caretPos.x], eax

.del_refresh:

        and     [esi+TAsmEdit._img_txt_valid], 0
        and     [esi+TAsmEdit._img_margin_valid], 0

        exec    esi, TAsmEdit:RectChanged2, 0
        exec    esi, TAsmEdit:UpdateCaretPos

.del_ok:
        exec    esi, TAsmEdit:SelChangeBegin
        exec    esi, TAsmEdit:SelStartHere
        exec    esi, TAsmEdit:SelEndHere
        exec    esi, TAsmEdit:SelChangeEnd
        jmp     .finish

        jae     .text_ok

        mov     edx, [edi+eax]
        cmp     [edx+TTextLine.syn_array], 0
        jne     .syn_ok

        stdcall [esi+TAsmEdit._syntax_proc], edx, [.context]
        mov     [.context], eax

.syn_ok:
        stdcall __RenderOneLine, [.pImage], edx, [.recta.left], [.recta.right], [.rectr.left], [.rectr.top]

        mov     eax, [edx+TTextLine.syn_context]
        mov     [.context], eax

; and now, scan for chunks and draw them

.draw_chunk_loop:

        mov     ecx, esi              ; the start of the chunk text

.inner_chunk_loop:
        sub     [.chlen], 1
        jc      .next_chunk           ; CF=1 only once.

        dec     [.toChar]
        js      .end_chunk_final      ; draw the final chunk and exits.

        sub     [.chlen], 1
        jc      .next_chunk           ; CF=1 only once.

        cmp     esi, [.gap_end]
        jae     .ofs_ok

        cmp     esi, [.gap_start]
        jb      .ofs_ok

        call    .draw_current_chunk

        sbb     eax, -2

        add     esi, eax
        jmp     .inner_chunk_loop


.next_chunk:

        call    .draw_current_chunk

        mov     ebx, [.chunk]
        inc     ebx
        cmp     ebx, [edi+TArray.count]
        ja      .default_color

        movzx   edx, word [edi+ TArray.array + sizeof.TTextChunk * ebx + TTextChunk.len]
        jmp     .set_color


.end_chunk_final:

        call    .draw_current_chunk


.finish:
        popad
        return

        idiv    [esi+TAsmEdit._font_width]
        test    edx, edx
        jz      @f
        inc     eax
@@:
        mov     [esi+TAsmEdit._width_ch], eax

;        OutputValue "Screen width:", eax, 10, -1

; height
        mov     eax, [esi+TAsmEdit._height]
        cdq

        idiv    [esi+TAsmEdit._font_height]
        test    edx, edx
        jz      @f
        inc     eax
@@:
        mov     [esi+TAsmEdit._height_ch], eax

;        OutputValue "Screen height:", eax, 10, -1

        popad



        return
endp

        xor     ecx, ecx

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

        test    eax, eax
        jz      .end_text
        jz      .cr_ok

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

        stdcall EncodeUtf8, eax

        jmp     .line_loop

.new_line:
        xor     eax, $0d xor $0a
        cmp     [edi], al
        jne     .cr_ok
        inc     edi

.cr_ok:
        push    eax

        mov     esi, [esi]
        mov     [esi+TTextLine.ch_len], ecx
        stdcall IncCount, [ebx+TAsmEdit._line_widths], ecx
        mov     [ebx+TAsmEdit._line_widths], edx

        stdcall [ebx+TAsmEdit._syntax_proc], esi, [.context]
        mov     [.context], eax
        jmp     .text_loop

        pop     eax
        test    eax, eax
        jnz     .text_loop

.end_text:

        exec    ebx, TAsmEdit:ComputeLeftMarginWidth
        exec    ebx, TAsmEdit:UpdateScrollBar


.finish:

        popad

        sub     eax, ebx
        jle     .finish

        neg     edi

.do_scroll:
        DebugMsg "Do scroll."

        sub     eax, edi
        add     edx, eax
        cmovs   edx, ecx

        set     esi, TAsmEdit:PosY, edx
        exec    esi, TAsmEdit:RectChanged2, ecx

method TAsmEdit.DeleteLine      ;, .LineNum
begin
        return
endp


method TAsmEdit.DeleteChars     ;, .LineNum, .From, .To
method TAsmEdit.DeleteChar
begin
        pushad

        mov     esi, [.self]
        mov     edi, [esi+TAsmEdit._lines]
        mov     ebx, [.LineNum]
        mov     ebx, [esi+TAsmEdit._caretPos.y]

        shl     ebx, 2
        cmp     ebx, [edi+TText.GapBegin]
        jb      .skip
        add     ebx, [edi+TText.GapEnd]
        sub     ebx, [edi+TText.GapBegin]
.skip:
        cmp     ebx, [edi+TText.Length]
        jae     .finish
        jae     .not_deleted

        mov     ebx, [edi+ebx]
        stdcall TextIndexToPos, ebx, [.From]
        jc      .finish
        stdcall TextIndexToPos, ebx, [esi+TAsmEdit._caretPos.x]
        jc      .not_deleted

        stdcall TextMoveGap, ebx, eax
        mov     edx, [ebx+TTextLine.GapEnd]
        mov     ecx, [.From]

.loop:
        cmp     ecx, [.To]
        jae     .end_scan

        cmp     edx, [ebx+TTextLine.Length]
        cmova   edx, [ebx+TTextLine.Length]
        jae     .end_scan
        jae     .not_deleted

        movzx   eax, byte [ebx+edx]

                                ; compute the length of the UTF-8 character by its first byte (version without branches) Is it fast?
        not     al              ; utf-8 starts with one of: 0xxxxxxx, 110xxxxx, 1110xxxx, 11110xxx, 111110xx, 1111110x
        bsr     eax, eax        ; eax =                 7,  5,  4,  3,  2,  1
        sub     eax, 7          ; eax =                 0, -2, -3, -4, -5, -6
                                ; CF  =                 0,  1,  1,  1,  1,  1
        not     eax             ; eax =                -1, +1, +2, +3, +4, +5
        sbb     eax, -2         ; eax = edx + 2 - CF = +1, +2, +3, +4, +5, +6

        add     edx, eax
        inc     ecx
        jmp     .loop
        cmp     edx, [ebx+TTextLine.Length]
        cmova   edx, [ebx+TTextLine.Length]
        mov     [ebx+TTextLine.GapEnd], edx

.end_scan:
        mov     [ebx+TTextLine.GapEnd], edx
        sub     ecx, [.From]
        stdcall FreeMem, [ebx+TTextLine.syn_array]
        and     [ebx+TTextLine.syn_array], 0            ; reset the syntax array of the line...

        stdcall DecCount, [esi+TAsmEdit._line_widths], [ebx+TTextLine.ch_len]
        sub     [ebx+TTextLine.ch_len], ecx
        dec     [ebx+TTextLine.ch_len]
        stdcall IncCount, edx, [ebx+TTextLine.ch_len]
        mov     [esi+TAsmEdit._line_widths], edx

        and     [esi+TAsmEdit._img_txt_valid], 0
        and     [esi+TAsmEdit._img_margin_valid], 0
        exec    esi, TAsmEdit:RectChanged2, 0
        exec    esi, TAsmEdit:UpdateCaretPos

        clc
        popad
        return
.finish:

.not_deleted:
        stc
        popad
        return
endp


method TAsmEdit.JoinNextLine    ;, .LineNum
method TAsmEdit.JoinNextLine    ; .LineNum
begin
        pushad

        mov     esi, [.self]
        mov     edi, [esi+TAsmEdit._lines]
        mov     ebx, [.LineNum]
        test    ebx, ebx
        cmovs   ebx, [esi+TAsmEdit._caretPos.y]

        shl     ebx, 2
        lea     ecx, [ebx+4]

        cmp     ebx, [edi+TText.GapBegin]
        jb      .skip1
        stdcall TextMoveGap, edi, ecx   ; move the gap between the two lines.

        add     ebx, [edi+TText.GapEnd]
        sub     ebx, [edi+TText.GapBegin]
; here ebx is before the gap and ecx is after!
.skip1:

        cmp     ecx, [edi+TText.GapBegin]
        jb      .skip2
        add     ecx, [edi+TText.GapEnd]
        sub     ecx, [edi+TText.GapBegin]
.skip2:
        cmp     ecx, [edi+TText.Length]
        jae     .finish ; nothing to join

        cmp     ebx, [edi+TText.Length]
        jae     .finish

        add     [edi+TText.GapEnd], 4   ; free the place of the next line...

; first fix the new line widths...

        mov     edx, [esi+TAsmEdit._line_widths]

        mov     eax, [edi+ebx]
        push    [eax+TTextLine.ch_len]

        mov     [esi+TAsmEdit._line_widths], edx

; then join the texts

        stdcall TextAddText, [edi+ebx], -1, [edi+ecx]
        mov     [edi+ebx], edx

; then delete the next line
; then free the next line TTextLine structure...

        mov     eax, [edi+ecx]
        stdcall FreeMem, [eax+TTextLine.syn_array]
        stdcall TextFree, eax     ; delete the next line... but what about the debug info and other attributes?

; reset the syntax coloring of the new line
; reset the syntax coloring of the result line
        mov     eax, [edi+ebx]
        stdcall FreeMem, [eax+TTextLine.syn_array]
        and     [eax+TTextLine.syn_array], 0

        mov     eax, [.LineNum]
        lea     eax, [4*eax+4]
        stdcall TextMoveGap, edi, eax
        add     [edi+TText.GapEnd], 4

.finish:
        popad
        return
endp



method TAsmEdit.DeleteSelection
.rect RECT
.list dd ?
begin
        pushad

        exec    [.self], TAsmEdit:_AddSelRectanglesAbs, 0
        mov     [.list], edx

        OutputValue "Selection array count: ", [edx+TArray.count], 10, -1

        lea     edi, [edx+TArray.array]
        mov     ecx, [edx+TArray.count]
        test    ecx, ecx
        jz      .exit_empty

        mov     eax, ecx
        shl     eax, 4  ; sizeof.RECT
        add     edi, eax

.rect_loop:

        sub     edi, sizeof.RECT
        dec     ecx
        js      .finish

        OutputValue "RECT.left =", [edi+RECT.left], 10, -1
        OutputValue "RECT.top =", [edi+RECT.top], 10, -1
        OutputValue "RECT.right =", [edi+RECT.right], 10, -1
        OutputValue "RECT.bottom =", [edi+RECT.bottom], 10, -1

        mov     ebx, [edi+RECT.bottom]

.y_loop:
        dec     ebx
        cmp     ebx, [edi+RECT.top]
        jl      .rect_loop

.exit:
        stdcall FreeMem, [.list]
        clc
        popad
        return

.exit_empty:
        DebugMsg "Exit delete selection EMPTY!"

        stdcall FreeMem, [.list]
        stc
        popad
        return
endp

;   .pLineInfo - pointer to TTextLine structure.
;   .SynContext - input context of the highligher.
;
; Returns:
;       eax - output context of the highligher.
;
proc SyntaxFASM, .pTextLine, .SynContext
.Quo   rb 4
.start dd ?
.Quo   dd ?
.cnt   dd ?
begin
        pushad

        mov     esi, [.pTextLine]

        mov     edi, [esi+TTextLine.syn_array]
        test    edi, edi
        jnz     .array_ok

        stdcall CreateArray, sizeof.TTextChunk
        mov     edi, eax
        mov     [esi+TTextLine.syn_array], eax

.array_ok:

        xor     ebx, ebx                ; the offset inside the line.
        xor     edx, edx

        mov     [.Quo], bl
        mov     [.Quo], ebx
        mov     [edi+TArray.count], ebx
        mov     [.start], ebx
        mov     [.cnt], ebx
        dec     [.cnt]

.loop:
        add     ebx, edx
        inc     [.cnt]

        mov     eax, [esi+TTextLine.GapBegin]
        cmp     ebx, eax
        cmovae  eax, [esi+TTextLine.GapEnd]
        sub     eax, [esi+TTextLine.GapBegin]
        add     eax, ebx

        cmp     eax, [esi+TTextLine.Length]
        jae     .end_of_line

        stdcall DecodeUtf8, [esi+eax]

;        OutputValue "Char: ", eax, 16, 8

        cmp     [.SynContext], ciComment
        je      .endif
        je      .loop

        cmp     [.SynContext], ciString
        jne     .ifnotstr

        cmp     al,[.Quo]
        jne     .endif
        cmp     eax,[.Quo]
        jne     .loop

        add     ebx, edx
        xor     edx, edx
        call    .end_chunk
        mov     [.SynContext], ciText
        jmp     .loop

.ifnotstr:
        cmp     al, ';'
        cmp     eax, $ff
        ja      .text

        cmp     eax, ';'
        jne     .notrem

        call    .end_chunk
        mov     [.SynContext], ciComment
        jmp     .endif
        jmp     .loop

.notrem:
        cmp     al, '"'
        cmp     eax, '"'
        je      .str
        cmp     al, "'"
        cmp     eax, "'"
        jne     .notstr

.str:
        call    .end_chunk
        mov     [.SynContext], ciString
        mov     [.Quo], al
        jmp     .endif
        mov     [.Quo], eax
        jmp     .loop

.notstr:
        call    .CharInSymbols
        jnc     .notsym

        cmp     [.SynContext], ciSymbol
        je      .loop

        call    .end_chunk
        mov     [.SynContext], ciSymbol
        jmp     .endif
        jmp     .loop

.notsym:
        cmp     [.SynContext], ciNumber
        je      .endif
        je      .loop

        cmp     ebx, [.start]
        cmp     [.cnt], 0
        je      .maybenum

        cmp     [.SynContext], ciSymbol
        jne     .endif
        jne     .text

; The number begins only after ttChar or at the begining of the line.
.maybenum:
        cmp     al, '$'
        je      .num_start
        call    .CharInNum
        jnc     .notnum

        cmp     al, '-'
        je      .num_start

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

.num_start:
        call    .end_chunk
        mov     [.SynContext], ciNumber
        jmp     .endif
        jmp     .loop

.notnum:
.text:
        call    .end_chunk
        mov     [.SynContext], ciText
        cmp     [.SynContext], ciText
        je      .loop

.endif:
        call    .end_chunk
        mov     [.SynContext], ciText
        jmp     .loop


.end_of_line:
        call    .end_chunk

;        mov     eax, [.SynContext]
        xor     eax, eax                ; the assembly lines always end with context of 0 ???

        mov     [esi+TTextLine.syn_array], edi
        mov     [esi+TTextLine.syn_context], eax
        mov     [esp+4*regEAX], eax
        popad
        return


.end_chunk:
        push    eax ecx edx

        mov     ecx, ebx
        sub     ecx, [.start]
        mov     ecx, [.cnt]
        test    ecx, ecx
        jz      .chunk_processed

        mov     [.start], ebx
        and     [.cnt], 0

        stdcall AddArrayItems, edi, 1
        mov     edi, edx
        jc      .chunk_processed

;        OutputValue "Chunk length: ", ecx, 16, 8

        mov     [eax+TTextChunk.len], cx
        mov     ecx, [.SynContext]
        mov     [eax+TTextChunk.color], cl

;        OutputValue "Chunk color: ", ecx, 16, 8

.chunk_processed:
        pop     edx ecx eax
        retn


.CharInSymbols:

        stc
        pop     ecx edi
        ret
@@:
        clc
        pop     ecx edi
        retn


.CharInNum:
        cmp     al, '$'
        jne     @f
        stc
        retn

@@:
        cmp     al, '0'
        jb      @f
        cmp     al, '9'
        ja      @f
        stc
        retn
@@:
        clc
        retn


.symbol_characters db 27
                  db 9,0Ah,0Dh,1Ah,20h,'+-/*=<>()[]{}:,|&~#`;\'

endp

        mov     [.Quo], bl
        mov     [edi+TArray.count], ebx
        mov     [.start], ebx

.loop:
        add     ebx, edx
        cmp     ebx, [esi+TTextLine.TextLen]
        jae     .end_of_line

        mov     eax, ebx
        pos2ofs eax, esi

        cmp     eax, [esi+TTextLine.Length]
        jae     .end_of_line

        stdcall DecodeUtf8, [esi+eax]

        cmp     [.SynContext], ciComment
        je      .endif

        cmp     [.SynContext], ciString

                     x = 10, y = 40, width = 200, height = 200, \
                     SplitCell = SplitTest.cellAsmEdit,         \
                     Visible = TRUE


;utf8_long file "unicode_test.txt"
utf8_long file "test_utf8.asm"

;utf8_long db  "Test one line"
          dd   0



if ThemeGUI eq win_gui
  getfile imgArrowRight, '_test_images/right2.png'
end if