WebSVN – Kolibri OS – Diff – /programs/system/cpu/trunk/cpu.asm


;
;   PROCESS MANAGEMENT
;
;   VTurjanmaa
;   additions by M.Lisovin lisovin@26.ru
;   integrated with load_lib.obj by 
;   Compile with FASM for Menuet
;
 
  use32
  org    0x0
STACK_SIZE=1024
offset_y=22
offset_x=5
  db     'MENUET01'              ; 8 byte id
  dd     0x01                    ; header version
  dd     START                   ; start of code
  dd     I_END                   ; size of image
  dd     U_END+STACK_SIZE        ; memory for app
  dd     U_END+STACK_SIZE        ; esp
  dd     0x0 , 0x0               ; I_Param , I_Icon
 
include 'lang.inc'
include '../../../macros.inc'
include '../../../develop/libraries/box_lib/asm/trunk/editbox_ex.mac'
include '../../../develop/libraries/box_lib/load_lib.mac'
display_processes=32            ; number of processes to show
@use_library	;use load lib macros
START:                          ; start of execution
 
sys_load_library  library_name, cur_dir_path, library_path, system_path, \
err_message_found_lib, head_f_l, myimport, err_message_import, head_f_i
        inc     eax
        jz      close
; calculate window position
; at the center of the screen
    call calculate_window_pos
    
;main loop when process name isn't edited.    
red:    
        mcall   48,3,sc,40
        edit_boxes_set_sys_color edit1,edit1_end,sc
	xor	ebp,ebp
	inc	ebp
;    mov  ebp,1
    call draw_window            ; redraw all window
align 16
still:
    mov  eax,23                 ; wait here for event
    mov  ebx,100                ; 2 sec.
    mcall
 
    dec  eax                  ; redraw request ?
    jz   red
    dec  eax                  ; key in buffer ?
    jz   key
    dec  eax                  ; button in buffer ?
    jz   button
 
        push    dword edit1
        call    [edit_box_mouse]
 
 
still_end:    
    xor  ebp,ebp                ; draw new state of processes
    call draw_window
    jmp  still
 
 
  key:                          ; key
    mov  eax,2                  
    mcall
 
    cmp  ah,184                 ; PageUp
    je   pgdn
    cmp  ah,183
    je   pgup                   ; PageDown
    cmp  ah,27
    je   close                  ; Esc
 
        push    dword edit1
        call    [edit_box_key]
 
    jmp  still_end
 
  button:                       
; get button id  
    mov  eax,17                 
    mcall
    shr  eax,8                  
 
;id in [10,50] corresponds to terminate buttons.
    cmp  eax,10
    jb   noterm                 
    cmp  eax,50
    jg   noterm
 
;calculate button index        
    sub  eax,11
    
;calculate process slot    
    mov  ecx,[tasklist+4*eax]
    
;ignore empty buttons
    test ecx,ecx
    jle  still_end
;terminate application    
    mov  eax,18
    mov  ebx,2
    mcall
    jmp  still_end 
 
  noterm:
 
;special buttons
    dec  eax
    jz   close
 
    sub  eax,50
    jz   pgdn     ;51
    dec  eax
    jz   pgup     ;52
;    dec  eax
;    jz   read_string
    dec  eax
    jz   program_start  ;53
    dec  eax
    jz   reboot         ;54
    jmp  still_end
    
;buttons handlers    
 
  pgdn:
    sub  [list_start],display_processes
;    cmp  [list_start],0
    jge  still_end  
    mov  [list_start],0
    jmp  still_end  
 
  pgup:
    mov  eax,[list_add]  ;maximal displayed process slot
    mov  [list_start],eax
    jmp  still_end  
    
  program_start:    
    mov  eax,70
    mov  ebx,file_start
    mcall
    jmp  still_end
    
  reboot:    
    mov  eax,70
    mov  ebx,sys_reboot
    mcall
;close program if we going to reboot
 
  close:
    or   eax,-1                 ; close this program
    mcall
 
draw_next_process:
;input:
;  edi - current slot
;  [curposy] - y position
;output:
;  edi - next slot (or -1 if no next slot)
;registers corrupted!
    
;create button
    test  ebp,ebp
    jnz   .nodelete
;delete old button
    mov   eax,8
    mov   edx,[index]
    add   edx,(1 shl 31)+11
    mcall
 
.nodelete:
;create terminate process button
    mov   eax,8
    mov   ebx,(15-offset_x)*65536+100-offset_y
    mov   ecx,[curposy]
    shl   ecx,16
    mov   cx,10
    mov   edx,[index]
    add   edx,11
    mov   esi,0xaabbcc
;contrast    
    test  dword [index],1
    jz    .change_color_button
    mov   esi,0x8899aa
 
.change_color_button:
    mcall
    
;draw background for proccess information
    mov   eax,13
    mov   ebx,(115-offset_x)*65536+395
    ;ecx was already set
    mov   edx,0x88ff88
;contrast
    test  dword [index],1
    jz    .change_color_info
    mov   edx,0xddffdd
 
.change_color_info:
    mcall
    
;nothing else should be done
;if there is no process for this button    
    test  edi,edi
    jl    .ret
    
;find process
    inc   edi
;more comfortable register for next loop    
    mov   ecx,edi
;precacluate pointer to process buffer    
    mov   ebx,process_info_buffer
    
;find process loop
 
.find_loop:
    cmp   ecx,256
    jge   .no_processes
    
;load process information in buffer
    mov   eax,9
;    mov   ebx,process_info_buffer
    mcall
    
;if current slot greater than maximal slot,
;there is no more proccesses.    
    cmp   ecx,eax
    jg    .no_processes
    
;if slot state is equal to 9, it is empty.    
    cmp   [process_info_buffer+process_information.slot_state],9
    jnz   .process_found
    
    inc   ecx
    jmp   .find_loop
    
.no_processes:
    or   edi,-1
    ret
    
.process_found:
    mov  edi,ecx
    mov  [list_add],ecx
    
;get processor cpeed    
;for percent calculating
    mov  eax,18
    mov  ebx,5
    mcall
    
    xor  edx,edx
    mov  ebx,100
    div ebx
    
;eax = number of operation for 1% now
;calculate process cpu usage percent
    mov  ebx,eax
    mov  eax,[process_info_buffer+process_information.cpu_usage]
;    cdq
    xor edx,edx ; for CPU more 2 GHz - mike.dld 
 
    div  ebx
    mov  [cpu_percent],eax
    
;set text color to display process information
;([tcolor] variable)
;0%      : black    
;1-80%   : green
;81-100% : red
    test eax,eax
    jg   .no_black
    mov  [tcolor],eax
    jmp  .color_set
 
.no_black:   
    cmp  eax,80
    ja   .no_green
    mov  dword [tcolor],0x107a30
    jmp  .color_set
 
.no_green:
    mov  dword [tcolor],0xac0000
.color_set:
 
;show slot number
    mov  eax,47                
    mov  ebx,2*65536+1*256
;ecx haven't changed since .process_found    
;    mov  ecx,edi
    mov  edx,[curposy]
    add  edx,(20-offset_x)*65536+1
    mov  esi,[tcolor]
    mcall
    
;show process name
    mov  eax,4
    mov  ebx,[curposy]
    add  ebx,(50-offset_x)*65536+1
    mov  ecx,[tcolor]
    mov  edx,process_info_buffer.process_name
    mov  esi,11
    mcall
    
;show pid
    mov  eax,47
    mov  ebx,8*65536+1*256
    mov  ecx,[process_info_buffer.PID]
    mov  edx,[curposy]
    add  edx,(130-offset_x)*65536+1
    mov  esi,[tcolor]
    mcall
    
;show cpu usage
    mov  ecx,[process_info_buffer.cpu_usage]
    add  edx,60*65536
    mcall
    
;show cpu percent
    mov  ebx,3*65536+0*256
    mov  ecx,[cpu_percent]
    add  edx,60*65536
    mcall
    
;show memory start - obsolete
    mov  ebx,8*65536+1*256
    mov  ecx,[process_info_buffer.memory_start]
    add  edx,30*65536
    mcall
    
;show memory usage
    mov  ecx,[process_info_buffer.used_memory]
    inc  ecx
    add  edx,60*65536
    mcall
    
;show window stack and value
    mov  ecx,dword [process_info_buffer.window_stack_position]
    add  edx,60*65536
    mcall
    
;show window xy size
    mov  ecx,[process_info_buffer.box.left]
    shl  ecx,16
    add  ecx,[process_info_buffer.box.top]
    add  edx,60*65536
    mcall    
            
.ret:
;build index->slot map for terminating processes.
    mov  eax,[index]
    mov  [tasklist+4*eax],edi        
    ret
 
;read_string:
;clean string
;    mov  edi,start_application
;    xor  eax,eax
;    mov  ecx,60
;    cld
;    rep  stosb
;    call print_text
 
;    mov  edi,start_application
;edi now contains pointer to last symbol       
;    jmp  still1
 
;read string main loop
 
  f11:
;full update  
    push edi
	xor	ebp,ebp
	inc	ebp
;    mov  ebp,1
    call draw_window
    pop  edi
;
;  still1:  
;wait for message  
;    mov  eax,23
;    mov  ebx,100
;    mcall
;    cmp  eax,1
;    je   f11
;if no message - update process information    
;    cmp  eax,0
;    jnz  .message_received
;    push edi                ;edi should be saved since draw_window
;    xor  ebp,ebp            ;corrupt registers
;    call draw_window
;    pop  edi
;    jmp  still1
;    
;.message_received:
;    cmp  eax,2
;    jne  read_done          ;buttons message
;read char    
;    mov  eax,2
;    mcall
;    shr  eax,8
    
;if enter pressed, exit read string loop    
;    cmp  eax,13
;    je   read_done
;if backslash pressed?    
;    cmp  eax,8
;    jnz  nobsl
;decrease pointer to last symbol    
;    cmp  edi,start_application
;    jz   still1
;    dec  edi
;fill last symbol with space because
;print_text show all symbols    
;    mov  [edi],byte 32
;    call print_text
;    jmp  still1
;    
;  nobsl:
;write new symbol  
;    mov  [edi],al
;display new text
;    call print_text
;increment pointer to last symbol
;    inc  edi
;compare with end of string    
;    mov  esi,start_application
;    add  esi,60
;    cmp  esi,edi
;    jnz  still1
 
;exiting from read string loop
;
;  read_done:
;terminate string for file functions
;    mov  [edi],byte 0
 
;    call print_text
;    jmp  still
 
;
;print_text:
;display start_application string
 
;    pushad
    
;display text background
;    mov  eax,13
;    mov  ebx,64*65536+62*6
;    mov  ecx,400*65536+12
;    mov  edx,0xffffcc  ;0xeeeeee
;    mcall
    
;display text    
;    mov  eax,4                  
;    mov  edx,start_application  ;from start_application string
;    mov  ebx,70*65536+402       ;text center-aligned
;    xor  ecx,ecx                ;black text
;    mov  esi,60                 ;60 symbols
;    mcall
 
;    popad
;    ret
 
window_x_size=524
window_y_size=430
 
calculate_window_pos:
;set window size and position for 0 function
;to [winxpos] and [winypos] variables
 
;get screen size
    mov  eax,14
    mcall
    mov  ebx,eax
    
;calculate (x_screen-window_x_size)/2    
    shr  ebx,16+1
    sub  ebx,window_x_size/2
    shl  ebx,16
    mov  bx,window_x_size
;winxpos=xcoord*65536+xsize    
    mov  [winxpos],ebx
    
;calculate (y_screen-window_y_size)/2    
    and  eax,0xffff
    shr  eax,1
    sub  eax,window_y_size/2
    shl  eax,16
    mov  ax,window_y_size
;winypos=ycoord*65536+ysize    
    mov  [winypos],eax
    
    ret
 
;   *********************************************
;   *******  WINDOW DEFINITIONS AND DRAW ********
;   *********************************************
 
align 16
draw_window:
;ebp=1 - redraw all
;ebp=0 - redraw only process information
 
    test ebp,ebp
    jz   .show_process_info
    
    mov  eax,12                    ; function 12:tell os about windowdraw
;    mov  ebx,1                     ; 1, start of draw
    xor	 ebx,ebx
    inc  ebx
    mcall                      
 
                                   ; DRAW WINDOW
    xor  eax,eax                   ; function 0 : define and draw window
    mov  ebx,[winxpos]             ; [x start] *65536 + [x size]
    mov  ecx,[winypos]             ; [y start] *65536 + [y size]
    mov  edx,0x34ddffdd  ;ffffff   ; color of work area RRGGBB,8->color
    mov  edi,title                ; WINDOW CAPTION;
    mcall
 
                                   
    add  eax,4                     ; function 4 : write text to window
    mov  ebx,(22-offset_x)*65536+35-offset_y           ; draw info text with function 4
    xor  ecx,ecx
    mov  edx,text
    mov  esi,text_len
    mcall
 
        push    dword edit1
        call    [edit_box_draw]
 
align 16
.show_process_info:
    mov  edi,[list_start]
    mov  [list_add],edi
    mov  dword [index],0
    mov  dword [curposy],54-offset_y
 
.loop_draw:
    call draw_next_process
    inc  dword [index]
    add  dword [curposy],10
    cmp  [index],display_processes
    jl   .loop_draw
    
    test ebp,ebp
    jz   .end_redraw
    mov  eax,8
    mov  esi,0xaabbcc
                                    
; previous page button
    mov  ebx,(30-offset_x)*65536+96
    mov  ecx,(380-offset_y)*65536+10
    mov  edx,51
    mcall
                                    
; next page button  52
    mov  ebx,(130-offset_x)*65536+96
    inc  edx
    mcall
                              
; ">" (text enter) button
;    mov  ebx,30*65536+20
    add  ecx,20 shl 16
;    inc  edx
;    mcall
                                    
; run button 53
    mov  ebx,(456-offset_x)*65536+50
    inc  edx
    mcall
 
; reboot button    
    sub  ebx,120*65536              
    add  ebx,60
    sub  ecx,20 shl 16
    inc  edx
    mcall
    
;"PREV PAGE", "NEXT PAGE" and "REBOOT" labels
    mov  eax,4
    mov  ebx,(50-offset_x)*65536+382-offset_y
    xor  ecx,ecx
    mov  edx,tbts
    mov  esi,tbte-tbts
    mcall
 
;">" labels
;    mov  eax,4
;    mov  ebx,40*65536+402
;    xor  ecx,ecx
;    mov  edx,tbts_2
;    mov  esi,1
;    mcall
 
;"RUN" labels
;    mov  eax,4
    mov  ebx,(475-offset_x)*65536+402-offset_y
    xor  ecx,ecx
    mov  edx,tbts_3
    mov  esi,tbte_2-tbts_3
    mcall
 
;print application name in text box
;    call print_text
 
    mov  eax,12                    ; function 12:tell os about windowdraw
    mov  ebx,2                     ; 2, end of draw
    mcall
    
.end_redraw:
    ret
 
 
; DATA AREA
system_path      db '/sys/lib/'
library_name     db 'box_lib.obj',0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
err_message_found_lib   db 'Sorry I cannot load library box_lib.obj',0
head_f_i:
head_f_l        db 'System error',0
err_message_import      db 'Error on load import library box_lib.obj',0
 
myimport:   
 
edit_box_draw   dd      aEdit_box_draw
edit_box_key    dd      aEdit_box_key
edit_box_mouse  dd      aEdit_box_mouse
;version_ed      dd      aVersion_ed
 
;check_box_draw  dd      aCheck_box_draw
;check_box_mouse dd      aCheck_box_mouse
;version_ch      dd      aVersion_ch
 
;option_box_draw  dd      aOption_box_draw
;option_box_mouse dd      aOption_box_mouse
;version_op       dd      aVersion_op
 
                dd      0
                dd      0
 
aEdit_box_draw  db 'edit_box',0
aEdit_box_key   db 'edit_box_key',0
aEdit_box_mouse db 'edit_box_mouse',0
;aVersion_ed     db 'version_ed',0
 
;aCheck_box_draw  db 'check_box_draw',0
;aCheck_box_mouse db 'check_box_mouse',0
;aVersion_ch      db 'version_ch',0
 
;aOption_box_draw  db 'option_box_draw',0
;aOption_box_mouse db 'option_box_mouse',0
;aVersion_op       db 'version_op',0
 
edit1 edit_box 350,(64-offset_x),(398-offset_y),0xffffff,0x6f9480,0,0xAABBCC,0,start_application_c,start_application,mouse_dd,ed_focus,start_application_e,start_application_e
edit1_end:
list_start  dd 0
 
sys_reboot:
            dd 7
            dd 0
            dd 0
            dd 0
            dd 0
            db '/sys/end',0
 
if lang eq de
text:
  db 'NAME/BEENDEN        PID     CPU-LAST   % '
  db 'SPEICHER START/NUTZUNG  W-STACK  W-SIZE'
text_len = $-text
 
tbts:   db  'SEITE ZURUECK       SEITE VOR                      REBOOT SYSTEM'
tbte:
;tbts_2  db  '>'
tbts_3  db  'START'
tbte_2:
 
title  db   'Prozesse  - Ctrl/Alt/Del',0
 
else if lang eq et
text:
  db 'NIMI/LÕPETA         PID    CPU-KASUTUS %   '
  db 'MÄLU ALGUS/KASUTUS  W-PUHVER  W-SUURUS'
text_len = $-text
 
tbts:	db  'EELMINE LEHT   JÄRGMINE LEHT                     REBOODI SÜSTEEM'
tbte:
;tbts_2	db  '>'
tbts_3	db  'START'
tbte_2:
 
title  db   'Protsessid - Ctrl/Alt/Del',0
 
else
text:
  db 'NAME/TERMINATE      PID     CPU-USAGE  %   '
  db 'MEMORY START/USAGE  W-STACK   W-SIZE'
text_len = $-text
 
tbts:   db  'PREV PAGE       NEXT PAGE                         REBOOT SYSTEM'
tbte:
;tbts_2  db  '>'
tbts_3  db  'RUN'
tbte_2:
 
title  db   'Processes - Ctrl/Alt/Del',0
 
end if
file_start: dd 7
            dd 0,0,0,0
start_application: db '/sys/LAUNCHER',0
start_application_e=$-start_application-1
;                   times 60 db 0
rb	60
start_application_c=$-start_application-1
 
I_END:
sc system_colors
winxpos  rd 1
winypos  rd 1
mouse_dd	rd 1
cpu_percent rd 1
tcolor      rd 1
list_add    rd 1
curposy     rd 1
index       rd 1
tasklist    rd display_processes
process_info_buffer process_information
cur_dir_path    rb 1024
library_path    rb 1024
 
U_END:

Rev 1214	Rev 1228
1	;	1	;
2	; PROCESS MANAGEMENT	2	; PROCESS MANAGEMENT
3	;	3	;
4	; VTurjanmaa	4	; VTurjanmaa
5	; additions by M.Lisovin lisovin@26.ru	5	; additions by M.Lisovin lisovin@26.ru
6	; integrated with load_lib.obj by	6	; integrated with load_lib.obj by
7	; Compile with FASM for Menuet	7	; Compile with FASM for Menuet
8	;	8	;
9		9
10	use32	10	use32
11	org 0x0	11	org 0x0
12	STACK_SIZE=1024	12	STACK_SIZE=1024
13	offset_y=22	13	offset_y=22
14	offset_x=5	14	offset_x=5
15	db 'MENUET01' ; 8 byte id	15	db 'MENUET01' ; 8 byte id
16	dd 0x01 ; header version	16	dd 0x01 ; header version
17	dd START ; start of code	17	dd START ; start of code
18	dd I_END ; size of image	18	dd I_END ; size of image
19	dd U_END+STACK_SIZE ; memory for app	19	dd U_END+STACK_SIZE ; memory for app
20	dd U_END+STACK_SIZE ; esp	20	dd U_END+STACK_SIZE ; esp
21	dd 0x0 , 0x0 ; I_Param , I_Icon	21	dd 0x0 , 0x0 ; I_Param , I_Icon
22		22
23	include 'lang.inc'	23	include 'lang.inc'
24	include '../../../macros.inc'	24	include '../../../macros.inc'
25	include '../../../develop/libraries/box_lib/asm/trunk/editbox_ex.mac'	25	include '../../../develop/libraries/box_lib/asm/trunk/editbox_ex.mac'
26	include '../../../develop/libraries/box_lib/load_lib.mac'	26	include '../../../develop/libraries/box_lib/load_lib.mac'
27	display_processes=32 ; number of processes to show	27	display_processes=32 ; number of processes to show
28	@use_library ;use load lib macros	28	@use_library ;use load lib macros
29	START: ; start of execution	29	START: ; start of execution
30		30
31	sys_load_library library_name, cur_dir_path, library_path, system_path, \	31	sys_load_library library_name, cur_dir_path, library_path, system_path, \
32	err_message_found_lib, head_f_l, myimport, err_message_import, head_f_i	32	err_message_found_lib, head_f_l, myimport, err_message_import, head_f_i
33	inc eax	33	inc eax
34	jz close	34	jz close
35	; calculate window position	35	; calculate window position
36	; at the center of the screen	36	; at the center of the screen
37	call calculate_window_pos	37	call calculate_window_pos
38		38
39	;main loop when process name isn't edited.	39	;main loop when process name isn't edited.
40	red:	40	red:
-		41	mcall 48,3,sc,40
-		42	edit_boxes_set_sys_color edit1,edit1_end,sc
41	xor ebp,ebp	43	xor ebp,ebp
42	inc ebp	44	inc ebp
43	; mov ebp,1	45	; mov ebp,1
44	call draw_window ; redraw all window	46	call draw_window ; redraw all window
45	align 16	47	align 16
46	still:	48	still:
47	mov eax,23 ; wait here for event	49	mov eax,23 ; wait here for event
48	mov ebx,100 ; 2 sec.	50	mov ebx,100 ; 2 sec.
49	mcall	51	mcall
50		52
51	dec eax ; redraw request ?	53	dec eax ; redraw request ?
52	jz red	54	jz red
53	dec eax ; key in buffer ?	55	dec eax ; key in buffer ?
54	jz key	56	jz key
55	dec eax ; button in buffer ?	57	dec eax ; button in buffer ?
56	jz button	58	jz button
57		59
58	push dword edit1	60	push dword edit1
59	call [edit_box_mouse]	61	call [edit_box_mouse]
60		62
61		63
62	still_end:	64	still_end:
63	xor ebp,ebp ; draw new state of processes	65	xor ebp,ebp ; draw new state of processes
64	call draw_window	66	call draw_window
65	jmp still	67	jmp still
66		68
67		69
68	key: ; key	70	key: ; key
69	mov eax,2	71	mov eax,2
70	mcall	72	mcall
71		73
72	cmp ah,184 ; PageUp	74	cmp ah,184 ; PageUp
73	je pgdn	75	je pgdn
74	cmp ah,183	76	cmp ah,183
75	je pgup ; PageDown	77	je pgup ; PageDown
76	cmp ah,27	78	cmp ah,27
77	je close ; Esc	79	je close ; Esc
78		80
79	push dword edit1	81	push dword edit1
80	call [edit_box_key]	82	call [edit_box_key]
81		83
82	jmp still_end	84	jmp still_end
83		85
84	button:	86	button:
85	; get button id	87	; get button id
86	mov eax,17	88	mov eax,17
87	mcall	89	mcall
88	shr eax,8	90	shr eax,8
89		91
90	;id in [10,50] corresponds to terminate buttons.	92	;id in [10,50] corresponds to terminate buttons.
91	cmp eax,10	93	cmp eax,10
92	jb noterm	94	jb noterm
93	cmp eax,50	95	cmp eax,50
94	jg noterm	96	jg noterm
95		97
96	;calculate button index	98	;calculate button index
97	sub eax,11	99	sub eax,11
98		100
99	;calculate process slot	101	;calculate process slot
100	mov ecx,[tasklist+4*eax]	102	mov ecx,[tasklist+4*eax]
101		103
102	;ignore empty buttons	104	;ignore empty buttons
103	test ecx,ecx	105	test ecx,ecx
104	jle still_end	106	jle still_end
105	;terminate application	107	;terminate application
106	mov eax,18	108	mov eax,18
107	mov ebx,2	109	mov ebx,2
108	mcall	110	mcall
109	jmp still_end	111	jmp still_end
110		112
111	noterm:	113	noterm:
112		114
113	;special buttons	115	;special buttons
114	dec eax	116	dec eax
115	jz close	117	jz close
116		118
117	sub eax,50	119	sub eax,50
118	jz pgdn ;51	120	jz pgdn ;51
119	dec eax	121	dec eax
120	jz pgup ;52	122	jz pgup ;52
121	; dec eax	123	; dec eax
122	; jz read_string	124	; jz read_string
123	dec eax	125	dec eax
124	jz program_start ;53	126	jz program_start ;53
125	dec eax	127	dec eax
126	jz reboot ;54	128	jz reboot ;54
127	jmp still_end	129	jmp still_end
128		130
129	;buttons handlers	131	;buttons handlers
130		132
131	pgdn:	133	pgdn:
132	sub [list_start],display_processes	134	sub [list_start],display_processes
133	; cmp [list_start],0	135	; cmp [list_start],0
134	jge still_end	136	jge still_end
135	mov [list_start],0	137	mov [list_start],0
136	jmp still_end	138	jmp still_end
137		139
138	pgup:	140	pgup:
139	mov eax,[list_add] ;maximal displayed process slot	141	mov eax,[list_add] ;maximal displayed process slot
140	mov [list_start],eax	142	mov [list_start],eax
141	jmp still_end	143	jmp still_end
142		144
143	program_start:	145	program_start:
144	mov eax,70	146	mov eax,70
145	mov ebx,file_start	147	mov ebx,file_start
146	mcall	148	mcall
147	jmp still_end	149	jmp still_end
148		150
149	reboot:	151	reboot:
150	mov eax,70	152	mov eax,70
151	mov ebx,sys_reboot	153	mov ebx,sys_reboot
152	mcall	154	mcall
153	;close program if we going to reboot	155	;close program if we going to reboot
154		156
155	close:	157	close:
156	or eax,-1 ; close this program	158	or eax,-1 ; close this program
157	mcall	159	mcall
158		160
159	draw_next_process:	161	draw_next_process:
160	;input:	162	;input:
161	; edi - current slot	163	; edi - current slot
162	; [curposy] - y position	164	; [curposy] - y position
163	;output:	165	;output:
164	; edi - next slot (or -1 if no next slot)	166	; edi - next slot (or -1 if no next slot)
165	;registers corrupted!	167	;registers corrupted!
166		168
167	;create button	169	;create button
168	test ebp,ebp	170	test ebp,ebp
169	jnz .nodelete	171	jnz .nodelete
170	;delete old button	172	;delete old button
171	mov eax,8	173	mov eax,8
172	mov edx,[index]	174	mov edx,[index]
173	add edx,(1 shl 31)+11	175	add edx,(1 shl 31)+11
174	mcall	176	mcall
175		177
176	.nodelete:	178	.nodelete:
177	;create terminate process button	179	;create terminate process button
178	mov eax,8	180	mov eax,8
179	mov ebx,(15-offset_x)*65536+100-offset_y	181	mov ebx,(15-offset_x)*65536+100-offset_y
180	mov ecx,[curposy]	182	mov ecx,[curposy]
181	shl ecx,16	183	shl ecx,16
182	mov cx,10	184	mov cx,10
183	mov edx,[index]	185	mov edx,[index]
184	add edx,11	186	add edx,11
185	mov esi,0xaabbcc	187	mov esi,0xaabbcc
186	;contrast	188	;contrast
187	test dword [index],1	189	test dword [index],1
188	jz .change_color_button	190	jz .change_color_button
189	mov esi,0x8899aa	191	mov esi,0x8899aa
190		192
191	.change_color_button:	193	.change_color_button:
192	mcall	194	mcall
193		195
194	;draw background for proccess information	196	;draw background for proccess information
195	mov eax,13	197	mov eax,13
196	mov ebx,(115-offset_x)*65536+395	198	mov ebx,(115-offset_x)*65536+395
197	;ecx was already set	199	;ecx was already set
198	mov edx,0x88ff88	200	mov edx,0x88ff88
199	;contrast	201	;contrast
200	test dword [index],1	202	test dword [index],1
201	jz .change_color_info	203	jz .change_color_info
202	mov edx,0xddffdd	204	mov edx,0xddffdd
203		205
204	.change_color_info:	206	.change_color_info:
205	mcall	207	mcall
206		208
207	;nothing else should be done	209	;nothing else should be done
208	;if there is no process for this button	210	;if there is no process for this button
209	test edi,edi	211	test edi,edi
210	jl .ret	212	jl .ret
211		213
212	;find process	214	;find process
213	inc edi	215	inc edi
214	;more comfortable register for next loop	216	;more comfortable register for next loop
215	mov ecx,edi	217	mov ecx,edi
216	;precacluate pointer to process buffer	218	;precacluate pointer to process buffer
217	mov ebx,process_info_buffer	219	mov ebx,process_info_buffer
218		220
219	;find process loop	221	;find process loop
220		222
221	.find_loop:	223	.find_loop:
222	cmp ecx,256	224	cmp ecx,256
223	jge .no_processes	225	jge .no_processes
224		226
225	;load process information in buffer	227	;load process information in buffer
226	mov eax,9	228	mov eax,9
227	; mov ebx,process_info_buffer	229	; mov ebx,process_info_buffer
228	mcall	230	mcall
229		231
230	;if current slot greater than maximal slot,	232	;if current slot greater than maximal slot,
231	;there is no more proccesses.	233	;there is no more proccesses.
232	cmp ecx,eax	234	cmp ecx,eax
233	jg .no_processes	235	jg .no_processes
234		236
235	;if slot state is equal to 9, it is empty.	237	;if slot state is equal to 9, it is empty.
236	cmp [process_info_buffer+process_information.slot_state],9	238	cmp [process_info_buffer+process_information.slot_state],9
237	jnz .process_found	239	jnz .process_found
238		240
239	inc ecx	241	inc ecx
240	jmp .find_loop	242	jmp .find_loop
241		243
242	.no_processes:	244	.no_processes:
243	or edi,-1	245	or edi,-1
244	ret	246	ret
245		247
246	.process_found:	248	.process_found:
247	mov edi,ecx	249	mov edi,ecx
248	mov [list_add],ecx	250	mov [list_add],ecx
249		251
250	;get processor cpeed	252	;get processor cpeed
251	;for percent calculating	253	;for percent calculating
252	mov eax,18	254	mov eax,18
253	mov ebx,5	255	mov ebx,5
254	mcall	256	mcall
255		257
256	xor edx,edx	258	xor edx,edx
257	mov ebx,100	259	mov ebx,100
258	div ebx	260	div ebx
259		261
260	;eax = number of operation for 1% now	262	;eax = number of operation for 1% now
261	;calculate process cpu usage percent	263	;calculate process cpu usage percent
262	mov ebx,eax	264	mov ebx,eax
263	mov eax,[process_info_buffer+process_information.cpu_usage]	265	mov eax,[process_info_buffer+process_information.cpu_usage]
264	; cdq	266	; cdq
265	xor edx,edx ; for CPU more 2 GHz - mike.dld	267	xor edx,edx ; for CPU more 2 GHz - mike.dld
266		268
267	div ebx	269	div ebx
268	mov [cpu_percent],eax	270	mov [cpu_percent],eax
269		271
270	;set text color to display process information	272	;set text color to display process information
271	;([tcolor] variable)	273	;([tcolor] variable)
272	;0% : black	274	;0% : black
273	;1-80% : green	275	;1-80% : green
274	;81-100% : red	276	;81-100% : red
275	test eax,eax	277	test eax,eax
276	jg .no_black	278	jg .no_black
277	mov [tcolor],eax	279	mov [tcolor],eax
278	jmp .color_set	280	jmp .color_set
279		281
280	.no_black:	282	.no_black:
281	cmp eax,80	283	cmp eax,80
282	ja .no_green	284	ja .no_green
283	mov dword [tcolor],0x107a30	285	mov dword [tcolor],0x107a30
284	jmp .color_set	286	jmp .color_set
285		287
286	.no_green:	288	.no_green:
287	mov dword [tcolor],0xac0000	289	mov dword [tcolor],0xac0000
288	.color_set:	290	.color_set:
289		291
290	;show slot number	292	;show slot number
291	mov eax,47	293	mov eax,47
292	mov ebx,265536+1256	294	mov ebx,265536+1256
293	;ecx haven't changed since .process_found	295	;ecx haven't changed since .process_found
294	; mov ecx,edi	296	; mov ecx,edi
295	mov edx,[curposy]	297	mov edx,[curposy]
296	add edx,(20-offset_x)*65536+1	298	add edx,(20-offset_x)*65536+1
297	mov esi,[tcolor]	299	mov esi,[tcolor]
298	mcall	300	mcall
299		301
300	;show process name	302	;show process name
301	mov eax,4	303	mov eax,4
302	mov ebx,[curposy]	304	mov ebx,[curposy]
303	add ebx,(50-offset_x)*65536+1	305	add ebx,(50-offset_x)*65536+1
304	mov ecx,[tcolor]	306	mov ecx,[tcolor]
305	mov edx,process_info_buffer.process_name	307	mov edx,process_info_buffer.process_name
306	mov esi,11	308	mov esi,11
307	mcall	309	mcall
308		310
309	;show pid	311	;show pid
310	mov eax,47	312	mov eax,47
311	mov ebx,865536+1256	313	mov ebx,865536+1256
312	mov ecx,[process_info_buffer.PID]	314	mov ecx,[process_info_buffer.PID]
313	mov edx,[curposy]	315	mov edx,[curposy]
314	add edx,(130-offset_x)*65536+1	316	add edx,(130-offset_x)*65536+1
315	mov esi,[tcolor]	317	mov esi,[tcolor]
316	mcall	318	mcall
317		319
318	;show cpu usage	320	;show cpu usage
319	mov ecx,[process_info_buffer.cpu_usage]	321	mov ecx,[process_info_buffer.cpu_usage]
320	add edx,60*65536	322	add edx,60*65536
321	mcall	323	mcall
322		324
323	;show cpu percent	325	;show cpu percent
324	mov ebx,365536+0256	326	mov ebx,365536+0256
325	mov ecx,[cpu_percent]	327	mov ecx,[cpu_percent]
326	add edx,60*65536	328	add edx,60*65536
327	mcall	329	mcall
328		330
329	;show memory start - obsolete	331	;show memory start - obsolete
330	mov ebx,865536+1256	332	mov ebx,865536+1256
331	mov ecx,[process_info_buffer.memory_start]	333	mov ecx,[process_info_buffer.memory_start]
332	add edx,30*65536	334	add edx,30*65536
333	mcall	335	mcall
334		336
335	;show memory usage	337	;show memory usage
336	mov ecx,[process_info_buffer.used_memory]	338	mov ecx,[process_info_buffer.used_memory]
337	inc ecx	339	inc ecx
338	add edx,60*65536	340	add edx,60*65536
339	mcall	341	mcall
340		342
341	;show window stack and value	343	;show window stack and value
342	mov ecx,dword [process_info_buffer.window_stack_position]	344	mov ecx,dword [process_info_buffer.window_stack_position]
343	add edx,60*65536	345	add edx,60*65536
344	mcall	346	mcall
345		347
346	;show window xy size	348	;show window xy size
347	mov ecx,[process_info_buffer.box.left]	349	mov ecx,[process_info_buffer.box.left]
348	shl ecx,16	350	shl ecx,16
349	add ecx,[process_info_buffer.box.top]	351	add ecx,[process_info_buffer.box.top]
350	add edx,60*65536	352	add edx,60*65536
351	mcall	353	mcall
352		354
353	.ret:	355	.ret:
354	;build index->slot map for terminating processes.	356	;build index->slot map for terminating processes.
355	mov eax,[index]	357	mov eax,[index]
356	mov [tasklist+4*eax],edi	358	mov [tasklist+4*eax],edi
357	ret	359	ret
358		360
359	;read_string:	361	;read_string:
360	;clean string	362	;clean string
361	; mov edi,start_application	363	; mov edi,start_application
362	; xor eax,eax	364	; xor eax,eax
363	; mov ecx,60	365	; mov ecx,60
364	; cld	366	; cld
365	; rep stosb	367	; rep stosb
366	; call print_text	368	; call print_text
367		369
368	; mov edi,start_application	370	; mov edi,start_application
369	;edi now contains pointer to last symbol	371	;edi now contains pointer to last symbol
370	; jmp still1	372	; jmp still1
371		373
372	;read string main loop	374	;read string main loop
373		375
374	f11:	376	f11:
375	;full update	377	;full update
376	push edi	378	push edi
377	xor ebp,ebp	379	xor ebp,ebp
378	inc ebp	380	inc ebp
379	; mov ebp,1	381	; mov ebp,1
380	call draw_window	382	call draw_window
381	pop edi	383	pop edi
382	;	384	;
383	; still1:	385	; still1:
384	;wait for message	386	;wait for message
385	; mov eax,23	387	; mov eax,23
386	; mov ebx,100	388	; mov ebx,100
387	; mcall	389	; mcall
388	; cmp eax,1	390	; cmp eax,1
389	; je f11	391	; je f11
390	;if no message - update process information	392	;if no message - update process information
391	; cmp eax,0	393	; cmp eax,0
392	; jnz .message_received	394	; jnz .message_received
393	; push edi ;edi should be saved since draw_window	395	; push edi ;edi should be saved since draw_window
394	; xor ebp,ebp ;corrupt registers	396	; xor ebp,ebp ;corrupt registers
395	; call draw_window	397	; call draw_window
396	; pop edi	398	; pop edi
397	; jmp still1	399	; jmp still1
398	;	400	;
399	;.message_received:	401	;.message_received:
400	; cmp eax,2	402	; cmp eax,2
401	; jne read_done ;buttons message	403	; jne read_done ;buttons message
402	;read char	404	;read char
403	; mov eax,2	405	; mov eax,2
404	; mcall	406	; mcall
405	; shr eax,8	407	; shr eax,8
406		408
407	;if enter pressed, exit read string loop	409	;if enter pressed, exit read string loop
408	; cmp eax,13	410	; cmp eax,13
409	; je read_done	411	; je read_done
410	;if backslash pressed?	412	;if backslash pressed?
411	; cmp eax,8	413	; cmp eax,8
412	; jnz nobsl	414	; jnz nobsl
413	;decrease pointer to last symbol	415	;decrease pointer to last symbol
414	; cmp edi,start_application	416	; cmp edi,start_application
415	; jz still1	417	; jz still1
416	; dec edi	418	; dec edi
417	;fill last symbol with space because	419	;fill last symbol with space because
418	;print_text show all symbols	420	;print_text show all symbols
419	; mov [edi],byte 32	421	; mov [edi],byte 32
420	; call print_text	422	; call print_text
421	; jmp still1	423	; jmp still1
422	;	424	;
423	; nobsl:	425	; nobsl:
424	;write new symbol	426	;write new symbol
425	; mov [edi],al	427	; mov [edi],al
426	;display new text	428	;display new text
427	; call print_text	429	; call print_text
428	;increment pointer to last symbol	430	;increment pointer to last symbol
429	; inc edi	431	; inc edi
430	;compare with end of string	432	;compare with end of string
431	; mov esi,start_application	433	; mov esi,start_application
432	; add esi,60	434	; add esi,60
433	; cmp esi,edi	435	; cmp esi,edi
434	; jnz still1	436	; jnz still1
435		437
436	;exiting from read string loop	438	;exiting from read string loop
437	;	439	;
438	; read_done:	440	; read_done:
439	;terminate string for file functions	441	;terminate string for file functions
440	; mov [edi],byte 0	442	; mov [edi],byte 0
441		443
442	; call print_text	444	; call print_text
443	; jmp still	445	; jmp still
444		446
445	;	447	;
446	;print_text:	448	;print_text:
447	;display start_application string	449	;display start_application string
448		450
449	; pushad	451	; pushad
450		452
451	;display text background	453	;display text background
452	; mov eax,13	454	; mov eax,13
453	; mov ebx,6465536+626	455	; mov ebx,6465536+626
454	; mov ecx,400*65536+12	456	; mov ecx,400*65536+12
455	; mov edx,0xffffcc ;0xeeeeee	457	; mov edx,0xffffcc ;0xeeeeee
456	; mcall	458	; mcall
457		459
458	;display text	460	;display text
459	; mov eax,4	461	; mov eax,4
460	; mov edx,start_application ;from start_application string	462	; mov edx,start_application ;from start_application string
461	; mov ebx,70*65536+402 ;text center-aligned	463	; mov ebx,70*65536+402 ;text center-aligned
462	; xor ecx,ecx ;black text	464	; xor ecx,ecx ;black text
463	; mov esi,60 ;60 symbols	465	; mov esi,60 ;60 symbols
464	; mcall	466	; mcall
465		467
466	; popad	468	; popad
467	; ret	469	; ret
468		470
469	window_x_size=524	471	window_x_size=524
470	window_y_size=430	472	window_y_size=430
471		473
472	calculate_window_pos:	474	calculate_window_pos:
473	;set window size and position for 0 function	475	;set window size and position for 0 function
474	;to [winxpos] and [winypos] variables	476	;to [winxpos] and [winypos] variables
475		477
476	;get screen size	478	;get screen size
477	mov eax,14	479	mov eax,14
478	mcall	480	mcall
479	mov ebx,eax	481	mov ebx,eax
480		482
481	;calculate (x_screen-window_x_size)/2	483	;calculate (x_screen-window_x_size)/2
482	shr ebx,16+1	484	shr ebx,16+1
483	sub ebx,window_x_size/2	485	sub ebx,window_x_size/2
484	shl ebx,16	486	shl ebx,16
485	mov bx,window_x_size	487	mov bx,window_x_size
486	;winxpos=xcoord*65536+xsize	488	;winxpos=xcoord*65536+xsize
487	mov [winxpos],ebx	489	mov [winxpos],ebx
488		490
489	;calculate (y_screen-window_y_size)/2	491	;calculate (y_screen-window_y_size)/2
490	and eax,0xffff	492	and eax,0xffff
491	shr eax,1	493	shr eax,1
492	sub eax,window_y_size/2	494	sub eax,window_y_size/2
493	shl eax,16	495	shl eax,16
494	mov ax,window_y_size	496	mov ax,window_y_size
495	;winypos=ycoord*65536+ysize	497	;winypos=ycoord*65536+ysize
496	mov [winypos],eax	498	mov [winypos],eax
497		499
498	ret	500	ret

Subversion Repositories Kolibri OS

(root)/programs/system/cpu/trunk/cpu.asm – Rev 1214 → 1228