0,0 → 1,983 |
; |
; Modified from original icon editor |
; |
; Compile with FASM for Menuet |
; |
use32 |
org 0x0 |
db 'MENUET01' ; 8 byte id |
dd 0x01 ; header version |
dd START ; start of code |
dd I_END ; size of image |
dd 0x100000 ; memory for app |
dd 0x7fff0 ; esp |
dd 0x0 , 0x0 ; I_Param , I_Icon |
|
include 'lang.inc' |
include 'macros.inc' |
|
window_x_size equ 346 |
window_y_size equ 312 |
|
START: ; start of execution |
|
call draw_window ; at first, draw the window |
call get_screen_size ; get screen x and y size |
|
check_mouse: |
|
call draw_mouse ; are we editing the icon |
call check_colour ; are we selecting a colour |
|
still: |
|
mov eax,23 ; wait here for event |
mov ebx,1 ; for 1ms |
int 0x40 |
|
cmp eax,1 ; redraw request ? |
je red |
cmp eax,2 ; key in buffer ? |
je key |
cmp eax,3 ; button in buffer ? |
je button |
|
jmp check_mouse ; start loop again |
|
red: ; redraw |
call draw_window ; draw our window |
jmp check_mouse ; start the loop again |
key: |
|
mov eax,2 ; get a key |
int 0x40 ; do it |
shr eax,8 ; move it to al |
cmp byte [editstate],0 ; are we in edit mode |
je check_mouse ; if not start loop again |
cmp al,8 ; is it a backspace |
jne no_bksp ; if no jump over backspace code |
cmp byte [editpos],0 ; is it the first character |
je no_del_last ; if yes jump over backspace code |
dec byte [editpos] ; decrement our position |
xor ebx,ebx ; clear pointer |
mov bl,byte [editpos] ; get our position |
add ebx,icon ; add our offset |
mov byte [ebx],0 ; delete character |
no_del_last: |
call draw_filename ; update filename |
jmp check_mouse ; start loop again |
no_bksp: |
cmp al,13 ; is it the enter key |
jne no_enter ; no then jump over enter code |
mov byte [editstate],0 ; get out of edit mode |
call draw_filename ; update filename |
jmp check_mouse ; start loop again |
no_enter: |
cmp al,31 ; are we below character 31 |
jbe no_lit ; then must be illegal |
cmp al,97 ; are we below character 97 |
jb capital ; then must be ok |
sub eax,32 ; else subtract 32 from it to make it legal |
capital: |
xor ebx,ebx ; clear our pointer |
mov bl,byte [editpos] ; get our position |
add ebx,icon ; add our offset |
mov byte [ebx],al ; move our character into buffer |
inc byte [editpos] ; increment our edit position |
cmp byte [editpos],12 ; are we at our last position |
jne no_null_state ; no then jump over last position code |
mov byte [editstate],0 ; get out of edit mode |
no_null_state: |
call draw_filename ; update filename |
no_lit: |
jmp check_mouse ; start loop again |
|
button: ; button |
mov eax,17 ; get id |
int 0x40 |
|
cmp ah,1 ; button id=1 ? |
jne button_3 |
mov eax,-1 ; close this program |
int 0x40 |
button_3: |
cmp ah,3 ; was it button 3 - FILENAME |
jne button_4 ; no then try button 4 |
cld ; |
mov byte [editstate],1 ; enter edit mode |
mov edi,icon ; point to our buffer |
mov eax,0x20202020 ; file reg with 4 spaces |
mov ecx,3 ; going to write it 3 times |
rep stosd ; repeat giving 12 spaces |
mov byte [editpos],0 ; zero our edit position |
call draw_filename ; update filename |
jmp check_mouse ; start loop again |
button_4: |
cmp ah,4 ; was it button 4 - LOAD |
jne button_5 ; no then try button 5 |
mov byte [editstate],0 ; dont want to be in edit mode |
call draw_filename ; update filename |
call load_file ; load the file |
call draw_icon ; update icon screen |
call draw_graph ; update edit screen |
jmp check_mouse ; start loop again |
button_5: |
cmp ah,5 ; was it button 5 - SAVE |
jne button_6 ; no then try button 6 |
mov byte [editstate],0 ; dont want to be in edit mode |
call draw_filename ; update filename |
call save_file ; save the file |
jmp check_mouse ; start loop again |
button_6: |
cmp ah,6 ; was it button 6 - CLEAR ICON |
jne button_7 ; no then try button 7 |
mov byte [editstate],0 ; dont want to be in edit mode |
call draw_filename ; update filename |
call clear_graph_icon ; clear the icon and edit screens |
button_7: |
cmp ah,7 ; was it button 7 - FLIP ICON |
jne button_8 ; no then try button 8 |
call flip_icon ; flip |
button_8: |
cmp ah,8 ; was it button 8 - MIRROR ICON |
jne button_9 ; no then try button 9 |
call flip_diag ; flip L/R and U/D |
call flip_icon ; cheated now have to flip it |
button_9: |
cmp ah,9 ; was it button 9 - FLIP L/R and U/D |
jne button_10 ; no then try button 10 |
call flip_diag ; flip L/R and U/D |
call draw_icon ; update icon |
call draw_graph ; update graph |
button_10: |
cmp ah,10 ; was it button 9 - SET AS BGR |
jne check_mouse ; no then exit |
call set_background ; set as background |
|
jmp check_mouse ; start loop again |
|
; ********************************************* |
; ******* WINDOW DEFINITIONS AND DRAW ******** |
; ********************************************* |
draw_window: |
|
mov eax,12 ; function 12:tell os about windowdraw |
mov ebx,1 ; 1, start of draw |
int 0x40 |
; DRAW WINDOW |
mov eax,0 ; function 0 : define and draw window |
mov ebx,100*65536+window_x_size ; [x start] *65536 + [x size] |
mov ecx,100*65536+window_y_size ; [y start] *65536 + [y size] |
mov edx,0x03ffffff ; color of work area 0x00RRGGBB |
mov esi,0x807799bb ; color of grab bar 0x00RRGGBB |
mov edi,0x007799bb ; color of frames 0x00RRGGBB |
int 0x40 |
; WINDOW LABEL |
mov eax,4 ; function 4 : write text to window |
mov ebx,7*65536+7 ; [x start] *65536 + [y start] |
mov ecx,0xddeeff ; color of text 0x00RRGGBB |
mov edx,labelt ; pointer to text beginning |
mov esi,11 ; text length |
int 0x40 |
; DRAW BUTTON BAR |
mov eax,13 ; function 13 : draw bar |
mov ebx,5*65536+window_x_size-9 ; [x start] *65536 + [x size] |
mov ecx,(window_y_size-20)*65536+16 ; [y start] *65536 + [y size] |
mov edx,0x7799bb ; colour 0x00RRGGBB |
int 0x40 |
; DEFINE BUTTON 3 : FILENAME |
mov eax,8 ; function 8 : define button |
mov ebx,5*65536+62 ; [x start] *65536 + [x size] |
mov ecx,(window_y_size-19)*65536+14 ; [y start] *65536 + [y size] |
mov edx,3 ; button id number |
mov esi,0x7799bb ; button color 0x00RRGGBB |
int 0x40 |
; BUTTON 3 TEXT |
mov eax,4 ; function 4 : write text to window |
mov ebx,13*65536+window_y_size-15 ; [x start] *65536 + [y start] |
mov ecx,0xddeeff ; text color 0x00RRGGBB |
mov edx,button_text_3 ; pointer to text beginning |
mov esi,8 ; text length |
int 0x40 |
|
call draw_filename ; update filename |
|
; DEFINE BUTTON 4 : LOAD |
mov eax,8 ; function 8 : define button |
mov ebx,(window_x_size-87)*65536+38 ; [x start] *65536 + [x size] |
mov ecx,(window_y_size-19)*65536+14 ; [y start] *65536 + [y size] |
mov edx,4 ; button id number |
mov esi,0x7799bb ; button color 0x00RRGGBB |
int 0x40 |
; DEFINE BUTTON 5 : SAVE |
mov ebx,(window_x_size-43)*65536+38 ; [x start] *65536 + [x size] |
mov edx,5 ; button id number |
int 0x40 |
; DEFINE BUTTON 6 : CLEAR ICON |
mov ebx,268*65536+72 ; [x start] *65536 + [x size] |
mov ecx,65*65536+14 ; [y start] *65536 + [y size] |
mov edx,6 ; button id number |
int 0x40 |
; DEFINE BUTTON 7 : FLIP VERTICAL |
mov ecx,85*65536+14 ; [y start] *65536 + [y size] |
mov edx,7 ; button id number |
int 0x40 |
; DEFINE BUTTON 8 : FLIP HORIZONTAL |
mov ecx,105*65536+14 ; [y start] *65536 + [y size] |
mov edx,8 ; button id number |
int 0x40 |
; DEFINE BUTTON 9 : SET AS BACKGROUND |
mov ecx,125*65536+14 ; [y start] *65536 + [y size] |
mov edx,9 ; button id number |
int 0x40 |
; DEFINE BUTTON 10 : SET AS BACKGROUND |
mov ecx,145*65536+14 ; [y start] *65536 + [y size] |
mov edx,10 ; button id number |
int 0x40 |
; BUTTON 4 TEXT |
mov eax,4 ; function 4 : write text to window |
mov ebx,267*65536+window_y_size-15 ; [x start] *65536 + [y start] |
mov ecx,0xddeeff ; text color 0x00RRGGBB |
mov edx,button_text_4 ; pointer to text beginning |
mov esi,4 ; text length |
int 0x40 |
; BUTTON 5 TEXT |
mov ebx,311*65536+window_y_size-15 ; [x start] *65536 + [y start] |
mov edx,button_text_5 ; pointer to text beginning |
int 0x40 |
; BUTTON 6 TEXT |
mov ebx,275*65536+69 ; [x start] *65536 + [y start] |
mov edx,button_text_6 ; pointer to text beginning |
mov esi,10 ; text length |
int 0x40 |
; BUTTON 7 TEXT |
mov ebx,275*65536+89 ; [x start] *65536 + [y start] |
mov edx,button_text_7 ; pointer to text beginning |
int 0x40 |
; BUTTON 8 TEXT |
mov ebx,275*65536+109 ; [x start] *65536 + [y start] |
mov edx,button_text_8 ; pointer to text beginning |
int 0x40 |
; BUTTON 9 TEXT |
mov ebx,275*65536+129 ; [x start] *65536 + [y start] |
mov edx,button_text_9 ; pointer to text beginning |
int 0x40 |
; BUTTON 10 TEXT |
mov ebx,275*65536+149 ; [x start] *65536 + [y start] |
mov edx,button_text_10 ; pointer to text beginning |
int 0x40 |
; DRAW GRAPH BACKGROUND |
mov eax,13 ; function 13 : draw bar |
mov ebx,6*65536+257 ; [x start] *65536 + [x size] |
mov ecx,26*65536+257 ; [y start] *65536 + [y size] |
mov edx,0x7799bb ; colour 0x00RRGGBB |
int 0x40 |
; DRAW ICON BACKGROUND |
mov ebx,268*65536+34 ; [x start] *65536 + [x size] |
mov ecx,26*65536+34 ; [y start] *65536 + [y size] |
int 0x40 |
; DRAW PALETTE BACKGROUND |
mov ebx,268*65536+34 ; [x start] *65536 + [x size] |
mov ecx,217*65536+33 ; [y start] *65536 + [y size] |
int 0x40 |
; DRAW PALETTE BACKGROUND |
mov ebx,268*65536+33 ; [x start] *65536 + [x size] |
mov ecx,250*65536+33 ; [y start] *65536 + [y size] |
int 0x40 |
; DRAW PALETTE BACKGROUND |
mov ebx,301*65536+33 ; [x start] *65536 + [x size] |
mov ecx,249*65536+34 ; [y start] *65536 + [y size] |
int 0x40 |
; DRAW GREYSCALE BACKGROUND |
mov ebx,307*65536+34 ; [x start] *65536 + [x size] |
mov ecx,210*65536+34 ; [y start] *65536 + [y size] |
int 0x40 |
; DRAW SELECTED COLOUR BACKGROUND |
mov ebx,268*65536+73 ; [x start] *65536 + [x size] |
mov ecx,171*65536+34 ; [y start] *65536 + [y size] |
int 0x40 |
; DRAW WHITE TO START |
mov ebx,269*65536+71 ; [x start] *65536 + [x size] |
mov ecx,172*65536+32 ; [y start] *65536 + [y size] |
mov edx,0xffffff ; colour 0x00RRGGBB |
int 0x40 |
; DRAW PALETTE RED + GREEN SECTION |
xor edi,edi ; clear column loop count |
next_r_g_outer: |
xor esi,esi ; clear line loop count |
next_r_g_inner: |
mov eax,1 ; function 1 : putpixel |
mov ebx,edi ; get column count |
shr ebx,3 ; divide by 8 |
add ebx,269 ; add our x offset |
mov ecx,esi ; get our line count |
shr ecx,3 ; divide by 8 |
add ecx,218 ; add our y offset |
mov edx,255 ; maximum red |
sub edx,edi ; minus column count |
shl edx,8 ; into position 0x0000RR00 |
add edx,255 ; maximum green |
sub edx,esi ; minus line count |
shl edx,8 ; into position 0x00RRGG00 |
int 0x40 |
add esi,5 ; colour in steps of 5 to keep small |
cmp esi,255 ; have we done a line |
jne next_r_g_inner ; nop then do next pixel |
add edi,5 ; colour in steps of 5 to keep small |
cmp edi,255 ; have we done all columns |
jne next_r_g_outer ; no then start the next one |
|
; DRAW PALETTE GREEN + BLUE SECTION |
mov edi,0 ; as above |
next_g_b_outer: |
mov esi,0 |
next_g_b_inner: |
mov eax,1 |
mov ebx,edi |
shr ebx,3 |
add ebx,269 |
mov ecx,esi |
shr ecx,3 |
add ecx,250 |
mov edx,255 |
sub edx,edi |
shl edx,16 |
add edx,esi |
int 0x40 |
add esi,5 |
cmp esi,255 |
jne next_g_b_inner |
add edi,5 |
cmp edi,255 |
jne next_g_b_outer |
|
; DRAW PALETTE BLUE + RED SECTION |
mov edi,0 ; as above |
next_b_r_outer: |
mov esi,0 |
next_b_r_inner: |
mov eax,1 |
mov ebx,edi |
shr ebx,3 |
add ebx,301 |
mov ecx,esi |
shr ecx,3 |
add ecx,250 |
mov edx,edi |
shl edx,8 |
add edx,esi |
int 0x40 |
add esi,5 |
cmp esi,255 |
jne next_b_r_inner |
add edi,5 |
cmp edi,255 |
jne next_b_r_outer |
|
; DRAW GREYSCALE |
mov edi,0 |
next_b_w_outer: |
mov esi,0 |
next_b_w_inner: |
mov eax,1 |
mov ebx,edi |
shr ebx,3 |
add ebx,308 |
mov ecx,esi |
shr ecx,3 |
add ecx,211 |
mov edx,esi |
shl edx,8 |
add edx,esi |
shl edx,8 |
add edx,esi |
int 0x40 |
add esi,5 |
cmp esi,255 |
jne next_b_w_inner |
add edi,5 |
cmp edi,255 |
jne next_b_w_outer |
|
cmp [first_run],0 ; is it the first window draw |
jne dont_load ; no then dont reload the file |
call load_file ; load initial file |
mov [first_run],1 ; first window draw done |
dont_load: |
call draw_icon ; draw icon area |
call draw_graph ; draw edit area |
|
mov eax,12 ; function 12:tell os about windowdraw |
mov ebx,2 ; 2, end of draw |
int 0x40 |
|
ret ; return |
|
; ********************************************* |
; ******* SET BACKGROUND ******** |
; ********************************************* |
set_background: |
|
mov ecx,image+3600 ; point to our decode buffer |
mov edx,image+54+32*32*3-96 ; point to last line of bmp |
|
mov edi,0 ; zero line count |
decode_line: |
mov esi,0 ; zero column count |
decode_column: |
mov ebx,[edx] ; get our data |
mov [ecx],ebx ; store our data |
add ecx,4 ; add 4 bytes to pointer as using double word |
add edx,4 ; add 4 bytes to pointer |
inc esi ; increment column count |
cmp esi,24 ; have we done all columns |
jne decode_column ; no then do some more |
sub edx,192 ; move back 2 lines of bmp data |
inc edi ; increment line count |
cmp edi,33 ; have we done all lines |
jne decode_line ; no then do another one |
|
mov eax,15 ; background |
mov ebx,1 ; set background size |
mov ecx,32 ; x size |
mov edx,32 ; y size |
int 0x40 ; do it |
mov ebx,5 ; blockmove image to os bgr memory |
mov ecx,image+3600 ; point to image |
mov edx,0 ; start of bgr memory |
mov esi,32*32*3 ; byte count |
int 0x40 ; do it |
mov ebx,4 ; type of background draw |
mov ecx,1 ; tile |
int 0x40 ; do it |
mov ebx,3 ; draw background |
int 0x40 ; do it |
|
ret ; return |
|
; ********************************************* |
; ******* GET SCREEN X and Y SIZE ******** |
; ********************************************* |
get_screen_size: |
|
mov eax,14 ; function 14 : get screen max |
int 0x40 ; returns eax : 0xXXXXYYYY |
push eax ; save reg |
and eax,0x0000ffff ; split out y size |
add eax,1 ; add 1 to remove zero base |
mov [y_size],eax ; store for later |
pop eax ; restore reg |
shr eax,16 ; move x size down the reg |
add eax,1 ; add 1 to remove zero base |
mov [x_size],eax ; store for later |
|
ret |
|
; ********************************************* |
; ******* LOAD FILE ******** |
; ********************************************* |
load_file: |
|
mov eax,6 ; function 6 : load file |
mov ebx,icon ; point to the name |
mov ecx,0 ; reserved |
mov edx,200000 ; reserved |
mov esi,image ; point to image buffer |
int 0x40 ; do it |
|
ret ; return |
|
; ********************************************* |
; ******* SAVE FILE ******** |
; ********************************************* |
save_file: |
|
mov eax,33 ; function 33 : save file |
mov ebx,icon ; point to name |
mov ecx,image ; point to our data |
mov edx,54+32*32*3 ; how much data to transfer |
xor esi,esi ; 0 - create a new file |
int 0x40 ; do it |
|
ret ; return |
|
; ********************************************* |
; ******* DRAW FILENAME TO SCREEN ******** |
; ********************************************* |
draw_filename: |
; DRAW COLOUR BACKGROUND |
pusha ; save all registers on stack |
mov eax,13 ; function 13 : draw bar |
mov ebx,73*65536+81 ; [x start] *65536 + [x size] |
mov ecx,(window_y_size-19)*65536+15 ; [y start] *65536 + [y size] |
mov edx,0x557799 ; colour 0x00RRGGBB |
int 0x40 |
|
mov eax,4 ; function 4 : write text to window |
mov ebx,78*65536+(window_y_size-15) ; [y start] *65536 + [y size] |
xor ecx,ecx ; colour 0x00RRGGBB = black |
mov edx,icon ; point to text |
mov esi,12 ; number of characters to write |
cmp byte [editstate],1 ; are we in edit mode |
jne no_active_1 ; no then jump over change colour |
mov ecx,0x00112299 ; else change colour |
no_active_1: |
int 0x40 ; do it |
popa ; return all registers to original |
ret ; return |
|
; ********************************************* |
; ******* DRAW ICON FROM LOADED FILE ******** |
; ********************************************* |
draw_icon: |
|
mov ecx,27 ; y start position |
mov eax,image+51+32*32*3 ; point to our bmp data |
mov edi,0 ; line count |
line: |
mov esi,0 ; column count |
mov ebx,269+31 ; x start position |
pixel: |
mov edx,[eax] ; colour 0x00RRGGBB from image data |
push eax ; save our position |
mov eax,1 ; function 1 : put pixel |
int 0x40 ; do it |
pop eax ; restore our position |
sub eax,3 ; point to next pixel colour |
dec ebx ; move our x position |
inc esi ; increment our column count |
cmp esi,32 ; have we done all columns |
jne pixel ; no then do next pixel |
inc ecx ; move our y position |
inc edi ; increment line count |
cmp edi,32 ; have we done all lines |
jne line ; no then do next line |
|
ret ; return |
|
; ********************************************* |
; ******* DRAW GRAPH FROM LOADED FILE ******* |
; ********************************************* |
draw_graph: |
|
mov edi,0 ; line count |
mov eax,image+51+32*32*3 ; point to our bmp data |
next_lin: |
mov ecx,edi ; use our line count for position |
shl ecx,3 ; multiply by eight |
add ecx,27 ; add y start position |
shl ecx,16 ; move into top eight bytes [y start] |
add ecx,7 ; add box height [y size] |
mov esi,32 ; column count |
next_bo: |
mov ebx,esi ; use our column count for position |
shl ebx,3 ; multiply by eight |
add ebx,-1 ; add a correction |
shl ebx,16 ; and move into top eight bytes [x start] |
add ebx,7 ; add box width [x size] |
mov edx,[eax] ; point to bmp data |
push eax ; save our position |
mov eax,13 ; function 13 : draw bar |
int 0x40 ; do it |
pop eax ; restore our position |
sub eax,3 ; point to next pixel colour |
dec esi ; increment column count |
cmp esi,0 ; have we done all columns |
jne next_bo ; no then do the next column |
inc edi ; increment line count |
cmp edi,32 ; have we done all lines |
jne next_lin ; no then do the next line |
|
ret ; return |
|
; ********************************************* |
; ******* CLEAR GRAPH and ICON AREA ******** |
; ********************************************* |
clear_graph_icon: |
|
; CLEAR IMAGE DATA |
mov edi,image+54 ; point to our data |
mov eax,0x00000000 ; data to write |
mov ecx,(32*32*3)/4 ; how much data |
rep stosd ; repeat until all data transfered |
call draw_icon ; draw a blank icon |
call draw_graph ; draw a blank graph |
|
ret ; return |
|
; ********************************************* |
; ******* FLIP ICON TOP to BOTTOM ******** |
; ********************************************* |
flip_icon: |
|
mov ecx,image+54 ; point at first line |
mov edx,image+54+32*32*3+96 ; point 1 line past end |
|
mov edi,0 ; zero line count |
lines: |
mov esi,0 ; zero column count |
sub edx,192 ; move back 2 lines |
columns: |
mov eax,[ecx] ; get bytes |
mov ebx,[edx] ; get bytes |
mov [ecx],ebx ; swap bytes |
mov [edx],eax ; swap bytes |
add ecx,4 ; move pointer |
add edx,4 ; move pointer |
inc esi ; increment column count |
cmp esi,24 ; have we done all columns |
jne columns ; no then do next column |
inc edi ; increment line count |
cmp edi,16 ; have we done all lines |
jne lines ; no then do next line |
call draw_icon ; update icon |
call draw_graph ; update graph |
|
ret ; return |
|
; ********************************************* |
; ******* FLIP ICON DIAGONAL ******** |
; ********************************************* |
flip_diag: |
|
mov ecx,image+54 ; point line 1 first bytes |
mov edx,image+3600 ; point to buffer |
xor esi,esi ; zero byte count |
|
pusha ; save all registers |
copy_out: |
mov eax,[ecx] ; get bytes |
mov [edx],eax ; copy bytes |
add ecx,4 ; move pointer |
add edx,4 ; move pointer |
inc esi ; increment byte count |
cmp esi,24*32 ; have we done all bytes |
jne copy_out ; no then do the next |
popa ; restore all registers |
|
mov edx,image+3600+32*32*3-3 ; point to last bytes |
copy_in: |
mov eax,[edx] ; get bytes |
mov [ecx],eax ; copy to image first bytes |
add ecx,3 ; move pointer 3 bytes |
sub edx,3 ; move pointer 3 bytes |
inc esi ; increment byte count |
cmp esi,32*32 ; have we done all bytes |
jne copy_in ; no then do next |
|
ret ; return |
|
; ********************************************* |
; ******* DRAW MOUSE ON GRAPH / ICON ******** |
; ********************************************* |
draw_mouse: |
|
mov eax,37 ; function 37 |
mov ebx,2 ; sub function 2 : check for mouse button |
int 0x40 ; do it |
cmp eax,0 ; was a button pressed |
je exit_mouse ; no then jump to exit |
cmp eax,1 ; left hand button |
je colour_mouse ; we are using selected colour |
mov [draw_colour],0x000000 ; else draw with black |
jmp blank ; jmp over colour select |
colour_mouse: |
mov eax,[sel_colour] ; get our selected colour |
mov [draw_colour],eax ; save our selected colour |
blank: |
mov eax,37 ; function 37 |
mov ebx,1 ; sub function 1 : get mouse position |
int 0x40 ; do it |
push eax ; save our x/y position for later |
and eax,0x0000ffff ; y is in lower bytes |
add eax,1 ; add 1 because we are zero based |
mov [my_pos],eax ; save y position |
pop eax ; restore our x/y position |
shr eax,16 ; shift x into lower bytes |
add eax,1 ; add 1 because we are zero based |
mov [mx_pos],eax ; save x position |
cmp [mx_pos],7 ; check we are within x/y limits |
jle exit_mouse |
cmp [mx_pos],263 |
jge exit_mouse |
cmp [my_pos],27 |
jle exit_mouse |
cmp [my_pos],283 |
jge exit_mouse |
mov eax,[mx_pos] ; calculate nearest square and save |
sub eax,7 ; subtract 7 graph zero offset |
shr eax,3 ; divide by 8 (box size) loose remainder |
mov [icon_x],eax ; save for use later in icon |
shl eax,3 ; multiply by 8 to get box position |
add eax,7 ; add 7 graph zero offset |
mov [gx_pos],eax ; save graph x position |
mov eax,[my_pos] ; repeat for y |
sub eax,27 ; |
shr eax,3 ; |
mov [icon_y],eax ; |
shl eax,3 ; |
add eax,27 ; |
mov [gy_pos],eax ; |
mov eax,13 ; function 13 : draw bar |
mov ebx,[gx_pos] ; load graph x position |
shl ebx,16 ; shift into high bytes |
add ebx,7 ; add box size |
mov ecx,[gy_pos] ; repeat for y |
shl ecx,16 ; |
add ecx,7 ; |
mov edx,[draw_colour] ; give it a colour |
int 0x40 ; do it |
mov eax,1 ; function 1 : put pixel |
mov ebx,[icon_x] ; icon x from above |
add ebx,269 ; add icon x offset |
mov ecx,[icon_y] ; icon y from above |
add ecx,27 ; add icon y offset |
mov edx,[draw_colour] ; give it a colour |
int 0x40 ; do it |
mov ecx,image+54 ; point to our data |
mov ebx,31 ; 32 lines in image zero based |
sub ebx,[icon_y] ; get the correct line |
mov eax,96 ; 96 or 3 bytes per colour * 32 columns |
mul ebx ; multiply by 96 result in eax |
add ecx,eax ; add to our position |
mov ebx,[icon_x] ; get the correct column |
mov eax,3 ; 3 bytes per colour |
mul ebx ; multiply by 3 result in eax |
add ecx,eax ; add to our position |
mov ebx,[draw_colour] ; get our colour |
mov [ecx],bl ; move blue into image data |
mov [ecx+1],bh ; move green into image data |
shr ebx,16 ; shift red down |
mov [ecx+2],bl ; move red into image data |
exit_mouse: |
|
ret ; return |
|
; ********************************************* |
; ******* GET COLOUR TO DRAW WITH ******** |
; ********************************************* |
check_colour: |
|
mov eax,37 ; function 37 |
mov ebx,2 ; sub function 2 : check for mouse button |
int 0x40 ; do it |
cmp eax,0 ; was a button pressed |
je exit_draw ; no then jump to exit |
mov eax,37 ; function 37 |
mov ebx,1 ; sub function 1 : get mouse position |
int 0x40 ; do it |
push eax ; save our x/y position for later |
and eax,0x0000ffff ; y is in lower bytes |
add eax,1 ; add 1 because we are zero based |
mov [my_pos],eax ; save y position |
pop eax ; restore our x/y position |
shr eax,16 ; shift x into lower bytes |
add eax,1 ; add 1 because we are zero based |
mov [mx_pos],eax ; save x position |
cmp [mx_pos],270 ; check we are within x/y limits |
jl check_rb |
cmp [mx_pos],301 |
jg check_rb |
cmp [my_pos],219 |
jl check_rb |
cmp [my_pos],250 |
jg check_rb |
|
call decode_mouse |
|
mov edi,0 |
next_sel_rg_outer: |
mov esi,0 |
next_sel_rg_inner: |
mov eax,1 |
mov ebx,edi |
shr ebx,3 |
add ebx,308 |
mov ecx,esi |
shr ecx,3 |
add ecx,211 |
mov edx,[sel_colour] |
add edx,esi |
int 0x40 |
add esi,5 |
cmp esi,255 |
jne next_sel_rg_inner |
add edi,5 |
cmp edi,255 |
jne next_sel_rg_outer |
|
|
check_rb: |
|
cmp [mx_pos],270 ; check we are within x/y limits |
jl check_bg |
cmp [mx_pos],301 |
jg check_bg |
cmp [my_pos],251 |
jle check_bg |
cmp [my_pos],282 |
jg check_bg |
|
call decode_mouse |
|
mov edi,0 |
next_sel_rb_outer: |
mov esi,0 |
next_sel_rb_inner: |
mov ebx,edi |
shr ebx,3 |
add ebx,308 |
mov ecx,esi |
shr ecx,3 |
add ecx,211 |
mov edx,[sel_colour] |
mov eax,esi |
shl eax,8 |
add edx,eax |
mov eax,1 |
int 0x40 |
add esi,5 |
cmp esi,255 |
jne next_sel_rb_inner |
add edi,5 |
cmp edi,255 |
jne next_sel_rb_outer |
|
|
check_bg: |
|
cmp [mx_pos],301 ; check we are within x/y limits |
jl get_colour |
cmp [mx_pos],333 |
jg get_colour |
cmp [my_pos],251 |
jl get_colour |
cmp [my_pos],282 |
jg get_colour |
|
call decode_mouse |
|
mov edi,0 |
next_sel_bg_outer: |
mov esi,0 |
next_sel_bg_inner: |
mov ebx,edi |
shr ebx,3 |
add ebx,308 |
mov ecx,esi |
shr ecx,3 |
add ecx,211 |
mov edx,[sel_colour] |
mov eax,esi |
shl eax,16 |
add edx,eax |
mov eax,1 |
int 0x40 |
add esi,5 |
cmp esi,255 |
jne next_sel_bg_inner |
add edi,5 |
cmp edi,255 |
jne next_sel_bg_outer |
|
get_colour: |
|
cmp [mx_pos],309 ; check we are within x/y limits |
jl exit_draw |
cmp [mx_pos],340 |
jg exit_draw |
cmp [my_pos],212 |
jl exit_draw |
cmp [my_pos],243 |
jg exit_draw |
|
call decode_mouse |
|
mov eax,13 |
mov ebx,269*65536+71 |
mov ecx,172*65536+32 |
mov edx,[sel_colour] |
int 0x40 |
|
mov eax,[sel_colour] |
mov [draw_colour],eax |
|
mov eax,47 |
xor ebx,ebx |
mov ebx,6 |
shl ebx,16 |
mov bh,1 |
mov ecx,[sel_colour] |
mov edx,273*65536+176 |
mov esi,0x000000 |
int 0x40 |
|
exit_draw: |
|
ret |
|
; ********************************************* |
; ******* DECODE MOUSE POSITION GET PIX ***** |
; ********************************************* |
|
decode_mouse: |
|
mov eax,37 |
xor ebx,ebx |
int 0x40 |
mov ebx,eax |
mov ecx,eax |
and ebx,0xffff0000 |
shr ebx,16 |
and ecx,0x0000ffff |
mov eax,[x_size] |
imul ecx,eax |
add ebx,ecx |
mov eax,35 |
dec ebx |
int 0x40 |
|
mov [sel_colour],eax |
|
ret |
|
; ********************************************* |
; ******* DATA AREA ***** |
; ********************************************* |
|
mx_pos dd 0x0 |
my_pos dd 0x0 |
|
gx_pos dd 0x0 |
gy_pos dd 0x0 |
|
icon_x dd 0x0 |
icon_y dd 0x0 |
|
x_size dd 0x0 |
y_size dd 0x0 |
|
sel_colour dd 0x00ffffff |
draw_colour dd 0x00ffffff |
|
button_text_3 db 'FILENAME' |
button_text_4 db 'LOAD' |
button_text_5 db 'SAVE' |
button_text_6 db 'CLEAR ICON' |
button_text_7 db 'FLIP VERT ' |
button_text_8 db 'FLIP HORIZ' |
button_text_9 db 'FLIP DIAG ' |
button_text_10 db 'SET AS BGR' |
|
labelt: db 'ICON EDITOR' |
|
icon: db 'WRITE.BMP ' |
|
editpos db 0 |
editstate db 0 |
|
first_run db 0 |
|
image: |
|
I_END: |
Property changes: |
Added: svn:eol-style |
+native |
\ No newline at end of property |