Subversion Repositories Kolibri OS

#include 

#include 

  #define DBG(format,...) printf(format,##__VA_ARGS__)

#else

  #define DBG(format,...)

#endif

{

    uint32_t val;

    struct

    {

        short  x;

        short  y;

    };

}pos_t;

{

    uint32_t val;

    struct

    {

        uint8_t   state;

        uint8_t   code;

        uint16_t  ctrl_key;

    };

}oskey_t;

void BeginDraw(void)

{

    __asm__ __volatile__(

    "int $0x40" ::"a"(12),"b"(1));

};

void EndDraw(void)

{

    __asm__ __volatile__(

    "int $0x40" ::"a"(12),"b"(2));

};

                       color_t workcolor, uint32_t style)

{

    "int $0x40"

    ::"a"(0),

      "b"((x << 16) | (w & 0xFFFF)),

      "c"((y << 16) | (h & 0xFFFF)),

      "d"((style << 24) | (workcolor & 0xFFFFFF)),

      "D"(name));

};

pos_t get_mouse_pos(void)

{

    pos_t val;

    "int $0x40 \n\t"

    "rol $16, %%eax"

    :"=a"(val)

    :"a"(37),"b"(1));

    return val;

}

pos_t get_cursor_pos(void)

{

    pos_t val;

    "int $0x40 \n\t"

    "rol $16, %%eax"

    :"=a"(val)

    :"a"(37),"b"(0));

    return val;

}

uint32_t get_mouse_buttons(void)

{

    uint32_t val;

    "int $0x40"

    :"=a"(val)

    :"a"(37),"b"(2));

    return val;

};

uint32_t get_mouse_wheels(void)

{

    uint32_t val;

    "int $0x40 \n\t"

    "rol $16, %%eax"

    :"=a"(val)

    :"a"(37),"b"(7));

    return val;

};

uint32_t wait_for_event(uint32_t time)

{

    uint32_t val;

    __asm__ __volatile__(

    "int $0x40"

    :"=a"(val)

    :"a"(23), "b"(time));

    return val;

};

{

    uint32_t val;

    __asm__ __volatile__(

    "int $0x40"

    :"=a"(val)

    :"a"(11));

    return val;

};

uint32_t get_tick_count(void)

{

    uint32_t val;

    __asm__ __volatile__(

    "int $0x40"

    :"=a"(val)

    :"a"(26),"b"(9));

    return val;

};

oskey_t get_key(void)

{

    oskey_t val;

    __asm__ __volatile__(

    "int $0x40"

    :"=a"(val)

    :"a"(2));

    return val;

}

void draw_line(int xs, int ys, int xe, int ye, color_t color)

{

    __asm__ __volatile__(

    "int $0x40"

    ::"a"(38), "d"(color),

      "b"((xs << 16) | xe),

      "c"((ys << 16) | ye));

}

void draw_bar(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));

}

void draw_bitmap(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));

}

void draw_text_sys(const char *text, int x, int y, int len, color_t color)

{

    __asm__ __volatile__(

    "int $0x40"

    ::"a"(4),"d"(text),

      "b"((x << 16) | y),

      "S"(len),"c"(color));

}

void *user_alloc(size_t size)

{

    void  *val;

    __asm__ __volatile__(

    "int $0x40"

    :"=a"(val)

    :"a"(68),"b"(12),"c"(size));

    return val;

}

int user_free(void *mem)

{

    int  val;

    __asm__ __volatile__(

    "int $0x40"

    :"=a"(val)

    :"a"(68),"b"(12),"c"(mem));

    return val;

}

int *user_unmap(void *base, size_t offset, size_t size)

{

    void  *val;

    __asm__ __volatile__(

    "int $0x40"

    :"=a"(val)

    :"a"(68),"b"(26),"c"(base),"d"(offset),"S"(size));

    return val;

}

extern inline

void    exit(int status)  __attribute__((noreturn)) ;

void    exit(int status)

{

    __asm__ __volatile__(

    "int $0x40"

    ::"a"(-1));

    for(;;);

}

*/

uint32_t  load_cursor(void *path, uint32_t flags)

{

    uint32_t  val;

    __asm__ __volatile__(

    "int $0x40"

    :"=a"(val)

    :"a"(37), "b"(4), "c"(path), "d"(flags));

    return val;

}

uint32_t  set_cursor(uint32_t  cursor)

{

    uint32_t  old;

    __asm__ __volatile__(

    "int $0x40"

    :"=a"(old)

    :"a"(37), "b"(5), "c"(cursor));

    return old;

}

int destroy_cursor(uint32_t cursor)

{

    int ret;

    __asm__ __volatile__(

    "int $0x40"

    :"=a"(ret)

    :"a"(37), "b"(6), "c"(cursor)

    :"memory");

    return ret;

};

{

    __asm__ __volatile__(

    "int $0x40"

    :

    :"a"(9), "b"(info), "c"(-1));

}

void* user_realloc(void *mem, size_t size)

{

    void *val;

    __asm__ __volatile__(

    "int $0x40"

    :"=a"(val)

    :"a"(68),"b"(20),"c"(size),"d"(mem)

    :"memory");

}

{

    int dstx;

    int dsty;

    int w;

    int h;

    int srcy;

    int srcw;

    int srch;

    int   stride;

};

                        int src_x, int src_y, int w, int h,

                        int src_w, int src_h, int stride);