/kernel/trunk/blkdev/disk.inc |
---|
1241,7 → 1241,6 |
add ebp, 8 ; ebp points to part of PARTITION structure |
xor eax, eax ; first sector of the partition |
call fs_read32_sys |
;push eax |
; 2. Run tests for all supported filesystems. If at least one test succeeded, |
; go to 4. |
; For tests: |
1249,6 → 1248,9 |
; [esp] = error code after bootsector read: 0 = ok, otherwise = failed, |
; ebx points to the buffer for bootsector, |
; ebx+[esi+DISK.MediaInfo.SectorSize] points to sector-sized buffer that can be used for anything. |
; lock fs list |
mov ecx, [fs_list] |
@@: |
cmp ecx, fs_list |
1260,7 → 1262,8 |
test eax, eax |
jnz .success |
pop eax |
mov eax, ecx |
pop ecx |
mov ecx, [ecx] |
jmp @b |
@@: |
1301,6 → 1304,8 |
sub ebp, 8 ; restore ebp |
; 4. Return with eax = pointer to PARTITION or NULL. |
pop ecx |
; unlock fs list |
ret |
iglobal |
/kernel/trunk/const.inc |
---|
223,6 → 223,7 |
OS_BASE = 0x80000000 |
window_data = OS_BASE + 0x0001000 |
background_window = window_data + sizeof.WDATA |
;TASK_TABLE = OS_BASE + 0x0003000 |
;CURRENT_TASK = OS_BASE + 0x0003000 |
231,7 → 232,7 |
;TASK_DATA = OS_BASE + 0x0003020 |
;TASK_EVENT = OS_BASE + 0x0003020 |
CDDataBuf = OS_BASE + 0x0005000 |
;CDDataBuf = OS_BASE + 0x0005000 |
;unused 0x6000 - 0x8fff |
494,7 → 495,7 |
exc_handler dd ? ;+32 |
except_mask dd ? ;+36 |
pl0_stack dd ? ;+40 |
cursor dd ? ;+44 ; WDATA |
dd ? ;+44 |
fd_ev dd ? ;+48 |
bk_ev dd ? ;+52 |
fd_obj dd ? ;+56 |
502,7 → 503,7 |
saved_esp dd ? ;+64 |
io_map rd 2 ;+68 |
dbg_state dd ? ;+76 |
cur_dir dd ? ;+80 |
cur_dir dd ? ;+80 ; directory this thread |
wait_timeout dd ? ;+84 |
saved_esp0 dd ? ;+88 |
wait_begin dd ? ;+92 +++ |
511,20 → 512,20 |
tls_base dd ? ;+104 |
event_mask dd ? ;+108 stores event types allowed for task |
tid dd ? ;+112 thread id |
draw_bgr_x dd ? ;+116 ; WDATA |
draw_bgr_y dd ? ;+120 ; WDATA |
dd ? ;+116 |
dd ? ;+120 |
state db ? ;+124 thread state |
wnd_number db ? ;+125 |
dw ? ;+126 |
dd ? ;+128 |
window dd ? ;+128 ptr WDATA |
dd ? ;+132 |
dd ? ;+136 |
counter_sum dd ? ;+140 ; R |
saved_box BOX ;+144 ; WDATA |
rd 4 ;+144 |
ipc_start dd ? ;+160 |
ipc_size dd ? ;+164 |
occurred_events dd ? ;+168 ; mask which accumulates occurred events |
debugger_slot dd ? ;+172 |
debugger_slot dd ? ;+172 ; index in SLOT_BASE array |
terminate_protection dd ? ;+176 |
keyboard_mode db ? ;+180 |
rb 3 |
537,7 → 538,7 |
in_schedule LHEAD ;+236 |
counter_add dd ? ;+244 ; R |
cpu_usage dd ? ;+248 ; R |
temp_cursor dd 0 ;+252 ; temporary place to save cursor |
dd ? ;+252 ; temporary place to save cursor |
ends |
assert sizeof.APPDATA = 256 |
575,7 → 576,9 |
WSTATE_MAXIMIZED = 00000001b |
WSTATE_MINIMIZED = 00000010b |
WSTATE_ROLLEDUP = 00000100b |
WSTATE_USED = 10000000b |
; fl_redraw |
WSTATE_REDRAW = 00000001b |
WSTATE_WNDDRAWN = 00000010b |
603,11 → 606,19 |
caption dd ? |
captionEncoding db ? |
rb 3 |
saved_box BOX |
cursor dd ? |
temp_cursor dd ? |
draw_bgr_x dd ? |
draw_bgr_y dd ? |
draw_data RECT |
thread dd ? ; prt APPDATA |
rb 64 - 16 - 4*2 - 4*2 - 4 - 16 |
ends |
label WDATA.fl_wstyle byte at WDATA.cl_workarea + 3 |
assert sizeof.WDATA = 64 |
assert sizeof.WDATA = 128 |
struct SYS_VARS |
bpp dd ? |
/kernel/trunk/core/sys32.inc |
---|
566,10 → 566,6 |
mov edi, esi |
mov ecx, sizeof.WDATA/4 |
rep stosd |
lea edi, [esi - window_data + draw_data] |
mov ecx, sizeof.WDATA/4 |
rep stosd |
popa |
; debuggee test |
/kernel/trunk/core/taskman.inc |
---|
969,8 → 969,6 |
mov [SLOT_BASE + ebx + APPDATA.fd_obj], edx |
mov [SLOT_BASE + ebx + APPDATA.bk_obj], edx |
mov ecx, [def_cursor] |
mov [SLOT_BASE + ebx + APPDATA.cursor], ecx |
mov eax, [pl0_stack] |
mov [SLOT_BASE + ebx + APPDATA.pl0_stack], eax |
add eax, RING0_STACK_SIZE |
993,22 → 991,29 |
mov eax, [slot] |
mov [SLOT_BASE + ebx + APPDATA.wnd_number], al |
mov ebx, eax |
shl ebx, BSF sizeof.WDATA |
lea ecx, [draw_data + ebx];ecx - pointer to draw data |
;mov ebx, eax |
shl eax, BSF sizeof.WDATA |
add eax, window_data |
mov ecx, eax |
mov [SLOT_BASE + ebx + APPDATA.window], eax |
mov [eax + WDATA.thread], ebx |
add [eax + WDATA.thread], SLOT_BASE |
; set window state to 'normal' (non-minimized/maximized/rolled-up) state |
mov [window_data + ebx + WDATA.fl_wstate], WSTATE_NORMAL |
mov [window_data + ebx + WDATA.fl_redraw], 1 |
mov [eax + WDATA.fl_wstate], WSTATE_NORMAL + WSTATE_USED |
mov [eax + WDATA.fl_redraw], WSTATE_REDRAW |
mov edx, [def_cursor] |
mov [eax + WDATA.cursor], edx |
;set draw data to full screen |
xor eax, eax |
mov [ecx + RECT.left], eax |
mov [ecx + RECT.top], eax |
mov [ecx + WDATA.draw_data.left], eax |
mov [ecx + WDATA.draw_data.top], eax |
mov eax, [screen_workarea.right] |
mov [ecx + RECT.right], eax |
mov [ecx + WDATA.draw_data.right], eax |
mov eax, [screen_workarea.bottom] |
mov [ecx + RECT.bottom], eax |
mov [ecx + WDATA.draw_data.bottom], eax |
mov ebx, [pl0_stack] |
mov esi, [params] |
/kernel/trunk/data32.inc |
---|
350,8 → 350,7 |
fpu_data: |
rb 0xa80 ; bochs avx512 |
fpu_data_size = $ - fpu_data |
draw_data: |
rb sizeof.WDATA*256 |
BPSLine_calc_area rd MAX_SCREEN_HEIGHT |
d_width_calc_area rd MAX_SCREEN_HEIGHT |
mouseunder rd 16*24 |
437,8 → 436,8 |
mididp dd ? |
midisp dd ? |
cdbase dd ? |
cdid dd ? |
;cdbase dd ? |
;cdid dd ? |
hdbase dd ? ; for boot 0x1f0 |
hdid dd ? |
548,3 → 547,6 |
rb 64*1024 |
sys_pgmap: |
rb 1024*1024/8 |
CDDataBuf: rb 0x1000 |
/kernel/trunk/gui/background.inc |
---|
289,11 → 289,12 |
jnz nosb8 |
mov ecx, [current_slot] |
mov ecx, [ecx + APPDATA.window] |
xor eax, eax |
xchg eax, [ecx + APPDATA.draw_bgr_x] |
xchg eax, [ecx + WDATA.draw_bgr_x] |
mov [esp + SYSCALL_STACK.eax], eax ; eax = [left]*65536 + [right] |
xor eax, eax |
xchg eax, [ecx + APPDATA.draw_bgr_y] |
xchg eax, [ecx + WDATA.draw_bgr_y] |
mov [esp + SYSCALL_STACK.ebx], eax ; ebx = [top]*65536 + [bottom] |
ret |
;--------------------------------------- |
328,11 → 329,11 |
mov [background_defined], 1 |
mov [draw_data + sizeof.WDATA + RECT.left], eax |
mov [draw_data + sizeof.WDATA + RECT.top], ebx |
mov [background_window + WDATA.draw_data.left], eax |
mov [background_window + WDATA.draw_data.top], ebx |
mov [draw_data + sizeof.WDATA + RECT.right], ecx |
mov [draw_data + sizeof.WDATA + RECT.bottom], edx |
mov [background_window + WDATA.draw_data.right], ecx |
mov [background_window + WDATA.draw_data.bottom], edx |
inc [REDRAW_BACKGROUND] |
call wakeup_osloop |
353,15 → 354,15 |
align 4 |
force_redraw_background: |
and [draw_data + sizeof.WDATA + RECT.left], 0 |
and [draw_data + sizeof.WDATA + RECT.top], 0 |
and [background_window + WDATA.draw_data.left], 0 |
and [background_window + WDATA.draw_data.top], 0 |
push eax ebx |
mov eax, [_display.width] |
mov ebx, [_display.height] |
dec eax |
dec ebx |
mov [draw_data + sizeof.WDATA + RECT.right], eax |
mov [draw_data + sizeof.WDATA + RECT.bottom], ebx |
mov [background_window + WDATA.draw_data.right], eax |
mov [background_window + WDATA.draw_data.bottom], ebx |
pop ebx eax |
inc [REDRAW_BACKGROUND] |
call wakeup_osloop |
424,7 → 425,7 |
; esi - buffer of 0x00RRGGBB |
mov eax, [img_background] |
cmp eax, static_background_data |
jz .ret_39_3 |
jz .fail_39_3 |
align 4 |
@@: |
movzx eax, cx ; store y in eax |
489,12 → 490,13 |
.end_copy_rect: |
xor eax, eax |
mov [esp + SYSCALL_STACK.eax], eax |
align 4 |
.ret_39_3: |
ret |
;-------------------------------------- |
align 4 |
.fail_39_3: |
mov eax, -1 |
align 4 |
.ret_39_3: |
mov [esp + SYSCALL_STACK.eax], -1 |
ret |
;-------------------------------------- |
align 4 |
/kernel/trunk/gui/mouse.inc |
---|
390,15 → 390,15 |
.set_resizing_cursor: |
; DEBUGF 1, ".set_resizing_cursor eax = %x\n", eax |
; change cursor to resizing cursor |
shl esi, BSF sizeof.APPDATA |
add esi, SLOT_BASE |
shl esi, BSF sizeof.WDATA |
add esi, window_data |
; if resizing cursor we need (eax) isnt set already, set it |
cmp eax, [esi + APPDATA.cursor] |
cmp eax, [esi + WDATA.cursor] |
je @f |
; DEBUGF 1, "changing cursor to resizing\n" |
xchg eax, [esi + APPDATA.cursor] ; set resizing cursor, prev cursor goes to eax |
xchg eax, [esi + WDATA.cursor] ; set resizing cursor, prev cursor goes to eax |
; save previous cursor (will be restored when we'll get out of the resizing area) |
; if we change resizing cursor to resizing cursor then dont update previous cursor |
cmp eax, [def_cursor_hresize] |
410,7 → 410,7 |
cmp eax, [def_cursor_dresize2] |
je @f |
mov [esi + APPDATA.temp_cursor], eax ; save prev cursor |
mov [esi + WDATA.temp_cursor], eax ; save prev cursor |
@@: |
jmp .end1 |
417,16 → 417,16 |
.not_in_resize_area: |
; DEBUGF 1, ".not_in_resize_area\n" |
shl esi, BSF sizeof.APPDATA |
add esi, SLOT_BASE |
mov eax, [esi + APPDATA.temp_cursor] |
shl esi, BSF sizeof.WDATA |
add esi, window_data |
mov eax, [esi + WDATA.temp_cursor] |
test eax, eax |
jz .end1 |
; restore prev cursor |
mov [esi + APPDATA.temp_cursor], 0 |
mov [esi + APPDATA.cursor], eax |
mov [esi + WDATA.temp_cursor], 0 |
mov [esi + WDATA.cursor], eax |
.end1: |
pop ebx eax |
819,15 → 819,15 |
mov eax, [MOUSE_X] |
shl eax, 16 |
mov ax, [MOUSE_Y] |
mov esi, [current_slot_idx] |
shl esi, BSF sizeof.WDATA |
mov bx, word[window_data + esi + WDATA.box.left] |
mov esi, [current_slot] |
mov esi, [esi + APPDATA.window] |
mov bx, word[esi + WDATA.box.left] |
shl ebx, 16 |
mov bx, word[window_data + esi + WDATA.box.top] |
mov bx, word[esi + WDATA.box.top] |
sub eax, ebx |
sub ax, word[window_data + esi + WDATA.clientbox.top] |
sub ax, word[esi + WDATA.clientbox.top] |
rol eax, 16 |
sub ax, word[window_data + esi + WDATA.clientbox.left] |
sub ax, word[esi + WDATA.clientbox.left] |
rol eax, 16 |
mov [esp + SYSCALL_STACK.eax], eax |
ret |
/kernel/trunk/gui/window.inc |
---|
78,12 → 78,12 |
mov eax, ebx |
mov ebx, ecx |
mov ecx, edx |
mov edx, [current_slot_idx] |
shl edx, BSF sizeof.WDATA |
add eax, [window_data + edx + WDATA.box.left] |
add ebx, [window_data + edx + WDATA.box.top] |
add eax, [window_data + edx + WDATA.clientbox.left] |
add ebx, [window_data + edx + WDATA.clientbox.top] |
mov edx, [current_slot] |
mov edx, [edx + APPDATA.window] |
add eax, [edx + WDATA.box.left] |
add ebx, [edx + WDATA.box.top] |
add eax, [edx + WDATA.clientbox.left] |
add ebx, [edx + WDATA.clientbox.top] |
xor edi, edi ; no force |
and ecx, 0xFBFFFFFF ;negate 0x04000000 save to mouseunder area |
jmp __sys_putpixel |
103,13 → 103,13 |
pop esi |
jnz .err |
mov eax, [current_slot_idx] |
shl eax, BSF sizeof.WDATA |
mov ebp, [window_data + eax + WDATA.box.left] |
add ebp, [window_data + eax + WDATA.clientbox.left] |
mov eax, [current_slot] |
mov eax, [eax + APPDATA.window] |
mov ebp, [eax + WDATA.box.left] |
add ebp, [eax + WDATA.clientbox.left] |
shl ebp, 16 |
add ebp, [window_data + eax + WDATA.box.top] |
add bp, word[window_data + eax + WDATA.clientbox.top] |
add ebp, [eax + WDATA.box.top] |
add bp, word[eax + WDATA.clientbox.top] |
test ecx, 0x08000000 ; redirect the output to the user area |
jnz @f |
add ebx, ebp |
147,10 → 147,10 |
shr eax, 16 ; eax - x.coord |
movzx edx, bx ; edx - y.size |
shr ebx, 16 ; ebx - y.coord |
mov esi, [current_slot_idx] |
shl esi, BSF sizeof.WDATA |
add eax, [window_data + esi + WDATA.clientbox.left] |
add ebx, [window_data + esi + WDATA.clientbox.top] |
mov esi, [current_slot] |
mov esi, [esi + APPDATA.window] |
add eax, [esi + WDATA.clientbox.left] |
add ebx, [esi + WDATA.clientbox.top] |
add ecx, eax |
add edx, ebx |
jmp vesa20_drawbar |
161,19 → 161,19 |
align 4 |
; system function 38 |
syscall_drawline: |
mov edi, [current_slot_idx] |
shl edi, BSF sizeof.WDATA |
movzx eax, word[window_data + edi + WDATA.box.left] |
mov edi, [current_slot] |
mov edi, [edi + APPDATA.window] |
movzx eax, word[edi + WDATA.box.left] |
mov ebp, eax |
add ebp, [window_data + edi + WDATA.clientbox.left] |
add ax, word[window_data + edi + WDATA.clientbox.left] |
add ebp, [edi + WDATA.clientbox.left] |
add ax, word[edi + WDATA.clientbox.left] |
add ebp, ebx |
shl eax, 16 |
movzx ebx, word[window_data + edi + WDATA.box.top] |
movzx ebx, word[edi + WDATA.box.top] |
add eax, ebp |
mov ebp, ebx |
add ebp, [window_data + edi + WDATA.clientbox.top] |
add bx, word[window_data + edi + WDATA.clientbox.top] |
add ebp, [edi + WDATA.clientbox.top] |
add bx, word[edi + WDATA.clientbox.top] |
add ebp, ecx |
shl ebx, 16 |
xor edi, edi |
483,9 → 483,9 |
; system function 71 |
syscall_window_settings: |
mov edi, [current_slot_idx] |
shl edi, BSF sizeof.WDATA |
or [edi + window_data + WDATA.fl_wstyle], WSTYLE_HASCAPTION |
mov edi, [current_slot] |
mov edi, [edi + APPDATA.window] |
or [edi + WDATA.fl_wstyle], WSTYLE_HASCAPTION |
cmp ebx, 2 |
jz @f |
xor edx, edx |
494,14 → 494,14 |
jc @f |
xor edx, edx |
@@: |
mov [window_data + edi + WDATA.caption], ecx |
mov [window_data + edi + WDATA.captionEncoding], dl |
mov [edi + WDATA.caption], ecx |
mov [edi + WDATA.captionEncoding], dl |
jmp window._.draw_window_caption |
;------------------------------------------------------------------------------ |
align 4 |
set_window_defaults: |
mov byte [window_data + sizeof.WDATA + WDATA.cl_titlebar + 3], 1 ; desktop is not movable |
mov byte [background_window + WDATA.cl_titlebar + 3], 1 ; desktop is not movable |
push eax ecx |
xor eax, eax |
mov ecx, WIN_STACK |
555,10 → 555,10 |
align 4 |
.next_window: |
movzx edi, word[WIN_POS + esi * 2] |
shl edi, BSF sizeof.WDATA ;size of TASKDATA and WDATA = 32 bytes |
shl edi, BSF sizeof.WDATA |
cmp byte [SLOT_BASE + edi*(sizeof.APPDATA/sizeof.WDATA) + APPDATA.state], TSTATE_FREE |
je .skip_window |
test byte [window_data + edi + WDATA.fl_wstate], WSTATE_USED |
jz .skip_window |
add edi, window_data |
test [edi + WDATA.fl_wstate], WSTATE_MINIMIZED |
1086,17 → 1086,17 |
movzx edi, word[WIN_POS + eax * 2] |
shl edi, BSF sizeof.WDATA |
; it is a unused slot? |
cmp byte [SLOT_BASE + edi*(sizeof.APPDATA/sizeof.WDATA) + APPDATA.state], TSTATE_FREE |
je @f |
test byte [window_data + edi + WDATA.fl_wstate], WSTATE_USED |
jz @f |
; it is a hidden thread? |
lea esi, [SLOT_BASE + edi*(sizeof.APPDATA/sizeof.WDATA) + APPDATA.app_name] |
cmp [esi], byte '@' |
je @f |
; is it already minimized? |
test [edi + window_data+WDATA.fl_wstate], WSTATE_MINIMIZED |
test [window_data + edi + WDATA.fl_wstate], WSTATE_MINIMIZED |
jnz @f |
; no it's not, let's do that |
or [edi + window_data+WDATA.fl_wstate], WSTATE_MINIMIZED |
or [window_data + edi + WDATA.fl_wstate], WSTATE_MINIMIZED |
inc edx |
;-------------------------------------- |
align 4 |
1291,13 → 1291,10 |
;-------------------------------------- |
align 4 |
.restore_size: |
mov eax, esi |
shl eax, BSF sizeof.APPDATA |
add eax, SLOT_BASE + APPDATA.saved_box |
push [eax + BOX.height] \ |
[eax + BOX.width] \ |
[eax + BOX.top] \ |
[eax + BOX.left] |
push [edi + WDATA.saved_box.height] \ |
[edi + WDATA.saved_box.width] \ |
[edi + WDATA.saved_box.top] \ |
[edi + WDATA.saved_box.left] |
mov eax, esp |
;-------------------------------------- |
align 4 |
1325,10 → 1322,6 |
align 4 |
;> esi = process slot |
sys_window_rollup_handler: |
mov edx, esi |
shl edx, BSF sizeof.APPDATA |
add edx, SLOT_BASE |
; toggle normal/rolled up window state |
mov bl, [edi + WDATA.fl_wstate] |
xor bl, WSTATE_ROLLEDUP |
1350,7 → 1343,7 |
test bl, WSTATE_MAXIMIZED |
jnz @f |
add esp, -sizeof.BOX |
lea eax, [edx + APPDATA.saved_box] |
lea eax, [edi + WDATA.saved_box] |
jmp .set_box |
;-------------------------------------- |
align 4 |
1543,17 → 1536,12 |
test cl, WSTATE_MAXIMIZED |
jnz .exit |
mov eax, edi |
sub eax, window_data |
shl eax, (BSF sizeof.APPDATA - BSF sizeof.WDATA) |
add eax, SLOT_BASE |
lea ebx, [edi + WDATA.box] |
xchg esp, ebx |
pop [eax + APPDATA.saved_box.left] \ |
[eax + APPDATA.saved_box.top] \ |
[eax + APPDATA.saved_box.width] \ |
pop [edi + WDATA.saved_box.left] \ |
[edi + WDATA.saved_box.top] \ |
[edi + WDATA.saved_box.width] \ |
edx |
xchg esp, ebx |
1561,7 → 1549,7 |
test ch, WSTATE_ROLLEDUP |
jnz .exit |
mov [eax + APPDATA.saved_box.height], edx |
mov [edi + WDATA.saved_box.height], edx |
;-------------------------------------- |
align 4 |
.exit: |
1661,8 → 1649,6 |
mov eax, [edi + WDATA.cl_frames] |
mov esi, [esp] |
sub edi, window_data |
shl edi, (BSF sizeof.APPDATA - BSF sizeof.WDATA) |
and cl, 0x0F |
cmp cl, 3 |
1676,7 → 1662,7 |
@@: |
mov [esi + WDATA.caption], eax |
add edi, SLOT_BASE + APPDATA.saved_box |
add edi, WDATA.saved_box |
movsd |
movsd |
movsd |
2186,7 → 2172,7 |
ja .exit.no_redraw |
movzx edx, word[esi] |
shl edx, BSF sizeof.WDATA ; size of TASKDATA and WDATA is 32 bytes |
shl edx, BSF sizeof.WDATA |
cmp byte [SLOT_BASE + edx*(sizeof.APPDATA/sizeof.WDATA) - sizeof.APPDATA + APPDATA.state], TSTATE_FREE |
je .next_window |
2453,10 → 2439,10 |
align 4 |
.next_window: |
movzx edi, word[WIN_POS + esi * 2] |
shl edi, BSF sizeof.WDATA ;size of TASKDATA and WDATA = 32 bytes |
shl edi, BSF sizeof.WDATA |
cmp byte [SLOT_BASE + edi*(sizeof.APPDATA/sizeof.WDATA) + APPDATA.state], TSTATE_FREE |
je .skip_window |
test byte [window_data + edi + WDATA.fl_wstate], WSTATE_USED |
jz .skip_window |
add edi, window_data |
test [edi + WDATA.fl_wstate], WSTATE_MINIMIZED |
/kernel/trunk/hid/mousedrv.inc |
---|
115,9 → 115,9 |
add eax, [_display.win_map] |
movzx edx, byte [ebx + eax] |
shl edx, BSF sizeof.APPDATA |
shl edx, BSF sizeof.WDATA |
; edx - thread slot of window under cursor |
mov esi, [SLOT_BASE + edx + APPDATA.cursor] ; cursor of window under cursor |
mov esi, [window_data + edx + WDATA.cursor] ; cursor of window under cursor |
; if cursor of window under cursor already equal to the |
; current_cursor then just draw it |
127,7 → 127,7 |
; eax = thread slot of current active window |
mov eax, [thread_count] |
movzx eax, word [WIN_POS + eax*2] |
shl eax, BSF sizeof.APPDATA |
shl eax, BSF sizeof.WDATA |
; window under cursor == active window ? |
cmp eax, edx |
138,7 → 138,7 |
and bl, mouse.WINDOW_RESIZE_S_FLAG or mouse.WINDOW_RESIZE_W_FLAG or mouse.WINDOW_RESIZE_E_FLAG |
test bl, bl |
jz .active_isnt_resizing |
mov esi, [SLOT_BASE + eax + APPDATA.cursor] ; esi = cursor of active window, it is resizing cursor |
mov esi, [window_data + eax + WDATA.cursor] ; esi = cursor of active window, it is resizing cursor |
jmp @f |
.active_isnt_resizing: |
153,7 → 153,7 |
je @f |
; set cursor of window under cursor |
mov esi, [SLOT_BASE + edx + APPDATA.cursor] |
mov esi, [window_data + edx + WDATA.cursor] |
cmp esi, [current_cursor] |
je .draw |
171,7 → 171,7 |
;align 4 |
;.fail: |
; mov ecx, [def_cursor] |
; mov [edx+SLOT_BASE+APPDATA.cursor], ecx |
; mov [window_data + edx + WDATA.cursor], ecx |
; stdcall [_display.move_cursor], ecx ; stdcall: [esp]=ebx,eax |
; popad |
; ret |
/kernel/trunk/kernel.asm |
---|
897,10 → 897,17 |
call boot_log |
call reserve_irqs_ports |
mov [SLOT_BASE + APPDATA.window], window_data |
mov [SLOT_BASE + sizeof.APPDATA + APPDATA.window], window_data + sizeof.WDATA |
mov [SLOT_BASE + sizeof.APPDATA*2 + APPDATA.window], window_data + sizeof.WDATA*2 |
mov [window_data + WDATA.thread], SLOT_BASE |
mov [window_data + sizeof.WDATA + WDATA.thread], SLOT_BASE + sizeof.APPDATA |
mov [window_data + sizeof.WDATA*2 + WDATA.thread], SLOT_BASE + sizeof.APPDATA*2 |
call init_display |
mov eax, [def_cursor] |
mov [SLOT_BASE + APPDATA.cursor + sizeof.APPDATA], eax |
mov [SLOT_BASE + APPDATA.cursor + sizeof.APPDATA*2], eax |
mov [window_data + sizeof.WDATA + WDATA.cursor], eax |
mov [window_data + sizeof.WDATA*2 + WDATA.cursor], eax |
; PRINT CPU FREQUENCY |
1179,6 → 1186,10 |
mov [edx + APPDATA.wnd_number], dh |
mov byte [edx + APPDATA.tid], dh |
movzx eax, dh |
shl eax, BSF sizeof.WDATA |
add eax, window_data |
mov [edx + APPDATA.window], eax |
ret |
endp |
1349,7 → 1360,6 |
mov byte [KEY_COUNT], al ; keyboard buffer |
mov byte [BTN_COUNT], al ; button buffer |
; mov [MOUSE_X],dword 100*65536+100 ; mouse x/y |
pop eax |
ret |
1554,14 → 1564,14 |
mov ebx, [esp+64+32-8+4] |
; add window start x & y |
mov ecx, [current_slot_idx] |
shl ecx, BSF sizeof.WDATA |
mov ecx, [current_slot] |
mov ecx, [ecx + APPDATA.window] |
mov eax, [window_data + ecx + WDATA.box.left] |
add eax, [window_data + ecx + WDATA.clientbox.left] |
mov eax, [ecx + WDATA.box.left] |
add eax, [ecx + WDATA.clientbox.left] |
shl eax, 16 |
add eax, [window_data + ecx + WDATA.box.top] |
add eax, [window_data + ecx + WDATA.clientbox.top] |
add eax, [ecx + WDATA.box.top] |
add eax, [ecx + WDATA.clientbox.top] |
add ebx, eax |
mov ecx, [esp+64+32-12+4] |
mov eax, [esp+64+8] ; background color (if given) |
1896,6 → 1906,7 |
; restore default cursor before killing |
pusha |
mov ecx, [current_slot] |
mov ecx, [ecx + APPDATA.window] |
call restore_default_cursor_before_killing |
popa |
@@: |
1924,11 → 1935,12 |
jmp .waitterm |
;------------------------------------------------------------------------------ |
align 4 |
; ecx - ptr WDATA |
restore_default_cursor_before_killing: |
pushfd |
cli |
mov eax, [def_cursor] |
mov [ecx + APPDATA.cursor], eax |
mov [ecx + WDATA.cursor], eax |
movzx eax, word [MOUSE_Y] |
movzx ebx, word [MOUSE_X] |
1936,8 → 1948,8 |
add eax, [_display.win_map] |
movzx edx, byte [ebx + eax] |
shl edx, BSF sizeof.APPDATA |
mov esi, [SLOT_BASE + edx + APPDATA.cursor] |
shl edx, BSF sizeof.WDATA |
mov esi, [window_data + edx + WDATA.cursor] |
cmp esi, [current_cursor] |
je @f |
1994,9 → 2006,9 |
;------------------------------------------------------------------------------ |
sysfn_shutdown: ; 18.9 = system shutdown |
cmp ecx, SYSTEM_SHUTDOWN |
jl exit_for_anyone |
jl .exit_for_anyone |
cmp ecx, SYSTEM_RESTART |
jg exit_for_anyone |
jg .exit_for_anyone |
mov [BOOT.shutdown_type], cl |
mov eax, [thread_count] |
2004,7 → 2016,7 |
mov [shutdown_processes], eax |
call wakeup_osloop |
and dword [esp + SYSCALL_STACK.eax], 0 |
exit_for_anyone: |
.exit_for_anyone: |
ret |
uglobal |
shutdown_processes: |
2055,10 → 2067,10 |
; restore default cursor before killing |
pusha |
mov ecx, [esp+32] |
shl ecx, BSF sizeof.APPDATA |
add ecx, SLOT_BASE |
shl ecx, BSF sizeof.WDATA |
add ecx, window_data |
mov eax, [def_cursor] |
cmp [ecx + APPDATA.cursor], eax |
cmp [ecx + WDATA.cursor], eax |
je @f |
call restore_default_cursor_before_killing |
@@: |
2172,8 → 2184,8 |
mov eax, edx |
shl edx, BSF sizeof.WDATA |
cmp [edx*(sizeof.APPDATA/sizeof.WDATA) + SLOT_BASE + APPDATA.state], TSTATE_FREE |
je .fail |
test [window_data + edx + WDATA.fl_wstate], WSTATE_USED |
jz .fail |
cmp ecx, 1 |
jnz .set_zmod |
2204,7 → 2216,7 |
call window._.redraw_top_wnd |
shl esi, BSF sizeof.WDATA |
mov [esi + window_data + WDATA.fl_redraw], 1 |
mov [esi + window_data + WDATA.fl_redraw], WSTATE_REDRAW |
mov eax, 1 |
2640,16 → 2652,16 |
cmp ebx, 2 |
jnz .srl1 |
mov edx, [current_slot_idx] ; return whole screen draw area for this app |
shl edx, BSF sizeof.WDATA |
mov [draw_data + edx + RECT.left], 0 |
mov [draw_data + edx + RECT.top], 0 |
mov edx, [current_slot] ; return whole screen draw area for this app |
mov edx, [edx + APPDATA.window] |
mov [edx + WDATA.draw_data.left], 0 |
mov [edx + WDATA.draw_data.top], 0 |
mov eax, [_display.width] |
dec eax |
mov [draw_data + edx + RECT.right], eax |
mov [edx + WDATA.draw_data.right], eax |
mov eax, [_display.height] |
dec eax |
mov [draw_data + edx + RECT.bottom], eax |
mov [edx + WDATA.draw_data.bottom], eax |
.srl1: |
ret |
2863,14 → 2875,14 |
;-------------------------------------- |
align 4 |
backgr: |
mov eax, [draw_data + sizeof.WDATA + RECT.left] |
mov eax, [background_window + WDATA.draw_data.left] |
shl eax, 16 |
add eax, [draw_data + sizeof.WDATA + RECT.right] |
add eax, [background_window + WDATA.draw_data.right] |
mov [BG_Rect_X_left_right], eax ; [left]*65536 + [right] |
mov eax, [draw_data + sizeof.WDATA + RECT.top] |
mov eax, [background_window + WDATA.draw_data.top] |
shl eax, 16 |
add eax, [draw_data + sizeof.WDATA + RECT.bottom] |
add eax, [background_window + WDATA.draw_data.bottom] |
mov [BG_Rect_Y_top_bottom], eax ; [top]*65536 + [bottom] |
call drawbackground |
2884,37 → 2896,43 |
;-------------------------------------- |
align 4 |
set_bgr_event: |
add edi, sizeof.APPDATA |
add edi, sizeof.WDATA |
mov eax, [BG_Rect_X_left_right] |
mov edx, [BG_Rect_Y_top_bottom] |
cmp [SLOT_BASE + edi + APPDATA.draw_bgr_x], 0 |
cmp [window_data + edi + WDATA.draw_bgr_x], 0 |
jz .set |
.join: |
cmp word [SLOT_BASE + edi + APPDATA.draw_bgr_x], ax |
cmp word [window_data + edi + WDATA.draw_bgr_x], ax |
jae @f |
mov word [SLOT_BASE + edi + APPDATA.draw_bgr_x], ax |
mov word [window_data + edi + WDATA.draw_bgr_x], ax |
@@: |
shr eax, 16 |
cmp word [SLOT_BASE + edi + APPDATA.draw_bgr_x + 2], ax |
cmp word [window_data + edi + WDATA.draw_bgr_x + 2], ax |
jbe @f |
mov word [SLOT_BASE + edi + APPDATA.draw_bgr_x + 2], ax |
mov word [window_data + edi + WDATA.draw_bgr_x + 2], ax |
@@: |
cmp word [SLOT_BASE + edi + APPDATA.draw_bgr_y], dx |
cmp word [window_data + edi + WDATA.draw_bgr_y], dx |
jae @f |
mov word [SLOT_BASE + edi + APPDATA.draw_bgr_y], dx |
mov word [window_data + edi + WDATA.draw_bgr_y], dx |
@@: |
shr edx, 16 |
cmp word [SLOT_BASE + edi + APPDATA.draw_bgr_y+2], dx |
cmp word [window_data + edi + WDATA.draw_bgr_y+2], dx |
jbe @f |
mov word [SLOT_BASE + edi + APPDATA.draw_bgr_y+2], dx |
mov word [window_data + edi + WDATA.draw_bgr_y+2], dx |
@@: |
jmp .common |
.set: |
mov [SLOT_BASE + edi + APPDATA.draw_bgr_x], eax |
mov [SLOT_BASE + edi + APPDATA.draw_bgr_y], edx |
mov [window_data + edi + WDATA.draw_bgr_x], eax |
mov [window_data + edi + WDATA.draw_bgr_y], edx |
.common: |
or [SLOT_BASE + edi + APPDATA.occurred_events], EVENT_BACKGROUND |
loop set_bgr_event |
mov eax, [window_data + edi + WDATA.thread] |
test eax, eax |
jz @f |
or [eax + APPDATA.occurred_events], EVENT_BACKGROUND |
@@: |
sub ecx, 1 |
jnz set_bgr_event |
;loop set_bgr_event |
pop edi ecx |
;--------- set event 5 stop ----------- |
dec [REDRAW_BACKGROUND] ; got new update request? |
2921,10 → 2939,10 |
jnz backgr |
xor eax, eax |
mov [draw_data + sizeof.WDATA + RECT.left], eax |
mov [draw_data + sizeof.WDATA + RECT.top], eax |
mov [draw_data + sizeof.WDATA + RECT.right], eax |
mov [draw_data + sizeof.WDATA + RECT.bottom], eax |
mov [background_window + WDATA.draw_data.left], eax |
mov [background_window + WDATA.draw_data.top], eax |
mov [background_window + WDATA.draw_data.right], eax |
mov [background_window + WDATA.draw_data.bottom], eax |
;-------------------------------------- |
align 4 |
nobackgr: |
2986,8 → 3004,8 |
.terminate: |
pushad |
mov ecx, eax |
shl ecx, BSF sizeof.APPDATA |
add ecx, SLOT_BASE |
shl ecx, BSF sizeof.WDATA |
add ecx, window_data |
call restore_default_cursor_before_killing |
popad |
3079,39 → 3097,38 |
jz .az |
mov dl, 0 |
lea eax, [edi + draw_data - window_data] |
mov ebx, [draw_limits.left] |
cmp ebx, [eax + RECT.left] |
cmp ebx, [edi + WDATA.draw_data.left] |
jae @f |
mov [eax + RECT.left], ebx |
mov [edi + WDATA.draw_data.left], ebx |
mov dl, 1 |
;-------------------------------------- |
align 4 |
@@: |
mov ebx, [draw_limits.top] |
cmp ebx, [eax + RECT.top] |
cmp ebx, [edi + WDATA.draw_data.top] |
jae @f |
mov [eax + RECT.top], ebx |
mov [edi + WDATA.draw_data.top], ebx |
mov dl, 1 |
;-------------------------------------- |
align 4 |
@@: |
mov ebx, [draw_limits.right] |
cmp ebx, [eax + RECT.right] |
cmp ebx, [edi + WDATA.draw_data.right] |
jbe @f |
mov [eax + RECT.right], ebx |
mov [edi + WDATA.draw_data.right], ebx |
mov dl, 1 |
;-------------------------------------- |
align 4 |
@@: |
mov ebx, [draw_limits.bottom] |
cmp ebx, [eax + RECT.bottom] |
cmp ebx, [edi + WDATA.draw_data.bottom] |
jbe @f |
mov [eax + RECT.bottom], ebx |
mov [edi + WDATA.draw_data.bottom], ebx |
mov dl, 1 |
;-------------------------------------- |
align 4 |
3123,19 → 3140,16 |
align 4 |
.az: |
mov eax, edi |
add eax, draw_data-window_data |
mov ebx, [draw_limits.left] ; set limits |
mov [eax + RECT.left], ebx |
mov [eax + WDATA.draw_data.left], ebx |
mov ebx, [draw_limits.top] |
mov [eax + RECT.top], ebx |
mov [eax + WDATA.draw_data.top], ebx |
mov ebx, [draw_limits.right] |
mov [eax + RECT.right], ebx |
mov [eax + WDATA.draw_data.right], ebx |
mov ebx, [draw_limits.bottom] |
mov [eax + RECT.bottom], ebx |
mov [eax + WDATA.draw_data.bottom], ebx |
sub eax, draw_data-window_data |
cmp dword [esp], 1 |
jne nobgrd |
inc [REDRAW_BACKGROUND] |
3203,7 → 3217,7 |
.found: |
pop ebp edi eax |
mov [eax + WDATA.fl_redraw], byte 1 ; mark as redraw |
mov [eax + WDATA.fl_redraw], WSTATE_REDRAW ; mark as redraw |
;-------------------------------------- |
align 4 |
ricino: |
3224,7 → 3238,7 |
mov ecx, [_display.win_map_size] |
shr ecx, 2 |
rep stosd |
mov byte[window_data + sizeof.WDATA + WDATA.z_modif], ZPOS_DESKTOP |
mov byte[background_window + WDATA.z_modif], ZPOS_DESKTOP |
mov [REDRAW_BACKGROUND], 0 |
ret |
;----------------------------------------------------------------------------- |
/kernel/trunk/memmap.inc |
---|
41,7 → 41,7 |
; 0x80000000 -> 0FFF physical page zero - do not write |
; (used by int 13h in some configurations) |
; |
; 0x80001000 -> 2FFF window_data - 256 entries |
; 0x80001000 -> 8FFF window_data - 256 entries |
; |
; 0000 dword x start |
; 0004 dword y start |
52,15 → 52,6 |
; 0018 dword color of frames |
; 001C dword window flags, +30 = window drawn, +31 redraw flag |
; |
; 3000 -> 4FFF free |
; |
; 5000 -> 68FF free (6k6) |
; 6900 -> 6EFF saved picture under mouse pointer (1k5) |
; |
; 6F00 -> 6FFF free (256) |
; |
; 7000 -> 7FFF used CD driver |
; |
; 8000 -> A3FF used FLOPPY driver |
; |
; A400 -> B0FF free (3k3), unused ACTIVE_PROC_STACK |
/kernel/trunk/video/cursors.inc |
---|
294,7 → 294,8 |
; cmp [eax+CURSOR.size], CURSOR_SIZE |
; jne .fail |
mov ebx, [current_slot] |
xchg eax, [ebx + APPDATA.cursor] |
mov ebx, [ebx + APPDATA.window] |
xchg eax, [ebx + WDATA.cursor] |
jmp .end |
;-------------------------------------- |
align 4 |
301,7 → 302,8 |
.fail: |
mov eax, [def_cursor] |
mov ebx, [current_slot] |
xchg eax, [ebx + APPDATA.cursor] |
mov ebx, [ebx + APPDATA.window] |
xchg eax, [ebx + WDATA.cursor] |
align 4 |
.end: |
mov [redrawmouse_unconditional], 1 |
464,10 → 466,11 |
jne .fail |
mov ebx, [current_slot] |
cmp esi, [ebx + APPDATA.cursor] |
mov ebx, [ebx + APPDATA.window] |
cmp esi, [ebx + WDATA.cursor] |
jne @F |
mov eax, [def_cursor] |
mov [ebx + APPDATA.cursor], eax |
mov [ebx + WDATA.cursor], eax |
;-------------------------------------- |
align 4 |
@@: |
/kernel/trunk/video/vesa20.inc |
---|
2013,9 → 2013,9 |
pushad |
; External loop for all y from start to end |
mov ebx, [draw_data + sizeof.WDATA + RECT.top] ; y start |
mov ebx, [background_window + WDATA.draw_data.top] ; y start |
dp2: |
mov ebp, [draw_data + sizeof.WDATA + RECT.left] ; x start |
mov ebp, [background_window + WDATA.draw_data.left] ; x start |
; 1) Calculate pointers in WinMapAddress (does pixel belong to OS thread?) [ebp] |
; and LFB data (output for our function) [edi] |
; mov eax, [BytesPerScanLine] |
2113,7 → 2113,7 |
add ebp, edx |
add eax, edx |
cmp eax, [draw_data + sizeof.WDATA + RECT.right] |
cmp eax, [background_window + WDATA.draw_data.right] |
ja dp4 |
sub ecx, edx |
jnz dp3 |
2128,7 → 2128,7 |
dp4: |
; next scan line |
inc ebx |
cmp ebx, [draw_data + sizeof.WDATA + RECT.bottom] |
cmp ebx, [background_window + WDATA.draw_data.bottom] |
jbe dp2 |
popad |
mov [EGA_counter], 1 |
2166,8 → 2166,8 |
push eax ; low |
; External loop for all y from start to end |
mov ebx, [draw_data + sizeof.WDATA + RECT.top] ; y start |
mov ebp, [draw_data + sizeof.WDATA + RECT.left] ; x start |
mov ebx, [background_window + WDATA.draw_data.top] ; y start |
mov ebp, [background_window + WDATA.draw_data.left] ; x start |
; 1) Calculate pointers in WinMapAddress (does pixel belong to OS thread?) [ebp] |
; and LFB data (output for our function) [edi] |
; mov eax, [BytesPerScanLine] |
2309,7 → 2309,7 |
add eax, 1 |
mov [esp+20], eax |
add esi, 4 |
cmp eax, [draw_data + sizeof.WDATA + RECT.right] |
cmp eax, [background_window + WDATA.draw_data.right] |
jbe sdp3a |
sdp4: |
2317,11 → 2317,11 |
mov ebx, [esp+24] |
add ebx, 1 |
mov [esp+24], ebx |
cmp ebx, [draw_data + sizeof.WDATA + RECT.bottom] |
cmp ebx, [background_window + WDATA.draw_data.bottom] |
ja sdpdone |
; advance edi, ebp to next scan line |
sub eax, [draw_data + sizeof.WDATA + RECT.left] |
sub eax, [background_window + WDATA.draw_data.left] |
sub ebp, eax |
add ebp, [_display.width] |
sub edi, eax |
2346,7 → 2346,7 |
lea eax, [eax*3] |
imul eax, [BgrDataWidth] |
sub [esp], eax |
mov eax, [draw_data + sizeof.WDATA + RECT.left] |
mov eax, [background_window + WDATA.draw_data.left] |
mov [esp+20], eax |
test ebx, ebx |
jz sdp3 |
2386,7 → 2386,7 |
mov eax, [esp+20+8] |
add eax, 1 |
mov [esp+20+8], eax |
cmp eax, [draw_data + sizeof.WDATA + RECT.right] |
cmp eax, [background_window + WDATA.draw_data.right] |
ja @f |
add ecx, [esp+36+8] |
mov eax, edx |
2396,7 → 2396,7 |
sub esi, eax |
jmp smooth_line |
@@: |
mov eax, [draw_data + sizeof.WDATA + RECT.left] |
mov eax, [background_window + WDATA.draw_data.left] |
mov [esp+20+8], eax |
ret |