WebSVN – Kolibri OS – Diff – /programs/games/mine/trunk/kos_sys.h--


/*
    Sphinx C-- header file for KolibriOS applications.
    Based on msys.h-- written by Alexey Sugonyaev and modified by Barry Kauler.
    This file is rewritten by Ivan Poddubny.
 
    e-mail: ivan-yar@bk.ru
*/
 
// KeyCode constant
#define UP_KEY		130+48
#define DOWN_KEY	129+48
#define LEFT_KEY	128+48
#define RIGHT_KEY	131+48
#define RETURN_KEY	13
#define BACKSPACE_KEY	8
 
//Button options
#define BT_DEL      0x80000000
#define BT_HIDE     0x40000000
#define BT_NOFRAME  0x20000000
 
// Color constant
#define clWhite		0x00ffffff
#define clGray		0x00808080
#define clLightGray	0x00c0c0c0
#define clWhiteGray 0x00E2E2E2
#define clDarkGray	0x00707070
#define clBlack		0x00000000
#define clRed		0x00ff0000
#define clGreen		0x0000ff00
#define clBlue		0x000000ff
 
// Events
#define evReDraw	1
#define evKey		2
#define evButton	3
#define evMouse		6
#define evIPC		7
#define evStack     8
 
#define OLD -1
 
struct FileInfo
{
  dword	read,
	firstBlock,
	qnBlockRead,
	retPtr,
	Work;
  byte	filedir;
};
 
struct ProcessInfo
{
  dword cpu_usage;
  word  winstackpos;
  word  winstackval;
  word  not_used1;
  byte  name[12];
  dword memstart,
        memory_used,
        PID,
        xstart,
        ystart,
        xsize,
        ysize;
  byte  not_used2[974];
};
 
#define SystemColors SystemColours // usa/british
 
struct SystemColours
{
  dword nonset1,
        nonset2,
        work_dark,
        work_light,
        w_title,
        w_work,
        w_work_button,
        w_work_button_text,
        w_work_text,
        w_work_graph;
};
 
/*********************************************************
  0 = DEFINE WINDOW
  {x_start|y_start}, {x_size|y_size}, color_back, color_title, color_frames
             EBX = [x_start][x_size]
             ECX = [y_start][y_size]
             EDX, ESI, EDI = [00RRGGBB]
*********************************************************/
 
inline fastcall void sys_draw_window(dword EBX, ECX, EDX, ESI, EDI)
{
 EAX = 0;               // function 0 : define and draw window
 $int 0x40
}
 
 
/*********************************************************
01 = PUTPIXEL
     ebx [x]
     ecx [y]
     edx pixel color 0x0XRRGGBB
                        ^ 0 normal put, 1 negative
     ret: nothing changed
*********************************************************/
 
inline fastcall void sys_put_pixel(dword EBX,ECX,EDX)
{
  EAX=1;
  $int 0x40
}
 
 
/*********************************************************
02 = GET KEY
     ret: al 0 successful -> ah = key
          al 1 no key in buffer
     MODIFIED, see below...
*********************************************************/
 
inline fastcall dword sys_get_key()
{
  EAX = 2;              // just read it key from buffer
  $int  0x40
  $shr eax,8
}            //return eax=key code.
 
 
/*********************************************************
03 = GET SYSTEM CLOCK
        ret: eax 0x00SSMMHH sec,min,hour
*********************************************************/
 
#define sys_get_time sys_get_clock
inline fastcall dword sys_get_clock()
{
  EAX=3;
  $int 0x40
}
 
 
/*********************************************************
04 = WRITE TEXT TO WINDOW
     ebx [x start]*65536 + [y start]
     ecx text color 0x00RRGGBB
     edx pointer to text beginning
     esi text length
     return: nothing changed
*********************************************************/
 
#define sys_print_text sys_write_text
inline fastcall void sys_write_text(dword EBX, ECX, EDX, ESI)
{
  EAX = 4;
  $int 0x40;
}
 
inline fastcall void sys_write_char(dword EBX, ECX, EDX)
{
  EAX = 4;
  ESI = 1;
  $int 0x40
}
 
 
/*********************************************************
05 = DELAY X/100 SECS
     ebx delay in 1/100 secs
     ret: nothing changed
*********************************************************/
 
#define sys_wait sys_delay
inline fastcall void sys_delay(dword EBX)
{
  EAX = 5;
  $int 0x40
}
 
 
/*********************************************************
06 = OPEN FILE FROM FLOPPY
     ebx pointer to filename -> 11 capital letters
     ecx set 0x00000000 - reserved
     edx set 0xffffffff - reserved
     esi read to mem position
     ret: ebx = file size
*********************************************************/
 
inline fastcall dword sys_open_file_floppy(dword EBX, ESI)
{
  ECX = 0;
  EDX = -1;
  EAX = 6;
  $int 0x40
}
 
 
/*********************************************************
07 = PUTIMAGE
     ebx pointer to image in memory - RRGGBBRRGGBB..
     ecx image size [x]*65536+[y]
     edx image position in window [x]*65536+[y]
     ret: eax 0 succesful, 1 overlapped
*********************************************************/
 
inline fastcall dword sys_put_image(dword EBX, ECX, EDX)
{
  EAX = 7;
  $int 0x40
}
 
 
/*********************************************************
08 = DEFINE BUTTON
     ebx [x start]*65536 + [x size]
     ecx [y start]*65536 + [y size]
     edx button id number
     esi button color 0x 00 RR GG BB
     ret: nothing changed
*********************************************************/
 
inline fastcall void sys_draw_button(dword EBX, ECX, EDX, ESI)
{
  EAX = 8;
  $int 0x40
}
 
inline fastcall void sys_delete_button(dword EDX)
{
  EAX = 8;
  EDX |= 0x80000000;
  $int 0x40
}
 
 
/*********************************************************
09 = PROCESS INFO
     ebx pointer to 1024 bytes table
     ecx process number or -1 = who am I
     ret: eax number of processes
          table :  +00  dword   cpu usage
                   +04   word   processes position in windowing stack
                   +06   word   window stack value at ecx
                   +10  12 db   name of the process
                   +22  dword   start of processes memory
                   +26  dword   memory used by process
                   +30  dword   PID of the process
                   +34  dword   window x start
                   +38  dword   window y start
                   +42  dword   window x size
                   +46  dword   window y size
*********************************************************/
 
inline fastcall dword sys_process_info(dword EBX, ECX)
{
  EAX = 9;
  $int 0x40
}
 
 
/*********************************************************
10 = WAIT FOR EVENT
     ret: eax event type,
            1 window redraw,
            2 key in buffer,
            3 button pressed
*********************************************************/
 
inline fastcall dword sys_wait_event()
{
  EAX = 10;              // wait here for event
  $int 0x40
}
 
 
/*********************************************************
11 = CHECK FOR EVENT, NO WAIT
     ret: eax 0 no event,
              1 window redraw,
              2 key in buffer,
              3 button pressed
*********************************************************/
 
inline fastcall dword sys_nowait_event()
{
  EAX = 11;
  $int 0x40
}
 
 
/*********************************************************
12 = WINDOW REDRAW
  EBX=1 start of draw, =2 end of draw.
*********************************************************/
 
inline fastcall void sys_window_redraw(dword EBX)
{
  EAX = 12;              // function 12:tell os about windowdraw
  $int 0x40
}
 
inline fastcall void sys_begin_draw()
{
  EAX = 12;
  EBX = 1;
  $int 0x40
}
 
inline fastcall void sys_end_draw()
{
  EAX = 12;
  EBX = 2;
  $int 0x40
}
 
/*********************************************************
13 = DRAW BAR
DrawBar(EBX=[xstart][xsize],ECX=[ystart][ysize],EDX=[0x00RRGGBB])
     ebx [x start]*65536 + [x size]
     ecx [y start]*65536 + [y size]
     edx color 0x00RRGGBB
     ret: nothing changed
*********************************************************/
 
inline fastcall void sys_draw_bar(dword EBX, ECX, EDX)
{
  EAX = 13;
  $int 0x40
}
 
 
/*********************************************************
14 = GET SCREEN MAX
     ret: eax [screen x max]*65536 + [screen y max]
*********************************************************/
 
inline fastcall dword sys_get_screen_size()
{
  EAX = 14;
  $int 0x40
}
 
 
/*********************************************************
15 = BACKGROUND
     ebx 1 : set background size
             ecx x size
             edx y size
     ebx 2 : write to background memory - max (0x100000-16)
             ecx position in memory in bytes
             edx color 0x00RRGGBB
     ebx 3 : draw background
     ebx 4 : type of background draw
             ecx 1 - tile
             ecx 2 - stretch
     ebx 5 : blockmove image to os bgr memory
             ecx - from
             edx - to where in os bgr memory
             esi - count of bytes to move
*********************************************************/
 
inline fastcall void sys_set_background(dword EBX, ECX, EDX, ESI)
{
  EAX = 15;
  $int 0x40
}
 
 
/*********************************************************
17 = GET PRESSED BUTTON ID
  ret: al 0 successful -> ah = id number al 1 no key in buffer.
  MODIFIED, see below.
*********************************************************/
 
inline fastcall dword sys_get_button_id()
{
  EAX = 17;            // Get ID
  $int  0x40
  $shr eax,8
}      //eax=id, eax=0 no id.
 
 
/*********************************************************
18 = SYSTEM SERVICE
     ebx 1 - system boot
     ebx 2 - force terminate , ecx process no
     ebx 4 - idle clock cycles / second
     ebx 5 - time stamp counter / second - cpu speed
HD-> ebx 6 - save ramdisk to /hd/1/menuet.img
*********************************************************/
 
inline fastcall dword sys_service(dword EBX, ECX)
{
  EAX = 18;
  $int 0x40
}
 
inline fastcall void sys_shutdown()
{
  EAX = 18;
  EBX = 1;
  $int 0x40
}
 
inline fastcall void sys_kill(dword ECX)
{
  EAX = 18;
  EBX = 2;
  $int 0x40
}
 
inline fastcall dword sys_get_idle()
{
  EAX = 18;
  EBX = 4;
  $int 0x40
}
 
inline fastcall dword sys_get_tscsec()
{
  EAX = 18;
  EBX = 5;
  $int 0x40
}
 
 
/*********************************************************
19 = START PROGRAM from RAMDISK
     ebx point to 11 char filename
     ecx 0, or point to ASCIIZ start parameters - max 256 bytes
     ret: eax 0      successful
          eax other  error code
*********************************************************/
 
inline fastcall dword sys_exec_app_ramdisk(dword EBX, ECX)
{
  EAX = 19;
  $int 0x40
}
 
 
/*********************************************************
20 = MIDI INTERFACE - MPU401
     ebx  1 - reset device
     ebx  2 - cl midi data to output
*********************************************************/
 
inline fastcall void sys_midi(dword EBX)
{
  EAX = 20;
  $int 0x40
}
 
 
/*********************************************************
21 = SETUP FOR DEVICES
     ebx 1=roland mpu midi base , base io address
     ebx 2=keyboard 1 base keymap  2 shift keymap (ecx pointer to keymap)
                    9 country 1eng 2fi 3ger 4rus
     ebx 3=cd base  1 pri.master  2 pri slave,
                    3 sec master  4 sec slave
     ebx 4=sb16 base, base io address
     ebx 5=system language, 1eng 2fi 3ger 4rus
     ebx 6=wss base, base io address
     ebx 7=hd base, 1 pri.master  2 pri slave
                    3 sec master  4 sec slave
     ebx 8=fat32 partition in hd
*********************************************************/
 
inline fastcall void sys_setup_devices(dword EBX, ECX)
{
  EAX = 21;
  $int 0x40
}
 
 
/*********************************************************
23 = WAIT FOR EVENT WITH TIMEOUT
     ebx time to delay in hs
     ret: eax event type: 0 no event, 1 window redraw,
                          2 key in buffer, 3 button
*********************************************************/
 
inline fastcall dword sys_wait_event_timeout(dword EBX)
{
  EAX = 23;
  $int 0x40
}
 
 
/*********************************************************
24 = CD AUDIO
     ebx 1 - play from ecx 00 FR SS MM
     ebx 2 - get playlist size of ecx to [edx]
     ebx 3 - stop/pause play
*********************************************************/
 
inline fastcall void sys_cd_audio(dword EBX, ECX, EDX)
{
  EAX = 24;
  $int 0x40
}
 
 
/*********************************************************
25 = SB16 - mixer I
     ebx 1 - set main volume cl [L]*16+[R]
     ebx 2 - set cd   volume cl [L]*16+[R]
*********************************************************/
 
inline fastcall void sys_sb16_mixer_1(dword EBX, ECX)
{
  EAX = 25;
  $int 0x40
}
 
 
/*********************************************************
26 = GET SETUP FOR DEVICES
     ebx 1=roland mpu midi base , base io address
     ebx 2=keyboard 1 base keymap  2 shift keymap
                    9 country 1eng 2fi 3ger 4rus
     ebx 3=cd base  1 pri.master  2 pri slave,
                    3 sec master  4 sec slave
     ebx 4=sb16 base, base io address
     ebx 5=system language, 1eng 2fi 3ger 4rus
     ebx 6=wss base, base io address
     ebx 7=hd base, 1 pri.master  2 pri slave
                    3 sec master  4 sec slave
     ebx 8=fat32 partition in hd
     ebx 9=1/100 timer tics from start -> eax
     return value in eax
*********************************************************/
 
inline fastcall dword sys_get_setup_devices(dword EBX)
{
  EAX = 26;
  $int 0x40
}
 
 
/*********************************************************
27 = WINDOWS SOUND SYSTEM
     ebx 1 - set main volume to cl 0-255
     ebx 2 - set cd   volume to cl 0-255
*********************************************************/
 
inline fastcall void sys_windows_sound_system(dword EBX, ECX)
{
  EAX = 27;
  $int 0x40
}
 
 
/*********************************************************
28 = SB16 - mixer II
     ebx 1 - set main volume to cl 0-255
     ebx 2 - set cd   volume to cl 0-255
*********************************************************/
 
inline fastcall void sys_sb16_mixer_2(dword EBX, ECX)
{
  EAX = 28;
  $int 0x40
}
 
 
/*********************************************************
29 = GET DATE
     ret: eax 0x00YYDDMM year date month
*********************************************************/
 
inline fastcall dword sys_get_date()
{
  EAX = 29;
  $int 0x40
}
 
 
/*********************************************************
30 = READ HD
     ebx  pointer to file
     ecx  file lenght
     edx  block to read, starts from 1, blocksize = 512 bytes
     esi  reserved, set as 1
     edi  pointer to return/work area (atleast 20 000 bytes)
     return: work_area+1024 <- requested block of 512 bytes
*********************************************************/
 
inline fastcall dword sys_read_hd(dword EBX, ECX, EDX, ESI, EDI)
{
  EAX = 30;
  $int 0x40
}
 
 
/*********************************************************
31 = START APP FROM HD
     ebx  pointer to file
     ecx  file lenght
     edx  pointer to return/work area (atleast 20 000 bytes)
     ret  eax=0 successful, eax<>0 errorcode
*********************************************************/
 
inline fastcall dword sys_exec_app_hd()
{
  EAX = 31;
  $int 0x40
}
 
 
/*********************************************************
32 = DELETE FILE FROM FLOPPY IMAGE IN MEMORY
     ebx  pointer to filename
*********************************************************/
 
inline fastcall dword sys_floppy_delete(EBX)
{
  EAX = 32;
  $int 0x40
}
 
 
/*********************************************************
33 = SAVE FILE TO FLOPPY IMAGE IN MEMORY
     ebx  pointer to file name
     ecx  pointer to data
     edx  count to write in bytes
     esi  0 create new , ( 1 append - not implemented yet )
*********************************************************/
 
inline fastcall dword sys_floppy_save(EBX,ECX,EDX)
{
  EAX = 33;
  ESI = 0;
  $int 0x40
}
 
 
/*********************************************************
34 = READ DIRECTORY FROM FLOPPY
     ebx  reserved : set as zero
     ecx  reserved : set as zero
     edx  start 512 block to read
     esi  reserved : set as 1
     edi  pointer to return area
*********************************************************/
 
/*********************************************************
35 = READ SCREEN PIXEL
     ebx = pixel count from top left of the screen
     return : eax = 0x00RRGGBB
*********************************************************/
 
inline fastcall dword sys_read_pixel(dword EBX)
{
  EAX = 35;
  $int 0x40
}
 
 
/*********************************************************
37 = READ MOUSE POSITION
     ebx=0 screen relative
     ebx=1 window relative
     ebx=2 buttons pressed
     return in eax
*********************************************************/
 
inline fastcall dword sys_read_mouse(dword EBX)
{
  EAX = 37;
  $int 0x40
}
 
 
/*********************************************************
38 = DRAW LINE
     ebx  [x start] shl 16 + [x end]
     ecx  [y start] shl 16 + [y end]
     edx  colour 0x00RRGGBB
     return : nothing changed
*********************************************************/
 
inline fastcall void sys_draw_line(dword EBX, ECX, EDX)
{
  EAX = 38;
  $int 0x40
}
 
 
/*********************************************************
39 = GET BACKGROUND
     ebx=1 -> eax=[bgr x size] shl 16 + [bgr y size]
     ebx=2
       ecx= postition of backgrounds memorymap to return in eax
     ebx=4 -> eax=1 tiled, eax=2 stretched
*********************************************************/
 
inline fastcall dword sys_get_background(dword EBX, ECX)
{
  EAX = 39;
  $int 0x40
}
 
 
/*********************************************************
40 = SET BITFIELD FOR WANTED EVENTS
     as default:
     ebx = 00000000 00000000 00000000 00000111b  events:
                                             I   window draw
                                            I    key in buffer
                                           I     button in buffer
                                          I      (end request)
                                         I       desktop background draw
                                        I        mouse change
                                       I         IPC message
                                      I          stack
           I---------------I                     get irqs data
 
*********************************************************/
 
//sys_set_event_mask()
//{
//}
 
/*********************************************************
41 = GET IRQ OWNER
     ebx = irq
     return : PID of the process
*********************************************************/
 
/*********************************************************
42 = GET DATA READ BY IRQ
     ebx  IRQ number
     return :  eax  number of bytes in buffer
                bl  data
               ecx  0 = successful data read
                    1 = no data in buffer
                    2 = incorrect IRQ owner
*********************************************************/
 
/*********************************************************
43 = SEND/READ DATA TO/FROM DEVICE
   
     SEND:
 
     bl : data
     cx : port
 
     return: eax: status of read ( 0 if successful, other if error )
 
     READ:
 
     ecx : bit 31 set + port
 
     return: eax: 0 status of read ( 0 if successful, other if error )
             ebx: low 8 bits : value
*********************************************************/
 
inline fastcall dword sys_read_port(word CX)
{
  EAX = 43;
  ECX |= 0x80000000;   // set bit 31
  $int 0x40
}
 
inline fastcall dword sys_read_port_fast(dword ECX)
{
  EAX = 43;
  $int 0x40
}
 
inline fastcall dword sys_write_port(word CX,byte BL)
{
  EAX = 43;
  $int 0x40
}
 
 
/*********************************************************
44 = PROGRAM IRQ's
     ebx  pointer to table
     ecx  irq number
*********************************************************/
 
inline fastcall void sys_program_irqs(dword EBX,ECX)
{
  EAX = 44;
  $int 0x40
}
 
 
/*********************************************************
45 = RESERVE/FREE IRQ
     ebx  0 reserve  1 free
     ecx  IRQ number
 
     ret  eax 0 successful,  1 error
*********************************************************/
 
inline fastcall dword sys_reserve_irq(dword ECX)
{
  EAX = 45;
  EBX = 0;
  $int 0x40
}
 
inline fastcall dword sys_free_irq(dword ECX)
{
  EAX = 45;
  EBX = 1;
  $int 0x40
}
 
 
/*********************************************************
46 = RESERVE/FREE PORT AREA
     ebx  0 reserve  1 free
     ecx  port area start
     edx  port area end
     ret  eax 0 successful,  1 error
*********************************************************/
 
inline fastcall dword sys_reserve_port_area(dword ECX,EDX)
{
  EAX = 46;
  EBX = 0;
  $int 0x40
}
 
inline fastcall dword sys_free_port_area()
{
  EAX = 46;
  EBX = 1;
  $int 0x40
}
 
 
/*********************************************************
47 = DISPLAY NUMBER TO WINDOW
     ebx = print type, bl=0 -> ecx is number
                       bl=1 -> ecx is pointer
                       bh=0 -> display decimal
                       bh=1 -> display hexadecimal
                       bh=2 -> display binary
           bits 16-21 = number of digits to display (0-32)
           bits 22-31 = reserved
     ecx = number or pointer
     edx = x shl 16 + y
     esi = color
*********************************************************/
inline fastcall void sys_write_number(dword EBX, ECX, EDX, ESI)
{
  EAX = 47;
  $int 0x40
}
 
 
/*********************************************************
48 = DEFINE GENERAL WINDOW PROPERTIES
     ebx = 0      apply/redraw
        ecx = 0 , apply/redraw desktop
     ebx = 1      define button style
        ecx = 0 , set flat buttons
        ecx = 1 , set 3d buttons
     ebx = 2      define window colors
        ecx = pointer to table
        edx = number of bytes defined
     ebx = 3      get define window colors
        ecx = pointer to table
        edx = number of bytes to get
     ebx = 4      get window skin height
*********************************************************/
 
inline fastcall void sys_redraw_desktop()
{
  EAX = 48;
  EBX = ECX = 0;
  $int 0x40
}
 
inline fastcall void sys_set_button_style(dword ECX)
{
  EAX = 48;
  EBX = 1;
  $int 0x40
}
 
inline fastcall void sys_set_colors(dword ECX,EDX)
{
  EAX = 48;
  EBX = 2;
  $int 0x40
}
 
inline fastcall void sys_get_colors(dword ECX,EDX)
{
  EAX = 48;
  EBX = 3;
  $int 0x40
}
 
inline fastcall dword sys_get_skin_height()
{
  EAX = 48;
  EBX = 4;
  $int 0x40
}
 
 
/*********************************************************
50 = FREE FORM WINDOW SHAPE AND SCALE
     ebx = 0 ; shape reference area
       ecx = pointer to reference area
             byte per pixel, 0 not used, 1=used, other = reserved
     ebx = 1 ; scale of reference area (default 1:1)
       ecx : scale is set to 2^ecx
     return: nothing changed
*********************************************************/
 
inline void sys_freeform_window(dword EBX,ECX)
{
  EAX = 50;
  $int 0x40
}
 
 
/*********************************************************
51 = CREATE THREAD
     ebx = 1  ; create
       ecx    ; = thread entry point
       edx    ; = thread stack position
     return : eax = pid or 0xfffffff0+ for error
*********************************************************/
 
inline fastcall dword sys_create_thread(dword ECX,EDX)
{
  EAX = 51;
  EBX = 1;
  $int 0x40
}
 
 
/*********************************************************
52 = STACK DRIVER STATUS
     - see stack.txt
           net.h--
 
 
53 = SOCKET INTERFACE
     - see stack.txt
           net.h--
*********************************************************/
 
 
/*********************************************************
55 = SOUND INTERFACE
   
     ebx = 0     ; load sound block
       ecx =     ; pointer to (default size 65536 byte) soundblock
   
     ebx = 1     ; play (default 44 khz 8 bit mono) sound block
 
     ebx = 2     ; set format
       ecx = 1   ; set play block length
         edx =   ; block length
*********************************************************/
 
inline fastcall void sys_sound_load(dword ECX)
{
  EAX = 55;
  EBX = 0;
  $int 0x40
}
 
inline fastcall void sys_sound_play()
{
  EAX = 55;
  EBX = 1;
  $int 0x40
}
 
inline fastcall void sys_sound_format_length(dword EDX)
{
  EAX = 55;
  EBX = 2;
  ECX = 1;
  $int 0x40
}
 
 
/*********************************************************
56 = WRITE FILE TO HD
     ebx  pointer to 12 char filename
     ecx  bytes to write
     edx  pointer to data to write
     esi  pointer to path
          path db 0
*********************************************************/
 
 
/*********************************************************
57 = DELETE FILE FROM HD
     ebx   pointer to filename : 11 capital letters
     edx   pointer to path : path db 0
*********************************************************/
 
 
/*********************************************************
58 = SYSTEM TREE ACCESS
     ebx    pointer to fileinfo block
     fileinfo:
     dd   0x0                  ; 0=read (/write/delete/append)
     dd   0x0                  ; 512 block to read 0+
     dd   0x1                  ; blocks to read (/bytes to write/append)
     dd   0x20000              ; return data pointer
     dd   0x10000              ; work area for os - 16384 bytes
     db   '/RAMDISK/FIRST/KERNEL.ASM',0  ; ASCIIZ dir & filename
*********************************************************/
inline fastcall void sys_tree_access(dword EBX)
{
  EAX = 58;
  $int 0x40
}
 
 
/*********************************************************
59 = TRACE FOR SYSTEM CALLS FROM PROCESSES
     ebx = 0   ; get system events
       ecx     ; pointer to table  -> ; 64 bytes/system call descriptor
                                      ; +00 PID
                                      ; +32 EDI
                                      ; +36 ESI
                                      ; +40 EBP
                                      ; +44 ESP
                                      ; +48 EBX
                                      ; +52 EDX
                                      ; +56 ECX
                                      ; +60 EAX
       edx     ; number of bytes to return to table (currently max 16*64)
     return:  eax = number of system calls from start
                     latest call is saved to (eax mod 16)*64 in table
               ebx = 0 : above format
*********************************************************/
 
inline fastcall void sys_syscall_trace(dword ECX,EDX)
{
  EAX = 59;
  EBX = 0;
  $int 0x40
}
 
 
/*********************************************************
60 = IPC
	ebx = 1 ; define receive area
		ecx = pointer to start
		edx = size of area
 
	ebx = 2 ; send message
		ecx = PID
		edx = pointer to message
		esi = length
*********************************************************/
 
inline fastcall void sys_ipc_init(dword ECX, EDX)
{
  EAX = 60;
  EBX = 1;
  $int 0x40
}
 
inline fastcall void sys_ipc_send(dword ECX, EDX, ESI)
{
  EAX = 60;
  EBX = 2;
  $int 0x40
}
 
 
/*********************************************************
63 = GENERAL DEBUG BOARD
   
     ebx = 1 write byte in cl
     ebx = 2 read byte : ebx = 1 -> byte in al ; ebx = 0 -> no data
*********************************************************/
 
inline fastcall void sys_debug_write_char(byte CL)
{
  EAX = 63;
  EBX = 1;
  $int 0x40
}
 
:fastcall void sys_debug_write_string(dword ESI)
{
  $pusha
  CL = DSBYTE[ESI];
  while(CL!=0)
  {
    sys_debug_write_char(CL);
    ESI++;
    CL = DSBYTE[ESI];
  }
  $popa
}
 
inline fastcall dword sys_debug_read_char(dword EBX)
{
  EAX = 63;
  EBX = 2;
  $int 0x40
}
 
 
inline fastcall dword window_move_size(dword EBX,ECX,EDX,ESI){
	EAX = 67;
	$int 0x40
}
 
 
/*********************************************************
-1 = EXIT PROCESS
*********************************************************/
 
inline fastcall void sys_exit_process()
{
 $or  eax,0xffffffff
 $int 0x40
}

Rev 7661	Rev 7786
1	/*	1	/*
2	Sphinx C-- header file for KolibriOS applications.	2	Sphinx C-- header file for KolibriOS applications.
3	Based on msys.h-- written by Alexey Sugonyaev and modified by Barry Kauler.	3	Based on msys.h-- written by Alexey Sugonyaev and modified by Barry Kauler.
4	This file is rewritten by Ivan Poddubny.	4	This file is rewritten by Ivan Poddubny.
5		5
6	e-mail: ivan-yar@bk.ru	6	e-mail: ivan-yar@bk.ru
7	*/	7	*/
8		8
9	// KeyCode constant	9	// KeyCode constant
10	#define UP_KEY 130+48	10	#define UP_KEY 130+48
11	#define DOWN_KEY 129+48	11	#define DOWN_KEY 129+48
12	#define LEFT_KEY 128+48	12	#define LEFT_KEY 128+48
13	#define RIGHT_KEY 131+48	13	#define RIGHT_KEY 131+48
14	#define RETURN_KEY 13	14	#define RETURN_KEY 13
15	#define BACKSPACE_KEY 8	15	#define BACKSPACE_KEY 8
16		16
17	//Button options	17	//Button options
18	#define BT_DEL 0x80000000	18	#define BT_DEL 0x80000000
19	#define BT_HIDE 0x40000000	19	#define BT_HIDE 0x40000000
20	#define BT_NOFRAME 0x20000000	20	#define BT_NOFRAME 0x20000000
21		21
22	// Color constant	22	// Color constant
23	#define clWhite 0x00ffffff	23	#define clWhite 0x00ffffff
24	#define clGray 0x00808080	24	#define clGray 0x00808080
25	#define clLightGray 0x00c0c0c0	25	#define clLightGray 0x00c0c0c0
26	#define clWhiteGray 0x00E2E2E2	26	#define clWhiteGray 0x00E2E2E2
27	#define clDarkGray 0x00707070	27	#define clDarkGray 0x00707070
28	#define clBlack 0x00000000	28	#define clBlack 0x00000000
29	#define clRed 0x00ff0000	29	#define clRed 0x00ff0000
30	#define clGreen 0x0000ff00	30	#define clGreen 0x0000ff00
31	#define clBlue 0x000000ff	31	#define clBlue 0x000000ff
32		32
33	// Events	33	// Events
34	#define evReDraw 1	34	#define evReDraw 1
35	#define evKey 2	35	#define evKey 2
36	#define evButton 3	36	#define evButton 3
37	#define evMouse 6	37	#define evMouse 6
38	#define evIPC 7	38	#define evIPC 7
39	#define evStack 8	39	#define evStack 8
40		40
41	#define OLD -1	41	#define OLD -1
42		42
43	struct FileInfo	43	struct FileInfo
44	{	44	{
45	dword read,	45	dword read,
46	firstBlock,	46	firstBlock,
47	qnBlockRead,	47	qnBlockRead,
48	retPtr,	48	retPtr,
49	Work;	49	Work;
50	byte filedir;	50	byte filedir;
51	};	51	};
52		52
53	struct ProcessInfo	53	struct ProcessInfo
54	{	54	{
55	dword cpu_usage;	55	dword cpu_usage;
56	word winstackpos;	56	word winstackpos;
57	word winstackval;	57	word winstackval;
58	word not_used1;	58	word not_used1;
59	byte name[12];	59	byte name[12];
60	dword memstart,	60	dword memstart,
61	memory_used,	61	memory_used,
62	PID,	62	PID,
63	xstart,	63	xstart,
64	ystart,	64	ystart,
65	xsize,	65	xsize,
66	ysize;	66	ysize;
67	byte not_used2[974];	67	byte not_used2[974];
68	};	68	};
69		69
70	#define SystemColors SystemColours // usa/british	70	#define SystemColors SystemColours // usa/british
71		71
72	struct SystemColours	72	struct SystemColours
73	{	73	{
74	dword nonset1,	74	dword nonset1,
75	nonset2,	75	nonset2,
76	work_3d_dark,	76	work_dark,
77	work_3d_light,	77	work_light,
78	w_title,	78	w_title,
79	w_work,	79	w_work,
80	w_work_button,	80	w_work_button,
81	w_work_button_text,	81	w_work_button_text,
82	w_work_text,	82	w_work_text,
83	w_work_graph;	83	w_work_graph;
84	};	84	};
85		85
86	/*********************************************************	86	/*********************************************************
87	0 = DEFINE WINDOW	87	0 = DEFINE WINDOW
88	{x_start\|y_start}, {x_size\|y_size}, color_back, color_title, color_frames	88	{x_start\|y_start}, {x_size\|y_size}, color_back, color_title, color_frames
89	EBX = [x_start][x_size]	89	EBX = [x_start][x_size]
90	ECX = [y_start][y_size]	90	ECX = [y_start][y_size]
91	EDX, ESI, EDI = [00RRGGBB]	91	EDX, ESI, EDI = [00RRGGBB]
92	*********************************************************/	92	*********************************************************/
93		93
94	inline fastcall void sys_draw_window(dword EBX, ECX, EDX, ESI, EDI)	94	inline fastcall void sys_draw_window(dword EBX, ECX, EDX, ESI, EDI)
95	{	95	{
96	EAX = 0; // function 0 : define and draw window	96	EAX = 0; // function 0 : define and draw window
97	$int 0x40	97	$int 0x40
98	}	98	}
99		99
100		100
101	/*********************************************************	101	/*********************************************************
102	01 = PUTPIXEL	102	01 = PUTPIXEL
103	ebx [x]	103	ebx [x]
104	ecx [y]	104	ecx [y]
105	edx pixel color 0x0XRRGGBB	105	edx pixel color 0x0XRRGGBB
106	^ 0 normal put, 1 negative	106	^ 0 normal put, 1 negative
107	ret: nothing changed	107	ret: nothing changed
108	*********************************************************/	108	*********************************************************/
109		109
110	inline fastcall void sys_put_pixel(dword EBX,ECX,EDX)	110	inline fastcall void sys_put_pixel(dword EBX,ECX,EDX)
111	{	111	{
112	EAX=1;	112	EAX=1;
113	$int 0x40	113	$int 0x40
114	}	114	}
115		115
116		116
117	/*********************************************************	117	/*********************************************************
118	02 = GET KEY	118	02 = GET KEY
119	ret: al 0 successful -> ah = key	119	ret: al 0 successful -> ah = key
120	al 1 no key in buffer	120	al 1 no key in buffer
121	MODIFIED, see below...	121	MODIFIED, see below...
122	*********************************************************/	122	*********************************************************/
123		123
124	inline fastcall dword sys_get_key()	124	inline fastcall dword sys_get_key()
125	{	125	{
126	EAX = 2; // just read it key from buffer	126	EAX = 2; // just read it key from buffer
127	$int 0x40	127	$int 0x40
128	$shr eax,8	128	$shr eax,8
129	} //return eax=key code.	129	} //return eax=key code.
130		130
131		131
132	/*********************************************************	132	/*********************************************************
133	03 = GET SYSTEM CLOCK	133	03 = GET SYSTEM CLOCK
134	ret: eax 0x00SSMMHH sec,min,hour	134	ret: eax 0x00SSMMHH sec,min,hour
135	*********************************************************/	135	*********************************************************/
136		136
137	#define sys_get_time sys_get_clock	137	#define sys_get_time sys_get_clock
138	inline fastcall dword sys_get_clock()	138	inline fastcall dword sys_get_clock()
139	{	139	{
140	EAX=3;	140	EAX=3;
141	$int 0x40	141	$int 0x40
142	}	142	}
143		143
144		144
145	/*********************************************************	145	/*********************************************************
146	04 = WRITE TEXT TO WINDOW	146	04 = WRITE TEXT TO WINDOW
147	ebx [x start]*65536 + [y start]	147	ebx [x start]*65536 + [y start]
148	ecx text color 0x00RRGGBB	148	ecx text color 0x00RRGGBB
149	edx pointer to text beginning	149	edx pointer to text beginning
150	esi text length	150	esi text length
151	return: nothing changed	151	return: nothing changed
152	*********************************************************/	152	*********************************************************/
153		153
154	#define sys_print_text sys_write_text	154	#define sys_print_text sys_write_text
155	inline fastcall void sys_write_text(dword EBX, ECX, EDX, ESI)	155	inline fastcall void sys_write_text(dword EBX, ECX, EDX, ESI)
156	{	156	{
157	EAX = 4;	157	EAX = 4;
158	$int 0x40;	158	$int 0x40;
159	}	159	}
160		160
161	inline fastcall void sys_write_char(dword EBX, ECX, EDX)	161	inline fastcall void sys_write_char(dword EBX, ECX, EDX)
162	{	162	{
163	EAX = 4;	163	EAX = 4;
164	ESI = 1;	164	ESI = 1;
165	$int 0x40	165	$int 0x40
166	}	166	}
167		167
168		168
169	/*********************************************************	169	/*********************************************************
170	05 = DELAY X/100 SECS	170	05 = DELAY X/100 SECS
171	ebx delay in 1/100 secs	171	ebx delay in 1/100 secs
172	ret: nothing changed	172	ret: nothing changed
173	*********************************************************/	173	*********************************************************/
174		174
175	#define sys_wait sys_delay	175	#define sys_wait sys_delay
176	inline fastcall void sys_delay(dword EBX)	176	inline fastcall void sys_delay(dword EBX)
177	{	177	{
178	EAX = 5;	178	EAX = 5;
179	$int 0x40	179	$int 0x40
180	}	180	}
181		181
182		182
183	/*********************************************************	183	/*********************************************************
184	06 = OPEN FILE FROM FLOPPY	184	06 = OPEN FILE FROM FLOPPY
185	ebx pointer to filename -> 11 capital letters	185	ebx pointer to filename -> 11 capital letters
186	ecx set 0x00000000 - reserved	186	ecx set 0x00000000 - reserved
187	edx set 0xffffffff - reserved	187	edx set 0xffffffff - reserved
188	esi read to mem position	188	esi read to mem position
189	ret: ebx = file size	189	ret: ebx = file size
190	*********************************************************/	190	*********************************************************/
191		191
192	inline fastcall dword sys_open_file_floppy(dword EBX, ESI)	192	inline fastcall dword sys_open_file_floppy(dword EBX, ESI)
193	{	193	{
194	ECX = 0;	194	ECX = 0;
195	EDX = -1;	195	EDX = -1;
196	EAX = 6;	196	EAX = 6;
197	$int 0x40	197	$int 0x40
198	}	198	}
199		199
200		200
201	/*********************************************************	201	/*********************************************************
202	07 = PUTIMAGE	202	07 = PUTIMAGE
203	ebx pointer to image in memory - RRGGBBRRGGBB..	203	ebx pointer to image in memory - RRGGBBRRGGBB..
204	ecx image size [x]*65536+[y]	204	ecx image size [x]*65536+[y]
205	edx image position in window [x]*65536+[y]	205	edx image position in window [x]*65536+[y]
206	ret: eax 0 succesful, 1 overlapped	206	ret: eax 0 succesful, 1 overlapped
207	*********************************************************/	207	*********************************************************/
208		208
209	inline fastcall dword sys_put_image(dword EBX, ECX, EDX)	209	inline fastcall dword sys_put_image(dword EBX, ECX, EDX)
210	{	210	{
211	EAX = 7;	211	EAX = 7;
212	$int 0x40	212	$int 0x40
213	}	213	}
214		214
215		215
216	/*********************************************************	216	/*********************************************************
217	08 = DEFINE BUTTON	217	08 = DEFINE BUTTON
218	ebx [x start]*65536 + [x size]	218	ebx [x start]*65536 + [x size]
219	ecx [y start]*65536 + [y size]	219	ecx [y start]*65536 + [y size]
220	edx button id number	220	edx button id number
221	esi button color 0x 00 RR GG BB	221	esi button color 0x 00 RR GG BB
222	ret: nothing changed	222	ret: nothing changed
223	*********************************************************/	223	*********************************************************/
224		224
225	inline fastcall void sys_draw_button(dword EBX, ECX, EDX, ESI)	225	inline fastcall void sys_draw_button(dword EBX, ECX, EDX, ESI)
226	{	226	{
227	EAX = 8;	227	EAX = 8;
228	$int 0x40	228	$int 0x40
229	}	229	}
230		230
231	inline fastcall void sys_delete_button(dword EDX)	231	inline fastcall void sys_delete_button(dword EDX)
232	{	232	{
233	EAX = 8;	233	EAX = 8;
234	EDX \|= 0x80000000;	234	EDX \|= 0x80000000;
235	$int 0x40	235	$int 0x40
236	}	236	}
237		237
238		238
239	/*********************************************************	239	/*********************************************************
240	09 = PROCESS INFO	240	09 = PROCESS INFO
241	ebx pointer to 1024 bytes table	241	ebx pointer to 1024 bytes table
242	ecx process number or -1 = who am I	242	ecx process number or -1 = who am I
243	ret: eax number of processes	243	ret: eax number of processes
244	table : +00 dword cpu usage	244	table : +00 dword cpu usage
245	+04 word processes position in windowing stack	245	+04 word processes position in windowing stack
246	+06 word window stack value at ecx	246	+06 word window stack value at ecx
247	+10 12 db name of the process	247	+10 12 db name of the process
248	+22 dword start of processes memory	248	+22 dword start of processes memory
249	+26 dword memory used by process	249	+26 dword memory used by process
250	+30 dword PID of the process	250	+30 dword PID of the process
251	+34 dword window x start	251	+34 dword window x start
252	+38 dword window y start	252	+38 dword window y start
253	+42 dword window x size	253	+42 dword window x size
254	+46 dword window y size	254	+46 dword window y size
255	*********************************************************/	255	*********************************************************/
256		256
257	inline fastcall dword sys_process_info(dword EBX, ECX)	257	inline fastcall dword sys_process_info(dword EBX, ECX)
258	{	258	{
259	EAX = 9;	259	EAX = 9;
260	$int 0x40	260	$int 0x40
261	}	261	}
262		262
263		263
264	/*********************************************************	264	/*********************************************************
265	10 = WAIT FOR EVENT	265	10 = WAIT FOR EVENT
266	ret: eax event type,	266	ret: eax event type,
267	1 window redraw,	267	1 window redraw,
268	2 key in buffer,	268	2 key in buffer,
269	3 button pressed	269	3 button pressed
270	*********************************************************/	270	*********************************************************/
271		271
272	inline fastcall dword sys_wait_event()	272	inline fastcall dword sys_wait_event()
273	{	273	{
274	EAX = 10; // wait here for event	274	EAX = 10; // wait here for event
275	$int 0x40	275	$int 0x40
276	}	276	}
277		277
278		278
279	/*********************************************************	279	/*********************************************************
280	11 = CHECK FOR EVENT, NO WAIT	280	11 = CHECK FOR EVENT, NO WAIT
281	ret: eax 0 no event,	281	ret: eax 0 no event,
282	1 window redraw,	282	1 window redraw,
283	2 key in buffer,	283	2 key in buffer,
284	3 button pressed	284	3 button pressed
285	*********************************************************/	285	*********************************************************/
286		286
287	inline fastcall dword sys_nowait_event()	287	inline fastcall dword sys_nowait_event()
288	{	288	{
289	EAX = 11;	289	EAX = 11;
290	$int 0x40	290	$int 0x40
291	}	291	}
292		292
293		293
294	/*********************************************************	294	/*********************************************************
295	12 = WINDOW REDRAW	295	12 = WINDOW REDRAW
296	EBX=1 start of draw, =2 end of draw.	296	EBX=1 start of draw, =2 end of draw.
297	*********************************************************/	297	*********************************************************/
298		298
299	inline fastcall void sys_window_redraw(dword EBX)	299	inline fastcall void sys_window_redraw(dword EBX)
300	{	300	{
301	EAX = 12; // function 12:tell os about windowdraw	301	EAX = 12; // function 12:tell os about windowdraw
302	$int 0x40	302	$int 0x40
303	}	303	}
304		304
305	inline fastcall void sys_begin_draw()	305	inline fastcall void sys_begin_draw()
306	{	306	{
307	EAX = 12;	307	EAX = 12;
308	EBX = 1;	308	EBX = 1;
309	$int 0x40	309	$int 0x40
310	}	310	}
311		311
312	inline fastcall void sys_end_draw()	312	inline fastcall void sys_end_draw()
313	{	313	{
314	EAX = 12;	314	EAX = 12;
315	EBX = 2;	315	EBX = 2;
316	$int 0x40	316	$int 0x40
317	}	317	}
318		318
319	/*********************************************************	319	/*********************************************************
320	13 = DRAW BAR	320	13 = DRAW BAR
321	DrawBar(EBX=[xstart][xsize],ECX=[ystart][ysize],EDX=[0x00RRGGBB])	321	DrawBar(EBX=[xstart][xsize],ECX=[ystart][ysize],EDX=[0x00RRGGBB])
322	ebx [x start]*65536 + [x size]	322	ebx [x start]*65536 + [x size]
323	ecx [y start]*65536 + [y size]	323	ecx [y start]*65536 + [y size]
324	edx color 0x00RRGGBB	324	edx color 0x00RRGGBB
325	ret: nothing changed	325	ret: nothing changed
326	*********************************************************/	326	*********************************************************/
327		327
328	inline fastcall void sys_draw_bar(dword EBX, ECX, EDX)	328	inline fastcall void sys_draw_bar(dword EBX, ECX, EDX)
329	{	329	{
330	EAX = 13;	330	EAX = 13;
331	$int 0x40	331	$int 0x40
332	}	332	}
333		333
334		334
335	/*********************************************************	335	/*********************************************************
336	14 = GET SCREEN MAX	336	14 = GET SCREEN MAX
337	ret: eax [screen x max]*65536 + [screen y max]	337	ret: eax [screen x max]*65536 + [screen y max]
338	*********************************************************/	338	*********************************************************/
339		339
340	inline fastcall dword sys_get_screen_size()	340	inline fastcall dword sys_get_screen_size()
341	{	341	{
342	EAX = 14;	342	EAX = 14;
343	$int 0x40	343	$int 0x40
344	}	344	}
345		345
346		346
347	/*********************************************************	347	/*********************************************************
348	15 = BACKGROUND	348	15 = BACKGROUND
349	ebx 1 : set background size	349	ebx 1 : set background size
350	ecx x size	350	ecx x size
351	edx y size	351	edx y size
352	ebx 2 : write to background memory - max (0x100000-16)	352	ebx 2 : write to background memory - max (0x100000-16)
353	ecx position in memory in bytes	353	ecx position in memory in bytes
354	edx color 0x00RRGGBB	354	edx color 0x00RRGGBB
355	ebx 3 : draw background	355	ebx 3 : draw background
356	ebx 4 : type of background draw	356	ebx 4 : type of background draw
357	ecx 1 - tile	357	ecx 1 - tile
358	ecx 2 - stretch	358	ecx 2 - stretch
359	ebx 5 : blockmove image to os bgr memory	359	ebx 5 : blockmove image to os bgr memory
360	ecx - from	360	ecx - from
361	edx - to where in os bgr memory	361	edx - to where in os bgr memory
362	esi - count of bytes to move	362	esi - count of bytes to move
363	*********************************************************/	363	*********************************************************/
364		364
365	inline fastcall void sys_set_background(dword EBX, ECX, EDX, ESI)	365	inline fastcall void sys_set_background(dword EBX, ECX, EDX, ESI)
366	{	366	{
367	EAX = 15;	367	EAX = 15;
368	$int 0x40	368	$int 0x40
369	}	369	}
370		370
371		371
372	/*********************************************************	372	/*********************************************************
373	17 = GET PRESSED BUTTON ID	373	17 = GET PRESSED BUTTON ID
374	ret: al 0 successful -> ah = id number al 1 no key in buffer.	374	ret: al 0 successful -> ah = id number al 1 no key in buffer.
375	MODIFIED, see below.	375	MODIFIED, see below.
376	*********************************************************/	376	*********************************************************/
377		377
378	inline fastcall dword sys_get_button_id()	378	inline fastcall dword sys_get_button_id()
379	{	379	{
380	EAX = 17; // Get ID	380	EAX = 17; // Get ID
381	$int 0x40	381	$int 0x40
382	$shr eax,8	382	$shr eax,8
383	} //eax=id, eax=0 no id.	383	} //eax=id, eax=0 no id.
384		384
385		385
386	/*********************************************************	386	/*********************************************************
387	18 = SYSTEM SERVICE	387	18 = SYSTEM SERVICE
388	ebx 1 - system boot	388	ebx 1 - system boot
389	ebx 2 - force terminate , ecx process no	389	ebx 2 - force terminate , ecx process no
390	ebx 4 - idle clock cycles / second	390	ebx 4 - idle clock cycles / second
391	ebx 5 - time stamp counter / second - cpu speed	391	ebx 5 - time stamp counter / second - cpu speed
392	HD-> ebx 6 - save ramdisk to /hd/1/menuet.img	392	HD-> ebx 6 - save ramdisk to /hd/1/menuet.img
393	*********************************************************/	393	*********************************************************/
394		394
395	inline fastcall dword sys_service(dword EBX, ECX)	395	inline fastcall dword sys_service(dword EBX, ECX)
396	{	396	{
397	EAX = 18;	397	EAX = 18;
398	$int 0x40	398	$int 0x40
399	}	399	}
400		400
401	inline fastcall void sys_shutdown()	401	inline fastcall void sys_shutdown()
402	{	402	{
403	EAX = 18;	403	EAX = 18;
404	EBX = 1;	404	EBX = 1;
405	$int 0x40	405	$int 0x40
406	}	406	}
407		407
408	inline fastcall void sys_kill(dword ECX)	408	inline fastcall void sys_kill(dword ECX)
409	{	409	{
410	EAX = 18;	410	EAX = 18;
411	EBX = 2;	411	EBX = 2;
412	$int 0x40	412	$int 0x40
413	}	413	}
414		414
415	inline fastcall dword sys_get_idle()	415	inline fastcall dword sys_get_idle()
416	{	416	{
417	EAX = 18;	417	EAX = 18;
418	EBX = 4;	418	EBX = 4;
419	$int 0x40	419	$int 0x40
420	}	420	}
421		421
422	inline fastcall dword sys_get_tscsec()	422	inline fastcall dword sys_get_tscsec()
423	{	423	{
424	EAX = 18;	424	EAX = 18;
425	EBX = 5;	425	EBX = 5;
426	$int 0x40	426	$int 0x40
427	}	427	}
428		428
429		429
430	/*********************************************************	430	/*********************************************************
431	19 = START PROGRAM from RAMDISK	431	19 = START PROGRAM from RAMDISK
432	ebx point to 11 char filename	432	ebx point to 11 char filename
433	ecx 0, or point to ASCIIZ start parameters - max 256 bytes	433	ecx 0, or point to ASCIIZ start parameters - max 256 bytes
434	ret: eax 0 successful	434	ret: eax 0 successful
435	eax other error code	435	eax other error code
436	*********************************************************/	436	*********************************************************/
437		437
438	inline fastcall dword sys_exec_app_ramdisk(dword EBX, ECX)	438	inline fastcall dword sys_exec_app_ramdisk(dword EBX, ECX)
439	{	439	{
440	EAX = 19;	440	EAX = 19;
441	$int 0x40	441	$int 0x40
442	}	442	}
443		443
444		444
445	/*********************************************************	445	/*********************************************************
446	20 = MIDI INTERFACE - MPU401	446	20 = MIDI INTERFACE - MPU401
447	ebx 1 - reset device	447	ebx 1 - reset device
448	ebx 2 - cl midi data to output	448	ebx 2 - cl midi data to output
449	*********************************************************/	449	*********************************************************/
450		450
451	inline fastcall void sys_midi(dword EBX)	451	inline fastcall void sys_midi(dword EBX)
452	{	452	{
453	EAX = 20;	453	EAX = 20;
454	$int 0x40	454	$int 0x40
455	}	455	}
456		456
457		457
458	/*********************************************************	458	/*********************************************************
459	21 = SETUP FOR DEVICES	459	21 = SETUP FOR DEVICES
460	ebx 1=roland mpu midi base , base io address	460	ebx 1=roland mpu midi base , base io address
461	ebx 2=keyboard 1 base keymap 2 shift keymap (ecx pointer to keymap)	461	ebx 2=keyboard 1 base keymap 2 shift keymap (ecx pointer to keymap)
462	9 country 1eng 2fi 3ger 4rus	462	9 country 1eng 2fi 3ger 4rus
463	ebx 3=cd base 1 pri.master 2 pri slave,	463	ebx 3=cd base 1 pri.master 2 pri slave,
464	3 sec master 4 sec slave	464	3 sec master 4 sec slave
465	ebx 4=sb16 base, base io address	465	ebx 4=sb16 base, base io address
466	ebx 5=system language, 1eng 2fi 3ger 4rus	466	ebx 5=system language, 1eng 2fi 3ger 4rus
467	ebx 6=wss base, base io address	467	ebx 6=wss base, base io address
468	ebx 7=hd base, 1 pri.master 2 pri slave	468	ebx 7=hd base, 1 pri.master 2 pri slave
469	3 sec master 4 sec slave	469	3 sec master 4 sec slave
470	ebx 8=fat32 partition in hd	470	ebx 8=fat32 partition in hd
471	*********************************************************/	471	*********************************************************/
472		472
473	inline fastcall void sys_setup_devices(dword EBX, ECX)	473	inline fastcall void sys_setup_devices(dword EBX, ECX)
474	{	474	{
475	EAX = 21;	475	EAX = 21;
476	$int 0x40	476	$int 0x40
477	}	477	}
478		478
479		479
480	/*********************************************************	480	/*********************************************************
481	23 = WAIT FOR EVENT WITH TIMEOUT	481	23 = WAIT FOR EVENT WITH TIMEOUT
482	ebx time to delay in hs	482	ebx time to delay in hs
483	ret: eax event type: 0 no event, 1 window redraw,	483	ret: eax event type: 0 no event, 1 window redraw,
484	2 key in buffer, 3 button	484	2 key in buffer, 3 button
485	*********************************************************/	485	*********************************************************/
486		486
487	inline fastcall dword sys_wait_event_timeout(dword EBX)	487	inline fastcall dword sys_wait_event_timeout(dword EBX)
488	{	488	{
489	EAX = 23;	489	EAX = 23;
490	$int 0x40	490	$int 0x40
491	}	491	}
492		492
493		493
494	/*********************************************************	494	/*********************************************************
495	24 = CD AUDIO	495	24 = CD AUDIO
496	ebx 1 - play from ecx 00 FR SS MM	496	ebx 1 - play from ecx 00 FR SS MM
497	ebx 2 - get playlist size of ecx to [edx]	497	ebx 2 - get playlist size of ecx to [edx]
498	ebx 3 - stop/pause play	498	ebx 3 - stop/pause play
499	*********************************************************/	499	*********************************************************/
500		500

Subversion Repositories Kolibri OS

(root)/programs/games/mine/trunk/kos_sys.h-- @ 3979 – Rev 7661 → 7786