#include <stdlib.h>
#include <stdio.h>
#include <menuet/os.h>
#include <kos32sys.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;
//#define KEEP_OBSOLETE_STYLE3
#ifdef KEEP_OBSOLETE_STYLE3
static int IsStyle4Available=0;
#endif
void kol_define_window(unsigned short x1,unsigned short y1,unsigned short xsize,unsigned short ysize,
unsigned long body_color,unsigned long grab_color,unsigned long frame_color)
{
unsigned long 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 MenuetOS_SDL_RepaintWnd(void)
{
begin_draw();
kol_define_window(1,1,vm_suf->hidden->win_size_x+9,vm_suf->hidden->win_size_y+get_skin_height()+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)
draw_bitmap(vm_suf->hidden->__video_buffer, 0,0,
vm_suf->hidden->win_size_x,vm_suf->hidden->win_size_y);
end_draw();
}
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)
{
draw_bitmap(this->hidden->__video_buffer, 0,0,
vm_suf->hidden->win_size_x,vm_suf->hidden->win_size_y);
}
}
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_skin_height+4;
unsigned newwidth = width+9;
sys_change_window(-1, -1, newwidth, newheight);
}
else
{
set_wanted_events_mask(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)
{
draw_bitmap(surface->pixels, 0,0,surface->w,surface->h);
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));
return res;
}
int KolibriOS_ShowWMCursor(_THIS,WMcursor*cursor)
{
if (!cursor)
{
if (!has_null_cursor)
{
unsigned* u
= malloc(32*32*4);
if (!u) return 1;
__asm__("int $0x40":"=a"(null_cursor):
"a"(37),"b"(4),"c"(u),"d"(2));
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)
{
dev
->hidden
= (struct SDL_PrivateVideoData
*)malloc((sizeof *dev
->hidden
));
}
if((dev==NULL) || (dev->hidden==NULL))
{
SDL_OutOfMemory();
if(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,
};