Subversion Repositories Kolibri OS

Compare Revisions

Regard whitespace Rev 1858 → Rev 1859

/kernel/branches/Kolibri-A/trunk/core/syscall.inc
44,10 → 44,28
 
align 32
syscall_entry:
push ecx
; sti
push ecx
and eax, 3
call dword [servetable3 + eax * 4]
; and eax, 3
; call dword [servetable3 + eax * 4]
 
mov edi, [esp+4]
mov ecx, [esp+8]
mov edx, [esp+12]
mov ebx, [esp+16]
and al, 1
jz .hline
mov eax, [esp+20]
sti
call vline
jmp .done
.hline:
mov eax, [esp+20]
sti
call hline
.done:
 
 
pop ecx
sysret
 
155,8 → 173,8
align 4
servetable3: ; Kolibri-A special service
 
dd paleholder ; 0
dd paleholder ; 1
dd hline ; 0
dd vline ; 1
dd paleholder ; 2
dd sys_end ; last
 
/kernel/branches/Kolibri-A/trunk/data32.inc
315,13 → 315,32
srv.bk rd 1
 
 
align 16
align 64
img_draw_core_fn rd 1 ; putimage variables & helpers
img_draw_edge_fn rd 1
img_lfb_origin rd 1
img_buf_origin rd 1
img_buf_line_size rd 1
img_palette rd 1
img_bitoffset rd 1
img_edgeoffset rd 1
img_bytes_per_pix rd 1
img_map_right rd 1
img_map_x rd 1
img_pix_x rd 1 ; real Xsize
img_pix_y rd 1 ; real Ysize
img_screen_x rd 1
img_screen_y rd 1
 
_display display_t
 
align 64
_WinMapWidth rd 1
_WinMapHeight rd 1
_WinMapAddress rd 1
_WinMapSize rd 1
 
align 16
_display display_t
 
def_cursor rd 1
current_cursor rd 1
hw_cursor rd 1
/kernel/branches/Kolibri-A/trunk/gui/mouse.inc
378,9 → 378,11
 
mov eax, [mouse.state.pos.x]
sub eax, [mouse.active_sys_window.delta.x]
and al, 0xFC ; <<<<<<<<<<<<<<<<<<<
mov [mouse.active_sys_window.new_box.left], eax
mov eax, [mouse.state.pos.y]
sub eax, [mouse.active_sys_window.delta.y]
and al, 0xFE ; <<<<<<<<<<<<<<<<<<<
mov [mouse.active_sys_window.new_box.top], eax
 
mov eax, [mouse.active_sys_window.new_box.left]
411,15 → 413,16
 
mov eax, [mouse.state.pos.x]
sub eax, [mouse.active_sys_window.delta.x]
and al, 0xFC ; <<<<<<<<<<<<<<<<<<<
mov [mouse.active_sys_window.new_box.left], eax
sub eax, [mouse.active_sys_window.old_box.left]
sub [mouse.active_sys_window.new_box.width], eax
 
mov eax, [mouse.active_sys_window.new_box.width]
sub eax, 127
sub eax, 128
jge @f
add [mouse.active_sys_window.new_box.left], eax
mov [mouse.active_sys_window.new_box.width], 127
mov [mouse.active_sys_window.new_box.width], 128
@@: mov eax, [mouse.active_sys_window.new_box.left]
or eax, eax
jge .check_resize_s
434,6 → 437,7
mov eax, [mouse.state.pos.y]
add eax, [mouse.active_sys_window.delta.y]
sub eax, [mouse.active_sys_window.old_box.top]
and al, 0xFC ; <<<<<<<<<<<<<<<<<<<
mov [mouse.active_sys_window.new_box.height], eax
 
push eax
466,12 → 470,13
mov eax, [mouse.state.pos.x]
add eax, [mouse.active_sys_window.delta.x]
sub eax, [mouse.active_sys_window.old_box.left]
and al, 0xFC ; <<<<<<<<<<<<<<<<<<<
mov [mouse.active_sys_window.new_box.width], eax
 
mov eax, [mouse.active_sys_window.new_box.width]
cmp eax, 127
cmp eax, 128
jge @f
mov eax, 127
mov eax, 128
mov [mouse.active_sys_window.new_box.width], eax
@@: add eax, [mouse.active_sys_window.new_box.left]
cmp eax, [Screen_Max_X]
701,4 → 706,4
ret
 
diff16 "mouse code end ",0,$
diff16 "mouse code size",mouse_check_events,$
diff10 "mouse code size",mouse_check_events,$
/kernel/branches/Kolibri-A/trunk/gui/window.inc
328,15 → 328,19
cmp ebx, -1
jne @f
mov ebx, [edi + WDATA.box.left]
and bl, 0xFC
@@: cmp ecx, -1
jne @f
mov ecx, [edi + WDATA.box.top]
and cl, 0xFE
@@: cmp edx, -1
jne @f
mov edx, [edi + WDATA.box.width]
and dl, 0xFC
@@: cmp esi, -1
jne @f
mov esi, [edi + WDATA.box.height]
and esi, 0xFFFFFFFE
 
@@: push esi edx ecx ebx
mov eax, esp
344,14 → 348,6
call window._.set_window_box
add esp, BOX.sizeof
 
; NOTE: do we really need this? to be reworked
; mov byte[DONT_DRAW_MOUSE], 0 ; mouse pointer
; mov byte[MOUSE_BACKGROUND], 0 ; no mouse under
; mov byte[MOUSE_DOWN], 0 ; react to mouse up/down
 
; NOTE: do we really need this? to be reworked
; call [draw_pointer]
 
.exit:
ret
 
519,8 → 515,10
mov eax, [edi + WDATA.box.width]
sub eax, ebx
jle @f
and bl, 0xFC ; <<<<<<<
mov [edi + WDATA.box.width], ebx
@@: sub ebx, [edi + WDATA.box.width]
and bl, 0xFC ; <<<<<<<
mov [edi + WDATA.box.left], ebx
 
.fix_vertical:
532,8 → 530,10
mov eax, [edi + WDATA.box.height]
sub eax, ebx
jle @f
and bl, 0xFE ; <<<<<<<
mov [edi + WDATA.box.height], ebx
@@: sub ebx, [edi + WDATA.box.height]
and bl, 0xFE ; <<<<<<<
mov [edi + WDATA.box.top], ebx
jmp .fix_client_box
 
555,7 → 555,8
call window._.set_window_clientbox
 
add edi, WDATA.sizeof
loop .next_window
dec ecx
jne .next_window ; <<<<<<<<<<<
 
.exit:
ret
1454,7 → 1455,9
movzx eax, cx
mov [edi + WDATA.box.height], eax
sar ebx, 16
and bl, 0xFC ; <<<<<<<<
sar ecx, 16
and cl, 0xFE ; <<<<<<<<
mov [edi + WDATA.box.left], ebx
mov [edi + WDATA.box.top], ecx
 
1673,10 → 1676,11
 
; get WinMap start
push esi
mov edi, [Screen_Max_X]
inc edi
mov edi, [_WinMapWidth]
mov esi, edi
imul edi, ebx
shr eax, 1
shr eax, 1
add edi, eax
add edi, [_WinMapAddress]
pop eax
1715,12 → 1719,13
 
; get WinMap start -> ebp
push eax
mov eax, [Screen_Max_X] ; screen_sx
inc eax
mov eax, [_WinMapWidth] ; <<<<
imul eax, ebx
add eax, [esp]
add eax, [_WinMapAddress]
mov ebp, eax
mov ebp, [esp]
shr ebp, 1
shr ebp, 1
add ebp, eax
add ebp, [_WinMapAddress]
 
mov edi, [edi + APPDATA.wnd_shape]
pop eax
2085,4 → 2090,4
ret
 
diff16 "window code end",0,$
diff16 "window.inc size",syscall_draw_window,$
diff10 "window.inc size",syscall_draw_window,$
/kernel/branches/Kolibri-A/trunk/hid/mousedrv.inc
35,19 → 35,6
;include 'm_com.inc'
 
 
;test_mario79:
; push esi
; push eax
; mov [write_error_to],process_test_m79+43
; movzx eax,al ;[DevErrorCode]
; call writehex
; mov esi,process_test_m79
; call sys_msg_board_str
; pop eax
; pop esi
; ret
;process_test_m79 db 'K : Process - test Mario79 error 00000000',13,10,0
 
draw_mouse_under:
; return old picture
 
109,9 → 96,12
push eax
push ebx
 
mov ecx, [Screen_Max_X]
inc ecx
mul ecx
mov ecx, ebx ; <<<<
shr ecx, 1
imul ecx, [_WinMapWidth]
shr eax, 1
shr eax, 1
add eax, ecx
add eax, [_WinMapAddress]
movzx edx, byte [ebx+eax]
shl edx, 8
286,9 → 276,11
add edx,window_data
movzx eax, word [MOUSE_X]
movzx ebx, word [MOUSE_Y]
mov ecx,[Screen_Max_X]
inc ecx
imul ecx,ebx
mov ecx, ebx ; <<<<
shr ecx, 1
imul ecx, [_WinMapWidth]
shr eax, 1
shr eax, 1
add ecx,eax
add ecx, [_WinMapAddress]
mov eax, [CURRENT_TASK]
454,3 → 446,5
@@:
ret
 
diff16 "window code end",0,$
diff10 "mousedrv size ",draw_mouse_under,$
/kernel/branches/Kolibri-A/trunk/kernel.asm
320,11 → 320,9
mov eax, [BOOT_VAR + 0x9044] ; version & flags
mov [apm_vf], eax
; -----------------------------------------
; movzx eax,byte [BOOT_VAR+0x9010] ; mouse port
; mov [0xF604],byte 1 ;al
mov al, [BOOT_VAR+0x901F] ; DMA access
mov [allow_dma_access], al
movzx eax, byte [BOOT_VAR+0x9000] ; bpp
mov eax, 32 ; <<<<<<<<< bpp
mov [ScreenBPP],al
 
mov [_display.bpp], eax
336,6 → 334,9
dec eax
mov [Screen_Max_X],eax
mov [screen_workarea.right],eax
inc eax
shr eax, 2
mov [_WinMapWidth], eax ; 1 tyle = 4 pixels
movzx eax,word [BOOT_VAR+0x900C] ; Y max
mov [_display.height], eax
dec eax
345,17 → 346,13
mov [SCR_MODE],eax
mov eax,[BOOT_VAR+0x9014] ; Vesa 1.2 bnk sw add
mov [BANK_SWITCH],eax
mov [BytesPerScanLine],word 640*4 ; Bytes PerScanLine
cmp [SCR_MODE],word 0x13 ; 320x200
je @f
cmp [SCR_MODE],word 0x12 ; VGA 640x480
je @f
movzx eax, word[BOOT_VAR+0x9001] ; for other modes
mov [BytesPerScanLine],ax
mov [_display.pitch], eax
@@:
mov eax, [_display.width]
mul [_display.height]
mov eax, [_display.height]
shr eax, 1
mul [_WinMapWidth]
mov [_WinMapSize], eax
 
mov esi, BOOT_VAR+0x9080
500,10 → 497,10
mov [graph_data_l+4],al
mov [graph_data_l+7],ah
or [KERNEL_ALLOC_FLAG], dword PG_NOCACHE
; or [KERNEL_ALLOC_FLAG], dword PG_NOCACHE
stdcall kernel_alloc, [_WinMapSize]
mov [_WinMapAddress], eax
xor [KERNEL_ALLOC_FLAG], dword PG_NOCACHE
; xor [KERNEL_ALLOC_FLAG], dword PG_NOCACHE
 
xor eax,eax
inc eax
606,6 → 603,17
mov esi, boot_memdetect
call boot_log
 
; <<<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>
mov ebx, img_test_struct
mov ecx, 3*65536 + 4
mov edx, 32*65536 + 512
mov esi, 32
xor edi, edi
mov ebp, edi
call sys_putimage_palette.forced
 
;<<<<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>
 
movzx ecx, word [boot_y]
or ecx, (10+29*6) shl 16 ; "Determining amount of memory"
sub ecx, 10
2241,6 → 2249,7
; je nosb31
;draw_background_temp:
; mov [bgrchanged],1 ;0
 
mov [background_defined], 1
mov byte[BACKGROUND_CHANGED], 1
call force_redraw_background
2838,24 → 2847,25
 
 
; check if pixel is allowed to be drawn
; -- not in use any more ?
 
checkpixel:
push eax edx
;checkpixel:
; push eax ebx edx
; shr ebx, 1
; mov edx, [_WinMapWidth] ; <<<<
; imul edx, ebx
; shr eax, 2
; add eax, [_WinMapAddress]
; mov dl, [eax+edx]
;
; xor ecx, ecx
; mov eax, [CURRENT_TASK]
; cmp al, dl
; setne cl
;
; pop edx ebx eax
; ret
 
mov edx,[Screen_Max_X] ; screen x size
inc edx
imul edx, ebx
add eax, [_WinMapAddress]
mov dl, [eax+edx] ; lea eax, [...]
 
xor ecx, ecx
mov eax, [CURRENT_TASK]
cmp al, dl
setne cl
 
pop edx eax
ret
 
iglobal
cpustring db 'CPU',0
endg
2903,12 → 2913,6
jz nobackgr
cmp [background_defined], 0
jz nobackgr
; mov [draw_data+32 + RECT.left],dword 0
; mov [draw_data+32 + RECT.top],dword 0
; mov eax,[Screen_Max_X]
; mov ebx,[Screen_Max_Y]
; mov [draw_data+32 + RECT.right],eax
; mov [draw_data+32 + RECT.bottom],ebx
@@:
call drawbackground
xor eax, eax
2950,8 → 2954,6
je system_shutdown
 
noshutdown:
 
 
mov eax,[TASK_COUNT] ; termination
mov ebx,TASK_DATA+TASKDATA.state
mov esi,1
2970,19 → 2972,13
ret
 
; redraw screen
; eax , if process window_data base is eax, do not set flag/limits
 
redrawscreen:
 
; eax , if process window_data base is eax, do not set flag/limits
 
pushad
push eax
 
;;; mov ebx,2
;;; call delay_hs
 
;mov ecx,0 ; redraw flags for apps
xor ecx,ecx
xor ecx,ecx ; redraw flags for apps
newdw2:
 
inc ecx
3034,8 → 3030,6
 
cmp dword[esp], 1
jnz .az
; cmp byte[BACKGROUND_CHANGED], 0
; jnz newdw8
cmp byte[REDRAW_BACKGROUND], 0
jz .az
mov dl, 0
3086,6 → 3080,7
jne nobgrd
inc byte[REDRAW_BACKGROUND]
 
 
newdw8:
nobgrd:
 
3106,7 → 3101,6
ret
 
calculatebackground: ; background
 
mov edi, [_WinMapAddress] ; set os to use all pixels
mov eax,0x01010101
mov ecx, [_WinMapSize]
3122,11 → 3116,7
imax dd 0x0
endg
 
 
 
delay_ms: ; delay in 1/1000 sec
 
 
push eax
push ecx
 
3154,7 → 3144,6
 
ret
 
 
set_app_param:
mov edi, [TASK_BASE]
mov eax, [edi + TASKDATA.event_mask]
3162,8 → 3151,6
mov [esp+32], eax
ret
 
 
 
delay_hs: ; delay in 1/100 secs
; ebx = delay time
push ecx
3189,7 → 3176,6
 
align 16 ;very often call this subrutine
memmove: ; memory move in bytes
 
; eax = from
; ebx = to
; ecx = no of bytes
3219,54 → 3205,6
ret
 
 
; <diamond> Sysfunction 34, read_floppy_file, is obsolete. Use 58 or 70 function instead.
;align 4
;
;read_floppy_file:
;
;; as input
;;
;; eax pointer to file
;; ebx file lenght
;; ecx start 512 byte block number
;; edx number of blocks to read
;; esi pointer to return/work area (atleast 20 000 bytes)
;;
;;
;; on return
;;
;; eax = 0 command succesful
;; 1 no fd base and/or partition defined
;; 2 yet unsupported FS
;; 3 unknown FS
;; 4 partition not defined at hd
;; 5 file not found
;; ebx = size of file
;
; mov edi,[TASK_BASE]
; add edi,0x10
; add esi,[edi]
; add eax,[edi]
;
; pushad
; mov edi,esi
; add edi,1024
; mov esi,0x100000+19*512
; sub ecx,1
; shl ecx,9
; add esi,ecx
; shl edx,9
; mov ecx,edx
; cld
; rep movsb
; popad
;
; mov [esp+36],eax
; mov [esp+24],ebx
; ret
 
 
 
align 4
 
sys_programirq:
3294,7 → 3232,6
 
 
reserve_free_irq:
 
xor esi, esi
inc esi
cmp ecx, 16
3317,7 → 3254,6
jmp ril1
 
reserve_irq:
 
cmp dword [ecx], 0
jne ril1
 
3355,37 → 3291,26
 
drawbackground:
inc [mouse_pause]
cmp [SCR_MODE],word 0x12
je dbrv20
dbrv12:
cmp [SCR_MODE],word 0100000000000000b
jge dbrv20
; cmp [SCR_MODE],word 0x13
; je dbrv20
; call vesa12_drawbackground
; cmp [BgrDrawMode],dword 1
; jne bgrstr
; call vesa20_drawbackground_tiled
call drawbackground
dec [mouse_pause]
call [draw_pointer]
ret
dbrv20:
cmp [BgrDrawMode],dword 1
jne bgrstr
call vesa20_drawbackground_tiled
dec [mouse_pause]
call [draw_pointer]
ret
bgrstr:
call vesa20_drawbackground_stretch
dec [mouse_pause]
call [draw_pointer]
ret
; bgrstr:
; call vesa20_drawbackground_stretch
; dec [mouse_pause]
; call [draw_pointer]
; ret
 
; ====================================================================
align 4
 
syscall_putimage: ; PutImage
syscall_putimage: ; PutImage = SysFn07
sys_putimage:
test ecx,0x80008000
jnz .exit
test ecx,0x0000FFFF
test ecx,0x80008000 ; ecx = { SizeX | SizeY }
jnz .exit ; edx = { OrigX | OrigY }
test ecx,0x0000FFFF ; ebx points to the 24bpp-image
jz .exit
test ecx,0xFFFF0000
jnz @f
3392,39 → 3317,39
.exit:
ret
@@:
push edi
mov edi,[current_slot]
add dx,word[edi+APPDATA.wnd_clientbox.top]
rol edx,16
add dx,word[edi+APPDATA.wnd_clientbox.left]
pop edi
rol edx,16
.forced:
push ebp esi 0
mov ebp, putimage_get24bpp
mov esi, putimage_init24bpp
sys_putimage_bpp:
; cmp [SCR_MODE], word 0x12
; jz @f ;.doit
; mov eax, vesa12_putimage
; cmp [SCR_MODE], word 0100000000000000b
; jae @f
; cmp [SCR_MODE], word 0x13
; jnz .doit
;@@:
mov eax, vesa20_putimage
.doit:
.forced: ; called from gui/skincode.inc [215]
push esi
mov esi, ecx
shr esi, 16 ; SizeX
lea esi, [esi*2+esi] ; 3 bytes per pixel
mov [img_buf_line_size], esi
mov [img_draw_core_fn], draw_core_24bpp
mov [img_draw_edge_fn], draw_edge_24bpp
mov [img_bytes_per_pix], 3
pop esi
 
sys_putimage_bpp: ; only called from sys_putimage_palette
inc [mouse_pause]
call eax
call _putimage
dec [mouse_pause]
pop ebp esi ebp
jmp [draw_pointer]
 
 
align 4
sys_putimage_palette:
sys_putimage_palette: ; sysFn 65
; ebx = pointer to image
; ecx = [xsize]*65536 + [ysize]
; edx = [xstart]*65536 + [ystart]
; esi = number of bits per pixel, must be 8, 24 or 32
; esi = number of bits per pixel, must be 1, 8, 24 or 32
; edi = pointer to palette
; ebp = row delta
; ebp = line offset
mov eax, [CURRENT_TASK]
shl eax, 8
add dx, word [eax+SLOT_BASE+APPDATA.wnd_clientbox.top]
3432,253 → 3357,48
add dx, word [eax+SLOT_BASE+APPDATA.wnd_clientbox.left]
rol edx, 16
.forced:
cmp esi, 1
jnz @f
push edi
mov eax, [edi+4]
sub eax, [edi]
push eax
push dword [edi]
push 0ffffff80h
mov edi, esp
call put_mono_image
add esp, 12
pop edi
mov [img_palette], edi
mov eax, esi
cmp eax, 32 ;>32bpp (stupid call)
ja .exit
shr al, 3 ; 0=1bpp, other lo-pix modes not supported
push esi
mov [img_bytes_per_pix], eax
mov esi, [eax*4 + img_core_proc_0]
mov [img_draw_core_fn], esi
mov esi, [eax*4 + img_edge_proc_0]
mov [img_draw_edge_fn], esi
mov esi, ecx
shr esi, 16 ; esi = SizeX
or al, al
jz .1bpp
imul esi, eax
jmp .done
.1bpp:
add esi, 7
shr esi, 3 ; 8 pixels per byte
.done:
add esi, ebp ; + line offset
mov [img_buf_line_size], esi
pop esi
jmp _putimage ;<<< sys_putimage_bpp
.exit:
ret
@@:
cmp esi, 2
jnz @f
push edi
push 0ffffff80h
mov edi, esp
call put_2bit_image
pop eax
pop edi
ret
@@:
cmp esi, 4
jnz @f
push edi
push 0ffffff80h
mov edi, esp
call put_4bit_image
pop eax
pop edi
ret
@@:
push ebp esi ebp
cmp esi, 8
jnz @f
mov ebp, putimage_get8bpp
mov esi, putimage_init8bpp
jmp sys_putimage_bpp
@@:
cmp esi, 15
jnz @f
mov ebp, putimage_get15bpp
mov esi, putimage_init15bpp
jmp sys_putimage_bpp
@@:
cmp esi, 16
jnz @f
mov ebp, putimage_get16bpp
mov esi, putimage_init16bpp
jmp sys_putimage_bpp
@@:
cmp esi, 24
jnz @f
mov ebp, putimage_get24bpp
mov esi, putimage_init24bpp
jmp sys_putimage_bpp
@@:
cmp esi, 32
jnz @f
mov ebp, putimage_get32bpp
mov esi, putimage_init32bpp
jmp sys_putimage_bpp
@@:
pop ebp esi ebp
ret
 
put_mono_image:
push ebp esi ebp
mov ebp, putimage_get1bpp
mov esi, putimage_init1bpp
jmp sys_putimage_bpp
put_2bit_image:
push ebp esi ebp
mov ebp, putimage_get2bpp
mov esi, putimage_init2bpp
jmp sys_putimage_bpp
put_4bit_image:
push ebp esi ebp
mov ebp, putimage_get4bpp
mov esi, putimage_init4bpp
jmp sys_putimage_bpp
align 4
img_core_proc_0 dd draw_core_1bpp
img_core_proc_1 dd draw_core_8bpp
img_core_proc_2 dd draw_core_16bpp
img_core_proc_3 dd draw_core_24bpp
img_core_proc_4 dd draw_core_32bpp
 
putimage_init24bpp:
lea eax, [eax*3]
putimage_init8bpp:
ret
img_edge_proc_0 dd draw_edge_1bpp
img_edge_proc_1 dd draw_edge_8bpp
img_edge_proc_2 dd draw_edge_16bpp
img_edge_proc_3 dd draw_edge_24bpp
img_edge_proc_4 dd draw_edge_32bpp
 
align 16
putimage_get24bpp:
movzx eax, byte [esi+2]
shl eax, 16
mov ax, [esi]
add esi, 3
ret 4
align 16
putimage_get8bpp:
movzx eax, byte [esi]
push edx
mov edx, [esp+8]
mov eax, [edx+eax*4]
pop edx
inc esi
ret 4
 
putimage_init1bpp:
add eax, ecx
push ecx
add eax, 7
add ecx, 7
shr eax, 3
shr ecx, 3
sub eax, ecx
pop ecx
ret
align 16
putimage_get1bpp:
push edx
mov edx, [esp+8]
mov al, [edx]
add al, al
jnz @f
lodsb
adc al, al
@@:
mov [edx], al
sbb eax, eax
and eax, [edx+8]
add eax, [edx+4]
pop edx
ret 4
 
putimage_init2bpp:
add eax, ecx
push ecx
add ecx, 3
add eax, 3
shr ecx, 2
shr eax, 2
sub eax, ecx
pop ecx
ret
align 16
putimage_get2bpp:
push edx
mov edx, [esp+8]
mov al, [edx]
mov ah, al
shr al, 6
shl ah, 2
jnz .nonewbyte
lodsb
mov ah, al
shr al, 6
shl ah, 2
add ah, 1
.nonewbyte:
mov [edx], ah
mov edx, [edx+4]
movzx eax, al
mov eax, [edx+eax*4]
pop edx
ret 4
 
putimage_init4bpp:
add eax, ecx
push ecx
add ecx, 1
add eax, 1
shr ecx, 1
shr eax, 1
sub eax, ecx
pop ecx
ret
align 16
putimage_get4bpp:
push edx
mov edx, [esp+8]
add byte [edx], 80h
jc @f
movzx eax, byte [edx+1]
mov edx, [edx+4]
and eax, 0x0F
mov eax, [edx+eax*4]
pop edx
ret 4
@@:
movzx eax, byte [esi]
add esi, 1
mov [edx+1], al
shr eax, 4
mov edx, [edx+4]
mov eax, [edx+eax*4]
pop edx
ret 4
 
putimage_init32bpp:
shl eax, 2
ret
align 16
putimage_get32bpp:
lodsd
ret 4
 
putimage_init15bpp:
putimage_init16bpp:
add eax, eax
ret
align 16
putimage_get15bpp:
; 0RRRRRGGGGGBBBBB -> 00000000RRRRR000GGGGG000BBBBB000
push ecx edx
movzx eax, word [esi]
add esi, 2
mov ecx, eax
mov edx, eax
and eax, 0x1F
and ecx, 0x1F shl 5
and edx, 0x1F shl 10
shl eax, 3
shl ecx, 6
shl edx, 9
or eax, ecx
or eax, edx
pop edx ecx
ret 4
 
align 16
putimage_get16bpp:
; RRRRRGGGGGGBBBBB -> 00000000RRRRR000GGGGGG00BBBBB000
push ecx edx
movzx eax, word [esi]
add esi, 2
mov ecx, eax
mov edx, eax
and eax, 0x1F
and ecx, 0x3F shl 5
and edx, 0x1F shl 11
shl eax, 3
shl ecx, 5
shl edx, 8
or eax, ecx
or eax, edx
pop edx ecx
ret 4
 
; ==================================================
; eax x beginning
; ebx y beginning
; ecx x end
3693,28 → 3413,13
add edx,[esi+APPDATA.wnd_clientbox.top]
.forced:
inc [mouse_pause]
; call [disable_mouse]
cmp [SCR_MODE],word 0x12
je dbv20
sdbv20:
; cmp [SCR_MODE],word 0100000000000000b
; jge dbv20
; cmp [SCR_MODE],word 0x13
; je dbv20
; call vesa12_drawbar
; dec [mouse_pause]
; call [draw_pointer]
; ret
dbv20:
; dbv20:
call vesa20_drawbar
dec [mouse_pause]
call [draw_pointer]
ret
jmp [draw_pointer]
 
 
 
kb_read:
 
push ecx edx
 
mov ecx,0x1ffff ; last 0xffff, new value in view of fast CPU's
3745,15 → 3450,6
push ecx edx
 
mov dl,al
; mov ecx,0x1ffff ; last 0xffff, new value in view of fast CPU's
; kw_loop1:
; in al,0x64
; test al,0x20
; jz kw_ok1
; loop kw_loop1
; mov ah,1
; jmp kw_exit
; kw_ok1:
in al,0x60
mov ecx,0x1ffff ; last 0xffff, new value in view of fast CPU's
kw_loop:
4491,7 → 4187,12
stdcall kernel_free, [_WinMapAddress]
 
mov eax, [_display.width]
mul [_display.height]
shr eax, 1
shr eax, 1
mov [_WinMapWidth], eax
mov eax, [_display.height]
shr eax, 1
mul [_WinMapWidth]
mov [_WinMapSize], eax
 
stdcall kernel_alloc, eax
/kernel/branches/Kolibri-A/trunk/kernel32.inc
224,9 → 224,7
 
; display
 
;include "video/vesa12.inc" ; Vesa 1.2 functions
include "video/vesa20.inc" ; Vesa 2.0 functions
;include "video/vga.inc" ; VGA 16 color functions
include "video/graph32.inc" ; 32bpp graphics
include "video/cursors.inc" ; cursors functions
 
; Network Interface & TCPIP Stack
/kernel/branches/Kolibri-A/trunk/video/vesa20.inc
File deleted
Property changes:
Deleted: svn:keywords
-Rev
\ No newline at end of property
/kernel/branches/Kolibri-A/trunk/video/graph32.inc
0,0 → 1,1237
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ;;
;; Copyright (C) KolibriOS team 2004-2010. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License ;;
;; ;;
;; GRAPH32.INC ;;
;; ;;
;; 32bpp graph engine for Kolibri-A ;;
;; ;;
;; art_zh (kolibri@jerdev.co.uk) Dec. 2010 : ;;
;; - 4x2 granularity & tiled winmap structure ;;
;; - speed-optimized line/box graphics ;;
;; ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 1708 $
 
 
;*************************************************
; getpixel
;
; in:
; eax = x coordinate
; ebx = y coordinate
;
; ret:
; ecx = 00 RR GG BB
 
 
get_pixel:
mov ecx, [BytesPerScanLine]
imul ecx, ebx
lea ecx, [ecx+eax*4] ; ecx = x*4+(y*y multiplier)
mov ecx, [ecx+LFB_BASE]
and ecx, 0xffffff
ret
 
;-----------------------------------------------------------------------------------
; esi : Buffer origin
; edi : Screen origin
; ebp : Map origin
; ecx : block height (pix)
; ebx : bit[24] = odd line; bh = temp; bl = current task
 
align 4
draw_aligned_box:
pushad
xor edx, edx
.new_line:
btr ebx, 26
mov eax, [img_map_x]
xor ecx, ecx
cmp bl, byte[ebp] ; check the left tile first
jz .new_tile
bts ebx, 26 ; ebx[26] = 1 if edi/esi already pushed
jc .seek_visible
push edi
push esi
jmp .seek_visible
.new_tile:
inc ecx ; visible - scan the open space
cmp ecx, eax
jz .end_of_line
cmp bl, byte[ebp+ecx] ; overlapped? draw the visible segment if so
je .new_tile
 
call [img_draw_core_fn] ; bpp-specific helper (see below)
 
.seek_visible:
inc ecx
cmp ecx, eax
je .next_line
cmp bl, byte[ebp+ecx]
jne .seek_visible
.got_visible:
sub eax, ecx
shl ecx, 4
add edi, ecx ; shift the left edge
shr ecx, 2
imul ecx, [img_bytes_per_pix]
add esi, ecx
xor ecx, ecx
jmp .new_tile
 
.end_of_line:
call [img_draw_core_fn]
 
.next_line:
bt ebx, 26
jnc @f
pop esi
pop edi
@@: inc edx
cmp edx, [esp+24] ; stacked ecx = image height
je .finish
add edi, [BytesPerScanLine]
add esi, [img_buf_line_size]
btc ebx, 24 ; odd line?
jnc .new_line
add ebp, [_WinMapWidth]
jmp .new_line
 
.finish:
popad
ret
 
;--------------------------------
; ebx : bit[24] = odd line; bh = reserved; bl = current task
; ecx : column height (pix)
; edx : max tile offset: 0, 4, 8, or 12 bytes (1,2,3 or 4 pix to draw)
; ebp : map origin
; esi : buffer image origin
; edi : LFB-origin (4byte-aligned)
 
align 4
draw_unaligned_edge:
pushad
mov eax, [img_buf_line_size]
mov bh, dl ; store the 1st tile offset
bt ebx, 24 ; check if the 1st line odd
jnc .new_tile
cmp bl, byte[ebp]
jne @f
call [img_draw_edge_fn] ; bpp-specific helper (see below)
@@:
dec ecx
jz .exit
add edi, [BytesPerScanLine]
add ebp, [_WinMapWidth]
add esi, eax
btr ebx, 24
.new_tile:
cmp bl, byte[ebp]
jne .skip_tile
call [img_draw_edge_fn]
dec ecx
jz .exit
add edi, [BytesPerScanLine]
add esi, eax
call [img_draw_edge_fn]
dec ecx
jz .exit
add edi, [BytesPerScanLine]
add ebp, [_WinMapWidth]
add esi, eax
jmp .new_tile
.skip_tile:
sub cx, 2
jbe .exit
add edi, [BytesPerScanLine]
add edi, [BytesPerScanLine]
add esi, eax
add esi, eax
add ebp, [_WinMapWidth]
jmp .new_tile
.exit:
popad
ret
 
 
;-------------
; unaligned edge helpers
; esi -> left point of the image edge
; edi -> left point of the screen edge
; bh = edx = tile offset (0, 4, 8 or 12 bytes)
 
align 4
draw_edge_32bpp:
push eax
.putpix:
mov eax, [esi+edx]
mov [edi+edx], eax
sub dl, 4
jae .putpix
.exit:
mov dl, bh
pop eax
ret
align 4
draw_edge_24bpp:
push eax esi
xor dl, dl
.putpix:
mov eax, [esi]
and eax, 0x00FFFFFF
mov [edi+edx], eax
test dl, bh
jz .exit
add dl, 4
add esi, 3
jmp .putpix
.exit:
pop esi eax
ret
align 4
draw_edge_8bpp:
push eax esi ebp
xor dl, dl
mov ebp, [img_palette]
.putpix:
movzx eax, byte[esi]
mov eax, [ebp+eax*4]
mov [edi+edx], eax
test dl, bh
jz .exit
add dl, 4
inc esi
jmp .putpix
.exit:
pop ebp esi eax
ret
align 4
draw_edge_1bpp:
push eax ecx ebx ebp
mov ebp, [img_palette]
mov ebx, [ebp+4] ; forecolor
mov ebp, [ebp] ; backcolor
mov ecx, [img_edgeoffset] ; cl = 1 << left_edge_pix_num
mov ebp, [esi]
xor dl, dl
.testbit:
test ebp, ecx
jnz @f
mov eax, ebp
jmp .putpix
@@: mov eax, ebx
.putpix:
mov [edi+edx], eax
test dl, bh
jz .exit
add dl, 4
shl ecx, 1
jmp .testbit
.exit:
pop ebp ebx ecx eax
ret
 
draw_edge_16bpp:
draw_core_16bpp:
ret
 
;-------------
; aligned core helpers
; esi -> left point address (image)
; edi -> left point address (screen)
; cx = number of tiles to draw
align 4
draw_core_32bpp:
push ecx
shl ecx, 1
dec ecx
.putpix:
fld qword[esi+ecx*8] ; 2 qwords = 1 tile
fstp qword[edi+ecx*8]
dec cx
jnb .putpix
pop ecx
ret
align 4
draw_core_24bpp:
push eax ecx
shl ecx, 2
dec ecx
lea eax, [ecx*2+ecx]
.putpix:
mov eax, [esi+eax]
and eax, 0x00FFFFFF
mov [edi+ecx*4], eax
sub dx, 3
dec cx
jnb .putpix
pop ecx eax
ret
align 4
draw_core_8bpp:
pushad
mov ebp, [img_palette]
.putpix:
xor edx, edx
mov eax, dword[esi] ; block of 4 pixels
.putone:
movzx ebx, al
mov ebx, [ebp+ebx*4]
mov [edi+edx*4], ebx
shr eax, 8
inc dl
cmp dl, 4
jnz .putone
add esi, edx ;-)
add edi, 16
dec cx
jnz .putpix
.exit:
popad
ret
align 4
draw_core_1bpp:
pushad
mov ebp, [img_palette]
mov edx, [ebp+4] ; foreground color
mov ebp, [ebp] ; background color
mov ebx, [img_bitoffset]
shl ecx, 2 ; 1 tyle = 4 pix
dec ecx
jb .exit
.newblock:
mov eax, [esi]
.putpix:
test ebx, eax
jz .bkcolor
mov [edi], edx
jmp .nextpix
.bkcolor:
mov [edi], ebp
.nextpix:
dec cx
jb .exit
rol ebx, 1
jc .nextblock
add edi, 4
jmp .putpix
.nextblock:
add esi, 4
jmp .newblock
.exit:
popad
ret
 
;-----------------------------------------
virtual at esp
putimg:
.image_sx dd ? ; X-size (pix)
.image_sy dd ? ; Y-size
.stack_data = 2*4
end virtual
 
align 4
; ebx -> Buffer origin
; ecx = packed size [x|y]
; edx = packed coordinates [x|y]
 
_putimage:
; call [_display.disable_mouse]
pushad
sub esp, putimg.stack_data
mov [img_buf_origin], ebx ; save pointer to image buffer
mov esi, ebx ; pointer to image
.unpack_coords:
mov eax, ecx
and ecx, 0xFFFF ; Ysize
shr eax, 16 ; Xsize
mov [putimg.image_sy], ecx
mov [putimg.image_sx], eax
mov eax, edx
and edx, 0xFFFF ; Ytop
shr eax, 16 ; Xleft
.calculate_abs_coords:
mov ebx, [TASK_BASE-twdw + WDATA.box.left]
mov ecx, [TASK_BASE-twdw + WDATA.box.top]
add ebx, eax
add ecx, edx
mov [img_screen_x], ebx ; abs Xleft
; mov [img_screen_y], ecx ; ecx = abs Ytop ; hold it !
.check_x_size:
mov ebx, [TASK_BASE-twdw + WDATA.box.width]
inc ebx ; ebx = window Xsize
sub ebx, eax ; eax = rel Xleft
jbe .finish ; image is out of the window
mov eax, [putimg.image_sx]
cmp ebx, eax ; real_sx = MIN(wnd_sx-image_cx, image_sx);
jae @f
mov eax, ebx
@@: dec eax
mov [img_pix_x], eax
.check_y_size:
mov ebx, [TASK_BASE-twdw + WDATA.box.height]
inc ebx ; ebx = real window y-size
sub ebx, edx ; edx = rel Ytop
jbe .finish ; image isn't visible
mov edx, [putimg.image_sy]
cmp ebx, edx
jae @f
mov edx, ebx
@@: mov [img_pix_y], edx
 
.calculate_lfb_origin:
mov edi, ecx ; ecx = absY
imul edi, [BytesPerScanLine]
mov eax, [img_screen_x] ; eax = absX
lea edi, [edi+eax*4]
add edi, LFB_BASE ; edi -> Screen origin
mov [img_lfb_origin], edi
.calculate_map_origin:
xor ebx, ebx
mov bl, byte [img_bytes_per_pix]
or bl, bl
jnz @f
bts ebx, 25
@@: mov bl, byte [CURRENT_TASK] ; get process number
mov ebp, ecx ; ecx = absY
shr ebp, 1 ; CF= odd line
jnc @f
bts ebx, 24 ; ebx[24] = odd start line
@@: imul ebp, [_WinMapWidth]
add ebp, [_WinMapAddress]
mov ecx, eax ; eax = absX
shr ecx, 2
add eax, [img_pix_x]
shr eax, 2
add eax, ebp
mov [img_map_right], eax ; right edge tile
add ebp, ecx ; left edge Map origin
mov ecx, [img_pix_y]
sub eax, ebp
jz .thin_bar ; special case: all image is 1 tile thick
mov [img_map_x], eax ; tiles in row (excluding the right one)
 
; ----- at this point:
; esi = [img_buf_origin] -> buffered image
; edi = [img_lfb_origin] -> LFB image (corner point, 0RGB format)
; ebp -> corner tile position
; ecx = [img_pix_y] = image height
; bl = task #
; ebx[24] = 1 if the core Y is odd
; ebx[25] = 1bpp image
 
.start:
bt ebx, 25
jnc @f
xor eax, eax
inc al
mov [img_bitoffset], eax ; 1bpp image must be byte-aligned
mov [img_edgeoffset], eax
@@:
mov edx, edi
and edx, 0x0C
jz .go_right ; left edge already aligned
.left_edge:
mov dh, 0x0C
sub dh, dl
movzx edx, dh
call draw_unaligned_edge
dec [img_map_x]
shr edi, 4
inc edi ; align edi to the next 16-byte tile
shl edi, 4
mov [img_lfb_origin], edi ; core Screen origin
shr edx, 2
inc edx
sub [img_pix_x], edx ; shrink image width
bt ebx, 25
jnc @f
xchg dl, cl
mov eax, [img_edgeoffset] ; that's for 1bpp images only
shl eax, cl
mov [img_edgeoffset], eax
mov [img_bitoffset], eax
xchg dl, cl
@@: mov eax, edx
imul eax, [img_bytes_per_pix] ; 0 for 1bbp bitmaps
add esi, eax
mov [img_buf_origin], esi ; core Buffer origin
inc ebp ; core Map origin
.go_right:
mov eax, [img_map_x]
mov edx, eax
bt ebx, 25 ; 1bpp image ?
jc .shift_mono
shl eax, 2
imul eax, [img_bytes_per_pix]
jmp .get_right
.shift_mono:
shr eax, 1 ; 2 tiles = 1 byte Buffer offset
jnc .get_right
rol byte [img_edgeoffset], 4 ; odd number of tiles: shift 4bits
.get_right:
add esi, eax ; rightEdge Buffer origin
push ebp
add ebp, edx ; rightEdge Map origin
mov eax, [img_pix_x]
shl eax, 2 ; 1 pix = 4 bytes
add eax, edi ; rightEdge last pix (LFB addr)
movzx edx, al
and dl, 0x0C
jz .core_block ; rightEdge is already tile-aligned
and al, 0xF0
mov edi, eax ; rightEdge Screen origin
.right_edge:
call draw_unaligned_edge
dec [img_map_x]
.core_block:
pop ebp
mov eax, [img_map_x]
or eax, eax ; empty central core?
jz .finish
mov edi, [img_lfb_origin]
mov esi, [img_buf_origin]
call draw_aligned_box
.finish:
add esp, putimg.stack_data
; call [_display.enable_mouse]
popad
ret
 
.thin_bar: ; < a special case > : one-tile-wide image
mov edx, [img_pix_x]
shl edx, 2 ; edx = rightmost tile offset (0, 4, 8, or 12 bytes)
call draw_unaligned_edge
jmp .finish
 
 
align 64
img_test_struct:
dd 0x00112233, 0x00223344, 0x00334455, 0x00445566
dd 0x00223344, 0x00334455, 0x00445566, 0x00334455
dd 0x00334455, 0x00445566, 0x00334455, 0x00223344
dd 0x00445566, 0x00334455, 0x00223344, 0x00112233
 
;**************************************************************************************
align 4
__sys_putpixel:
_putpixel:
 
; eax = x coordinate
; ebx = y coordinate
; ecx = ?? RR GG BB ; 0x01000000 negation
; edi = 0x00000001 force
 
cmp [Screen_Max_X], eax
jb .exit0
cmp [Screen_Max_Y], ebx
jb .exit0
.check_forced:
test edi,1 ; force ?
jnz .checked
 
.not_forced:
push ebx eax
shr eax, 1
shr eax, 1
shr ebx, 1
imul ebx, [_WinMapWidth] ; win_map (X size)/2
add ebx, eax
mov al, byte [CURRENT_TASK]
mov bl, byte [_WinMapAddress+ebx]
cmp bl, al
pop eax ebx
jne .exit0
.checked:
push ebx
imul ebx, [BytesPerScanLine]
lea ebx, [ebx+eax*4]
bt ecx, 24
jnc .noneg
mov ecx, [LFB_BASE+ebx]
xor ecx, 0x00FFFFFF
.noneg:
mov [LFB_BASE+ebx], ecx
pop ebx
.exit0:
ret
 
 
 
align 4
put_pixel: ; left for compatibility with Vesa20_putpixel32
; eax = x
; ebx = y
imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier
lea edi, [ebx+eax*4] ; edi = x*4+(y*y multiplier)
; mov eax, [esp+32-8+4] ; eax = color
mov [LFB_BASE+edi], ecx
ret
 
 
; DRAWLINE
 
align 4
__sys_draw_line:
call [_display.disable_mouse]
 
; draw a line
; eax = HIWORD = x1
; LOWORD = x2
; ebx = HIWORD = y1
; LOWORD = y2
; ecx = color
; edi = force ?
pusha
 
dl_x1 equ esp+20
dl_y1 equ esp+16
dl_x2 equ esp+12
dl_y2 equ esp+8
dl_dx equ esp+4
dl_dy equ esp+0
 
xor edx, edx ; clear edx
xor esi, esi ; unpack arguments
xor ebp, ebp
mov si, ax ; esi = x2
mov bp, bx ; ebp = y2
shr eax, 16 ; eax = x1
shr ebx, 16 ; ebx = y1
push eax ; save x1
push ebx ; save y1
push esi ; save x2
push ebp ; save y2
 
; checking x-axis...
sub esi, eax ; esi = x2-x1
push esi ; save y2-y1
jl .x2lx1 ; is x2 less than x1 ?
jg .no_vline ; x1 > x2 ?
mov edx, ebp ; else (if x1=x2)
call vline
push edx ; necessary to rightly restore stack frame at .exit
jmp .exit
.x2lx1:
neg esi ; get esi absolute value
.no_vline:
; checking y-axis...
sub ebp, ebx ; ebp = y2-y1
push ebp ; save y2-y1
jl .y2ly1 ; is y2 less than y1 ?
jg .no_hline ; y1 > y2 ?
mov edx, [dl_x2] ; else (if y1=y2)
call hline
jmp .exit
 
.y2ly1:
neg ebp ; get ebp absolute value
.no_hline:
cmp ebp, esi
jle .x_rules ; |y2-y1| < |x2-x1| ?
cmp [dl_y2], ebx ; make sure y1 is at the begining
jge .no_reverse1
neg dword [dl_dx]
mov edx, [dl_x2]
mov [dl_x2], eax
mov [dl_x1], edx
mov edx, [dl_y2]
mov [dl_y2], ebx
mov [dl_y1], edx
.no_reverse1:
mov eax, [dl_dx]
cdq ; extend eax sing to edx
shl eax, 16 ; using 16bit fix-point maths
idiv ebp ; eax = ((x2-x1)*65536)/(y2-y1)
mov edx, ebp ; edx = counter (number of pixels to draw)
mov ebp, 1 *65536 ; <<16 ; ebp = dy = 1.0
mov esi, eax ; esi = dx
jmp .y_rules
 
.x_rules:
cmp [dl_x2], eax ; make sure x1 is at the begining
jge .no_reverse2
neg dword [dl_dy]
mov edx, [dl_x2]
mov [dl_x2], eax
mov [dl_x1], edx
mov edx, [dl_y2]
mov [dl_y2], ebx
mov [dl_y1], edx
.no_reverse2:
xor edx, edx
mov eax, [dl_dy]
cdq ; extend eax sing to edx
shl eax, 16 ; using 16bit fix-point maths
idiv esi ; eax = ((y2-y1)*65536)/(x2-x1)
mov edx, esi ; edx = counter (number of pixels to draw)
mov esi, 1 *65536 ;<< 16 ; esi = dx = 1.0
mov ebp, eax ; ebp = dy
.y_rules:
mov eax, [dl_x1]
mov ebx, [dl_y1]
shl eax, 16
shl ebx, 16
align 4
.draw:
push eax ebx
shr eax, 16
shr ebx, 16
call _putpixel
pop ebx eax
add ebx, ebp ; y = y+dy
add eax, esi ; x = x+dx
dec edx
jnz .draw
; force last drawn pixel to be at (x2,y2)
mov eax, [dl_x2]
mov ebx, [dl_y2]
call _putpixel
.exit:
add esp, 6*4
popa
call [draw_pointer] ; mouse
ret
 
align 4
hline:
; ------------ draw a horizontal line -------------
; eax = x1
; edx = x2
; ebx = y
; ecx = color
; edi = force ?
cmp ebx, [Screen_Max_Y]
jge .out
pushad
 
bt ecx, 24 ; color inversion check
rcl edi,1 ; forced graphics check
 
mov ebp, ebx
shr ebp, 1
imul ebp, [_WinMapWidth] ; ebp = screen map base
add ebp, [_WinMapAddress]
 
cmp edx, eax ; to make sure x2 > x1
jge @f
xchg eax, edx
@@:
cmp eax, [Screen_Max_X]
jge .exit
 
mov esi, eax
shr esi, 4
add ebp, esi ; ebp -> win_map element
 
imul ebx, [BytesPerScanLine] ; ebx -> LFB pix_line
add ebx, LFB_BASE
 
cmp edx, [Screen_Max_X] ; last check
jb @f
mov edx, [Screen_Max_X]
 
@@: mov esi, ecx ; store color here
mov cl, byte [CURRENT_TASK] ;
mov ch, cl
mov [CURRENT_TASK+2], cx
mov [CURRENT_TASK+1], cl ; replicate byte to dword
 
.newsegment:
mov ecx, [ebp] ; check the line segment (16 pixels!)
xor ecx, [CURRENT_TASK]
; -- the line ---
jmp dword [hline.drawtable + edi*4] ; a coolhack (C) Serge
 
 
align 4 ; internal loop
.invert_color:
mov esi, [ebx+eax*4]
xor esi, 0x00FFFFFF
align 4
.check_overlap:
or cl, cl
jz .putpixel
jmp .nextpixel
align 4
.invert_force:
mov esi, [ebx+eax*4]
xor esi, 0x00FFFFFF
align 4
.putpixel:
mov [ebx+eax*4], esi
align 4
.nextpixel:
inc eax
cmp eax, edx
ja .exit ; line drawn -- exit all loops
test al, 3
jz .newtile
.newpixel:
jmp dword [hline.drawtable + edi*4] ; the internal loop
.newtile:
inc ebp
test ebp, 3
jz .newsegment ; the external loop
shr ecx, 8
jmp dword [hline.drawtable + edi*4]
 
.exit:
mov eax, 0x0FF
and [CURRENT_TASK], eax
popad
.out:
ret
align 4
.drawtable:
dd .check_overlap ; general case
dd .invert_color
dd .putpixel ; force to draw it
dd .invert_force
 
 
align 4
vline:
; --------- draw a vertical line ------------
; eax = x
; ebx = y1
; edx = y2
; ecx = color
; edi = force ?
cmp eax, [Screen_Max_X]
jge .out
pushad
bt ecx, 24 ; color inversion check
rcl edi, 1 ; forced graphics check
 
cmp edx, ebx ; to make sure y2 > y1
jge @f
xchg ebx, edx
@@:
cmp ebx, [Screen_Max_Y]
jge .exit
mov ebp, ebx
shr ebp, 1
imul ebp, [_WinMapWidth]
add ebp, [_WinMapAddress]
mov esi, eax
shr esi, 1
shr esi, 1
add ebp, esi ; ebp = screen map at (x, y1)
push ebx
 
imul ebx, [BytesPerScanLine]
shl eax, 1
shl eax, 1
add eax, ebx
add eax, LFB_BASE
pop ebx ; restore ebx = y1
cmp edx, [Screen_Max_Y] ; the last check
jb .draw
mov edx, [Screen_Max_Y] ; to prevent off-screen drawing
 
.draw:
jmp dword [vline.drawtable + edi*4]
align 4
.invert_color:
mov ecx, [eax]
xor ecx, 0x00FFFFFF
align 4
.check_overlap:
movzx esi, byte [ebp]
cmp esi, [CURRENT_TASK]
je .putpixel
jmp .nextpixel
 
align 4
.invert_force:
mov ecx, [eax]
xor ecx, 0x00FFFFFF
align 4
.putpixel:
mov [eax], ecx
align 4
.nextpixel:
add eax, [BytesPerScanLine]
inc ebx
test bl, 1
jnz @f
add ebp, [_WinMapWidth]
@@:
cmp ebx, edx
ja .exit
jmp dword [vline.drawtable + edi*4]
.exit:
shr edi, 1
popad
 
.out:
ret
align 4
.drawtable:
dd .check_overlap ; general case
dd .invert_color
dd .putpixel ; force to draw it
dd .invert_force
 
 
;*************************************************
 
 
virtual at esp
drbar:
.bar_sx dd ?
.bar_sy dd ?
.bar_cx dd ?
.bar_cy dd ?
.abs_cx dd ?
.abs_cy dd ?
.real_sx dd ?
.real_sy dd ?
.color dd ?
.line_inc_scr dd ?
.line_inc_map dd ?
.stack_data = 4*11
end virtual
 
align 4
; eax cx
; ebx cy
; ecx xe
; edx ye
; edi color
vesa20_drawbar:
pushad
call [_display.disable_mouse]
sub esp, drbar.stack_data
mov [drbar.color], edi
sub edx, ebx
jle .exit
sub ecx, eax
jle .exit
mov [drbar.bar_sy], edx
mov [drbar.bar_sx], ecx
mov [drbar.bar_cx], eax
mov [drbar.bar_cy], ebx
mov edi, [TASK_BASE]
add eax, [edi-twdw + WDATA.box.left] ; win_cx
add ebx, [edi-twdw + WDATA.box.top] ; win_cy
mov [drbar.abs_cx], eax
mov [drbar.abs_cy], ebx
; real_sx = MIN(wnd_sx-bar_cx, bar_sx);
mov ebx, [edi-twdw + WDATA.box.width] ; ebx = wnd_sx
; note that WDATA.box.width is one pixel less than real window x-size
inc ebx
sub ebx, [drbar.bar_cx]
ja @f
.exit:
add esp, drbar.stack_data
popad
xor eax, eax
inc eax
ret
@@:
cmp ebx, [drbar.bar_sx]
jbe .end_x
mov ebx, [drbar.bar_sx]
.end_x:
mov [drbar.real_sx], ebx
; real_sy = MIN(wnd_sy-bar_cy, bar_sy);
mov ebx, [edi-twdw + WDATA.box.height] ; ebx = wnd_sy
inc ebx
sub ebx, [drbar.bar_cy]
ja @f
add esp, drbar.stack_data
popad
xor eax, eax
inc eax
ret
@@:
cmp ebx, [drbar.bar_sy]
jbe .end_y
mov ebx, [drbar.bar_sy]
.end_y:
mov [drbar.real_sy], ebx
; line_inc_map
mov eax, [Screen_Max_X]
sub eax, [drbar.real_sx]
inc eax
shr eax, 1 ; <<<<<<
shr eax, 1
mov [drbar.line_inc_map], eax ; vertical increment: map
; line_inc_scr
mov eax, [drbar.real_sx]
shl eax, 1
shl eax, 1
neg eax
add eax, [BytesPerScanLine]
mov [drbar.line_inc_scr], eax ; vertical increment: screen
; pointer to screen
mov edx, [drbar.abs_cy]
mov ebx, edx
imul edx, [BytesPerScanLine] ; edx = LFB line offset
mov eax, [drbar.abs_cx]
shl eax, 1
shl eax, 1
add edx, eax ; edx = LFB corner offset
; pointer to pixel map
shr ebx, 1
imul ebx, [_WinMapWidth] ; eax = Wmap corner pos
mov eax, [drbar.abs_cx]
shr eax, 1
shr eax, 1
add eax, ebx
add eax, [_WinMapAddress]
xchg eax, ebp ; ebp = Wmap corner
; get process number
mov ebx, [CURRENT_TASK]
 
; eax - RGB-color
; bl - process num
; ecx - pix counter (in a tile)
; edx - pointer to screen
; esi - counter
; edi - counter
 
mov eax, [drbar.color] ;; BBGGRR00
mov esi, 0
align 4
.new_y:
mov edi, [drbar.real_sx]
movzx ecx, dl
shr cl, 2 ; pix# = edx/4
and cl, 3 ; pix position in a tile
.new_tile:
cmp byte [ebp], bl
jne .skip
.new_x:
mov [LFB_BASE+edx], eax
add edx, 4
dec edi
jz .add_line
inc cl
and cl, 3
jnz .new_x
jmp .new_tile
.skip:
add edx, 4*4
and dl, 0xF0 ; LFB align 16
inc ebp
sub edi, 4 ; <<<<<
add edi, ecx ; left tile may be 1,2 or 3px only
jae .new_tile
 
.add_line:
add edx, [drbar.line_inc_scr]
; gradient-filled bars
test eax, 0x80000000
jz @f
test al, al
jz @f
dec al
@@:
inc esi
test esi, 1
jne @f
add ebp, [drbar.line_inc_map]
@@:
cmp esi, [drbar.real_sy]
jbe .new_y
add esp, drbar.stack_data
popad
xor eax, eax
ret
 
 
align 4
;drawbackground:
call [_display.disable_mouse]
pushad
; External loop for all y from start to end
mov ebx, [draw_data+32+RECT.top] ; y start
.fill_line:
mov edi, [draw_data+32+RECT.left] ; x start
shl edi, 1
shl edi, 1
mov eax, [BytesPerScanLine]
mul ebx
xchg edi, eax
add edi, eax
add edi, LFB_BASE
 
mov ebp, ebx
shr ebp, 1
imul ebp, [_WinMapWidth]
mov edx, eax
shr edx, 1
shr edx, 1
add ebp, edx
add ebp, [_WinMapAddress]
xor edx, edx
inc edx
mov esi, 0x0336677 ; <<< RGB
; eax = x, ebx = y (screen coordinates)
; ecx - aux. var
; edx = 1
; esi = 0RGB, edi -> output
; ebp = offset in WinMapAddress
.fill_tile:
cmp [ebp], dl
jnz .next_tile
mov [edi], esi
mov [edi+4], esi
mov [edi+8], esi
mov [edi+12],esi
mov ecx, [BytesPerScanLine]
mov [ecx+edi], esi
mov [ecx+edi+4], esi
mov [ecx+edi+8], esi
mov [ecx+edi+12],esi
.next_tile:
add edi, 4*4
add ebp, edx
add ax, 4
mov ecx, [draw_data+32+RECT.right]
shr ecx, 1
shr ecx, 1
cmp eax, ecx
jbe .fill_tile
 
.next_line:
inc ebx
mov ecx, [draw_data+32+RECT.bottom]
shr ecx, 1
jbe .fill_line
popad
ret
 
; ----------
 
 
drawbackground_stretch: ; left for future development
call drawbackground
ret
drawbackground_tiled: ; left for future development
call drawbackground
ret
 
uglobal
align 4
bgr_cur_line rd 1920 ; maximum width of screen
bgr_next_line rd 1920
endg
 
smooth_line:
mov al, [esi+2]
shl eax, 16
mov ax, [esi]
test ecx, ecx
jz @f
mov ebx, [esi+2]
shr ebx, 8
call [overlapping_of_points_ptr]
@@:
stosd
mov eax, [esp+20+8]
inc eax
mov [esp+20+8], eax
cmp eax, [draw_data+32+RECT.right]
ja @f
add ecx, [esp+36+8]
mov eax, edx
adc edx, [esp+40+8]
sub eax, edx
lea eax, [eax*3]
sub esi, eax
jmp smooth_line
@@:
mov eax, [draw_data+32+RECT.left]
mov [esp+20+8], eax
ret
 
align 16
overlapping_of_points:
push ecx edx
mov edx, eax
push esi
shr ecx, 26
mov esi, ecx
mov ecx, ebx
shl esi, 9
movzx ebx, dl
movzx eax, cl
sub eax, ebx
movzx ebx, dh
add dl, [BgrAuxTable+(eax+0x100)+esi]
movzx eax, ch
sub eax, ebx
add dh, [BgrAuxTable+(eax+0x100)+esi]
ror ecx, 16
ror edx, 16
movzx eax, cl
movzx ebx, dl
sub eax, ebx
add dl, [BgrAuxTable+(eax+0x100)+esi]
pop esi
mov eax, edx
pop edx
ror eax, 16
pop ecx
ret
 
iglobal
align 4
overlapping_of_points_ptr dd overlapping_of_points
endg
 
init_background:
mov edi, BgrAuxTable
xor edx, edx
.loop2:
mov eax, edx
shl eax, 8
neg eax
mov ecx, 0x200
.loop1:
mov byte [edi], ah
inc edi
add eax, edx
loop .loop1
add dl, 4
jnz .loop2
test byte [cpu_caps+(CAPS_MMX/8)], 1 shl (CAPS_MMX mod 8)
jz @f
mov [overlapping_of_points_ptr], overlapping_of_points_mmx
@@:
ret
 
align 16
overlapping_of_points_mmx:
movd mm0, eax
movd mm4, eax
movd mm1, ebx
pxor mm2, mm2
punpcklbw mm0, mm2
punpcklbw mm1, mm2
psubw mm1, mm0
movd mm3, ecx
psrld mm3, 24
packuswb mm3, mm3
packuswb mm3, mm3
pmullw mm1, mm3
psrlw mm1, 8
packuswb mm1, mm2
paddb mm4, mm1
movd eax, mm4
ret
diff16 "GRAPH32 code end ",0,$
diff10 "GRAPH32 code size",get_pixel,$