kolibrios/contrib/sdk/sources/newlib/libc/include/sys/kos.h

////////////////////////////////////////////
//  Copyright (C) 2021 maxcodehack, GPLv2 //
//           KolibriOS Syscalls           //
//               sys/kos.h                //
//                                        //
// Syscalls scheme: kos_XxxYyy            //
//				(e.g. kos_DrawWindow)     //
////////////////////////////////////////////

#include <stdint.h>
#include <string.h>

typedef unsigned int color_t;

// Struct for App running
#pragma pack(push,1)
typedef struct
{
unsigned	p00;
unsigned 	p04;
char	 	*p08;
unsigned	p12;
unsigned	p16;
char		p20;
char		*p21;
} kos_Struct70;
#pragma pack(pop)

// Blitter struct
struct blit_call
{
    int dstx;
    int dsty;
    int w;
    int h;
 
    int srcx;
    int srcy;
    int srcw;
    int srch;
 
    void *bitmap;
    int   stride;
};

// Process info for sysfn 9
#pragma pack(push, 1)
struct proc_info
{
        unsigned long cpu_usage;
        unsigned short pos_in_stack;
        unsigned short slot;
        unsigned short reserved;
        char name[12];
        unsigned long address;
        unsigned long memory_usage;
        unsigned long ID;
        unsigned long left,top;
        unsigned long width,height;
        unsigned short thread_state;
        unsigned short reserved2;
        unsigned long cleft, ctop, cwidth, cheight;
        unsigned char window_state;
        unsigned char reserved3[1024-71];
};
#pragma pack(pop)

// Color struct for sysfn ?
struct kolibri_system_colors {
  color_t frame_area;
  color_t grab_bar;
  color_t grab_bar_button;
  color_t grab_button_text;
  color_t grab_text;
  color_t work_area;
  color_t work_button;
  color_t work_button_text;
  color_t work_text;
  color_t work_graph;
};

typedef union __attribute__((packed))
{
    uint32_t val;
    struct
    {
        short  x;
        short  y;
    };
} pos_t;


/// Window Syscalls:
// Start drawing
static inline void kos_BeginDraw(void)
{
    __asm__ __volatile__(
    "int $0x40" ::"a"(12),"b"(1));
};

// End drawing
static inline void kos_EndDraw(void)
{
    __asm__ __volatile__(
    "int $0x40" ::"a"(12),"b"(2));
};

// Draw window
static inline void kos_DrawWindow(int x, int y, int w, int h, const char *title,
                       color_t bgcolor, uint32_t style)
{
    __asm__ __volatile__(
    "int $0x40"
    ::"a"(0),
     "b"((x << 16) | ((w-1) & 0xFFFF)),
     "c"((y << 16) | ((h-1) & 0xFFFF)),
     "d"((style << 24) | (bgcolor & 0xFFFFFF)),
     "D"(title),
     "S"(0) : "memory");
};

// Change window size
#define OLD -1
static inline void kos_ChangeWindow(int new_x, int new_y, int new_w, int new_h)
{
    __asm__ __volatile__(
        "int $0x40"
        ::"a"(67), "b"(new_x), "c"(new_y), "d"(new_w),"S"(new_h)
    );
}

/// Other GUI functions:
// Draw text
static inline void kos_DrawText(int x, int y, const char *text, color_t color)
{
    __asm__ __volatile__(
    "int $0x40"
    ::"a"(4),"d"(text),
      "b"((x << 16) | y),
      "S"(strlen(text)),"c"(color)
     :"memory");
}

// Draw button
static inline void kos_DrawButton(int x, int y, int w, int h, int id, color_t color)
{
    __asm__ __volatile__(
    "int $0x40"
    ::"a"(8),
      "b"(x * 65536 + w),
      "c"(y * 65536 + h),
      "d"(id),
      "S"(color));
};

// Draw button with text
void kos_DrawButtonWithText(int x, int y, int w, int h, int id, color_t color, const char* text)
{
	kos_DrawButton(x, y, w, h, id, color);

	int tx = ((((-strlen(text))*8)+w)/2)+x;
	int ty = h/2-7+y;

	kos_DrawText(tx, ty, text, 0x90000000);
};

// Draw line
static inline void kos_DrawLine(int x_start, int y_start, int x_end, int y_end, color_t color)
{
    __asm__ __volatile__(
    "int $0x40"
    ::"a"(38), "d"(color),
      "b"((x_start << 16) | x_end),
      "c"((y_start << 16) | y_end));
}

// Draw bar
static inline void kos_DrawBar(int x, int y, int w, int h, color_t color)
{
    __asm__ __volatile__(
    "int $0x40"
    ::"a"(13), "d"(color),
      "b"((x << 16) | w),
      "c"((y << 16) | h));
}

// Put one pixel
void kos_PutPixel(int x, int y, color_t color) {
	__asm__ __volatile__("int $0x40"
			 ::"a"(1),
			  "b"(x),
			  "c"(y),
			  "d"(color));
}

// Draw bitmap image
static inline void kos_DrawBitmap(void *bitmap, int x, int y, int w, int h)
{
    __asm__ __volatile__(
    "int $0x40"
    ::"a"(7), "b"(bitmap),
      "c"((w << 16) | h),
      "d"((x << 16) | y));
}


/// Skin:
// Return skin height
static inline uint32_t kos_SkinHeight(void)
{
    uint32_t height;
 
    __asm__ __volatile__(
    "int $0x40 \n\t"
    :"=a"(height)
    :"a"(48),"b"(4));
    return height;
};

/// Mouse:
// Get mouse position
#define POS_SCREEN 0
#define POS_WINDOW 1

static inline
pos_t kos_GetMousePos(int origin)
{
    pos_t val;
 
    __asm__ __volatile__(
    "int $0x40 \n\t"
    "rol $16, %%eax"
    :"=a"(val)
    :"a"(37),"b"(origin));
    return val;
}

// Get mouse buttons
static inline
uint32_t kos_GetMouseButtons(void)
{
    uint32_t val;
 
    __asm__ __volatile__(
    "int $0x40"
    :"=a"(val)
    :"a"(37),"b"(2));
    return val;
};

// Get mouse wheels
static inline
uint32_t kos_GetMouseWheels(void)
{
    uint32_t val;
 
    __asm__ __volatile__(
    "int $0x40 \n\t"
    :"=a"(val)
    :"a"(37),"b"(7));
    return val;
};

// Load cursor
static inline uint32_t kos_LoadCursor(void *path, uint32_t flags)
{
    uint32_t  val;
    __asm__ __volatile__(
    "int $0x40"
    :"=a"(val)
    :"a"(37), "b"(4), "c"(path), "d"(flags));
    return val;
}

// Set cursor
static inline uint32_t kos_SetCursor(uint32_t cursor)
{
    uint32_t  old;
    __asm__ __volatile__(
    "int $0x40"
    :"=a"(old)
    :"a"(37), "b"(5), "c"(cursor));
    return old;
};

// Destroy cursor
static inline int kos_DestroyCursor(uint32_t cursor)
{
    int ret;
    __asm__ __volatile__(
    "int $0x40"
    :"=a"(ret)
    :"a"(37), "b"(6), "c"(cursor)
    :"memory");
    return ret;
};

/// OS Events:
#define evReDraw  1
#define evKey     2
#define evButton  3
#define evExit    4
#define evDesktop 5
#define evMouse   6
#define evIPC     7
#define evNetwork 8
#define evDebug   9

static inline
uint32_t kos_WaitForEventTimeout(uint32_t time)
{
    uint32_t val;
    __asm__ __volatile__(
    "int $0x40"
    :"=a"(val)
    :"a"(23), "b"(time));
    return val;
};
 
static inline uint32_t kos_CheckForEvent(void)
{
    uint32_t val;
    __asm__ __volatile__(
    "int $0x40"
    :"=a"(val)
    :"a"(11));
    return val;
};
 
static inline uint32_t kos_WaitForEvent(void)
{
    uint32_t val;
    __asm__ __volatile__(
    "int $0x40"
    :"=a"(val)
    :"a"(10));
    return val;
};

/// Eventmask:
#define EVM_REDRAW        1
#define EVM_KEY           2
#define EVM_BUTTON        4
#define EVM_EXIT          8
#define EVM_BACKGROUND    16
#define EVM_MOUSE         32
#define EVM_IPC           64
#define EVM_STACK         128
#define EVM_DEBUG         256
#define EVM_STACK2        512
#define EVM_MOUSE_FILTER  0x80000000
#define EVM_CURSOR_FILTER 0x40000000
 
static inline uint32_t kos_SetMaskForEvents(uint32_t event_mask)
{
  uint32_t  old_event_mask;
    __asm__ __volatile__(
    "int $0x40"
    :"=a"(old_event_mask)
    :"a"(40),"b"(event_mask));
 
    return old_event_mask;
};

/// Other:
// Get key
int kos_GetKey()
{
	unsigned short key;
	__asm__ __volatile__("int $0x40":"=a"(key):"0"(2));
	if(!(key & 0xFF)) return (key>>8)&0xFF; else return 0;
}

// Get pressed button ID
static inline
uint32_t kos_GetButtonID(void)
{
    uint32_t val;
    __asm__ __volatile__(
    "int $0x40"
    :"=a"(val)
    :"a"(17));
    return val>>8;
};

// Sleep..
static inline void kos_Delay(uint32_t time)
{
    __asm__ __volatile__(
    "int $0x40"
    ::"a"(5), "b"(time)
    :"memory");
};

// Get screen size
static inline
pos_t kos_ScreenSize()
{
	pos_t size;
	__asm__ __volatile__(
	"int $0x40"
	:"=a"(size)
	:"a"(14));

	return size;
};

// Get system color table
static inline void kos_GetSystemColors(struct kolibri_system_colors *color_table)
{
	__asm__ __volatile__ ("int $0x40"
	:
	:"a"(48),"b"(3),"c"(color_table),"d"(40)
	);
}

// SysFn 9
static inline void kos_ProcessInfo(char *info)
{
    __asm__ __volatile__(
    "int $0x40"
    :
    :"a"(9), "b"(info), "c"(-1)
    :"memory");
};

// Blitter 
static inline void Blit(void *bitmap, int dst_x, int dst_y,
                        int src_x, int src_y, int w, int h,
                        int src_w, int src_h, int stride)
{
    volatile struct blit_call bc;
 
    bc.dstx = dst_x;
    bc.dsty = dst_y;
    bc.w    = w;
    bc.h    = h;
    bc.srcx = src_x;
    bc.srcy = src_y;
    bc.srcw = src_w;
    bc.srch = src_h;
    bc.stride = stride;
    bc.bitmap = bitmap;
 
    __asm__ __volatile__(
    "int $0x40"
    ::"a"(73),"b"(0),"c"(&bc.dstx));
};

void kos_RunApp(char* app, char* param)
{
	kos_Struct70 r;
	r.p00 = 7;
	r.p04 = 0;
	r.p08 = param;
	r.p12 = 0;
	r.p16 = 0;
	r.p20 = 0;
	r.p21 = app;
	__asm__ __volatile__ ("int $0x40"::"a"(70), "b"(&r));
}