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

Subversion Repositories Kolibri OS

(root)/programs/system/cpu/trunk/cpu.asm @ 1373 – Rev 1228 → 1266