Subversion Repositories Kolibri OS

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;                                                              ;;

;; Copyright (C) KolibriOS team 2004-2012. All rights reserved. ;;

;; Distributed under terms of the GNU General Public License    ;;

;;                                                              ;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

SYSTEM FUNCTIONS of OS Kolibri 0.7.7.0

Number of the function is located in the register eax.

The call of the system function is executed by "int 0x40" command.

All registers except explicitly declared in the returned value,

    including eflags, are preserved.

======================================================================

============== Function 0 - define and draw the window. ==============

======================================================================

Defines an application window. Draws a frame of the window, header and

working area. For skinned windows defines standard close and minimize

buttons.

Parameters:

  * eax = 0 - function number

  * ebx = [coordinate on axis x]*65536 + [size on axis x]

  * ecx = [coordinate on axis y]*65536 + [size on axis y]

  * edx = 0xXYRRGGBB, where:

    * Y = style of the window:

      * Y=0 - type I - fixed-size window

      * Y=1 - only define window area, draw nothing

      * Y=2 - type II - variable-size window

      * Y=3 - skinned window

      * Y=4 - skinned fixed-size window

      * other possible values (from 5 up to 15) are reserved,

        function call with such Y is ignored

    * RR, GG, BB = accordingly red, green, blue components of a color

      of the working area of the window (are ignored for style Y=1)

    * X = DCBA (bits)

      * A = 1 - window has caption; for styles Y=3,4 caption string

                  must be passed in edi, for other styles use

                  subfunction 1 of function 71

      * B = 1 - coordinates of all graphics primitives are relative to

                  window client area

      * C = 1 - don't fill working area on window draw

      * D = 0 - normal filling of the working area, 1 - gradient

    The following parameters are intended for windows

    of a type I and II, and ignored for styles Y=1,3:

  * esi = 0xXYRRGGBB - color of the header

    * RR, GG, BB define color

    * Y=0 - usual window, Y=1 - unmovable window (works for all window styles)

    * X defines a gradient of header: X=0 - no gradient,

      X=8 - usual gradient,

      for windows of a type II X=4 - negative gradient

    * other values of X and Y are reserved

  * edi = 0x00RRGGBB - color of the frame

Returned value:

  * function does not return value

Remarks:

  * Position and sizes of the window are installed by the first

    call of this function and are ignored at subsequent; to change

    position and/or sizes of already created window use function 67.

  * For windows with styles Y=3,4 and caption (A=1) caption string

    is set by the first call of this function and is ignored

    at subsequent (strictly speaking, is ignored after a call to

    subfunction 2 of function 12 - end redraw); to change caption of

    already created window use subfunction 1 of function 71.

  * If the window has appropriate styles, position and/or sizes can be

    changed by user. Current position and sizes can be obtained

    by function 9.

  * The window must fit on the screen. If the transferred

    coordinates and sizes do not satisfy to this condition,

    appropriate coordinate (or, probably, both) is considered as zero,

    and if it does not help too, the appropriate size

    (or, probably, both) is installed in a size of the screen.

    Further let us designate xpos,ypos,xsize,ysize - values passed

    in ebx,ecx. The coordinates are resulted concerning

    the left upper corner of the window, which, thus, is set as (0,0),

    coordinates of the right lower corner essence (xsize,ysize).

  * The sizes of the window are understood in sence of coordinates

    of the right lower corner. This concerns all other functions too.

    It means, that the real sizes are on 1 pixel more.

  * The window of type I looks as follows:

    * draw external frame of color indicated in edi, 1 pixel in width

    * draw header - rectangle with the left upper corner (1,1) and

      right lower (xsize-1,min(20,ysize-1)) color indicated in esi

      (taking a gradient into account)

    * if ysize>21, fill the working area of the window -

      rectangle with the left upper corner (1,21) and right lower

      (xsize-1,ysize-1) (sizes (xsize-1)*(ysize-21)) with color

      indicated in edx (taking a gradient into account)

    * if A=1 and caption has been already set by subfunction 1

      of function 71, it is drawn in the corresponding place of header

  * The window of style Y=1 looks as follows:

    * completely defined by the application

  * The window of type II looks as follows:

    * draw external frame of width 1 pixel with the "shaded" color

      edi (all components of the color decrease twice)

    * draw intermediate frame of width 3 pixels with color edi

    * draw internal frame of width 1 pixel with the "shaded" color edi

    * draw header - rectangle with the left upper corner (4,4)

      and right lower (xsize-4,min(20,ysize)) color, indicated in esi

      (taking a gradient into account)

    * if ysize>=26, fill the working area of the window -

      rectangle with the left upper corner (5,20) and right lower

      (xsize-5,ysize-5) with color indicated in edx

      (taking a gradient into account)

    * if A=1 and caption has been already set by subfunction 1

      of function 71, it is drawn in the corresponding place of header

  * The skinned window looks as follows:

    * draw external frame of width 1 pixel

      with color 'outer' from the skin

    * draw intermediate frame of width 3 pixel

      with color 'frame' from the skin

    * draw internal frame of width 1 pixel

      with color 'inner' from the skin

    * draw header (on bitmaps from the skin) in a rectangle

      (0,0) - (xsize,_skinh-1)

    * if ysize>=26, fill the working area of the window -

      rectangle with the left upper corner (5,_skinh) and right lower

      (xsize-5,ysize-5) with color indicated in edx

      (taking a gradient into account)

    * define two standard buttons: close and minimize

      (see function 8)

    * if A=1 and edi contains (nonzero) pointer to caption string,

      it is drawn in place in header defined in the skin

    * value _skinh is accessible as the result of call

      subfunction 4 of function 48

======================================================================

================ Function 1 - put pixel in the window. ===============

======================================================================

Parameters:

  * eax = 1 - function number

  * ebx = x-coordinate (relative to the window)

  * ecx = y-coordinate (relative to the window)

  * edx = 0x00RRGGBB - color of a pixel

    edx = 0x01xxxxxx - invert color of a pixel

          (low 24 bits are ignored)

Returned value:

  * function does not return value

======================================================================

============ Function 2 - get the code of the pressed key. ===========

======================================================================

Takes away the code of the pressed key from the buffer.

Parameters:

  * eax = 2 - function number

Returned value:

  * if the buffer is empty, function returns eax=1

  * if the buffer is not empty, function returns al=0,

    ah=code of the pressed key,

    bits 16-23 = contain scancode for pressed key in ASCII mode,

                 in the scancodes mode this bits cleared.

    bits 23-31 = zero

  * if there is "hotkey", function returns al=2,

    ah=scancode of the pressed key (0 for control keys),

    high word of eax contains a status of control keys at the moment

    of pressing a hotkey

Remarks:

  * There is a common system buffer of the pressed keys

    by a size of 120 bytes, organized as queue.

  * There is one more common system buffer on 120 "hotkeys".

  * If the application with the inactive window calls this function,

    the buffer of the pressed keys is considered to be empty.

  * By default this function returns ASCII-codes; to switch

    to the scancodes mode (and back) use function 66.

    However, hotkeys are always notificated as scancodes.

  * To find out, what keys correspond to what codes, start

    the application keyascii and scancode.

  * Scancodes come directly from keyboard and are fixed;

    ASCII-codes turn out with usage of the conversion tables,

    which can be set by subfunction 2 of function 21

    and get by subfunction 2 of function 26.

  * As a consequence, ASCII-codes take into account current

    keyboard layout (rus/en) as opposed to scancodes.

  * This function notifies only about those hotkeys, which were

    defined by this thread by subfunction 4 of function 66.

======================================================================

==================== Function 3 - get system time. ===================

======================================================================

Parameters:

  * eax = 3 - function number

Returned value:

  * eax = 0x00SSMMHH, where HH:MM:SS = Hours:Minutes:Seconds

  * each item is BCD-number, for example,

    for time 23:59:59 function returns 0x00595923

Remarks:

  * See also subfunction 9 of function 26 - get time from

    the moment of start of the system; it is more convenient, because

    returns simply DWORD-value of the time counter.

  * System time can be set by function 22.

======================================================================

============ Function 4 - draw text string in the window. ============

======================================================================

Parameters:

  * eax = 4 - function number

  * ebx = [coordinate on axis x]*65536 + [coordinate on axis y]

  * ecx = 0xXYRRGGBB, where

    * RR, GG, BB specify text color

    * X=ABnn (bits):

      * nn specifies the used font: 0=system monospaced,

        1=system font of variable width

      * A=0 - output esi characters, A=1 - output ASCIIZ-string

      * B=1 - fill background with the color edi

    * Y = Cnnn

      * C=1 redirect the output to the user area, specified in edi

      * nnn - not used in the current, must be 0 (zero)

  * edx = pointer to the beginning of the string

  * esi = for A=0 length of the string, must not exceed 255;

          for A=1 is ignored

  * edi = color to fill background, if B=1

  * edi = pointer to user area, for redirect, if C=1

Returned value:

  * function does not return value

Remarks:

  * First system font is read out at loading from the file char.mt,

    second - from char2.mt.

  * Both fonts have height 9 pixels, width of the monospaced font

    is equal to 6 pixels.

  * C=1, pixel depth = 32 bits, user area is as follows:

    dword Xsize

    dword Ysize

    rest of the area = Xsize * Y size * 4

  * You can not use B = 1 and C = 1, at the same time. Since in both

    cases, the register edi is used for different purposes.

======================================================================

========================= Function 5 - delay. ========================

======================================================================

Delays execution of the program on the given time.

Parameters:

  * eax = 5 - function number

  * ebx = time in the 1/100 of second

Returned value:

  * function does not return value

Remarks:

  * Passing ebx=0 does not transfer control to the next process

    and does not make any operations at all. If it is really required

    to transfer control to the next process (to complete a current

    time slice), use subfunction 1 of function 68.

======================================================================

============== Function 6 - read the file from ramdisk. ==============

======================================================================

Parameters:

  * eax = 6 - function number

  * ebx = pointer to the filename

  * ecx = number of start block, beginning from 1;

    ecx=0 - read from the beginning of the file (same as ecx=1)

  * edx = number of blocks to read;

    edx=0 - read one block (same as edx=1)

  * esi = pointer to memory area for the data

Returned value:

  * eax = file size in bytes, if the file was successfully read

  * eax = -1, if the file was not found

Remarks:

  * This function is out-of-date; function 70 allows

    to fulfil the same operations with the extended possibilities.

  * Block = 512 bytes.

  * For reading all file you can specify the certainly large value

    in edx, for example, edx = -1; but in this case be ready that

    the program will "fall", if the file will appear too large and can

    not be placed in the program memory.

  * The filename must be either in the format 8+3 characters

    (first 8 characters - name itself, last 3 - extension,

    the short names and extensions are supplemented with spaces),

    or in the format 8.3 characters "FILE.EXT"/"FILE.EX "

    (name no more than 8 characters, dot, extension 3 characters

    supplemented if necessary by spaces).

    The filename must be written with capital letters. The terminating

    character with code 0 is not necessary (not ASCIIZ-string).

  * This function does not support folders on the ramdisk.

======================================================================

=============== Function 7 - draw image in the window. ===============

======================================================================

Paramters:

  * eax = 7 - function number

  * ebx = pointer to the image in the format BBGGRRBBGGRR...

  * ecx = [size on axis x]*65536 + [size on axis y]

  * edx = [coordinate on axis x]*65536 + [coordinate on axis y]

Returned value:

  * function does not return value

Remarks:

  * Coordinates of the image are coordinates of the upper left corner

    of the image relative to the window.

  * Size of the image in bytes is 3*xsize*ysize.

======================================================================

=============== Function 8 - define/delete the button. ===============

======================================================================

Parameters for button definition:

  * eax = 8 - function number

  * ebx = [coordinate on axis x]*65536 + [size on axis x]

  * ecx = [coordinate on axis y]*65536 + [size on axis y]

  * edx = 0xXYnnnnnn, where:

    * nnnnnn = identifier of the button

    * high (31st) bit of edx is cleared

    * if 30th bit of edx is set - do not draw the button

    * if 29th bit of edx is set - do not draw a frame

      at pressing the button

  * esi = 0x00RRGGBB - color of the button

Parameters for button deleting:

  * eax = 8 - function number

  * edx = 0x80nnnnnn, where nnnnnn - identifier of the button

Returned value:

  * function does not return value

Remarks:

  * Sizes of the button must be more than 0 and less than 0x8000.

  * For skinned windows definition of the window

    (call of 0th function) creates two standard buttons -

    for close of the window with identifier 1 and

    for minimize of the window with identifier 0xffff.

  * The creation of two buttons with same identifiers is admitted.

  * The button with the identifier 0xffff at pressing is interpreted

    by the system as the button of minimization, the system handles

    such pressing independently, not accessing to the application.

    In rest it is usual button.

  * Total number of buttons for all applications is limited to 4095.

======================================================================

============ Function 9 - information on execution thread. ===========

======================================================================

Parameters:

  * eax = 9 - function number

  * ebx = pointer to 1-Kb buffer

  * ecx = number of the slot of the thread

    ecx = -1 - get information on the current thread

Returned value:

  * eax = maximum number of the slot of a thread

  * buffer pointed to by ebx contains the following information:

    * +0: dword: usage of the processor (how many time units

      per second leaves on execution of this thread)

    * +4: word: position of the window of thread in the window stack

    * +6: word: (has no relation to the specified thread)

      number of the thread slot, which window has in the window stack

      position ecx

    * +8: word: reserved

    * +10 = +0xA: 11 bytes: name of the process

      (name of the started file - executable file without extension)

    * +21 = +0x15: byte: reserved, this byte is not changed

    * +22 = +0x16: dword: address of the process in memory

    * +26 = +0x1A: dword: size of used memory - 1

    * +30 = +0x1E: dword: identifier (PID/TID)

    * +34 = +0x22: dword: coordinate of the thread window on axis x

    * +38 = +0x26: dword: coordinate of the thread window on axis y

    * +42 = +0x2A: dword: size of the thread window on axis x

    * +46 = +0x2E: dword: size of the thread window on axis y

    * +50 = +0x32: word: status of the thread slot:

      * 0 = thread is running

      * 1 = thread is suspended

      * 2 = thread is suspended while waiting for event

      * 3 = thread is terminating as a result of call to function -1

        or under duress as a result of call to subfunction 2

        of function 18 or termination of the system

      * 4 = thread is terminating as a result of exception

      * 5 = thread waits for event

      * 9 = requested slot is free, all other information on the slot

        is not meaningful

    * +52 = +0x34: word: reserved, this word is not changed

    * +54 = +0x36: dword: coordinate of the client area on axis x

    * +58 = +0x3A: dword: coordinate of the client area on axis y

    * +62 = +0x3E: dword: width of the client area

    * +66 = +0x42: dword: height of the client area

    * +70 = +0x46: byte: state of the window - bitfield

      * bit 0 (mask 1): window is maximized

      * bit 1 (mask 2): window is minimized to panel

      * bit 2 (mask 4): window is rolled up

    * +71 = +0x47: dword: event mask

    * +75 = +0x4B: byte: keyboard mode(ASCII = 0; SCAN = 1)

Remarks:

  * Slots are numbered starting from 1.

  * Returned value is not a total number of threads, because there

    can be free slots.

  * When process is starting, system automatically creates

    execution thread.

  * Function gives information on the thread. Each process has

    at least one thread. One process can create many threads,

    in this case each thread has its own slot and the fields

    +10, +22, +26 in these slots coincide.

    Applications have no common way to define whether two threads

    belong to one process.

  * The active window - window on top of the window stack -

    receives the messages on a keyboard input. For such window

    the position in the window stack coincides with returned value.

  * Slot 1 corresponds to special system thread, for which:

    * the window is in the bottom of the window stack, the fields

      +4 and +6 contain value 1

    * name of the process - "OS/IDLE" (supplemented by spaces)

    * address of the process in memory is 0, size of used memory is

      16 Mb (0x1000000)

    * PID=1

    * coordinates and sizes of the window and the client area are by

      convention set to 0

    * status of the slot is always 0 (running)

    * the execution time adds of time leaving on operations itself

      and idle time in waiting for interrupt (which can be got by call

      to subfunction 4 of function 18).

  * Beginning from slot 2, the normal applications are placed.

  * The normal applications are placed in memory at the address

    There is no intersection, as each process has its own page table.

  * At creation of the thread it is assigned the slot

    in the system table and identifier (Process/Thread IDentifier =

    PID/TID), which do not vary with time for given thread.

    After completion of the thread its slot can be anew used

    for another thread. The thread identifier can not be assigned

    to other thread even after completion of this thread.

    Identifiers, assigned to new threads, grow monotonously.

  * If the thread has not yet defined the window by call to

    function 0, the position and the sizes

    of its window are considered to be zero.

  * Coordinates of the client area are relative to the window.

  * At the moment only the part of the buffer by a size

    76 = 0x4C bytes is used. Nevertheless it is recommended to use

    1-Kb buffer for the future compatibility, in the future

    some fields can be added.

======================================================================

==================== Function 10 - wait for event. ===================

======================================================================

If the message queue is empty, waits for appearance of the message

in queue. In this state thread does not consume CPU time.

Then reads out the message from queue.

Parameters:

  * eax = 10 - function number

Returned value:

  * eax = event (see the list of events)

Remarks:

  * Those events are taken into account only which enter into

    a mask set by function 40. By default it is

    redraw, key and button events.

  * To check, whether there is a message in queue, use function 11.

    To wait for no more than given time, use function 23.

======================================================================

=============== Function 11 - check for event, no wait. ==============

======================================================================

If the message queue contains event, function reads out

and return it. If the queue is empty, function returns 0.

Parameters:

  * eax = 11 - function number

Returned value:

  * eax = 0 - message queue is empty

  * else eax = event (see the list of events)

Remarks:

  * Those events are taken into account only, which enter into

    a mask set by function 40. By default it is

    redraw, key and button events.

  * To wait for event, use function 10.

    To wait for no more than given time, use function 23.

======================================================================

=============== Function 12 - begin/end window redraw. ===============

======================================================================

---------------- Subfunction 1 - begin window redraw. ----------------

Parameters:

  * eax = 12 - function number

  * ebx = 1 - subfunction number

Returned value:

  * function does not return value

----------------- Subfunction 2 - end window redraw. -----------------

Parameters:

  * eax = 12 - function number

  * ebx = 2 - subfunction number

Returned value:

  * function does not return value

Remarks:

  * Subfunction 1 deletes all buttons defined with

    function 8, they must be defined again.

======================================================================

============ Function 13 - draw a rectangle in the window. ===========

======================================================================

Parameters:

  * eax = 13 - function number

  * ebx = [coordinate on axis x]*65536 + [size on axis x]

  * ecx = [coordinate on axis y]*65536 + [size on axis y]

  * edx = color 0xRRGGBB or 0x80RRGGBB for gradient fill

Returned value:

  * function does not return value

Remarks:

  * Coordinates are understood as coordinates of the left upper corner

    of a rectangle relative to the window.

======================================================================

=================== Function 14 - get screen size. ===================

======================================================================

Parameters:

  * eax = 14 - function number

Returned value:

  * eax = [xsize]*65536 + [ysize], where

  * xsize = x-coordinate of the right lower corner of the screen =

            horizontal size - 1

  * ysize = y-coordinate of the right lower corner of the screen =

            vertical size - 1

Remarks:

  * See also subfunction 5 of function 48 - get sizes of

    working area of the screen.

======================================================================

== Function 15, subfunction 1 - set a size of the background image. ==

======================================================================

Parameters:

  * eax = 15 - function number

  * ebx = 1 - subfunction number

  * ecx = width of the image

  * edx = height of the image

Returned value:

  * function does not return value

Remarks:

  * Before calling subfunctions 2 and 5 you should call this function

    to set image size!

  * For update of the screen (after completion of a series of commands

    working with a background) call subfunction 3.

  * There is a pair function for get size of the background image -

    subfunction 1 of function 39.

======================================================================

=== Function 15, subfunction 2 - put pixel on the background image. ==

======================================================================

Parameters:

  * eax = 15 - function number

  * ebx = 2 - subfunction number

  * ecx = offset

  * edx = color of a pixel 0xRRGGBB

Returned value:

  * function does not return value

Remarks:

  * Offset for a pixel with coordinates (x,y) is calculated as

    (x+y*xsize)*3.

  * If the given offset exceeds size set by subfunction 1,

    the call is ignored.

  * For update of the screen (after completion of a series of commands

    working with a background) call subfunction 3.

  * There is a pair function for get pixel on the background image -

    subfunction 2 of function 39.

======================================================================

=========== Function 15, subfunction 3 - redraw background. ==========

======================================================================

Parameters:

  * eax = 15 - function number

  * ebx = 3 - subfunction number

Returned value:

  * function does not return value

======================================================================

== Function 15, subfunction 4 - set drawing mode for the background. =

======================================================================

Parameters:

  * eax = 15 - function number

  * ebx = 4 - subfunction number

  * ecx = drawing mode:

    * 1 = tile

    * 2 = stretch

Returned value:

  * function does not return value

Remarks:

  * For update of the screen (after completion of a series of commands

    working with a background) call subfunction 3.

  * There is a pair function for get drawing mode of the background -

    subfunction 4 of function 39.

======================================================================

===================== Function 15, subfunction 5 =====================

============ Put block of pixels on the background image. ============

======================================================================

Parameters:

  * eax = 15 - function number

  * ebx = 5 - subfunction number

  * ecx = pointer to the data in the format BBGGRRBBGGRR...

  * edx = offset in data of the background image

  * esi = size of data in bytes = 3 * number of pixels

Returned value:

  * function does not return value

Remarks:

  * Offset and size are not checked for correctness.

  * Color of each pixel is stored as 3-bytes value BBGGRR.

  * Pixels of the background image are written sequentially

    from left to right, from up to down.

  * Offset of pixel with coordinates (x,y) is (x+y*xsize)*3.

  * For update of the screen (after completion of a series of commands

    working with a background) call subfunction 3.

======================================================================

===================== Function 15, subfunction 6 =====================

======== Map background data to the address space of process. ========

======================================================================

Parameters:

  * eax = 15 - function number

  * ebx = 6 - subfunction number

Returned value:

  * eax = pointer to background data, 0 if error

Remarks:

  * Mapped data are available for read and write.

  * Size of background data is 3*xsize*ysize. The system blocks

    changes of background sizes while process works with mapped data.

  * Color of each pixel is stored as 3-bytes value BBGGRR.

  * Pixels of the background image are written sequentially

    from left to right, from up to down.

======================================================================

===== Function 15, subfunction 7 - close mapped background data. =====

======================================================================

Parameters:

  * eax = 15 - function number

  * ebx = 7 - subfunction number

  * ecx = pointer to mapped data

Returned value:

  * eax = 1 - success, 0 - error

======================================================================

===================== Function 15, subfunction 8 =====================

============= Get coordinates of last draw the background ============

======================================================================

Parameters:

  * eax = 15 - function number

  * ebx = 8 - subfunction number

Returned value:

  * eax = [left]*65536 + [right]

  * ebx = [top]*65536 + [bottom]

Remarks:

  * (left,top) are coordinates of the left upper corner,

    (right,bottom) are coordinates of the right lower one.

  * For receiving more reliable information, call the function

    immediately after the event:

             5 = kernel finished redrawing of the desktop background

======================================================================

===================== Function 15, subfunction 9 =====================

============= Redraws a rectangular part of the background ===========

======================================================================

Parameters:

  * eax = 15 - function number

  * ebx = 9 - subfunction number

  * ecx = [left]*65536 + [right]

  * edx = [top]*65536 + [bottom]

Returned value:

  * function does not return value

Remarks:

  * (left,top) are coordinates of the left upper corner,

    (right,bottom) are coordinates of the right lower one.

  * If parameters are set incorrectly then background is not redrawn.

======================================================================

=============== Function 16 - save ramdisk on a floppy. ==============

======================================================================

Parameters:

  * eax = 16 - function number

  * ebx = 1 or ebx = 2 - on which floppy save

Returned value:

  * eax = 0 - success

  * eax = 1 - error

======================================================================

======= Function 17 - get the identifier of the pressed button. ======

======================================================================

Takes away the code of the pressed button from the buffer.

Parameters:

  * eax = 17 - function number

Returned value:

  * if the buffer is empty, function returns eax=1

  * if the buffer is not empty:

    * high 24 bits of eax contain button identifier (in particular,

      ah contains low byte of the identifier; if all buttons have

      the identifier less than 256, ah is enough to distinguish)

    * al = 0 - the button was pressed with left mouse button

    * al = bit corresponding to used mouse button otherwise

Remarks:

  * "Buffer" keeps only one button, at pressing the new button the

    information about old is lost.

  * The call of this function by an application with inactive window

    will return answer "buffer is empty".

  * Returned value for al corresponds to the state of mouse buttons

    as in subfunction 2 of function 37 at the beginning

    of button press, excluding lower bit, which is cleared.

======================================================================

===================== Function 18, subfunction 1 =====================

============= Make deactive the window of the given thread. ==========

======================================================================

Parameters:

  * eax = 18 - function number

  * ebx = 1 - subfunction number

  * ecx = number of the thread slot

Returned value:

  * function does not return value

======================================================================

= Function 18, subfunction 2 - terminate process/thread by the slot. =

======================================================================

Parameters:

  * eax = 18 - function number

  * ebx = 2 - subfunction number

  * ecx = number of the slot of process/thread

Returned value:

  * function does not return value

Remarks:

  * It is impossible to terminate system thread OS/IDLE (with

    number of the slot 1),

    it is possible to terminate any normal process/thread.

  * See also subfunction 18 - terminate

    process/thread by the identifier.

======================================================================

===================== Function 18, subfunction 3 =====================

============= Make active the window of the given thread. ============

======================================================================

Parameters:

  * eax = 18 - function number

  * ebx = 3 - subfunction number

  * ecx = number of the thread slot

Returned value:

  * function does not return value

Remarks:

  * If correct, but nonexistent slot is given,

    some window is made active.

  * To find out, which window is active, use subfunction 7.

======================================================================

===================== Function 18, subfunction 4 =====================

=========== Get counter of idle time units per one second. ===========

======================================================================

Idle time units are units, in which the processor stands idle

in waiting for interrupt (in the command 'hlt').

Parameters:

  * eax = 18 - function number

  * ebx = 4 - subfunction number

Returned value:

  * eax = value of the counter of idle time units per one second

======================================================================

========== Function 18, subfunction 5 - get CPU clock rate. ==========

======================================================================

Parameters:

  * eax = 18 - function number

  * ebx = 5 - subfunction number

Returned value:

  * eax = clock rate (modulo 2^32 clock ticks = 4GHz)

======================================================================

 Function 18, subfunction 6 - save ramdisk to the file on hard drive.

======================================================================

Parameters:

  * eax = 18 - function number

  * ebx = 6 - subfunction number

  * ecx = pointer to the full path to file

    (for example, "/hd0/1/kolibri/kolibri.img")

Returned value:

  * eax = 0 - success

  * else eax = error code of the file system

Remarks:

  * All folders in the given path must exist, otherwise function

    returns value 5, "file not found".

======================================================================

=========== Function 18, subfunction 7 - get active window. ==========

======================================================================

Parameters:

  * eax = 18 - function number

  * ebx = 7 - subfunction number

Returned value:

  * eax = number of the active window

    (number of the slot of the thread with active window)

Remarks:

  * Active window is at the top of the window stack and receives

    messages on all keyboard input.

  * To make a window active, use subfunction 3.

======================================================================

== Function 18, subfunction 8 - disable/enable the internal speaker. =

======================================================================

If speaker sound is disabled, all calls to subfunction 55 of

function 55 are ignored. If speaker sound is enabled,

they are routed on builtin speaker.

------------------- Subsubfunction 1 - get status. -------------------

Parameters:

  * eax = 18 - function number

  * ebx = 8 - subfunction number

  * ecx = 1 - number of the subsubfunction

Returned value:

  * eax = 0 - speaker sound is enabled; 1 - disabled

----------------- Subsubfunction 2 - toggle status. ------------------

Toggles states of disable/enable.

Parameters:

  * eax = 18 - function number

  * ebx = 8 - subfunction number

  * ecx = 2 - number of the subsubfunction

Returned value:

  * function does not return value

======================================================================

== Function 18, subfunction 9 - system shutdown with the parameter. ==

======================================================================

Parameters:

  * eax = 18 - function number

  * ebx = 9 - subfunction number

  * ecx = parameter:

    * 2 = turn off computer

    * 3 = reboot computer

    * 4 = restart the kernel from the file 'kernel.mnt' on ramdisk

Returned value:

  * at incorrect ecx the registers do not change (i.e. eax=18)

  * by correct call function always returns eax=0

    as the tag of success

Remarks:

  * Do not rely on returned value by incorrect call, it can be

    changed in future versions of the kernel.

======================================================================

======= Function 18, subfunction 10 - minimize topmost window. =======

======================================================================

Minimizes the topmost (active) window.

Parameters:

  * eax = 18 - function number

  * ebx = 10 - subfunction number

Returned value:

  * function does not return value

Remarks:

  * The minimized window from the point of view of function 9

    keeps position and sizes.

  * Restoring of an application window occurs at its activation by

    subfunction 3.

  * Usually there is no necessity to minimize/restore a window

    explicitly: minimization of a window is carried out by the system

    at pressing the minimization button (for skinned windows

    it is defined automatically by function 0,

    for other windows it can be defined manually by function 8),

    restore of a window is done by the application '@panel'.

======================================================================

 Function 18, subfunction 11 - get information on the disk subsystem.

======================================================================

Parameters:

  * eax = 18 - function number

  * ebx = 11 - subfunction number

  * ecx = type of the table:

    * 1 = short version, 10 bytes

    * 2 = full version, 65536 bytes

  * edx = pointer to the buffer (in the application) for the table

Returned value:

  * function does not return value

Format of the table: short version:

  * +0: byte: information about FDD's (drives for floppies),

    AAAABBBB, where AAAA gives type of the first drive, BBBB -

    of the second regarding to the following list:

    * 0 = there is no drive

    * 1 = 360Kb, 5.25''

    * 2 = 1.2Mb, 5.25''

    * 3 = 720Kb, 3.5''

    * 4 = 1.44Mb, 3.5''

    * 5 = 2.88Mb, 3.5'' (such drives are not used anymore)

    For example, for the standard configuration from one 1.44-drive

    here will be 40h, and for the case 1.2Mb on A: and 1.44Mb on B:

    the value is 24h.

  * +1: byte: information about hard disks and CD-drives, AABBCCDD,

    where AA corresponds to the controller IDE0, ..., DD - IDE3:

    * 0 = device is absent

    * 1 = hard drive

    * 2 = CD-drive

    For example, in the case HD on IDE0 and CD on IDE2

    this field contains 48h.

  * +2: 4 db: number of the retrieved partitions on hard disks

    at accordingly IDE0,...,IDE3.

    If the hard disk on IDEx is absent, appropriate byte is zero,

    otherwise it shows number of the recognized partitions, which

    can be not presented (if the drive is not formatted or if

    the file system is not supported). Current version of the kernel

    supports only FAT16, FAT32 and NTFS for hard disks.

  * +6: 4 db: reserved

Format of the table: full version:

  * +0: 10 db: same as for the short version

  * +10: 100 db: data for the first partition

  * +110: 100 db: data for the second partition

  * ...

  * +10+100*(n-1): 100 db: data for the last partition

The partitions are located as follows: at first sequentially all

recoginzed partitions on HD on IDE0 (if present),

then on HD on IDE1 (if present) and so on up to IDE3.

Format of the information about partition

(at moment only FAT is supported):

  * +0: dword: first physical sector of the partition

  * +4: dword: last physical sector of the partition

    (belongs to the partition)

  * +8: byte: file system type:

    16=FAT16, 32=FAT32, 1=NTFS

  * other data are dependent on file system, are modified with

    kernel modifications and therefore are not described

Remarks:

  * The short table can be used for obtaining the information about

    available devices.

======================================================================

========== Function 18, subfunction 13 - get kernel version. =========

======================================================================

Parameters:

  * eax = 18 - function number

  * ebx = 13 - subfunction number

  * ecx = pointer to the buffer (not less than 16 bytes), where

    the information will be placed

Returned value:

  * function does not return value

Structure of the buffer:

db a,b,c,d for version a.b.c.d

db 0: reserved

dd REV - kernel SVN revision number

For Kolibri 0.7.7.0+ kernel:

db 0,7,7,0

db 0

dd 1675

======================================================================

======= Function 18, subfunction 14 - wait for screen retrace. =======

======================================================================

Waits for the beginning of retrace of the scanning ray of the screen

monitor.

Parameters:

  * eax = 18 - function number

  * ebx = 14 - subfunction number

Returned value:

  * eax = 0 as the tag of success

Remarks:

  * Function is intended only for active high-efficiency graphics

    applications; is used for smooth output of a graphics.

======================================================================

== Function 18, subfunction 15 - center mouse cursor on the screen. ==

======================================================================

Parameters:

  * eax = 18 - function number

  * ebx = 15 - subfunction number

Returned value:

  * eax = 0 as the tag of success

======================================================================

========= Function 18, subfunction 16 - get size of free RAM. ========

======================================================================

Parameters:

  * eax = 18 - function number

  * ebx = 16 - subfunction number

Returned value:

  * eax = size of free memory in kilobytes

======================================================================

======== Function 18, subfunction 17 - get full amount of RAM. =======

======================================================================

Parameters:

  * eax = 18 - function number

  * ebx = 17 - subfunction number

Returned value:

  * eax = total size of existing memory in kilobytes

======================================================================

===================== Function 18, subfunction 18 ====================

============= Terminate process/thread by the identifier. ============

======================================================================

Parameters:

  * eax = 18 - function number

  * ebx = 18 - subfunction number

  * ecx = identifer of process/thread (PID/TID)

Returned value:

  * eax = 0 - success

  * eax = -1 - error (process is not found or is system)

Remarks:

  * It is impossible to terminate system thread OS/IDLE (identifier

    1), it is possible to terminate any normal process/thread.

  * See also subfunction 2 - terminate

    process/thread by given slot.

======================================================================

======== Function 18, subfunction 19 - get/set mouse features. =======

======================================================================

---------------- Subsubfunction 0 - get mouse speed. -----------------

Parameters:

  * eax = 18 - function number

  * ebx = 19 - subfunction number

  * ecx = 0 - subsubfunction number

Returned value:

  * eax = current mouse speed

---------------- Subsubfunction 1 - set mouse speed. -----------------

Parameters:

  * eax = 18 - function number

  * ebx = 19 - subfunction number

  * ecx = 1 - subsubfunction number

  * edx = new value for speed

Returned value:

  * function does not return value

---------------- Subsubfunction 2 - get mouse delay. -----------------

Parameters:

  * eax = 18 - function number

  * ebx = 19 - subfunction number

  * ecx = 2 - subsubfunction number

Returned value:

  * eax = current mouse delay

---------------- Subsubfunction 3 - set mouse delay. -----------------

Parameters:

  * eax = 18 - function number

  * ebx = 19 - subfunction number

  * ecx = 3 - subsubfunction number

  * edx = new value for mouse delay

Returned value:

  * function does not return value

----------- Subsubfunction 4 - set mouse pointer position. -----------

Parameters:

  * eax = 18 - function number

  * ebx = 19 - subfunction number

  * ecx = 4 - subsubfunction number

  * edx = [coordinate on axis x]*65536 + [coordinate on axis y]

Returned value:

  * function does not return value

-------- Subsubfunction 5 - simulate state of mouse buttons. ---------

Parameters:

  * eax = 18 - function number

  * ebx = 19 - subfunction number

  * ecx = 5 - subsubfunction number

  * edx = information about emulated state of mouse buttons:

    (same as return value in subfunction 2 of function 37)

    * bit 0 is set = left button is pressed

    * bit 1 is set = right button is pressed

    * bit 2 is set = middle button is pressed

    * bit 3 is set = 4th button is pressed

    * bit 4 is set = 5th button is pressed

Returned value:

  * function does not return value

Remarks:

  * It is recommended to set speed of the mouse (in subsubfunction 1)

    from 1 up to 9. The installed value is not inspected by the kernel

    code, so set it carefully, at incorrect value the cursor

    can "freeze". Speed of the mouse can be regulated through the

    application SETUP.

  * Recommended delay of the mouse (in subsubfunction 3) = 10. Lower

    value is not handled by COM mice. At the very large values the

    movement of the mouse on 1 pixel is impossible and the cursor will

    jump on the value of installed speed (subsubfunction 1). The

    installed value is not inspected by the kernel code.

    Mouse delay can be regulated through the application SETUP.

  * The subsubfunction 4 does not check the passed value. Before

    its call find out current screen resolution (with function 14)

    and check that the value of position is inside the limits of the

    screen.

======================================================================

======== Function 18, subfunction 20 - get information on RAM. =======

======================================================================

Parameters:

  * eax = 18 - function number

  * ebx = 20 - subfunction number

  * ecx = pointer to the buffer for information (36 bytes)

Returned value:

  * eax = total size of existing RAM in pages

    or -1 if error has occured

  * buffer pointed to by ecx contains the following information: