473 lines
13 KiB
PHP
473 lines
13 KiB
PHP
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ;;
|
|
;; 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 |