#5

git-svn-id: svn://kolibrios.org@8211 a494cfbc-eb01-0410-851d-a64ba20cac60

contrib/sdk/sources/SDL-1.2.2_newlib/src/SYSCALL/src/Makefile

@@ -0,0 +1,19 @@
+CC = kos32-gcc
+LD = kos32-ld
+
+SDK_DIR = $(abspath ../../../../../)
+
+CFLAGS = -c -fno-ident -O2 -fomit-frame-pointer -fno-ident -U__WIN32__ -U_Win32 -U_WIN32 -U__MINGW32__ -UWIN32
+
+INCLUDES = -I ../include -I $(SDK_DIR)/sources/newlib/libc/include
+
+FITZ_SRC := $(notdir $(wildcard *.c))
+OBJECTS =  $(patsubst %.c, %.o, $(FITZ_SRC))
+
+default: $(patsubst %.c,%.o,$(FITZ_SRC))
+
+%.o : %.c Makefile $(FITZ_SRC)
+	$(CC) $(CFLAGS) $(INCLUDES) -o $@ $<
+
+clean:
+	rm *.o

contrib/sdk/sources/SDL-1.2.2_newlib/src/SYSCALL/src/alloca.s

@@ -0,0 +1,6 @@
+#include <libc/asm.h>
+MK_C_SYM(_alloca)
+	sub	%eax, %esp
+	mov	(%esp,%eax),%eax
+	mov	%eax, (%esp)
+	ret

contrib/sdk/sources/SDL-1.2.2_newlib/src/SYSCALL/src/backgr.c

@@ -0,0 +1,26 @@
+#include<menuet/os.h>
+
+void __menuet__set_background_size(__u32 xsz,__u32 ysz)
+{
+ __asm__ __volatile__("int $0x40"::"a"(15),"b"(1),"c"(xsz),"d"(ysz));
+}
+
+void __menuet__write_background_mem(__u32 pos,__u32 color)
+{
+ __asm__ __volatile__("int $0x40"::"a"(15),"b"(2),"c"(pos),"d"(color));
+}
+
+void __menuet__draw_background(void)
+{
+ __asm__ __volatile__("int $0x40"::"a"(15),"b"(3));
+}
+
+void __menuet__set_background_draw_type(int type)
+{
+ __asm__ __volatile__("int $0x40"::"a"(15),"b"(3),"c"(type));
+}
+
+void __menuet__background_blockmove(char * src_ptr,__u32 bgr_dst,__u32 count)
+{
+ __asm__ __volatile__("int $0x40"::"a"(15),"b"(3),"c"(src_ptr),"d"(bgr_dst),"S"(count));
+}

contrib/sdk/sources/SDL-1.2.2_newlib/src/SYSCALL/src/bar.c

@@ -0,0 +1,9 @@
+#include<menuet/os.h>
+
+void __menuet__bar(__u16 x1,__u16 y1,__u16 xsize,__u16 ysize,__u32 color)
+{
+ __u32 a,b;
+ a=(x1<<16)|xsize;
+ b=(y1<<16)|ysize;
+ __asm__ __volatile__("int $0x40"::"a"(13),"b"(a),"c"(b),"d"(color));
+}

contrib/sdk/sources/SDL-1.2.2_newlib/src/SYSCALL/src/button.c

@@ -0,0 +1,17 @@
+#include<menuet/os.h>
+
+void __menuet__make_button(__u16 x1,__u16 y1,__u16 xsize,__u16 ysize,
+                           int id,__u32 color)
+{
+ __u32 a,b;
+ a=(x1<<16)|xsize;
+ b=(y1<<16)|ysize;
+ __asm__ __volatile__("int $0x40"::"a"(8),"b"(a),"c"(b),"d"(id),"S"(color));
+}
+
+int __menuet__get_button_id(void)
+{
+ __u16 __ret;
+ __asm__ __volatile__("int $0x40":"=a"(__ret):"0"(17));
+ if((__ret & 0xFF)==0) return (__ret>>8)&0xFF; else return -1;
+}

contrib/sdk/sources/SDL-1.2.2_newlib/src/SYSCALL/src/clock.c

@@ -0,0 +1,8 @@
+#include<menuet/os.h>
+
+__u32 __menuet__getsystemclock(void)
+{
+ __u32 __ret;
+ __asm__ __volatile__("int $0x40":"=a"(__ret):"0"(3));
+ return __ret;
+}

contrib/sdk/sources/SDL-1.2.2_newlib/src/SYSCALL/src/cofflib.c

@@ -0,0 +1,15 @@
+#include <menuet/os.h>
+#include <stdio.h>
+#include <string.h>
+
+IMP_TABLE __kolibri__cofflib_load(const char* name){
+	__asm__ __volatile__("int $0x40"::"a"(68L),"b"(19L),"c"((__u32)name));
+}
+
+__u32 __kolibri__cofflib_getproc(IMP_TABLE lib, const char* name){
+	if(!name || !name[0]) return 0;
+	int i;
+	for(i = 0; lib[i].name && strcmp(name, lib[i].name); i++);
+	if(lib[i].name) return (__u32)lib[i].pointer;
+	else return 0;
+}

contrib/sdk/sources/SDL-1.2.2_newlib/src/SYSCALL/src/date.c

@@ -0,0 +1,8 @@
+#include<menuet/os.h>
+
+__u32 __menuet__get_date(void)
+{
+ __u32 __ret;
+ __asm__ __volatile__("int $0x40":"=a"(__ret):"0"(29));
+ return __ret;
+}

contrib/sdk/sources/SDL-1.2.2_newlib/src/SYSCALL/src/debug.c

@@ -0,0 +1,5 @@
+#include <menuet/os.h>
+void __menuet__debug_out(const char* str){
+  while(*str)
+    __menuet__debug_out_byte(*str++);
+}

contrib/sdk/sources/SDL-1.2.2_newlib/src/SYSCALL/src/delay.c

@@ -0,0 +1,11 @@
+#include<menuet/os.h>
+
+void __menuet__delay100(int m)
+{
+ __asm__ __volatile__("int $0x40"::"a"(5),"b"(m));
+}
+
+void __menuet__idle(void)
+{
+ __menuet__delay100(10);
+}

contrib/sdk/sources/SDL-1.2.2_newlib/src/SYSCALL/src/dga.c

@@ -0,0 +1,19 @@
+#include<menuet/os.h>
+
+void __menuet__dga_get_caps(int * xres,int * yres,int * bpp,int * bpscan)
+{
+ int p;
+ __asm__ __volatile__("int $0x40":"=a"(p):"0"(61),"b"(1));
+ if(xres) *xres=(p>>16)&0xFFFF;
+ if(yres) *yres=p & 0xFFFF;
+ if(bpp)
+ {
+  __asm__ __volatile__("int $0x40":"=a"(p):"0"(61),"b"(2));
+  *bpp=p;
+ }
+ if(bpscan)
+ {
+  __asm__ __volatile__("int $0x40":"=a"(p):"0"(61),"b"(3));
+  *bpscan=p;
+ }
+}

contrib/sdk/sources/SDL-1.2.2_newlib/src/SYSCALL/src/event.c

@@ -0,0 +1,20 @@
+#include<menuet/os.h>
+
+int __menuet__wait_for_event(void)
+{
+ __u32 __ret;
+ __asm__ __volatile__("int $0x40":"=a"(__ret):"0"(10));
+ return __ret;
+}
+
+int __menuet__check_for_event(void)
+{
+ __u32 __ret;
+ __asm__ __volatile__("int $0x40":"=a"(__ret):"0"(11));
+ return __ret;
+}
+
+void __menuet__set_bitfield_for_wanted_events(__u32 ev)
+{
+ __asm__ __volatile__("int $0x40"::"a"(40),"b"(ev));
+}

contrib/sdk/sources/SDL-1.2.2_newlib/src/SYSCALL/src/exit.c

@@ -0,0 +1,6 @@
+#include<menuet/os.h>
+
+void __menuet__sys_exit(void)
+{
+ __asm__ __volatile__("int $0x40"::"a"(0xFFFFFFFF));
+}

contrib/sdk/sources/SDL-1.2.2_newlib/src/SYSCALL/src/file.c

@@ -0,0 +1,45 @@
+#include<menuet/os.h>
+#include<stdio.h>
+#include<stdarg.h>
+#include<string.h>
+
+__u32 __menuet__open(char * name,char * data)
+{
+ __u32 __ret;
+ __asm__ __volatile__("int $0x40":"=a"(__ret):"0"(6),"b"((__u32)name),"c"(0),"d"(0xFFFFFFFF),"S"((__u32)data));
+ return __ret;
+}
+
+void __menuet__save(char * name,char * data,__u32 count)
+{
+ __asm__ __volatile__("int $0x40"::"a"(33),"b"((__u32)name),"c"((__u32)data),"d"(count),"S"(0));
+}
+
+void __menuet__exec_ramdisk(char * filename,char * args,...)
+{
+ va_list argz;
+ char buffer[1024];
+ memset(buffer,0,1024);
+ if(args)
+ {
+  va_start(argz,args);
+  vsprintf(buffer,args,argz);
+ }
+ va_end(argz);
+ __asm__ __volatile__("int $0x40"::"a"(19),"b"(filename),"c"((args ? buffer : NULL)));
+}
+
+void __menuet__exec_hd(char * filename,char * args,...)
+{
+ va_list argz;
+ char buffer[1024];
+ char work_area[0xFFFF];
+ memset(buffer,0,1024);
+ if(args)
+ {
+  va_start(argz,args);
+  vsprintf(buffer,args,argz);
+ }
+ va_end(argz);
+ __asm__ __volatile__("int $0x40"::"a"(19),"b"(filename),"c"(args ? buffer : NULL),"d"(work_area));
+}

contrib/sdk/sources/SDL-1.2.2_newlib/src/SYSCALL/src/image.c

@@ -0,0 +1,9 @@
+#include<menuet/os.h>
+
+void __menuet__putimage(__u16 x1,__u16 y1,__u16 xsize,__u16 ysize,char * image)
+{
+ __u32 a,b;
+ a=(xsize<<16)|ysize;
+ b=(x1<<16)|y1;
+ __asm__ __volatile__("int $0x40"::"a"(7),"b"(image),"c"(a),"d"(b));
+}

contrib/sdk/sources/SDL-1.2.2_newlib/src/SYSCALL/src/ipc.c

@@ -0,0 +1,11 @@
+#include<menuet/os.h>
+
+void send_message(int pid,void * msg_ptr,int message_size)
+{
+ __asm__ __volatile__("int $0x40"::"a"(60),"b"(2),"c"(pid),"d"(msg_ptr),"S"(message_size));
+}
+
+void define_receive_area(msgrcva_t * rcva_ptr,int size)
+{
+ __asm__ __volatile__("int $0x40"::"a"(60),"b"(1),"c"(rcva_ptr),"d"(size));
+}

contrib/sdk/sources/SDL-1.2.2_newlib/src/SYSCALL/src/irq.c

@@ -0,0 +1,62 @@
+#include<menuet/os.h>
+
+__u32 __menuet__get_irq_owner(__u32 irq)
+{
+ __u32 __ret;
+ __asm__ __volatile__("int $0x40":"=a"(__ret):"0"(41),"b"(irq));
+ return __ret;
+}
+
+int __menuet__get_data_read_by_irq(__u32 irq,__u32 * num_bytes_in_buf,__u8 * data)
+{
+ __u32 a,b,c;
+ __asm__ __volatile__("int $0x40":"=a"(a),"=b"(b),"=c"(c):"0"(42),"1"(irq));
+ if(num_bytes_in_buf) *num_bytes_in_buf=a;
+ if(data) *data=b & 0xFF;
+ return c;
+}
+
+int __menuet__send_data_to_device(__u16 port,__u8 val)
+{
+ int __ret;
+ __asm__ __volatile__("int $0x40":"=a"(__ret):"0"(43),"b"(port),"c"(val));
+ return __ret;
+}
+
+void __menuet__program_irq(void * intr_table,__u32 irq_num)
+{
+ __asm__ __volatile__("int $0x40"::"a"(44),"b"(intr_table),"c"(irq_num));
+}
+
+int __menuet__reserve_irq(int irqno)
+{
+ int __ret;
+ __asm__ __volatile__("int $0x40":"=a"(__ret):"0"(45),"b"(0),"c"(irqno));
+ return __ret;
+}
+
+int __menuet__free_irq(int irqno)
+{
+ int __ret;
+ __asm__ __volatile__("int $0x40":"=a"(__ret):"0"(45),"b"(1),"c"(irqno));
+ return __ret;
+}
+
+int __menuet__reserve_port_area(__u32 start,__u32 end)
+{
+ int __ret;
+ __asm__("int $0x40":"=a"(__ret):"a"(45),"b"(0),"c"(start),"d"(end));
+ return __ret;
+}
+
+int __menuet__free_port_area(__u32 start,__u32 end)
+{
+ int __ret;
+ __asm__("int $0x40":"=a"(__ret):"a"(45),"b"(1),"c"(start),"d"(end));
+ return __ret;
+}
+
+void __menuet__define_app_internal_intrs(void * intr_table)
+{
+ __asm__("int $0x40"::"a"(49),"b"(0),"c"(intr_table));
+}

contrib/sdk/sources/SDL-1.2.2_newlib/src/SYSCALL/src/keyb.c

@@ -0,0 +1,8 @@
+#include<menuet/os.h>
+
+int __menuet__getkey(void)
+{
+ __u16 __ret;
+ __asm__ __volatile__("int $0x40":"=a"(__ret):"0"(2));
+ if(!(__ret & 0xFF)) return (__ret>>8)&0xFF; else return 0;
+}

contrib/sdk/sources/SDL-1.2.2_newlib/src/SYSCALL/src/line.c

@@ -0,0 +1,9 @@
+#include<menuet/os.h>
+
+void __menuet__line(__u16 x1,__u16 y1,__u16 x2,__u16 y2,__u32 color)
+{
+ __u32 b,c;
+ b=(x1<<16)|x1;
+ c=(y1<<16)|y2;
+ __asm__ __volatile__("int $0x40"::"a"(38),"b"(b),"c"(c),"d"(color));
+}

contrib/sdk/sources/SDL-1.2.2_newlib/src/SYSCALL/src/mpu401.c

@@ -0,0 +1,11 @@
+#include<menuet/os.h>
+
+void __menuet__reset_mpu401(void)
+{
+ __asm__ __volatile__("int $0x40"::"a"(20),"b"(1));
+}
+
+void __menuet__write_mpu401(__u8 d)
+{
+ __asm__ __volatile__("int $0x40"::"a"(20),"b"(2),"c"(d));
+}

contrib/sdk/sources/SDL-1.2.2_newlib/src/SYSCALL/src/param.c

@@ -0,0 +1,7 @@
+#include<menuet/os.h>
+
+#define APP_PARAM_SZ		(1024)
+#define APP_PATH_SZ             (1024)
+
+char __menuet__app_param_area[APP_PARAM_SZ];
+char __menuet__app_path_area[APP_PATH_SZ];

contrib/sdk/sources/SDL-1.2.2_newlib/src/SYSCALL/src/pci.c

@@ -0,0 +1,50 @@
+#include<menuet/os.h>
+
+#define PCI_FN		62
+
+void get_pci_version(__u8 * major,__u8 * minor)
+{
+ int r;
+ __asm__ __volatile__("int $0x40":"=a"(r):"0"(PCI_FN),"b"(0));
+ *minor=r&0xFF;
+ *major=(r>>8)&0xFF;
+}
+
+void pci_get_last_bus(__u8 * last_bus)
+{
+ __asm__ __volatile__("int $0x40":"=a"(*last_bus):"0"(PCI_FN),"b"(1));
+}
+
+void get_pci_access_mechanism(__u8 * mechanism)
+{
+ __asm__ __volatile__("int $0x40":"=a"(*mechanism):"0"(PCI_FN),"b"(2));
+}
+
+#define read_config(x,c,bits) \
+    __u##bits pci_read_config_##x (__u8 bus,__u8 dev,__u8 fn,__u8 reg) \
+    { \
+      __u##bits __ret; \
+      __u16 cx; \
+      __u16 bx; \
+      cx=(((fn&7)|(((dev)&~7)<<3))<<8)|reg; \
+      bx=(bus<<8)|(c); \
+      __asm__ __volatile__("int $0x40":"=a"(__ret):"0"(PCI_FN),"b"(bx),"c"(cx)); \
+      return __ret; \
+     }
+
+#define write_config(x,c,bits) \
+    void pci_write_config_##x (__u8 bus,__u8 dev,__u8 fn,__u8 reg,__u##bits val) \
+    { \
+     __u16 cx,bx; \
+     cx=(((fn&7)|(((dev)&~7)<<3))<<8)|reg; \
+     bx=(bus<<8)|(c); \
+     __asm__ __volatile__("int $0x40"::"a"(PCI_FN),"b"(bx),"c"(cx),"d"(val)); \
+    }
+
+#define rw_config(x,c,bits) \
+    read_config(x,4+c,bits) \
+    write_config(x,7+c,bits)
+        
+rw_config(byte,0,8)
+rw_config(word,1,16)
+rw_config(dword,2,32)

contrib/sdk/sources/SDL-1.2.2_newlib/src/SYSCALL/src/pixel.c

@@ -0,0 +1,6 @@
+#include<menuet/os.h>
+
+void __menuet__putpixel(__u32 x,__u32 y,__u32 color)
+{
+ __asm__ __volatile__("int $0x40"::"a"(1),"b"(x),"c"(y),"d"(color));
+}

contrib/sdk/sources/SDL-1.2.2_newlib/src/SYSCALL/src/process.c

@@ -0,0 +1,8 @@
+#include<menuet/os.h>
+
+int __menuet__get_process_table(struct process_table_entry * proctab,int pid)
+{
+ int __ret;
+ __asm__ __volatile__("int $0x40":"=a"(__ret):"0"(9),"b"((__u32)proctab),"c"(pid));
+ return __ret;
+}

contrib/sdk/sources/SDL-1.2.2_newlib/src/SYSCALL/src/screen.c

@@ -0,0 +1,9 @@
+#include<menuet/os.h>
+
+void __menuet__get_screen_max(__u16 * x,__u16 * y)
+{
+ __u32 v;
+ __asm__ __volatile__("int $0x40":"=a"(v):"0"(14));
+ if(x) *x=v>>16;
+ if(y) *y=v & 0xFFFF;
+}

contrib/sdk/sources/SDL-1.2.2_newlib/src/SYSCALL/src/sound.c

@@ -0,0 +1,11 @@
+#include<menuet/os.h>
+
+void __menuet__sound_load_block(char * blockptr)
+{
+ __asm__ __volatile__("int $0x40"::"a"(55),"b"(0),"c"(blockptr));
+}
+
+void __menuet__sound_play_block(void)
+{
+ __asm__ __volatile__("int $0x40"::"a"(55),"b"(1));
+}

contrib/sdk/sources/SDL-1.2.2_newlib/src/SYSCALL/src/systree.c

@@ -0,0 +1,16 @@
+#include<menuet/os.h>
+
+int __kolibri__system_tree_access(struct systree_info * info)
+{
+ int __ret;
+ int d0;
+ __asm__ __volatile__("int $0x40":"=a"(__ret),"=&b"(d0):"0"(70),"1"((__u32)info));
+ return __ret;
+}
+int __kolibri__system_tree_access2(struct systree_info2 * info)
+{
+ int __ret;
+ int d0;
+ __asm__ __volatile__("int $0x40":"=a"(__ret),"=&b"(d0):"0"(70),"1"((__u32)info));
+ return __ret;
+}

contrib/sdk/sources/SDL-1.2.2_newlib/src/SYSCALL/src/text.c

@@ -0,0 +1,6 @@
+#include<menuet/os.h>
+
+void __menuet__write_text(__u16 x,__u16 y,__u32 color,char * text,int len)
+{
+ __asm__ __volatile__("int $0x40"::"a"(4),"b"((x<<16)|y),"c"(color),"d"((__u32)text),"S"(len));
+}

contrib/sdk/sources/SDL-1.2.2_newlib/src/SYSCALL/src/thread.c

@@ -0,0 +1,12 @@
+#include<menuet/os.h>
+#include<stdio.h>
+#include<stdlib.h>
+
+void * __menuet__exec_thread(void (* func_ptr)(void),__u32 stack_size,int * retp)
+{
+ void * __stk, * __ret;
+ __ret=__stk=malloc(stack_size);
+ __stk+=stack_size-1;
+ __asm__ __volatile__("int $0x40":"=a"(*retp):"0"(51L),"b"(1L),"c"((__u32)func_ptr),"d"((__u32)__stk));
+ return __ret;
+}

contrib/sdk/sources/SDL-1.2.2_newlib/src/SYSCALL/src/window.c

@@ -0,0 +1,16 @@
+#include<menuet/os.h>
+
+void __menuet__define_window(__u16 x1,__u16 y1,__u16 xsize,__u16 ysize,
+     __u32 body_color,__u32 grab_color,__u32 frame_color)
+{
+ __u32 a,b;
+ a=(x1<<16)|xsize;
+ b=(y1<<16)|ysize;
+ __asm__ __volatile__("int $0x40"::"a"(0),"b"(a),"c"(b),"d"(body_color),"S"(grab_color),
+                      "D"(frame_color));
+}
+
+void __menuet__window_redraw(int status)
+{
+ __asm__ __volatile__("int $0x40"::"a"(12),"b"(status));
+}

contrib/sdk/sources/SDL-1.2.2_newlib/src/timer/dummy/SDL_systimer.c

@@ -0,0 +1,114 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@devolution.com
+*/
+
+#ifdef SAVE_RCSID
+static char rcsid =
+ "@(#) $Id: SDL_systimer.c,v 1.2 2001/04/26 16:50:18 hercules Exp $";
+#endif
+
+#include <stdio.h>
+#include <sys/time.h>
+#include <signal.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+
+#include "SDL_error.h"
+#include "SDL_timer.h"
+#include "SDL_timer_c.h"
+
+#if _POSIX_THREAD_SYSCALL_SOFT
+#include <pthread.h>
+#endif
+
+#if defined(DISABLE_THREADS) || defined(FORK_HACK)
+#define USE_ITIMER
+#endif
+
+
+/* The first ticks value of the application */
+//static struct timeval start;
+//static unsigned startlo,starthi;
+//static unsigned clockrate;
+static unsigned starttime;
+
+void SDL_StartTicks(void)
+{
+// gettimeofday(&start, NULL);
+//  __asm__ ("int $0x40" : "=a"(clockrate) : "a"(18),"b"(5));
+//  __asm__ ("rdtsc" : "=a"(startlo),"=d"(starthi));
+	__asm__ ("int $0x40" : "=a"(starttime) : "a"(26),"b"(9));
+}
+
+
+Uint32 SDL_GetTicks (void)
+{
+/* struct timeval now;
+ Uint32 ticks;
+ gettimeofday(&now, NULL);
+ ticks=(now.tv_sec-start.tv_sec)*1000+(now.tv_usec-start.tv_usec)/1000;
+ return(ticks);*/
+	/*int res;
+	__asm__ ("rdtsc\n\t"
+		"sub (_startlo),%%eax\n\t"
+		"sbb (_starthi),%%edx\n\t"
+		"push %%eax\n\t"
+		"mov %%edx,%%eax\n\t"
+		"mov $1000,%%ecx\n\t"
+		"mul %%ecx\n\t"
+		"xchg (%%esp),%%eax\n\t"
+		"mul %%ecx\n\t"
+		"add %%edx,(%%esp)\n\t"
+		"pop %%edx\n\t"
+		"divl (_clockrate)\n\t" : "=a"(res));
+	return res;*/
+	unsigned curtime;
+	__asm__ ("int $0x40" : "=a"(curtime) : "a"(26),"b"(9));
+	return (curtime-starttime)*10;
+}
+
+void SDL_Delay (Uint32 ms)
+{
+ __menuet__delay100(ms);
+/*  Uint32 start = SDL_GetTicks();
+  do
+    __asm__("int $0x40" :: "a"(68),"b"(1));
+  while (SDL_GetTicks()-start < ms);*/
+}
+
+int SDL_SYS_TimerInit(void)
+{
+	return(0);
+}
+
+void SDL_SYS_TimerQuit(void)
+{
+}
+
+int SDL_SYS_StartTimer(void)
+{
+	return(0);
+}
+
+void SDL_SYS_StopTimer(void)
+{
+}

contrib/sdk/sources/SDL-1.2.2_newlib/src/video/menuetos/SDL_menuetevents.c

@@ -0,0 +1,244 @@
+#include<menuet/os.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "SDL.h"
+#include "SDL_sysevents.h"
+#include "SDL_sysvideo.h"
+#include "SDL_events_c.h"
+#include "SDL_menuetvideo.h"
+
+extern void MenuetOS_SDL_RepaintWnd(void);
+
+void MenuetOS_InitOSKeymap(_THIS)
+{
+	__asm__("int $0x40"::"a"(66),"b"(1),"c"(1));
+}
+
+#define LSHIFT 1
+#define RSHIFT 2
+#define LCTRL 4
+#define RCTRL 8
+#define LALT 0x10
+#define RALT 0x20
+#define CAPS 0x40
+#define NUML 0x80
+#define SCRL 0x100
+
+#define SHIFT (LSHIFT+RSHIFT)
+#define CTRL (LCTRL+RCTRL)
+#define ALT (LALT+RALT)
+
+static SDLMod GetModState(void)
+{
+	unsigned controlstate;
+	__asm__("int $0x40":"=a"(controlstate):"a"(66),"b"(3));
+	SDLMod res = 0;
+	if (controlstate & LSHIFT)
+		res |= KMOD_LSHIFT;
+	if (controlstate & RSHIFT)
+		res |= KMOD_RSHIFT;
+	if (controlstate & LCTRL)
+		res |= KMOD_LCTRL;
+        if (controlstate & RCTRL)
+        	res |= KMOD_RCTRL;
+        if (controlstate & LALT)
+        	res |= KMOD_LALT;
+	if (controlstate & RALT)
+		res |= KMOD_RALT;
+	if (controlstate & CAPS)
+		res |= KMOD_CAPS;
+	if (controlstate & NUML)
+		res |= KMOD_NUM;
+	return res;
+}
+
+/*static __u8 scan2ascii(__u8 n,SDLMod mod)
+{
+	__u8 layout[128];
+	int layouttype;
+	int bControlLayout = 0;
+	if (mod & KMOD_ALT)
+		layouttype = 3;
+	else if (mod & KMOD_SHIFT)
+		layouttype = 2;
+	else
+	{
+		if (mod & KMOD_CTRL)
+			bControlLayout = 1;
+		layouttype = 1;
+	}
+	__asm__("int $0x40" :: "a"(26),"b"(2),"c"(layouttype),"d"(layout));
+	__u8 res = layout[n];
+	if (bControlLayout)
+		res -= 0x60;
+	return res;
+}*/
+static SDLKey sdlkeys[0x80] =
+{
+	// 0x0*
+	0, SDLK_ESCAPE, SDLK_1, SDLK_2, SDLK_3, SDLK_4, SDLK_5, SDLK_6,
+	SDLK_7, SDLK_8, SDLK_9, SDLK_0, SDLK_MINUS, SDLK_EQUALS, SDLK_BACKSPACE, SDLK_TAB,
+	// 0x1*
+	SDLK_q, SDLK_w, SDLK_e, SDLK_r, SDLK_t, SDLK_y, SDLK_u, SDLK_i,
+	SDLK_o, SDLK_p, SDLK_LEFTBRACKET, SDLK_RIGHTBRACKET, SDLK_RETURN, SDLK_LCTRL, SDLK_a, SDLK_s,
+	// 0x2*
+	SDLK_d, SDLK_f, SDLK_g, SDLK_h, SDLK_j, SDLK_k, SDLK_l, SDLK_SEMICOLON,
+	SDLK_QUOTE, SDLK_BACKQUOTE, SDLK_LSHIFT, SDLK_BACKSLASH, SDLK_z, SDLK_x, SDLK_c, SDLK_v,
+	// 0x3*
+	SDLK_b, SDLK_n, SDLK_m, SDLK_COMMA, SDLK_PERIOD, SDLK_SLASH, SDLK_RSHIFT, SDLK_KP_MULTIPLY,
+	SDLK_LALT, SDLK_SPACE, SDLK_CAPSLOCK, SDLK_F1, SDLK_F2, SDLK_F3, SDLK_F4, SDLK_F5,
+	// 0x4*
+	SDLK_F6, SDLK_F7, SDLK_F8, SDLK_F9, SDLK_F10, SDLK_NUMLOCK, SDLK_SCROLLOCK, SDLK_KP7,
+	SDLK_KP8, SDLK_KP9, SDLK_KP_MINUS, SDLK_KP4, SDLK_KP5, SDLK_KP6, SDLK_KP_PLUS, SDLK_KP1,
+	// 0x5*
+	SDLK_KP2, SDLK_KP3, SDLK_KP0, SDLK_KP_PERIOD, 0, 0, 0, SDLK_F11,
+	SDLK_F12, 0, 0, 0, 0, 0, 0, 0,
+	// 0x6*
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	// 0x7*
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0
+};
+static SDLKey sdlkeys_shift[0x80] =
+{
+	// 0x0*
+	0, SDLK_ESCAPE, SDLK_EXCLAIM, SDLK_AT, SDLK_HASH, SDLK_DOLLAR, '%', SDLK_CARET,
+	SDLK_AMPERSAND, SDLK_ASTERISK, SDLK_LEFTPAREN, SDLK_RIGHTPAREN, SDLK_UNDERSCORE, SDLK_PLUS, SDLK_BACKSPACE, SDLK_TAB,
+	// 0x1*
+	SDLK_q, SDLK_w, SDLK_e, SDLK_r, SDLK_t, SDLK_y, SDLK_u, SDLK_i,
+	SDLK_o, SDLK_p, '{', '}', SDLK_RETURN, SDLK_LCTRL, SDLK_a, SDLK_s,
+	// 0x2*
+	SDLK_d, SDLK_f, SDLK_g, SDLK_h, SDLK_j, SDLK_k, SDLK_l, SDLK_COLON,
+	SDLK_QUOTEDBL, '~', SDLK_LSHIFT, '|', SDLK_z, SDLK_x, SDLK_c, SDLK_v,
+	// 0x3*
+	SDLK_b, SDLK_n, SDLK_m, SDLK_LESS, SDLK_GREATER, SDLK_QUESTION, SDLK_RSHIFT, SDLK_KP_MULTIPLY,
+	SDLK_LALT, SDLK_SPACE, SDLK_CAPSLOCK, SDLK_F1, SDLK_F2, SDLK_F3, SDLK_F4, SDLK_F5,
+	// 0x4*
+	SDLK_F6, SDLK_F7, SDLK_F8, SDLK_F9, SDLK_F10, SDLK_NUMLOCK, SDLK_SCROLLOCK, SDLK_KP7,
+	SDLK_KP8, SDLK_KP9, SDLK_KP_MINUS, SDLK_KP4, SDLK_KP5, SDLK_KP6, SDLK_KP_PLUS, SDLK_KP1,
+	// 0x5*
+	SDLK_KP2, SDLK_KP3, SDLK_KP0, SDLK_KP_PERIOD, 0, 0, 0, SDLK_F11,
+	SDLK_F12, 0, 0, 0, 0, 0, 0, 0,
+	// 0x6*
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	// 0x7*
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0
+};
+static SDLKey sdlkeys_e0[0x80] =
+{
+	// 0x0*
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	// 0x1*
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, SDLK_KP_ENTER, SDLK_RCTRL, 0, 0,
+	// 0x2*
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	// 0x3*
+	0, 0, 0, 0, 0, SDLK_KP_DIVIDE, 0, SDLK_PRINT,
+	SDLK_RALT, 0, 0, 0, 0, 0, 0, 0,
+	// 0x4*
+	0, 0, 0, 0, 0, 0, 0, SDLK_HOME,
+	SDLK_UP, SDLK_PAGEUP, 0, SDLK_LEFT, 0, SDLK_RIGHT, 0, SDLK_END,
+	// 0x5*
+	SDLK_DOWN, SDLK_PAGEDOWN, SDLK_INSERT, SDLK_DELETE, 0, 0, 0, 0,
+	0, 0, 0, SDLK_LSUPER, SDLK_RSUPER, SDLK_MENU, 0, 0,
+	// 0x6*
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	// 0x7*
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+};
+
+extern void KolibriOS_CheckMouseMode(_THIS);
+void MenuetOS_PumpEvents(_THIS)
+{
+ int i;
+ SDL_keysym key;
+ static int ext_code=0;
+ static __u8 old_mode=0;
+ for (;;) {
+  i=__menuet__check_for_event();
+  switch(i)
+  {
+   case 0:
+    return;
+   case 1:
+    MenuetOS_SDL_RepaintWnd();
+    break;
+   case 2:
+    key.scancode = __menuet__getkey();
+    if (key.scancode == 0xE0 || key.scancode == 0xE1)
+    {ext_code=key.scancode;break;}
+    if (ext_code == 0xE1 && (key.scancode & 0x7F) == 0x1D) break;
+    if (ext_code == 0xE1 && key.scancode == 0xC5) {ext_code=0;break;}
+    key.mod = GetModState();
+    if (ext_code == 0xE1) key.mod &= ~KMOD_CTRL;
+    if (!(key.scancode&0x80))
+      old_mode = key.mod;
+    SDL_SetModState(key.mod);
+    int code = (key.scancode & 0x80) ? SDL_RELEASED : SDL_PRESSED;
+    key.scancode &= 0x7F;
+//    key.sym = scan2ascii(key.scancode,key.mod);
+    if (ext_code == 0xE1 && key.scancode == 0x45)
+	key.sym = SDLK_PAUSE;
+    else if (ext_code == 0xE0)
+	key.sym = sdlkeys_e0[key.scancode];
+    else if (old_mode & KMOD_SHIFT)
+	key.sym = sdlkeys_shift[key.scancode];
+    else
+	key.sym = sdlkeys[key.scancode];
+    ext_code = 0;
+    if (!key.sym) break;	
+    SDL_PrivateKeyboard(code,&key);
+    break;
+   case 3:
+    if(__menuet__get_button_id()==1) exit(0);
+    break;
+   case 6: {
+    int __tmp,mx,my;
+    static int oldmousestate = 0;
+    __asm__("int $0x40":"=a"(__tmp):"a"(37),"b"(1));
+    mx=(__tmp>>16);
+    my=(__tmp&0xffff);
+    if(mx>=0 && mx<this->hidden->win_size_x &&
+       my>=0 && my<this->hidden->win_size_y || this->input_grab != SDL_GRAB_OFF)
+    {
+     if (this->input_grab != SDL_GRAB_OFF)
+     {
+      int dx=mx-this->hidden->win_size_x/2;
+      int dy=my-this->hidden->win_size_y/2;
+      if (dx||dy)
+      {
+       SDL_PrivateMouseMotion(0,1,dx,dy);
+       KolibriOS_CheckMouseMode(this);
+      }
+     }
+     else
+      SDL_PrivateMouseMotion(0,0,mx,my);
+     __asm__("int $0x40":"=a"(__tmp):"a"(37),"b"(2));
+     if ((__tmp^oldmousestate)&1) {
+     if(__tmp&1)
+     {
+      SDL_PrivateMouseButton(SDL_PRESSED,SDL_BUTTON_LMASK,0,0);
+     } else {
+     SDL_PrivateMouseButton(SDL_RELEASED,SDL_BUTTON_LMASK,0,0);
+     } }
+     if ((__tmp^oldmousestate)&2) {
+     if(__tmp&2)
+     {
+      SDL_PrivateMouseButton(SDL_PRESSED,SDL_BUTTON_RMASK,0,0);
+     } else {
+     SDL_PrivateMouseButton(SDL_RELEASED,SDL_BUTTON_RMASK,0,0);
+     } }
+     oldmousestate = __tmp;
+    }
+   }
+  }
+ }
+}

contrib/sdk/sources/SDL-1.2.2_newlib/src/video/menuetos/SDL_menuetvideo.c

@@ -0,0 +1,348 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <menuet/os.h>
+#include "SDL.h"
+#include "SDL_error.h"
+#include "SDL_video.h"
+#include "SDL_mouse.h"
+#include "SDL_sysvideo.h"
+#include "SDL_pixels_c.h"
+#include "SDL_events_c.h"
+#include "SDL_menuetvideo.h"
+#include <string.h>
+
+static SDL_VideoDevice * vm_suf=NULL;
+static int was_initialized=0;
+
+static int has_null_cursor=0;
+static int null_cursor;
+
+inline int get_skinh(void)
+{
+	int res;
+	__asm__ ("int $0x40" : "=a"(res) : "a"(48),"b"(4));
+	return res;
+}
+
+//#define KEEP_OBSOLETE_STYLE3
+
+#ifdef KEEP_OBSOLETE_STYLE3
+static int IsStyle4Available=0;
+#endif
+
+void MenuetOS_SDL_RepaintWnd(void)
+{
+ __menuet__window_redraw(1);
+ __menuet__define_window(1,1,vm_suf->hidden->win_size_x+9,vm_suf->hidden->win_size_y+get_skinh()+4,
+#ifdef KEEP_OBSOLETE_STYLE3
+ 	IsStyle4Available?0x34000000:0x33000000
+#else
+	0x34000000
+#endif
+ 	,0,(int)vm_suf->hidden->__title);
+
+ // __asm__ __volatile__("int3");
+
+ if(vm_suf && vm_suf->hidden->__video_buffer)
+  __menuet__putimage(0,0,
+   vm_suf->hidden->win_size_x,vm_suf->hidden->win_size_y,
+   vm_suf->hidden->__video_buffer);
+ __menuet__window_redraw(2);
+}
+
+static int MenuetOS_AllocHWSurface(_THIS,SDL_Surface * surface)
+{
+ return -1;
+}
+
+static void MenuetOS_FreeHWSurface(_THIS,SDL_Surface * surface)
+{
+}
+
+static int MenuetOS_LockHWSurface(_THIS,SDL_Surface * surface)
+{
+ return 0;
+}
+
+static void MenuetOS_UnlockHWSurface(_THIS,SDL_Surface * surface)
+{
+}
+
+static void MenuetOS_DirectUpdate(_THIS,int numrects,SDL_Rect * rects)
+{
+ if(numrects)
+ {
+  __menuet__putimage(0,0,
+   vm_suf->hidden->win_size_x,vm_suf->hidden->win_size_y,
+   this->hidden->__video_buffer);
+ }
+}
+
+int MenuetOS_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
+{
+ return 0;
+}
+
+void MenuetOS_VideoQuit(_THIS)
+{
+	if (has_null_cursor)
+	{
+		__asm__("int $0x40"::"a"(37),"b"(6),"c"(null_cursor));
+		has_null_cursor = 0;
+	}
+}
+
+void MenuetOS_FinalQuit(void)
+{
+}
+
+void MenuetOS_SetCaption(_THIS,const char * title,const char * icon)
+{
+ this->hidden->__title=(char *)title;
+ if(was_initialized) __asm__("int $0x40"::"a"(71),"b"(1),"c"(title));
+}
+
+SDL_Surface * MenuetOS_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags)
+{
+ int ly;
+ char * lx;
+ if(bpp!=24) return NULL;
+ current->flags=flags;
+ current->w=width;
+ current->h=height;
+ current->pitch=width*(bpp>>3);
+
+ char info[100];
+ sprintf(info, "width = %d, height = %d, pitch = %d, bpp = %d\n", current->w, current->h, current->pitch, bpp);
+
+ void debug_board_write_byte(const char ch){
+   __asm__ __volatile__(
+			"int $0x40"
+			:
+			:"a"(63), "b"(1), "c"(ch));
+ }
+
+ void debug_board_write_str(const char* str){
+   while(*str)
+     debug_board_write_byte(*str++);
+ }
+
+ debug_board_write_str(info);
+ // __asm__ __volatile__("int3");
+ 
+ current->pixels=this->hidden->__video_buffer=realloc(this->hidden->__video_buffer,
+	current->pitch*current->h);
+ this->hidden->__lines=(unsigned char **)realloc(this->hidden->__lines,
+		    sizeof(unsigned char *)*current->h);
+
+ for(ly=0,lx=current->pixels;ly<current->h;ly++,lx+=current->pitch)
+   this->hidden->__lines[ly]=lx;
+
+ this->UpdateRects=MenuetOS_DirectUpdate;
+ this->hidden->win_size_x=width;
+ this->hidden->win_size_y=height;
+ vm_suf=this;
+ if (was_initialized)
+ {
+  unsigned newheight = height+get_skinh()+4;
+  unsigned newwidth = width+9;
+  __asm__("int $0x40"::"a"(67),"b"(-1),"c"(-1),"d"(newwidth),"S"(newheight));
+ }
+ else
+ {
+  __menuet__set_bitfield_for_wanted_events(0x27);
+  was_initialized=1;
+  MenuetOS_SDL_RepaintWnd();
+ }
+ return current;
+}
+
+/*static SDL_Rect video_mode[4];
+static SDL_Rect * SDL_modelist[4]={NULL,NULL,NULL,NULL};*/
+
+static SDL_Rect ** MenuetOS_ListModes(_THIS,SDL_PixelFormat * fmt,Uint32 flags)
+{
+// return (&SDL_modelist[((fmt->BitsPerPixel+7)/8)-1]);
+	if (fmt->BitsPerPixel==24)
+		return (SDL_Rect**)-1;
+	else
+		return NULL;
+}
+
+static int MenuetOS_Available(void)
+{
+ return 1;
+}
+
+static void MenuetOS_DeleteDevice(_THIS)
+{
+// free(this->hidden->__video_buffer);	// it will be freed as current->pixels
+ free(this->hidden->__lines);
+}
+
+static int MenuetOS_VideoInit(_THIS,SDL_PixelFormat * vformat)
+{
+#ifdef KEEP_OBSOLETE_STYLE3
+	char buf[16];
+	__asm__("int $0x40"::"a"(18),"b"(13),"c"(buf));
+	if (buf[5]=='K' && buf[6]=='o' && buf[7]=='l' && buf[8]=='i')
+		/* kernels up to 0.7.0.0 do not support style 4 */;
+	else if (*(unsigned*)(buf+5) >= 549)
+		/* window style 4 was introduced in revision 549 */
+		IsStyle4Available = 1;
+#endif
+ vformat->BitsPerPixel=24;
+ vformat->BytesPerPixel=3;
+ this->info.wm_available=1;
+ this->info.hw_available=0;
+ this->info.video_mem=0x200000;
+/* video_mode[3].x=0;
+ video_mode[3].y=0;
+ video_mode[3].w=320;
+ video_mode[3].h=200;
+ video_mode[2].x=0;
+ video_mode[2].y=0;
+ video_mode[2].w=640;
+ video_mode[2].h=400;
+ video_mode[1].x=0;
+ video_mode[1].y=0;
+ video_mode[1].w=320;
+ video_mode[1].h=240;
+ video_mode[0].x=0;
+ video_mode[0].y=0;
+ video_mode[0].w=640;
+ video_mode[0].h=480;
+ SDL_modelist[2]=video_mode+0;*/
+ return 0;
+}
+
+static int MenuetOS_FlipHWSurface(_THIS,SDL_Surface * surface)
+{
+ __menuet__putimage(0,0,surface->w,surface->h,
+  surface->pixels);
+ return 0;
+}
+
+WMcursor* KolibriOS_CreateWMCursor(_THIS,
+	Uint8* data, Uint8* mask, int w, int h, int hot_x, int hot_y)
+{
+	int i,j;
+	Uint32* cursor;
+	WMcursor* res;
+
+	if (w>32 || h>32) return NULL;
+	if (w%8 || h%8) return NULL;
+	cursor = (Uint32*)malloc(32*32*4);
+	if (!cursor) return NULL;
+	for (i=0;i<32;i++)
+		for (j=0;j<32;j++)
+		{
+			if (i>=h || j>=w)
+			{
+				cursor[i*32+j] = 0x00000000;
+				continue;
+			}
+			if (mask[i*w/8+j/8] & (0x80>>(j&7)))
+				cursor[i*32+j] = (data[i*w/8+j/8] & (0x80>>(j&7)))?0xFF000000:0xFFFFFFFF;
+			else
+				cursor[i*32+j] = 0x00000000;
+		}
+	__asm__ ("int $0x40" : "=a"(res) : "a"(37),"b"(4),
+		"c"(cursor),"d"((hot_x<<24)+(hot_y<<16)+2));
+	free(cursor);
+	return res;
+}
+int KolibriOS_ShowWMCursor(_THIS,WMcursor*cursor)
+{
+	if (!cursor)
+	{
+		if (!has_null_cursor)
+		{
+			unsigned* u = malloc(32*32*4);
+			if (!u) return 1;
+			memset(u,0,32*32*4);
+			__asm__("int $0x40":"=a"(null_cursor):
+				"a"(37),"b"(4),"c"(u),"d"(2));
+			free(u);
+			has_null_cursor = 1;
+		}
+		cursor = (WMcursor*)null_cursor;
+	}
+	__asm__("int $0x40" : : "a"(37),"b"(5),"c"(cursor));
+	return 1;
+}
+void KolibriOS_FreeWMCursor(_THIS,WMcursor*cursor)
+{
+	__asm__("int $0x40" : : "a"(37),"b"(6),"c"(cursor));
+}
+void KolibriOS_CheckMouseMode(_THIS)
+{
+	if (this->input_grab == SDL_GRAB_OFF)
+		return;
+	struct process_table_entry buf;
+	int res;
+	__asm__ volatile("int $0x40" : "=a"(res): "a"(9), "b"(&buf), "c"(-1));
+	if (res == buf.pos_in_windowing_stack)
+	{
+		int x = buf.winx_start + buf.client_left + this->hidden->win_size_x/2;
+		int y = buf.winy_start + buf.client_top + this->hidden->win_size_y/2;
+		__asm__("int $0x40" : : "a"(18),"b"(19),"c"(4),
+			"d"(x*65536+y));
+	}
+}
+
+char def_title[] = "KolibriOS SDL App";
+static SDL_VideoDevice * MenuetOS_CreateDevice(int indx)
+{
+ SDL_VideoDevice * dev;
+ dev=(SDL_VideoDevice *)malloc(sizeof(SDL_VideoDevice));
+ if(dev) 
+ {
+  memset(dev,0,(sizeof *dev));
+  dev->hidden = (struct SDL_PrivateVideoData *)malloc((sizeof *dev->hidden));
+ }
+ if((dev==NULL) || (dev->hidden==NULL)) 
+ {
+  SDL_OutOfMemory();
+  if(dev) 
+  {
+   free(dev);
+  }
+  return(0);
+ }
+ memset(dev->hidden,0,(sizeof *dev->hidden));
+ dev->hidden->__title = def_title;
+ dev->VideoInit=MenuetOS_VideoInit;
+ dev->ListModes=MenuetOS_ListModes;
+ dev->SetVideoMode=MenuetOS_SetVideoMode;
+ dev->SetColors=MenuetOS_SetColors;
+ dev->UpdateRects=NULL;
+ dev->VideoQuit=MenuetOS_VideoQuit;
+ dev->AllocHWSurface=MenuetOS_AllocHWSurface;
+ dev->CheckHWBlit=NULL;
+ dev->FillHWRect=NULL;
+ dev->SetHWColorKey=NULL;
+ dev->SetHWAlpha=NULL;
+ dev->LockHWSurface=MenuetOS_LockHWSurface;
+ dev->UnlockHWSurface=MenuetOS_UnlockHWSurface;
+ dev->FlipHWSurface=MenuetOS_FlipHWSurface;
+ dev->FreeHWSurface=MenuetOS_FreeHWSurface;
+ dev->SetCaption=MenuetOS_SetCaption;
+ dev->SetIcon=NULL;
+ dev->IconifyWindow=NULL;
+ dev->GrabInput=NULL;
+ dev->GetWMInfo=NULL;
+ dev->InitOSKeymap=MenuetOS_InitOSKeymap;
+ dev->PumpEvents=MenuetOS_PumpEvents;
+ dev->free=MenuetOS_DeleteDevice;
+	dev->CreateWMCursor = KolibriOS_CreateWMCursor;
+	dev->FreeWMCursor = KolibriOS_FreeWMCursor;
+	dev->ShowWMCursor = KolibriOS_ShowWMCursor;
+	dev->CheckMouseMode = KolibriOS_CheckMouseMode;
+ return dev;
+}
+
+VideoBootStrap mosvideo_bootstrab={
+ "menuetos","MenuetOS Device Driver",
+ MenuetOS_Available,MenuetOS_CreateDevice,
+};

contrib/sdk/sources/SDL-1.2.2_newlib/src/video/menuetos/SDL_menuetvideo.h

@@ -0,0 +1,20 @@
+#ifndef _SDL_menuetvideo_h
+#define _SDL_menuetvideo_h
+
+#include "SDL_mouse.h"
+#include "SDL_sysvideo.h"
+
+#define _THIS	SDL_VideoDevice *this
+
+struct SDL_PrivateVideoData {
+ unsigned char * __video_buffer;
+ char 	       * __title;
+ int		 win_size_x,win_size_y;
+ int		 vx_ofs,vy_ofs;
+ unsigned char** __lines;
+};
+
+void MenuetOS_InitOSKeymap(_THIS);
+void MenuetOS_PumpEvents(_THIS);
+
+#endif