Subversion Repositories Kolibri OS

Compare Revisions

Regard whitespace Rev 9104 → Rev 9105

/programs/develop/libraries/console_coff/console.asm
10,6 → 10,36
include 'font.inc'
include 'conscrl.inc'
 
struc process_info
{
.cpu_usage dd ? ; +0
.window_stack_position dw ? ; +4
.window_stack_value dw ? ; +6
dw ? ; +8
.process_name rb 12 ; +10
.memory_start dd ? ; +22
.used_memory dd ? ; +26
.PID dd ? ; +30
.box.x dd ? ; +34
.box.y dd ? ; +38
.box.width dd ? ; +42
.box.height dd ? ; +46
.slot_state dw ? ; +50
dw ? ; +52
.client_box.x dd ? ; +54
.client_box.y dd ? ; +58
.client_box.width dd ? ; +62
.client_box.height dd ? ; +66
.wnd_state db ? ; +70
rb (1024-71)
}
 
OP_EXIT = 1
OP_SET_TITLE = 2
OP_REDRAW = 3
OP_GETCH = 4
OP_RESIZE = 5
 
;void __stdcall START(dword state);
START:
; N.B. The current kernel implementation does not require
36,8 → 66,8
pop eax
pop [con.wnd_width]
pop [con.wnd_height]
pop [con.scr_width]
pop [con.scr_height]
pop [con.main_scr_width]
pop [con.main_scr_height]
pop [con.title]
push eax
 
57,16 → 87,32
add eax, 4
add edx, 4
loop .1
; allocate memory for console data & bitmap data
mov eax, [con.scr_width]
mul [con.scr_height]
 
; Allocate memory for console data & bitmap data
; First, calculate required amount of bytes
 
; Main buffer
mov eax, [con.main_scr_width]
mul [con.main_scr_height]
; 2 bytes per on-screen character (1 flags and 1 ascii)
lea ecx, [eax+eax]
 
; Alternate buffer
mov [con.altbuffer], ecx
mov eax, [con.wnd_width]
mul [con.wnd_height]
; 2 bytes per on-screen character (1 flags and 1 ascii)
lea ecx, [ecx+2*eax]
 
; Bitmap data
mov eax, [con.wnd_width]
mul [con.wnd_height]
imul eax, font_width*font_height
mov ebx, eax
push ebx ecx
add ecx, eax
 
; malloc
push 68
pop eax
push 12
75,13 → 121,29
pop ecx ebx
mov edx, con.nomem_err
test eax, eax
jz con.fatal
jz .fatal
 
; Set pointers to the buffers
mov [con.mainbuffer], eax
add [con.altbuffer], eax
 
; Set active buffer pointer and dimensions
mov [con.data], eax
 
push [con.main_scr_width]
pop [con.scr_width]
 
push [con.main_scr_height]
pop [con.scr_height]
 
; Clear text buffers
push edi
mov edi, eax
shr ecx, 1
mov ax, 0x0720
rep stosw
 
; Clear bitmap buffer
mov ecx, ebx
mov [con.image], edi
xor eax, eax
88,6 → 150,7
rep stosb
pop edi
and byte [con_flags+1], not 2
 
; create console thread
push 51
pop eax
98,11 → 161,12
int 0x40
mov edx, con.thread_err
test eax, eax
js con.fatal
js .fatal
mov [con.console_tid], eax
pop ebx
ret
con.fatal:
 
.fatal:
; output string to debug board and die
mov cl, [edx]
test cl, cl
113,7 → 177,7
inc ebx
int 0x40
inc edx
jmp con.fatal
jmp .fatal
@@:
or eax, -1
int 0x40
154,7 → 218,7
con_init_check:
mov ah,[con.init_cmd]
test ah,ah
jne cmd_init_yes
jne .yes
 
push con.title_init_console
push -1
163,13 → 227,14
push -1
 
call con_init
.yes:
ret
 
cmd_init_yes:
 
ret
; void __stdcall con_write_asciiz(const char* string);
con_write_asciiz:
 
call con_init_check
 
push ebx esi
or ebx, -1
mov esi, [esp+12]
179,6 → 244,7
 
; void __stdcall con_write_string(const char* string, dword length);
con_write_length:
 
push ebx esi
mov esi, [esp+12]
mov ebx, [esp+16]
265,7 → 331,9
 
; int __cdecl con_printf(const char* format, ...)
con_printf:
 
call con_init_check
 
xor eax, eax
pushad
call con.get_data_ptr
797,7 → 865,7
push 55
pop eax
mov ebx, eax
mov esi, con.beep2
mov esi, con.bell
int 0x40
popa
ret
806,20 → 874,52
mov [con_esc_attr_n], 1
and [con_esc_attrs], 0
ret
 
.esc_mode:
cmp [con_sci], 0
jnz .esc_sci
cmp al, '['
jnz @f
mov [con_sci], 1
ret
@@:
je .esc_sqro
cmp al, ']'
je .esc_sqrc
cmp al, '('
je .esc_rndo
cmp al, '>'
je .keypm_norm
cmp al, '='
je .keypm_alt
; Unrecognized escape sequence, print it to screen
push eax
mov al, 27
call con.write_char
pop eax
jmp con.write_char
 
.esc_sqro:
mov [con_sci], 1
ret
.esc_sqrc:
mov [con_sci], 2
ret
.esc_rndo:
mov [con_sci], 4
ret
 
.keypm_norm:
; TODO: turn numlock on
mov [con_esc], 0
ret
 
.keypm_alt:
; TODO: turn numlock off
mov [con_esc], 0
ret
 
.esc_sci:
cmp [con_sci], 3
je .string
cmp [con_sci], 4
je .g0charset
; this is real Esc sequence
cmp al, '?' ; DEC private mode (DECSET/DECRST sequences)
je .questionmark
839,6 → 939,42
mov [con_esc_attrs+(ecx-1)*4], edx
pop edx ecx eax
ret
.g0charset:
; Designate G0 Character Set
; Unimplemented: read and ignore.
mov [con_sci], 0
mov [con_esc], 0
ret
.string:
cmp al, 0x07 ; bell
je .string_end
cmp al, 0x9C ; string terminator
je .string_end
push ecx
mov ecx, [con_osc_strlen]
cmp ecx, 255
jae @f
mov [con_osc_str+ecx], al
inc [con_osc_strlen]
@@:
pop ecx
ret
.string_end:
mov [con_sci], 0
mov [con_esc], 0
pusha
mov ecx, [con_osc_strlen]
mov byte[con_osc_str+ecx], 0
cmp [con_esc_attrs+0], 0 ; Set Icon and Window Title
je .set_title
cmp [con_esc_attrs+0], 2 ; Set Window Title
je .set_title
ret
.set_title:
push con_osc_str
call con_set_title
popa
ret
.questionmark:
push ecx
mov ecx, [con_esc_attr_n]
854,79 → 990,373
@@:
mov [con_esc_attr_n], eax
and [con_esc_attrs+(eax-1)*4], 0
; Check for operating system command
cmp [con_sci], 2
jne @f
cmp [con_esc_attr_n], 2
jne @f
; Next argument is string
mov [con_sci], 3
mov [con_osc_strlen], 0
@@:
pop eax
ret
.not_digit:
mov [con_esc], 0
mov [con_sci], 0 ; in any case, leave Esc mode
cmp al, 'J'
jz .clear
cmp al, 'H'
jz .setcursor
cmp al, 'f'
jz .setcursor
cmp al, 'm'
jz .set_attr
 
; cmp al, '@'
; je .insert_chars
cmp al, 'A'
jz .cursor_up
je .cursor_up
cmp al, 'B'
jz .cursor_down
je .cursor_down
cmp al, 'C'
jz .cursor_right
je .cursor_right
cmp al, 'D'
jz .cursor_left
cmp al, 'l'
je .dec_rst
cmp al, 'h'
je .dec_set
je .cursor_left
; cmp al, 'E'
; je .cursor_next_line
; cmp al, 'F'
; je .cursor_prev_line
; cmp al, 'G'
; je .cursor_next_line
; cmp al, 'S'
; je .scroll_page_up
; cmp al, 'T'
; je .scroll_page_down
cmp al, 'H'
je .cursor_position
cmp al, 'J'
je .erase_in_display
cmp al, 'K'
je .erase_in_line
cmp al, 'L'
je .insert_lines
cmp al, 'M'
je .delete_lines
cmp al, 'P'
je .delete_chars
cmp al, 'X'
je .erase_chars
 
cmp al, 'd'
je .line_position_abs
; cmp al, 'e'
; je .line_position_rel
cmp al, 'f'
je .cursor_position
cmp al, 'h'
je .set_mode
cmp al, 'l'
je .reset_mode
cmp al, 'm'
je .set_attr
cmp al, 'r'
je .scroll_region
; cmp al, 's'
; je .save_cursor_pos
; cmp al, 't'
; je .window_manip
; cmp al, 'u'
; je .restore_cursor_pos
 
ret ; simply skip unknown sequences
 
.dec_rst:
.insert_lines:
 
push eax ebx ecx esi
mov eax, [con_esc_attrs+0] ; amount of lines to scroll down
test eax, eax
jnz @f ; default is 1
inc eax
@@:
; Check that we are inside the scroll region
mov ebx, [con.cur_y]
cmp ebx, [con.scroll_top]
jb .no_insert_lines
add ebx, eax
cmp ebx, [con.scroll_bot]
ja .no_insert_lines
; Move cursor to the left
mov [con.cur_x], 0
call con.get_data_ptr
; Calc amount of chars in requested numer of lines
mov ebx, [con.scr_width]
imul ebx, eax
; Move the lines down (in backwards order)
push edi
mov ecx, [con.scroll_bot]
sub ecx, [con.cur_y]
sub ecx, eax
imul ecx, [con.scr_width]
lea esi, [edi + 2*ecx - 2]
lea edi, [esi + 2*ebx]
std
rep movsw
cld
pop edi
; Insert empty lines
push edi
mov ecx, ebx
mov ah, byte[con_flags]
mov al, ' '
rep stosw
pop edi
.no_insert_lines:
pop esi ecx ebx eax
ret
 
.delete_lines:
 
push eax ebx ecx esi
mov eax, [con_esc_attrs+0] ; amount of lines to scroll up
test eax, eax
jnz @f ; default is 1
inc eax
@@:
; Check that we are inside the scroll region
mov ebx, [con.cur_y]
cmp ebx, [con.scroll_top]
jb .no_delete_lines
add ebx, eax
cmp ebx, [con.scroll_bot]
ja .no_delete_lines
; Move cursor to the left
mov [con.cur_x], 0
call con.get_data_ptr
; Calc amount of chars in requested numer of lines
mov ebx, [con.scr_width]
imul ebx, eax
; Move the lines up
mov ecx, [con.scroll_bot]
sub ecx, [con.cur_y]
imul ecx, [con.scr_width]
lea esi, [edi + 2*ebx]
rep movsw
; Set new cursor row position
add [con.cur_y], eax
; Add empty lines till end of scroll region
push edi
mov ecx, ebx
mov ah, byte[con_flags]
mov al, ' '
rep stosw
pop edi
.no_delete_lines:
pop esi ecx ebx eax
ret
 
.scroll_region:
push eax ebx
cmp [con_esc_attr_n], 2
jb .no_scroll_region
mov eax, [con_esc_attrs+0] ; top
dec eax
js .no_scroll_region
cmp eax, [con.wnd_height]
ja .no_scroll_region
 
mov ebx, [con_esc_attrs+4] ; bottom
dec ebx
js .no_scroll_region
cmp ebx, [con.wnd_height]
ja .no_scroll_region
 
cmp eax, ebx
ja .no_scroll_region
 
mov [con.scroll_top], eax
mov [con.scroll_bot], ebx
 
.no_scroll_region:
pop ebx eax
ret
 
.reset_mode:
mov eax, [con_esc_attrs]
cmp eax, 0xffffffff
jne .no_dec_rst
mov eax, [con_esc_attrs+4]
cmp eax, 1
je .dec_rst_app_cursor_keys
; cmp eax, 7
; je .dec_rst_wraparound
; cmp eax, 12
; je .dec_rst_cursor_blink
cmp eax, 25
je .hide_cursor
je .dec_rst_cursor
; cmp eax, 1000
; je .dec_rst_mouse
; cmp eax, 1002
; je .dec_rst_buttons
; cmp eax, 1006
; je .dec_rst_mouse_sgr
cmp eax, 1049
je .dec_rst_altbuff
; cmp eax, 2004
; je .dec_rst_brck_paste
.no_dec_rst:
; cmp eax, 2
; je .rst_keyb_action_mode
; cmp eax, 4
; je .set_replace_mode
ret
.hide_cursor:
mov [con.cursor_height], 0
ret
 
.dec_set:
.set_mode:
mov eax, [con_esc_attrs]
cmp eax, 0xffffffff
jne .no_dec_set
mov eax, [con_esc_attrs+4]
cmp eax, 1
je .dec_set_app_cursor_keys
; cmp eax, 7
; je .dec_set_wraparound
; cmp eax, 12
; je .dec_set_cursor_blink
cmp eax, 25
je .show_cursor
je .dec_set_cursor
; cmp eax, 1000
; je .dec_set_mouse
; cmp eax, 1002
; je .set_buttons
; cmp eax, 1006
; je .dec_rst_mouse_sgr
cmp eax, 1049
je .dec_set_altbuff
; cmp eax, 2004
; je .dec_set_brck_paste
.no_dec_set:
; cmp eax, 2
; je .set_keyb_action_mode
; cmp eax, 4
; je .set_insert_mode
ret
 
.show_cursor:
.dec_set_app_cursor_keys:
mov [cursor_esc], 27 + ('O' shl 8)
ret
 
.dec_rst_app_cursor_keys:
mov [cursor_esc], 27 + ('[' shl 8)
ret
 
.dec_set_cursor:
mov [con.cursor_height], (15*font_height+50)/100 ; default height
ret
 
.dec_rst_cursor:
mov [con.cursor_height], 0
ret
 
.dec_set_altbuff:
; Switch buffer
push [con.altbuffer]
pop [con.data]
; Set new buffer size
push [con.wnd_width]
pop [con.scr_width]
push [con.wnd_height]
pop [con.scr_height]
; Save cursor
push [con.cur_x]
pop [con.main_cur_x]
push [con.cur_y]
pop [con.main_cur_y]
; Save window position
push [con.wnd_xpos]
pop [con.main_wnd_xpos]
push [con.wnd_ypos]
pop [con.main_wnd_ypos]
; Clear screen
mov edi, [con.altbuffer]
mov eax, [con.wnd_width]
mul [con.wnd_height]
mov ecx, eax
mov ah, byte[con_flags]
mov al, ' '
rep stosw
; Reset cursor position
mov [con.cur_x], 0
mov [con.cur_y], 0
; Reset window position
mov [con.wnd_xpos], 0
mov [con.wnd_ypos], 0
; Get new data ptr so we can sart writing to new buffer
call con.get_data_ptr
; Finally, tell the GUI the window has been resized
; (Redraw scrollbar and image)
mov [con.thread_op], OP_RESIZE
jmp con.wake
 
.dec_rst_altbuff:
; Switch buffer
push [con.mainbuffer]
pop [con.data]
; Set new buffer size
push [con.main_scr_width]
pop [con.scr_width]
push [con.main_scr_height]
pop [con.scr_height]
; Restore cursor
push [con.main_cur_x]
pop [con.cur_x]
push [con.main_cur_y]
pop [con.cur_y]
; Restore window position
push [con.main_wnd_xpos]
pop [con.wnd_xpos]
push [con.main_wnd_ypos]
pop [con.wnd_ypos]
; Get new data ptr so we can sart writing to new buffer
call con.get_data_ptr
; Finally, tell the GUI the window has been resized
; (Redraw scrollbar and image)
mov [con.thread_op], OP_RESIZE
jmp con.wake
 
.erase_chars:
push edi ecx
mov ecx, [con_esc_attrs]
test ecx, ecx
jnz @f
inc ecx
@@:
mov ah, byte[con_flags]
mov al, ' '
rep stosw
pop ecx edi
; Unclear where cursor should point to now..
ret
 
.delete_chars:
push edi ecx
mov ecx, [con_esc_attrs]
test ecx, ecx
jnz @f
inc ecx
@@:
sub edi, 2
mov ah, byte[con_flags]
mov al, ' '
std
rep stosw
cld
pop ecx edi
ret
 
.erase_in_line:
mov eax, [con_esc_attrs]
test eax, eax
jz .erase_till_end_of_line ; <esc>[0K (or <esc>[K)
jz .erase_after ; <esc>[0K (or <esc>[K)
dec eax
jz .erase_till_start_of_line ; <esc>[1K
jz .erase_before ; <esc>[1K
dec eax
je .erase_current_line ; <esc>[2K
ret ; unknown sequence
 
.erase_till_end_of_line:
.erase_after:
push edi ecx
mov edi, [con.cur_y]
imul edi, [con.scr_width]
add edi, [con.cur_x]
shl edi, 1
add edi, [con.data]
mov ecx, [con.scr_width]
sub ecx, [con.cur_x]
mov ah, byte[con_flags]
935,7 → 1365,7
pop ecx edi
ret
 
.erase_till_start_of_line:
.erase_before:
push edi ecx
mov edi, [con.cur_y]
imul edi, [con.scr_width]
961,17 → 1391,17
pop ecx edi
ret
 
.clear:
.erase_in_display:
mov eax, [con_esc_attrs]
test eax, eax
jz .clear_till_end_of_screen ; <esc>[0J (or <esc>[J)
jz .erase_below ; <esc>[0J (or <esc>[J)
dec eax
jz .clear_till_start_of_screen ; <esc>[1J
jz .erase_above ; <esc>[1J
dec eax
je .cls ; <esc>[2J
je .erase_all ; <esc>[2J
ret ; unknown sequence
 
.clear_till_end_of_screen:
.erase_below:
push edi ecx
mov ecx, [con.scr_width]
imul ecx, [con.scr_height]
992,7 → 1422,7
pop ecx edi
ret
 
.clear_till_start_of_screen:
.erase_above:
push edi ecx
mov ecx, [con.cur_y]
imul ecx, [con.scr_width]
1004,7 → 1434,7
pop ecx edi
ret
 
.cls: ; clear screen completely
.erase_all: ; clear screen completely
push ecx
and [con.cur_x], 0
and [con.cur_y], 0
1017,68 → 1447,92
pop edi ecx
.nosetcursor:
ret
.setcursor:
cmp [con_esc_attr_n], 2
je @f
xor eax, eax
mov [con.cur_x], eax
.line_position_abs:
mov eax, [con_esc_attrs]
dec eax
jns @f
inc eax
@@:
cmp eax, [con.scr_height]
jae .nolinepos
mov [con.cur_y], eax
jmp .j_get_data
jmp con.get_data_ptr
.nolinepos:
ret
.cursor_position:
; We always have at least one con_esc_attr, defaulting to 0
; Coordinates however are 1-based
; First comes Y (row) and then X (column)
mov eax, [con_esc_attrs]
dec eax
jns @f
inc eax
@@:
mov eax, [con_esc_attrs]
cmp eax, [con.scr_height]
jae .no_y
mov [con.cur_y], eax
.no_y:
cmp [con_esc_attr_n], 2
jb .no_x
mov eax, [con_esc_attrs+4]
dec eax
jns @f
inc eax
@@:
cmp eax, [con.scr_width]
jae @f
jae .no_x
mov [con.cur_x], eax
@@:
mov eax, [con_esc_attrs+4]
cmp eax, [con.scr_height+4]
jae @f
mov [con.cur_y], eax
.no_x:
.j_get_data:
jmp con.get_data_ptr
.cursor_up:
cmp [con_esc_attr_n], 1
jnz .nosetcursor
mov eax, [con.cur_y]
sub eax, [con_esc_attrs]
jnc @f
xor eax, eax
mov eax, [con_esc_attrs]
test eax, eax
jnz @f
inc eax ; default = 1
@@:
mov [con.cur_y], eax
sub [con.cur_y], eax
jns .j_get_data
mov [con.cur_y], 0
jmp .j_get_data
.cursor_down:
cmp [con_esc_attr_n], 1
jnz .nosetcursor
mov eax, [con.cur_y]
add eax, [con_esc_attrs]
mov eax, [con_esc_attrs]
test eax, eax
jnz @f
inc eax ; default = 1
@@:
add eax, [con.cur_y]
cmp eax, [con.scr_height]
jb @f
ja @f
mov [con.cur_y], eax
jmp .j_get_data
@@:
mov eax, [con.scr_height]
dec eax
@@:
mov [con.cur_y], eax
jmp .j_get_data
.cursor_right:
cmp [con_esc_attr_n], 1
jnz .nosetcursor
mov eax, [con.cur_x]
add eax, [con_esc_attrs]
mov eax, [con_esc_attrs]
test eax, eax
jnz @f
inc eax ; default = 1
@@:
add eax, [con.cur_x]
cmp eax, [con.scr_width]
jb @f
ja @f
mov [con.cur_x], eax
jmp .j_get_data
@@:
mov eax, [con.scr_width]
dec eax
@@:
mov [con.cur_x], eax
jmp .j_get_data
.cursor_left:
cmp [con_esc_attr_n], 1
jnz .nosetcursor
mov eax, [con.cur_x]
sub eax, [con_esc_attrs]
jnc @f
xor eax, eax
test eax, eax
jnz @f
inc eax ; default = 1
@@:
mov [con.cur_x], eax
sub [con.cur_x], eax
jns .j_get_data
mov [con.cur_x], 0
jmp .j_get_data
.set_attr:
push eax ecx edx
1093,110 → 1547,128
jz .attr_bgr_bold
cmp al, 7
jz .attr_reversed
; cmp al, 8
; jz .attr_invisible
cmp al, 27
jz .attr_normal ; FIXME: not inverse
; cmp al, 28
; jz .attr_visible
 
; Forground colors
xor edx, edx
cmp al, 30
cmp al, 30 ; Black
jz .attr_color
mov dl, 4
cmp al, 31
cmp al, 31 ; Red
jz .attr_color
mov dl, 2
cmp al, 32
cmp al, 32 ; Green
jz .attr_color
mov dl, 6
cmp al, 33
cmp al, 33 ; Yellow
jz .attr_color
mov dl, 1
cmp al, 34
cmp al, 34 ; Blue
jz .attr_color
mov dl, 5
cmp al, 35
cmp al, 35 ; Purple
jz .attr_color
mov dl, 3
cmp al, 36
cmp al, 36 ; Cyan
jz .attr_color
mov dl, 7
cmp al, 37
cmp al, 37 ; White
jz .attr_color
mov dl, 7
cmp al, 39 ; Default - White
jz .attr_color
 
; Background colors
xor edx, edx
cmp al, 40
cmp al, 40 ; Black
jz .attr_bgr_color
mov dl, 0x40
cmp al, 41
cmp al, 41 ; Red
jz .attr_bgr_color
mov dl, 0x20
cmp al, 42
cmp al, 42 ; Green
jz .attr_bgr_color
mov dl, 0x60
cmp al, 43
cmp al, 43 ; Yellow
jz .attr_bgr_color
mov dl, 0x10
cmp al, 44
cmp al, 44 ; Blue
jz .attr_bgr_color
mov dl, 0x50
cmp al, 45
cmp al, 45 ; Magenta
jz .attr_bgr_color
mov dl, 0x30
cmp al, 46
cmp al, 46 ; Cyan
jz .attr_bgr_color
mov dl, 0x70
cmp al, 47
cmp al, 47 ; White
jz .attr_bgr_color
mov dl, 0
cmp al, 49 ; Default - Black
jz .attr_bgr_color
 
; 16-color support, bright colors follow
; Foreground colors
mov dl, 0x08
cmp al, 90
cmp al, 90 ; Black
jz .attr_color
mov dl, 4 + 8
cmp al, 91
cmp al, 91 ; Red
jz .attr_color
mov dl, 2 + 8
cmp al, 92
cmp al, 92 ; Green
jz .attr_color
mov dl, 6 + 8
cmp al, 93
cmp al, 93 ; Yellow
jz .attr_color
mov dl, 1 + 8
cmp al, 94
cmp al, 94 ; Blue
jz .attr_color
mov dl, 5 + 8
cmp al, 95
cmp al, 95 ; Magenta
jz .attr_color
mov dl, 3 + 8
cmp al, 96
cmp al, 96 ; Cyan
jz .attr_color
mov dl, 7 + 8
cmp al, 97
cmp al, 97 ; White
jz .attr_color
 
; Background colors
mov dl, 0x80
cmp al, 100
cmp al, 100 ; Black
jz .attr_bgr_color
mov dl, 0x80 + 0x40
cmp al, 101
cmp al, 101 ; Red
jz .attr_bgr_color
mov dl, 0x80 + 0x20
cmp al, 102
cmp al, 102 ; Green
jz .attr_bgr_color
mov dl, 0x80 + 0x60
cmp al, 103
cmp al, 103 ; Yellow
jz .attr_bgr_color
mov dl, 0x80 + 0x10
cmp al, 104
cmp al, 104 ; Blue
jz .attr_bgr_color
mov dl, 0x80 + 0x50
cmp al, 105
cmp al, 105 ; Magenta
jz .attr_bgr_color
mov dl, 0x80 + 0x30
cmp al, 106
cmp al, 106 ; Cyan
jz .attr_bgr_color
mov dl, 0x80 + 0x70
cmp al, 107
cmp al, 107 ; White
jnz .attr_continue
 
.attr_bgr_color:
mov eax, [con_flags]
and al, 0x0F
or al, byte [con_flags_attr]
or al, dl
mov [con_flags], eax
jmp .attr_continue
1203,20 → 1675,22
.attr_color:
mov eax, [con_flags]
and al, 0xF0
or al, byte [con_flags_attr]
or al, dl
mov [con_flags], eax
jmp .attr_continue
.attr_normal:
mov byte [con_flags], 7
mov byte [con_flags_attr], 0
mov byte [con_flags], 0x07
jmp .attr_continue
.attr_reversed:
mov byte [con_flags], 0x70
jmp .attr_continue
.attr_bold:
or byte [con_flags], 8
or byte [con_flags_attr], 0x08
jmp .attr_continue
.attr_bgr_bold:
or byte [con_flags], 0x80
or byte [con_flags_attr], 0x80
.attr_continue:
inc ecx
cmp ecx, [con_esc_attr_n]
1381,7 → 1855,7
 
cmp byte [esp+4], 0
jz .noexit
mov [con.thread_op], 1
mov [con.thread_op], OP_EXIT
call con.wake
ret 4
1414,7 → 1888,7
con_set_title:
mov eax, [esp+4]
mov [con.title], eax
mov [con.thread_op], 2
mov [con.thread_op], OP_SET_TITLE
call con.wake
ret 4
 
1432,7 → 1906,7
con.force_entered_char:
cmp [con.entered_char], -1
jnz .ret
mov [con.thread_op], 4
mov [con.thread_op], OP_GETCH
call con.wake
test byte [con_flags+1], 2
jnz .ret
1479,6 → 1953,194
xchg ax, [con.entered_char]
ret
 
; int __stdcall con_get_input(int *bufptr, int buflen);
con_get_input:
call con_init_check
; Wait for input available
call con.force_entered_char
test byte [con_flags+1], 2
jnz .none
 
push ebx
mov ebx, [esp+12]
.check_more:
; Avoid buffer overflow
cmp dword[esp+8], 16
jl .no_more
; Check element available
cmp [con.entered_char], 0xFFFF
je .no_more
; Get an element from the input queue
mov eax, 0xFFFF
xchg ax, [con.entered_char]
; Function keys F1-F4
cmp ah, 0x3B
jb @f
cmp ah, 0x3E
jbe .f1_4
@@:
; Function keys F5-F8
cmp ah, 0x3F
jb @f
je .f5
cmp ah, 0x42
jbe .f6_8
@@:
; Function keys F9-F12
cmp ah, 0x43
je .f9
cmp ah, 0x44
je .f10
cmp ah, 0x57
je .f11
cmp ah, 0x58
je .f12
; Cursor keys
cmp ah, 0x47
je .home
cmp ah, 0x48
je .up
cmp ah, 0x49
je .pgup
; cmp ah, 0x4a
; je .minus
cmp ah, 0x4b
je .left
cmp ah, 0x4c
je .begin
cmp ah, 0x4d
je .right
; cmp ah, 0x4e
; je .plus
cmp ah, 0x4f
je .end
cmp ah, 0x50
je .down
cmp ah, 0x51
je .pgdown
cmp ah, 0x52
je .insert
cmp ah, 0x53
je .delete
; regular ASCII
mov byte[ebx], al
mov eax, 1
.got_input:
and eax, 0xff
sub [esp+8], eax
add ebx, eax
jmp .check_more
.no_more:
mov eax, ebx
sub eax, [esp+12]
pop ebx
ret 8
 
.none:
xor eax, eax
ret 8
 
.f1_4:
; F1 = SSR P, F2 = SS3 Q ..
; SS3 = 0x8f (8bit) or 0x1b + 'O' (7-bit)
mov word[ebx], 27 + ('O' shl 8)
add ah, 'P' - 59
mov byte[ebx+2], ah
mov al, 3
jmp .got_input
.f5:
; CSI = 0x9b (8bit) or 0x1b + '[' (7-bit)
mov byte[ebx], 27
mov dword[ebx+1], '[15~'
mov al, 5
jmp .got_input
.f6_8:
mov byte[ebx], 27
xor al, al
shl eax, 8
add eax, '[17~' - (0x40 shl 16)
mov dword[ebx+1], eax
mov al, 5
jmp .got_input
.f9:
mov byte[ebx], 27
mov dword[ebx+1], '[20~'
mov al, 5
jmp .got_input
.f10:
mov byte[ebx], 27
mov dword[ebx+1], '[21~'
mov al, 5
jmp .got_input
.f11:
mov byte[ebx], 27
mov dword[ebx+1], '[23~'
mov al, 5
jmp .got_input
.f12:
mov byte[ebx], 27
mov dword[ebx+1], '[24~'
mov al, 5
jmp .got_input
.up:
mov eax, 'A' shl 16
add eax, [cursor_esc]
mov dword[ebx], eax
mov al, 3
jmp .got_input
.down:
mov eax, 'B' shl 16
add eax, [cursor_esc]
mov dword[ebx], eax
mov al, 3
jmp .got_input
.right:
mov eax, 'C' shl 16
add eax, [cursor_esc]
mov dword[ebx], eax
mov al, 3
jmp .got_input
.left:
mov eax, 'D' shl 16
add eax, [cursor_esc]
mov dword[ebx], eax
mov al, 3
jmp .got_input
.home:
mov eax, 'H' shl 16
add eax, [cursor_esc]
mov dword[ebx], eax
mov al, 3
jmp .got_input
.end:
mov eax, 'F' shl 16
add eax, [cursor_esc]
mov dword[ebx], eax
mov al, 3
jmp .got_input
.insert:
mov dword[ebx], 27 + ('[2~' shl 8)
mov al, 4
jmp .got_input
.delete:
mov dword[ebx], 27 + ('[3~' shl 8)
mov al, 4
jmp .got_input
.pgup:
mov dword[ebx], 27 + ('[5~' shl 8)
mov al, 4
jmp .got_input
.pgdown:
mov dword[ebx], 27 + ('[6~' shl 8)
mov al, 4
jmp .got_input
.begin:
mov dword[ebx], 27 + ('[E' shl 8)
mov al, 3
jmp .got_input
 
 
 
; char* __stdcall con_gets(char* str, int n);
con_gets:
pop eax
1808,7 → 2470,7
je cmd_init_no
push edi
call con.write_special_char.cls
call con.write_special_char.erase_all
pop edi
call con.update_screen
1872,7 → 2534,7
mov [con.wnd_ypos], eax
.done:
pop eax
mov [con.thread_op], 3
mov [con.thread_op], OP_REDRAW
 
con.wake:
pushad
2126,7 → 2788,38
jz con.redraw_image
dec eax
jz con.getch
dec eax
jz con.resize
jmp con.msg_loop
con.resize:
push 48
pop eax
push 4
pop ebx
int 0x40
 
mov edx, [con.def_wnd_x-2]
mov edx, [con.wnd_width]
imul edx, font_width
add edx, 5+5-1
 
mov esi, [con.def_wnd_y-2]
mov esi, [con.wnd_height]
imul esi, font_height
lea esi, [eax + esi + 5-1]
; place for scrollbar
mov eax, [con.wnd_height]
cmp eax, [con.scr_height]
jae @f
add edx, con.vscroll_width
@@:
push 67
pop eax
mov ebx, -1
mov ecx, ebx
int 0x40
call con.draw_window
jmp con.msg_loop
con.set_title:
push 71
pop eax
2406,6 → 3099,7
xor ebx, ebx
inc ebx
int 0x40
 
mov al, 48
mov bl, 4
int 0x40
2427,18 → 3121,14
@@:
xor eax, eax
int 0x40
;Leency{
 
mov eax,9
mov ebx,process_info_buffer
mov ecx,-1
int 0x40
mov eax,[ebx+70]
mov [window_status],eax
test [window_status],100b ; window is rolled up
test [process_info_buffer.wnd_state], 110b ; window is rolled up or minimized to panel
jnz .exit
test [window_status],10b ; window is minimized to panel
jnz .exit
;}Leency - I'm in diamond code...
 
call con.draw_image
 
.exit:
2606,6 → 3296,9
db '1', '2', '3'
db '0', '.'
 
 
cursor_esc dd 27 + ('[' shl 8)
 
; ‚ ⥪ã饩 ॠ«¨§ æ¨¨ §­ ç¥­¨ï ¯® 㬮«ç ­¨î â ª®¢ë.
; ‚ ¡ã¤ã饬 ®­¨, ¢®§¬®¦­®, ¡ã¤ãâ áç¨â뢠âìáï ª ª ¯ à ¬¥âàë ¨§ ini-ä ©«  console.ini.
con.def_wnd_width dd 80
2617,39 → 3310,12
 
con.init_cmd db 0
con.title_init_console db "Console",0
 
struc process_info
{
cpu_usage dd ? ; +0
window_stack_position dw ? ; +4
window_stack_value dw ? ; +6
dw ? ; +8
process_name rb 12 ; +10
memory_start dd ? ; +22
used_memory dd ? ; +26
PID dd ? ; +30
box.x dd ? ; +34
box.y dd ? ; +38
box.width dd ? ; +42
box.height dd ? ; +46
slot_state dw ? ; +50
dw ? ; +52
client_box.x dd ? ; +54
client_box.y dd ? ; +58
client_box.width dd ? ; +62
client_box.height dd ? ; +66
wnd_state db ? ; +70
rb (1024-71)
}
process_info_buffer process_info
window_status rd 1
 
con.vscroll_pt dd -1
 
align 16
EXPORTS:
dd szStart, START
dd szVersion, 0x00020008
dd szVersion, 0x00020009
dd szcon_init, con_init
dd szcon_write_asciiz, con_write_asciiz
dd szcon_write_string, con_write_length
2669,9 → 3335,11
dd szcon_get_cursor_pos, con_get_cursor_pos
dd szcon_set_cursor_pos, con_set_cursor_pos
dd szcon_set_title, con_set_title
dd szcon_get_input, con_get_input
dd 0
 
con_flags dd 7
con_flags dd 0x07 ; black on white
con_flags_attr dd 0 ; Modifiers (for example, high intensity colors)
con.cursor_height dd (15*font_height+50)/100
con.input_start dd con.input_buffer
con.input_end dd con.input_buffer
2680,6 → 3348,8
con_esc_attrs dd 0,0,0,0
con_esc db 0
con_sci db 0
con_osc_str rb 256
con_osc_strlen dd 0
 
con.entered_char dw -1
con.bGetchRequested db 0
2707,6 → 3377,7
szcon_get_cursor_pos db 'con_get_cursor_pos',0
szcon_set_cursor_pos db 'con_set_cursor_pos',0
szcon_set_title db 'con_set_title',0
szcon_get_input db 'con_get_input',0
 
con.thread_err db 'Cannot create console thread!',13,10,0
con.nomem_err db 'Not enough memory!',13,10,0
2713,39 → 3384,51
con.aFinished db ' [Finished]',0
con.aNull db '(null)',0
con.beep db 0x90, 0x3C, 0x00
con.beep2 db 0x85, 0x25, 0x85, 0x40, 0x00
con.bell db 0x85, 0x25, 0x85, 0x40, 0x00
con.ipc_buf dd 0,8,0,0
db 0
 
section '.data' data readable writable align 16
 
process_info_buffer process_info
 
con.finished_title rb 256
 
con.cur_x rd 1
con.cur_y rd 1
con.wnd_xpos rd 1
con.wnd_ypos rd 1
con.cur_x dd ? ; Active cursor column (0 based)
con.cur_y dd ? ; Active cursor row (0 based)
con.main_cur_x dd ? ; Saved cursor position for main buffer
con.main_cur_y dd ? ; Saved cursor position for main buffer
con.wnd_xpos dd ? ; Active window position in active buffer
con.wnd_ypos dd ? ; Active window position in active buffer
con.main_wnd_xpos dd ? ; Saved window position for main buffer
con.main_wnd_ypos dd ? ; Saved window position for main buffer
con.scroll_top dd ? ; VT100 scroll region
con.scroll_bot dd ? ; VT100 scroll region
 
con.wnd_width rd 1
con.wnd_height rd 1
con.scr_width rd 1
con.scr_height rd 1
con.title rd 1
con.data rd 1
con.image rd 1
con.console_tid rd 1
con.data_width rw 1
con.data_height rw 1
con.vscrollbar_size rd 1
con.vscrollbar_pos rd 1
con.up_first_time rd 1
con.down_first_time rd 1
con.scroll_up_first_time rd 1
con.scroll_down_first_time rd 1
con.bUpPressed_saved rb 1
con.bDownPressed_saved rb 1
con.bScrollingUp_saved rb 1
con.bScrollingDown_saved rb 1
con.wnd_width dd ? ; window width (= alt buffer width)
con.wnd_height dd ? ; window height (= alt buffer height)
con.main_scr_width dd ? ; main buffer width
con.main_scr_height dd ? ; main buffer height
con.scr_width dd ? ; active buffer width
con.scr_height dd ? ; active buffer height
con.title dd ?
con.data dd ? ; active buffer ptr
con.mainbuffer dd ?
con.altbuffer dd ?
con.image dd ?
con.console_tid dd ?
con.data_width dw ? ; width in pixels
con.data_height dw ? ; height in pixels
con.vscrollbar_size dd ?
con.vscrollbar_pos dd ?
con.up_first_time dd ?
con.down_first_time dd ?
con.scroll_up_first_time dd ?
con.scroll_down_first_time dd ?
con.bUpPressed_saved db ?
con.bDownPressed_saved db ?
con.bScrollingUp_saved db ?
con.bScrollingDown_saved db ?
 
con.input_buffer rw 128
con.input_buffer_end = $
2752,12 → 3435,11
 
con.kbd_layout rb 128
 
; 1 = exit, 2 = set title, 3 = redraw, 4 = getch
con.thread_op rb 1
con.bUpPressed rb 1
con.bDownPressed rb 1
con.bScrollingUp rb 1
con.bScrollingDown rb 1
con.thread_op db ?
con.bUpPressed db ?
con.bDownPressed db ?
con.bScrollingUp db ?
con.bScrollingDown db ?
 
con.stack rb 1024
con.stack_top = $
/programs/develop/libraries/console_coff/console_en.txt
79,13 → 79,33
46 = cyan background
47 = white background
The following sequences appeared in version 5 of library:
Esc[2J - clear screen, move cursor to upper left corner
Esc[<number1>;<number2>H = Esc[<number1>;<number2>f -
move cursor to <number1>,<number2>
Esc[<number>A - move cursor to <number> lines up
Esc[<number>B - move cursor to <number> lines down
Esc[<number>C - move cursor to <number> positions right
Esc[<number>D - move cursor to <number> positions left
Esc[<number1>;<number2>H = Esc[<number1>;<number2>f -
move cursor to <number1>,<number2>
Esc[2J - clear screen, move cursor to upper left corner
The following sequences appeared in version 9 of library:
Esc[J or Esc[0J - Erase everything below cursor
Esc[1J - Erase everything above cursor
Esc[K - Erase in line
Esc[<number>L - Insert <number> lines at the cursor position
Esc[<number>M - Delete <number> lines at the cursor position
Esc[<number>P - Delete <number chars at the cursor position
Esc[<number>X - Erase <number chars at the cursor position
Esc[<number>d - Set cursor to absolute line position
Esc[<number1>;<number2>f - Cursor position
Esc[<mode>h - Set mode (see below)
Esc[<mode>l - Reset mode (see below)
The following modes are currently supported:
?1 - Application cursor keys
?25 - Show/Hide cursor
?1049 - Alternative screen buffer. The alternative buffer has no scrollback.
Esc[<number1>;<number2>r - Set scroll region from row <number1> to row <number2>
(Use in combination with insert/delete lines)
Esc]0<string>ST/BEL - Set window caption. The string is terminated with ASCII char 0x07 or 0x9C.
Esc]2<string>ST/BEL - Implemented identical as Esc]0.
*/
/* signal "console closed"; appeared in version 6;
ignored by con_set_flags */
160,3 → 180,8
parameters beyond the relevant range (from 0 to 1 scr_width-
for x, from 0 to 1 for scr_height-y, scr_width scr_height and were asked if
call con_init), then the corresponding coordinate of the cursor does not change.
 
int __stdcall con_get_input(char* buf, int buflen);
Read as many input events as are available and fit in the receive buffer.
Input event can be regular ASCII code from keyboard, but also escape codes for special keys.
The support for mouse events via escape codes is not yet implemented.
/programs/develop/libraries/console_coff/console_ru.txt
78,13 → 78,34
46 = áèðþçîâûé ôîí
47 = áåëûé ôîí
Ñëåäóþùèå ïîñëåäîâàòåëüíîñòè ïîÿâèëèñü â âåðñèè 5 áèáëèîòåêè:
Esc[2J - î÷èñòèòü ýêðàí, ïåðåìåñòèòü êóðñîð â ëåâûé âåðõíèé óãîë
Esc[<number1>;<number2>H = Esc[<number1>;<number2>f -
óñòàíîâèòü êóðñîð â ïîçèöèþ ñ êîîðäèíàòàìè <number1>,<number2>
Esc[<number>A - ïåðåìåñòèòü êóðñîð íà <number> ñòðîê ââåðõ
Esc[<number>B - ïåðåìåñòèòü êóðñîð íà <number> ñòðîê âíèç
Esc[<number>C - ïåðåìåñòèòü êóðñîð íà <number> ïîçèöèé âïðàâî
Esc[<number>D - ïåðåìåñòèòü êóðñîð íà <number> ïîçèöèé âëåâî
Esc[<number1>;<number2>H = Esc[<number1>;<number2>f -
óñòàíîâèòü êóðñîð â ïîçèöèþ ñ êîîðäèíàòàìè <number1>,<number2>
Esc[2J - î÷èñòèòü ýêðàí, ïåðåìåñòèòü êóðñîð â ëåâûé âåðõíèé óãîë
Ñëåäóþùèå ïîñëåäîâàòåëüíîñòè ïîÿâèëèñü â âåðñèè 9 áèáëèîòåêè:
Esc[J or Esc[0J - Erase everything below cursor
Esc[1J - Erase everything above cursor
Esc[K - Erase in line
Esc[<number>L - Insert <number> lines at the cursor position
Esc[<number>M - Delete <number> lines at the cursor position
Esc[<number>P - Delete <number chars at the cursor position
Esc[<number>X - Erase <number chars at the cursor position
Esc[<number>d - Set cursor to absolute line position
Esc[<number1>;<number2>f - Cursor position
Esc[<mode>h - Set mode (see below)
Esc[<mode>l - Reset mode (see below)
The following modes are currently supported:
?1 - Application cursor keys
?25 - Show/Hide cursor
?1049 - Alternative screen buffer. The alternative buffer has no scrollback.
Esc[<number1>;<number2>r - Set scroll region from row <number1> to row <number2>
(Use in combination with insert/delete lines)
Esc]0<string>ST/BEL - Set window caption. The string is terminated with ASCII char 0x07 or 0x9C.
Esc]2<string>ST/BEL - Implemented identical as Esc]0.
*/
/* ñèãíàë î çàêðûòèè îêíà êîíñîëè; ïîÿâèëñÿ â âåðñèè 6 áèáëèîòåêè;
ôëàã èãíîðèðóåòñÿ ôóíêöèåé con_set_flags */
163,3 → 184,8
ïàðàìåòðîâ âûõîäèò çà ïðåäåëû ñîîòâåòñòâóþùåãî äèàïàçîíà (îò 0 äî scr_width-1
äëÿ x, îò 0 äî scr_height-1 äëÿ y, scr_width è scr_height áûëè çàäàíû ïðè
âûçîâå con_init), òî ñîîòâåòñòâóþùàÿ êîîðäèíàòà êóðñîðà íå ìåíÿåòñÿ.
 
int __stdcall con_get_input(char* buf, int buflen);
Read as many input events as are available and fit in the receive buffer.
Input event can be regular ASCII code from keyboard, but also escape codes for special keys.
The support for mouse events via escape codes is not yet implemented.