kolibrios-fun/programs/network/ircc/textbox.inc

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                                 ;;
;; Copyright (C) KolibriOS team 2004-2024. All rights reserved.    ;;
;; Distributed under terms of the GNU General Public License       ;;
;;                                                                 ;;
;;   Written by hidnplayr@kolibrios.org                            ;;
;;                                                                 ;;
;;         GNU GENERAL PUBLIC LICENSE                              ;;
;;          Version 2, June 1991                                   ;;
;;                                                                 ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


text_insert_newlines:                   ; esi = ASCIIZ string

        xor     edx, edx                ; number of lines of text
        cmp     byte[esi], 0
        je      .done
  .next_line:
        xor     ebx, ebx
        mov     ecx, [textbox_width]
        inc     ecx
  .more:
        dec     ecx
        jz      .end_of_line
  .next_byte:
        lodsb                           ; get one character of the string
        test    al, al                  ; end of string?
        jz      .almost_done
        cmp     al, ' '                 ; it's a space! remember its position
        je      .space
        cmp     al, 13                  ; we already inserted a newline once, make it a space again
        je      .soft_nl
        cmp     al, 10                  ; it's a newline, continue onto the next line
        je      .newline
        and     al, 0xc0                ; Is it a multi byte UTF8 char?
        cmp     al, 0x80
        je      .next_byte
        jmp     .more
  .newline:
        inc     edx
        jmp     .next_line
  .soft_nl:
        mov     byte[esi-1], ' '
  .space:
        mov     ebx, esi                ; last detected space
        jmp     .more
  .end_of_line:
        inc     edx
        test    ebx, ebx                ; did we detect any spaces on this line?
        jz      .next_line              ; no:   just continue onto the next line
        mov     byte[ebx-1], 13         ; yes:  replace last space on line with a soft newline
        mov     esi, ebx                ;       and continue parsing just after last space
        jmp     .next_line              ;
  .almost_done:
        dec     esi
  .done:

        ret


;----------------------------------
; scan untill next line is reached
;
; When you set the direction flag before calling, you can also scan for previous line!
; IN:   esi
; OUT:  esi
;----------------------------------
text_nextline:

        mov     ecx, [textbox_width]
  .loop:
        lodsb
        test    al, al
        jz      .done
        cmp     al, 10
        je      .done
        cmp     al, 13
        je      .done
        and     al, 0xc0
        cmp     al, 0x80
        je      .loop           ; This byte is the second, third or fourth byte of a multi-byte UTF8 char
        dec     ecx
        jnz     .loop
  .done:
        ret

;----------------------------------
; print string
;
; IN:   esi = ptr to string
;       bl = char which marks end of string
; OUT:  esi = ptr to end of str
;----------------------------------
print_string:

        push    eax
  .loop:
        lodsb
        cmp     al, bl
        je      .done
        cmp     al, 13
        je      .loop
        test    al, al
        jz      .done
        call    print_char
        jmp     .loop
  .done:
        pop     eax

        ret


;----------------------------------
; print ASCIIZ string
;
; IN:   esi = ptr to ASCIIZ string
; OUT:  esi = ptr to end of str
;----------------------------------
print_asciiz:

        push    eax
  .loop:
        lodsb
        test    al, al
        jz      .done
        call    print_char
        jmp     .loop
  .done:
        pop     eax

        ret


;----------------------------------
; print character
;
; IN:   al = char to print
; OUT:  /
;----------------------------------
print_char:

        push    esi edi
        mov     esi, [window_print]
        mov     edi, [esi + window.text_write]
        stosb
        cmp     edi, [esi + window.text_end]
        jae     .uh_ow
        mov     [esi + window.text_write], edi
  .continue:
        or      [esi + window.flags], FLAG_UPDATED
        pop     edi esi

        ret

  .uh_ow:
        pusha
        mov     edi, [esi + window.text_start]
        mov     [esi + window.text_print], edi
        lea     esi, [edi + TEXT_BUFFERSIZE/2]
        call    text_nextline
        mov     ecx, TEXT_BUFFERSIZE/8
        rep     movsd
        mov     esi, edi
        call    text_insert_newlines

        mov     ebx, [window_print]
        mov     [ebx + window.text_lines], edx
        mov     [ebx + window.text_scanned], esi
        mov     [ebx + window.text_write], esi
        mov     [ebx + window.text_line_print], 0
        popa

        jmp     .continue



;-----------------------------------------------
; Draw text of the current window to the screen
;
; IN:   /
; OUT:  /
;-----------------------------------------------
draw_channel_text:

        mov     edi, [window_active]
        and     [edi + window.flags], not FLAG_UPDATED  ; clear the 'window is updated' flag

; Scan new text for newlines
        mov     esi, [edi + window.text_scanned]
        call    text_insert_newlines
        add     [edi + window.text_lines], edx
        mov     [edi + window.text_scanned], esi

; Is scrollbar at lowest position?
        test    [edi + window.flags], FLAG_SCROLL_LOW
        jnz     .yesscroll                              ; Yes
        cmp     [scroll2.all_redraw], 1                 ; No
        jnz      .noscroll
        mov     edx, [textbox_height]
        add     edx, [edi + window.text_line_print]
    cmp edx, [edi + window.text_lines]
        jl      .noscroll
  .yesscroll:
; Scrollbar was at lowest position, scroll down automatically when new text arrived.
        mov     edx, [edi + window.text_lines]
        sub     edx, [textbox_height]
        jg      @f
        mov     [edi + window.text_line_print], 0
        jmp     .noscroll                               ; There are less lines of text than fit into the window, dont scroll..
  @@:
        sub     edx, [edi + window.text_line_print]
        je      .noscroll                               ; We are already at the bottom pos, dont scroll..
  .scroll_to_pos:               ; edx = number of lines to go up/down (flags must indicate direction)
        pushf
        add     [edi + window.text_line_print], edx
        mov     esi, [edi + window.text_print]
        popf
        jg      .loop_forward
        std                     ; set direction flag so we can scan backwards
        dec     esi
        dec     esi             ; move our cursor just in front of newline, for scanning backwards
  .loop_backward:
        call    text_nextline
        inc     edx
        jnz     .loop_backward
        inc     esi
        inc     esi             ; move the cursor just after last newline
        cld
        jmp     .ok

  .loop_forward:
        call    text_nextline
        dec     edx
        jnz     .loop_forward
  .ok:
        mov     [edi + window.text_print], esi
  .noscroll:

; Update and draw scrollbar when nescessary
        mov     edx, [edi + window.text_lines]
        cmp     edx, [textbox_height]
        jbe     .scroll_done

        mov     [scroll2.max_area], edx
        mov     eax, [edi + window.text_line_print]
        mov     [scroll2.position], eax

        push    dword scroll2                   ; redraw scrollbar
        call    [scrollbar_draw]
        mov     [scroll2.all_redraw], 0         ; next time, dont redraw it completely
  .scroll_done:

; Calculate start offset coordinates (align text to bottom)
        mov     ebx, [textbox_height]
        sub     ebx, [edi + window.text_lines]
        jb      .no_offset
        imul    ebx, FONT_HEIGHT
        push    [edi + window.text_start]
        pop     [edi + window.text_print]
        jmp     .draw_text
  .no_offset:
        xor     ebx, ebx
  .draw_text:

; Prepare to actually draw some text
        add     ebx, TEXT_X shl 16 + TEXT_Y     ; text coordinates
        mov     ecx, [colors.work_text]         ; default text color
        or      ecx, 0x30000000
        mov     edx, [edi + window.text_print]  ; start of text to print

; Scan backwards on line for color escape codes
        mov     esi, edx
        push    edx
        std
  @@:
        lodsb
        cmp     al, 0           ; end of text
        je      @f
        cmp     al, 10          ; hard newline
        je      @f
        cmp     al, 3           ; mIRC escape code
        jne     @b

        cld
        lea     edx, [esi+2]
        call    dec_to_esi
        jz      @f
        mov     ecx, [irc_colors + 4*esi]
        or      ecx, 0x30000000                 ; UTF-8 text

        cmp     byte[edx], ','                  ; background color?
        jne     @f
        inc     edx
        call    dec_to_esi
        jz      @f
        mov     edi, [irc_colors + 4*esi]
        or      ecx, 0x40000000                 ; enable background color
  @@:
        cld

        pop     edx
        mov     eax, [textbox_height]           ; max number of lines to draw
  .drawloop:
        cmp     byte[edx], 0
        je      .end_of_text

; Clear one row of characters
        pusha
        mov     cx, bx
        shl     ecx, 16
        mov     cx, FONT_HEIGHT
        mov     ebx, TEXT_X shl 16
        mov     bx, word[textbox_width]
        imul    bx, FONT_WIDTH
        mov     edx, [colors.work]
        mcall   13                              ; draw rectangle
        popa

        push    eax
  .line:
        cmp     byte[edx], 0x20
        jae     .printable
        cmp     byte[edx], 0
        je      .end_of_text
        cmp     byte[edx], 13
        je      .newline_soft
        cmp     byte[edx], 10
        je      .newline_hard

        cmp     byte[edx], 3                    ; escape code for mIRC colors
        jne     .no_colors
        inc     edx
        call    dec_to_esi
        jz      .line
        mov     ecx, [irc_colors + 4*esi]
        or      ecx, 0x30000000

        cmp     byte[edx], ','                  ; background color?
        jne     .line
        inc     edx
        call    dec_to_esi
        jz      .line
        mov     edi, [irc_colors + 4*esi]
        or      ecx, 0x40000000
  .no_colors:

; Some non-printable, just skip it
        inc     edx
        jmp     .line

;-------------------------------------------
; Count characters until 0, 10, 13 or 3 byte

  .printable:
        push    edx
        xor     esi, esi
        dec     esi
  .next_char:
        inc     esi
        cmp     esi, [textbox_width]
        je      .cnt_done
        mov     al, byte[edx]
        cmp     al, 0x20
        jb      .cnt_done

        inc     edx
        test    al, 10000000b
        jz      .next_char              ; 1 byte wide

        add     edx, 3
        and     al, 11111000b
        cmp     al, 11110000b
        je      .next_char              ; 4 bytes wide

        dec     edx
        and     al, 11110000b
        cmp     al, 11100000b
        je      .next_char              ; 3 bytes wide
        dec     edx                     ; 2 bytes wide
        jmp     .next_char
  .cnt_done:
        mov     eax, edx
        pop     edx
        push    eax
        mcall   4                       ; draw text
        pop     edx                     ; next start ptr

        cmp     esi, [textbox_width]
        je      .line_full
        imul    esi, FONT_WIDTH shl 16
        add     ebx, esi
        jmp     .line

  .newline_hard:
        mov     ecx, [colors.work_text]
        or      ecx, 0x30000000
  .newline_soft:
        inc     edx
  .line_full:
        and     ebx, 0x0000ffff
        add     ebx, TEXT_X shl 16 + FONT_HEIGHT
        pop     eax
        dec     eax
        jnz     .drawloop
  .end_of_text:

        ret




dec_to_esi:

        xor     esi, esi
  .loop:
        movzx   eax, byte[edx]
        sub     al, '0'
        jb      .done
        cmp     al, 9
        ja      .done
        inc     edx
        lea     esi, [esi*4 + esi]      ; esi * 5
        lea     esi, [esi*2 + eax]      ; esi * 2 + eax
        jmp     .loop
  .done:
        cmp     esi, 16
        jae     .fail
        ret

  .fail:
        xor     esi, esi
        ret



if TIMESTAMP
print_timestamp:

        pusha
        mcall   3                       ; get system time
        mov     ebx, eax

        mov     al, '['
        call    print_char
        mov     ecx, TIMESTAMP
  .loop:
        mov     al, bl
        shr     al, 4
        add     al, '0'
        call    print_char

        mov     al, bl
        and     al, 0x0f
        add     al, '0'
        call    print_char

        dec     ecx
        jz      .done

        mov     al, ':'
        call    print_char
        shr     ebx, 8
        jmp     .loop
  .done:
        mov     al, ']'
        call    print_char
        mov     al, ' '
        call    print_char

        popa
        ret
end if