Newer
Older
#if (defined(__MACH__) && defined(__APPLE__))
#include <Carbon/Carbon.h>
#endif
#include <stdarg.h>
#include <stdio.h> /* NULL */
#ifdef __unix__
#include <dlfcn.h>
#include "gen_defs.h"
#include "genwrap.h"
#include "dirwrap.h"
#include "xpbeep.h"
#if (defined CIOLIB_IMPORTS)
#undef CIOLIB_IMPORTS
#endif
#if (defined CIOLIB_EXPORTS)
#undef CIOLIB_EXPORTS
#endif
#include "ciolib.h"
#include "vidmodes.h"
#include "allfonts.h"
#include "SDL.h"
/********************************************************/
/* Low Level Stuff */
/* This should all be called from the same thread! */
/********************************************************/
SDL_Surface *win=NULL;
SDL_mutex *sdl_keylock;
SDL_mutex *sdl_ufunc_lock;
SDL_sem *sdl_key_pending;
SDL_sem *sdl_init_complete;
SDL_sem *sdl_ufunc_ret;
int sdl_ufunc_retval;
SDL_Surface *sdl_font=NULL;
SDL_Surface *sdl_cursor=NULL;
static int lastcursor_x=0;
static int lastcursor_y=0;
static int sdl_current_font=-99;
static int lastfg=-1;
static int lastbg=-1;
static unsigned int sdl_pending_mousekeys=0;
static SDL_Thread *blinker_thread;
static SDL_Thread *mouse_thread;
struct video_stats vstat;
/* 256 bytes so I can cheat */
unsigned char sdl_keybuf[256]; /* Keyboard buffer */
unsigned char sdl_key=0; /* Index into keybuf for next key in buffer */
unsigned char sdl_keynext=0; /* Index into keybuf for next free position */
struct sdl_keyvals {
int keysym
,key
,shift
,ctrl
,alt;
};
struct sdl_drawchar {
int x
,y
,ch
,fg
,bg
,blink;
};
enum {
SDL_USEREVENT_UPDATERECT
,SDL_USEREVENT_SETTITLE
,SDL_USEREVENT_SETNAME
,SDL_USEREVENT_SETVIDMODE
,SDL_USEREVENT_SHOWMOUSE
,SDL_USEREVENT_HIDEMOUSE
,SDL_USEREVENT_COPY
,SDL_USEREVENT_PASTE
,SDL_USEREVENT_LOADFONT
};
const struct sdl_keyvals sdl_keyval[] =
{
{SDLK_BACKSPACE, 0x08, 0x08, 0x7f, 0x0e00},
{SDLK_TAB, 0x09, 0x0f00, 0x9400, 0xa500},
{SDLK_RETURN, 0x0d, 0x0d, 0x0a, 0xa600},
{SDLK_ESCAPE, 0x1b, 0x1b, 0x1b, 0x0100},
{SDLK_SPACE, 0x20, 0x20, 0x0300, 0x20},
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
{SDLK_0, '0', ')', 0, 0x8100},
{SDLK_1, '1', '!', 0, 0x7800},
{SDLK_2, '2', '@', 0x0300, 0x7900},
{SDLK_3, '3', '#', 0, 0x7a00},
{SDLK_4, '4', '$', 0, 0x7b00},
{SDLK_5, '5', '%', 0, 0x7c00},
{SDLK_6, '6', '^', 0x1e, 0x7d00},
{SDLK_7, '7', '&', 0, 0x7e00},
{SDLK_8, '8', '*', 0, 0x7f00},
{SDLK_9, '9', '(', 0, 0x8000},
{SDLK_a, 'a', 'A', 0x01, 0x1e00},
{SDLK_b, 'b', 'B', 0x02, 0x3000},
{SDLK_c, 'c', 'C', 0x03, 0x2e00},
{SDLK_d, 'd', 'D', 0x04, 0x2000},
{SDLK_e, 'e', 'E', 0x05, 0x1200},
{SDLK_f, 'f', 'F', 0x06, 0x2100},
{SDLK_g, 'g', 'G', 0x07, 0x2200},
{SDLK_h, 'h', 'H', 0x08, 0x2300},
{SDLK_i, 'i', 'I', 0x09, 0x1700},
{SDLK_j, 'j', 'J', 0x0a, 0x2400},
{SDLK_k, 'k', 'K', 0x0b, 0x2500},
{SDLK_l, 'l', 'L', 0x0c, 0x2600},
{SDLK_m, 'm', 'M', 0x0d, 0x3200},
{SDLK_n, 'n', 'N', 0x0e, 0x3100},
{SDLK_o, 'o', 'O', 0x0f, 0x1800},
{SDLK_p, 'p', 'P', 0x10, 0x1900},
{SDLK_q, 'q', 'Q', 0x11, 0x1000},
{SDLK_r, 'r', 'R', 0x12, 0x1300},
{SDLK_s, 's', 'S', 0x13, 0x1f00},
{SDLK_t, 't', 'T', 0x14, 0x1400},
{SDLK_u, 'u', 'U', 0x15, 0x1600},
{SDLK_v, 'v', 'V', 0x16, 0x2f00},
{SDLK_w, 'w', 'W', 0x17, 0x1100},
{SDLK_x, 'x', 'X', 0x18, 0x2d00},
{SDLK_y, 'y', 'Y', 0x19, 0x1500},
{SDLK_z, 'z', 'Z', 0x1a, 0x2c00},
{SDLK_PAGEUP, 0x4900, 0x4900, 0x8400, 0x9900},
{SDLK_PAGEDOWN, 0x5100, 0x5100, 0x7600, 0xa100},
{SDLK_END, 0x4f00, 0x4f00, 0x7500, 0x9f00},
{SDLK_HOME, 0x4700, 0x4700, 0x7700, 0x9700},
{SDLK_LEFT, 0x4b00, 0x4b00, 0x7300, 0x9b00},
{SDLK_UP, 0x4800, 0x4800, 0x8d00, 0x9800},
{SDLK_RIGHT, 0x4d00, 0x4d00, 0x7400, 0x9d00},
{SDLK_DOWN, 0x5000, 0x5000, 0x9100, 0xa000},
{SDLK_INSERT, 0x5200, 0x5200, 0x9200, 0xa200},
{SDLK_DELETE, 0x5300, 0x5300, 0x9300, 0xa300},
{SDLK_KP0, 0x5200, 0x5200, 0x9200, 0},
{SDLK_KP1, 0x4f00, 0x4f00, 0x7500, 0},
{SDLK_KP2, 0x5000, 0x5000, 0x9100, 0},
{SDLK_KP3, 0x5100, 0x5100, 0x7600, 0},
{SDLK_KP4, 0x4b00, 0x4b00, 0x7300, 0},
{SDLK_KP5, 0x4c00, 0x4c00, 0x8f00, 0},
{SDLK_KP6, 0x4d00, 0x4d00, 0x7400, 0},
{SDLK_KP7, 0x4700, 0x4700, 0x7700, 0},
{SDLK_KP8, 0x4800, 0x4800, 0x8d00, 0},
{SDLK_KP9, 0x4900, 0x4900, 0x8400, 0},
{SDLK_KP_MULTIPLY, '*', '*', 0x9600, 0x3700},
{SDLK_KP_PLUS, '+', '+', 0x9000, 0x4e00},
{SDLK_KP_MINUS, '-', '-', 0x8e00, 0x4a00},
{SDLK_KP_PERIOD, 0x7f, 0x7f, 0x5300, 0x9300},
{SDLK_KP_DIVIDE, '/', '/', 0x9500, 0xa400},
{SDLK_KP_ENTER, 0x0d, 0x0d, 0x0a, 0xa600},
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
{SDLK_F1, 0x3b00, 0x5400, 0x5e00, 0x6800},
{SDLK_F2, 0x3c00, 0x5500, 0x5f00, 0x6900},
{SDLK_F3, 0x3d00, 0x5600, 0x6000, 0x6a00},
{SDLK_F4, 0x3e00, 0x5700, 0x6100, 0x6b00},
{SDLK_F5, 0x3f00, 0x5800, 0x6200, 0x6c00},
{SDLK_F6, 0x4000, 0x5900, 0x6300, 0x6d00},
{SDLK_F7, 0x4100, 0x5a00, 0x6400, 0x6e00},
{SDLK_F8, 0x4200, 0x5b00, 0x6500, 0x6f00},
{SDLK_F9, 0x4300, 0x5c00, 0x6600, 0x7000},
{SDLK_F10, 0x4400, 0x5d00, 0x6700, 0x7100},
{SDLK_F11, 0x8500, 0x8700, 0x8900, 0x8b00},
{SDLK_F12, 0x8600, 0x8800, 0x8a00, 0x8c00},
{SDLK_BACKSLASH, '\\', '|', 0x1c, 0x2b00},
{SDLK_SLASH, '/', '?', 0, 0x3500},
{SDLK_MINUS, '-', '_', 0x1f, 0x8200},
{SDLK_EQUALS, '=', '+', 0, 0x8300},
{SDLK_LEFTBRACKET, '[', '{', 0x1b, 0x1a00},
{SDLK_RIGHTBRACKET, ']', '}', 0x1d, 0x1b00},
{SDLK_SEMICOLON, ';', ':', 0, 0x2700},
{SDLK_BACKSLASH, '\'', '"', 0, 0x2800},
{SDLK_COMMA, ',', '<', 0, 0x3300},
{SDLK_PERIOD, '.', '>', 0, 0x3400},
{SDLK_BACKQUOTE, '`', '~', 0, 0x2900},
{0, 0, 0, 0, 0} /** END **/
};
const int sdl_tabs[10]={9,17,25,33,41,49,57,65,73,80};
/* *nix copy/paste stuff */
SDL_sem *sdl_pastebuf_set;
SDL_sem *sdl_pastebuf_copied;
SDL_mutex *sdl_copybuf_mutex;
char *sdl_copybuf=NULL;
char *sdl_pastebuf=NULL;
#if !defined(NO_X) && defined(__unix__)
#include "SDL_syswm.h"
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/keysym.h>
#include <X11/Xatom.h>
#define CONSOLE_CLIPBOARD XA_PRIMARY
int sdl_x11available=0;
/* X functions */
struct x11 {
int (*XFree) (void *data);
Window (*XGetSelectionOwner) (Display*, Atom);
int (*XConvertSelection) (Display*, Atom, Atom, Atom, Window, Time);
int (*XGetWindowProperty) (Display*, Window, Atom, long, long, Bool, Atom, Atom*, int*, unsigned long *, unsigned long *, unsigned char **);
int (*XChangeProperty) (Display*, Window, Atom, Atom, int, int, _Xconst unsigned char*, int);
Status (*XSendEvent) (Display*, Window, Bool, long, XEvent*);
int (*XSetSelectionOwner) (Display*, Atom, Window, Time);
};
struct x11 sdl_x11;
#endif
/* Called from all threads */
void sdl_user_func(int func, ...)
{
unsigned int *i;
va_list argptr;
void **args;
ev.type=SDL_USEREVENT;
ev.user.data1=NULL;
ev.user.data2=NULL;
ev.user.code=func;
va_start(argptr, func);
switch(func) {
case SDL_USEREVENT_UPDATERECT:
/* Only send event if the last event wasn't already handled */
case SDL_USEREVENT_SETNAME:
if((ev.user.data1=strdup(va_arg(argptr, char *)))==NULL) {
va_end(argptr);
return;
}
case SDL_USEREVENT_SETICON:
ev.user.data1=va_arg(argptr, void *);
if((ev.user.data2=(unsigned long *)malloc(sizeof(unsigned long)))==NULL) {
va_end(argptr);
return;
}
*(unsigned long *)ev.user.data2=va_arg(argptr, unsigned long);
while(sdl.PeepEvents(&ev, 1, SDL_ADDEVENT, 0xffffffff)!=1);
break;
case SDL_USEREVENT_SETTITLE:
if((ev.user.data1=strdup(va_arg(argptr, char *)))==NULL) {
va_end(argptr);
return;
}
break;
case SDL_USEREVENT_SETVIDMODE:
if((ev.user.data1=(void *)malloc(sizeof(int)))==NULL) {
va_end(argptr);
return;
}
*((int *)ev.user.data1)=va_arg(argptr, int);
if((ev.user.data2=(void *)malloc(sizeof(int)))==NULL) {
free(ev.user.data1);
va_end(argptr);
return;
}
*((int *)ev.user.data2)=va_arg(argptr, int);
case SDL_USEREVENT_COPY:
case SDL_USEREVENT_PASTE:
case SDL_USEREVENT_SHOWMOUSE:
case SDL_USEREVENT_HIDEMOUSE:
}
va_end(argptr);
}
/* Called from main thread only */
int sdl_user_func_ret(int func, ...)
{
unsigned int *i;
va_list argptr;
void **args;
SDL_Event ev;
int passed=FALSE;
char *p;
sdl.mutexP(sdl_ufunc_lock);
ev.type=SDL_USEREVENT;
ev.user.data1=NULL;
ev.user.data2=NULL;
ev.user.code=func;
va_start(argptr, func);
switch(func) {
case SDL_USEREVENT_LOADFONT:
p=va_arg(argptr, char *);
if(p!=NULL) {
if((ev.user.data1=strdup(p))==NULL) {
va_end(argptr);
}
}
while(sdl.PeepEvents(&ev, 1, SDL_ADDEVENT, 0xffffffff)!=1);
passed=TRUE;
break;
case SDL_USEREVENT_QUIT:
while(sdl.PeepEvents(&ev, 1, SDL_ADDEVENT, 0xffffffff)!=1);
passed=TRUE;
break;
}
if(passed)
sdl.SemWait(sdl_ufunc_ret);
else
sdl_ufunc_retval=-1;
sdl.mutexV(sdl_ufunc_lock);
va_end(argptr);
return(sdl_ufunc_retval);
}
void exit_sdl_con(void)
{
sdl_user_func_ret(SDL_USEREVENT_QUIT);
}
#if (defined(__MACH__) && defined(__APPLE__))
int sdl_using_quartz=0;
#endif
#if !defined(NO_X) && defined(__unix__)
int sdl_using_x11()
{
char driver[16];
return(FALSE);
if(!strcmp(driver,"x11"))
return(TRUE);
if(!strcmp(driver,"dga"))
return(TRUE);
return(FALSE);
}
#endif
void sdl_copytext(const char *text, size_t buflen)
{
#if (defined(__MACH__) && defined(__APPLE__))
if(sdl_using_quartz) {
FREE_AND_NULL(sdl_copybuf);
sdl_copybuf=(char *)malloc(buflen+1);
if(sdl_copybuf!=NULL) {
strcpy(sdl_copybuf, text);
sdl_user_func(SDL_USEREVENT_COPY,0,0,0,0);
return;
}
#endif
#if !defined(NO_X) && defined(__unix__)
if(sdl_x11available && sdl_using_x11()) {
FREE_AND_NULL(sdl_copybuf);
sdl_copybuf=(char *)malloc(buflen+1);
if(sdl_copybuf!=NULL) {
strcpy(sdl_copybuf, text);
sdl_user_func(SDL_USEREVENT_COPY,0,0,0,0);
}
FREE_AND_NULL(sdl_copybuf);
sdl_copybuf=(char *)malloc(buflen+1);
if(sdl_copybuf!=NULL)
strcpy(sdl_copybuf, text);
return;
}
char *sdl_getcliptext(void)
{
char *ret=NULL;
#if (defined(__MACH__) && defined(__APPLE__))
if(sdl_using_quartz) {
sdl_user_func(SDL_USEREVENT_PASTE,0,0,0,0);
if(sdl_pastebuf!=NULL) {
ret=(char *)malloc(strlen(sdl_pastebuf)+1);
if(ret!=NULL)
strcpy(ret,sdl_pastebuf);
#if !defined(NO_X) && defined(__unix__)
if(sdl_x11available && sdl_using_x11()) {
sdl_user_func(SDL_USEREVENT_PASTE,0,0,0,0);
if(sdl_pastebuf!=NULL) {
ret=(char *)malloc(strlen(sdl_pastebuf)+1);
if(ret!=NULL)
strcpy(ret,sdl_pastebuf);
ret=(char *)malloc(strlen(sdl_pastebuf)+1);
if(ret!=NULL)
strcpy(ret,sdl_copybuf);
return(ret);
}
/* Blinker Thread */
while(1) {
SLEEP(500);
if(vstat.blink)
vstat.blink=FALSE;
else
vstat.blink=TRUE;
sdl_user_func(SDL_USEREVENT_UPDATERECT,0,0,0,0);
/* Called from main thread only (Passes Event) */
int sdl_init_mode(int mode)
struct video_params vmode;
int idx; /* Index into vmode */
int i;
int oldcols=vstat.cols;
if(load_vmode(&vstat, mode))
return(-1);
/* Deal with 40 col doubling */
if(oldcols != vstat.cols) {
if(oldcols == 40)
vstat.scaling /= 2;
if(vstat.cols == 40)
vstat.scaling *= 2;
}
if(vstat.scaling < 1)
vstat.scaling = 1;
sdl_user_func(SDL_USEREVENT_SETVIDMODE,vstat.charwidth*vstat.cols*vstat.scaling, vstat.charheight*vstat.rows*vstat.scaling);
/* Initialize video memory with black background, white foreground */
for (i = 0; i < vstat.cols*vstat.rows; ++i)
vstat.vmem[i] = 0x0700;
vstat.currattr=7;
vstat.mode=mode;
sdl_user_func(SDL_USEREVENT_UPDATERECT,0,0,0,0);
return(0);
}
/* Called from main thread only (Passes Event) */
int sdl_draw_char(unsigned short vch, int xpos, int ypos, int update)
vstat.vmem[ypos*vstat.cols+xpos]=vch;
if(update) {
#if 0 /* Currently, an update always updates the whole screen... so don't hold the mutex */
sdl_user_func(SDL_USEREVENT_UPDATERECT,xpos*vstat.charwidth*vstat.scaling,ypos*vstat.charheight*vstat.scaling,vstat.charwidth*vstat.scaling,vstat.charheight*vstat.scaling);
#else
sdl_user_func(SDL_USEREVENT_UPDATERECT,0,0,0,0);
#endif
return(0);
/* Called from main thread only (Passes Event) */
#if !defined(NO_X) && defined(__unix__)
void *dl;
#endif
vstat.vmem=NULL;
vstat.scaling=1;
sdl_updated=1;
if(mode==CIOLIB_MODE_SDL_FULLSCREEN)
fullscreen=1;
sdl_user_func(SDL_USEREVENT_INIT);
if(sdl_init_good) {
cio_api.mode=fullscreen?CIOLIB_MODE_SDL_FULLSCREEN:CIOLIB_MODE_SDL;
FreeConsole();
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
#endif
#if !defined(NO_X) && defined(__unix__)
#if defined(__APPLE__) && defined(__MACH__) && defined(__POWERPC__)
if((dl=dlopen("/usr/X11R6/lib/libX11.dylib",RTLD_LAZY|RTLD_GLOBAL))!=NULL) {
#else
if((dl=dlopen("libX11.so",RTLD_LAZY))!=NULL) {
#endif
sdl_x11available=TRUE;
if(sdl_x11available && (sdl_x11.XFree=dlsym(dl,"XFree"))==NULL) {
dlclose(dl);
sdl_x11available=FALSE;
}
if(sdl_x11available && (sdl_x11.XGetSelectionOwner=dlsym(dl,"XGetSelectionOwner"))==NULL) {
dlclose(dl);
sdl_x11available=FALSE;
}
if(sdl_x11available && (sdl_x11.XConvertSelection=dlsym(dl,"XConvertSelection"))==NULL) {
dlclose(dl);
sdl_x11available=FALSE;
}
if(sdl_x11available && (sdl_x11.XGetWindowProperty=dlsym(dl,"XGetWindowProperty"))==NULL) {
dlclose(dl);
sdl_x11available=FALSE;
}
if(sdl_x11available && (sdl_x11.XChangeProperty=dlsym(dl,"XChangeProperty"))==NULL) {
dlclose(dl);
sdl_x11available=FALSE;
}
if(sdl_x11available && (sdl_x11.XSendEvent=dlsym(dl,"XSendEvent"))==NULL) {
dlclose(dl);
sdl_x11available=FALSE;
}
if(sdl_x11available && (sdl_x11.XSetSelectionOwner=dlsym(dl,"XSetSelectionOwner"))==NULL) {
dlclose(dl);
sdl_x11available=FALSE;
}
}
if(sdl_x11available)
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
}
/********************************************************/
/* High Level Stuff */
/********************************************************/
/* Called from main thread only (Passes Event) */
int sdl_puttext(int sx, int sy, int ex, int ey, void *fill)
{
int x,y;
unsigned char *out;
WORD sch;
struct text_info ti;
gettextinfo(&ti);
if( sx < 1
|| sy < 1
|| ex < 1
|| ey < 1
|| sx > ti.screenwidth
|| sy > ti.screenheight
|| sx > ex
|| sy > ey
|| ex > ti.screenwidth
|| ey > ti.screenheight
|| fill==NULL)
return(0);
out=fill;
for(y=sy-1;y<ey;y++) {
for(x=sx-1;x<ex;x++) {
sch=*(out++);
sch |= (*(out++))<<8;
vstat.vmem[y*vstat.cols+x]=sch;
sdl_user_func(SDL_USEREVENT_UPDATERECT,0,0,0,0);
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
return(1);
}
/* Called from main thread only */
int sdl_gettext(int sx, int sy, int ex, int ey, void *fill)
{
int x,y;
unsigned char *out;
WORD sch;
struct text_info ti;
gettextinfo(&ti);
if( sx < 1
|| sy < 1
|| ex < 1
|| ey < 1
|| sx > ti.screenwidth
|| sy > ti.screenheight
|| sx > ex
|| sy > ey
|| ex > ti.screenwidth
|| ey > ti.screenheight
|| fill==NULL)
return(0);
out=fill;
for(y=sy-1;y<ey;y++) {
for(x=sx-1;x<ex;x++) {
sch=vstat.vmem[y*vstat.cols+x];
*(out++)=sch & 0xff;
*(out++)=sch >> 8;
}
}
return(1);
}
/* Called from main thread only */
void sdl_textattr(int attr)
{
vstat.currattr=attr;
}
/* Called from main thread only */
int sdl_kbhit(void)
{
int ret;
ret=(sdl_key!=sdl_keynext);
return(ret);
}
/* Called from main thread only */
void sdl_delay(long msec)
{
}
/* Called from main thread only */
int sdl_wherey(void)
{
return(vstat.curs_row+1);
}
/* Called from main thread only */
int sdl_wherex(void)
{
return(vstat.curs_col+1);
/* Called from BOTH THREADS */
int sdl_beep(void)
{
/* ToDo BEEP! */
BEEP(440,100);
return(0);
}
/* Put the character _c on the screen at the current cursor position.
* The special characters return, linefeed, bell, and backspace are handled
* properly, as is line wrap and scrolling. The cursor position is updated.
*/
/* Called from main thread only */
int sdl_putch(int ch)
{
struct text_info ti;
WORD sch;
int i;
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
sch=(vstat.currattr<<8)|ch;
switch(ch) {
case '\r':
gettextinfo(&ti);
vstat.curs_col=ti.winleft-1;
break;
case '\n':
gettextinfo(&ti);
if(wherey()==ti.winbottom-ti.wintop+1)
wscroll();
else
vstat.curs_row++;
break;
case '\b':
if(vstat.curs_col>0)
vstat.curs_col--;
sdl_draw_char((vstat.currattr<<8)|' ',vstat.curs_col,vstat.curs_row,TRUE);
break;
case 7: /* Bell */
sdl_beep();
break;
case '\t':
for(i=0;i<10;i++) {
if(sdl_tabs[i]>wherex()) {
while(wherex()<sdl_tabs[i]) {
putch(' ');
}
break;
}
}
if(i==10) {
putch('\r');
putch('\n');
}
break;
default:
gettextinfo(&ti);
if(wherey()==ti.winbottom-ti.wintop+1
&& wherex()==ti.winright-ti.winleft+1) {
sdl_draw_char(sch,vstat.curs_col,vstat.curs_row,TRUE);
wscroll();
gotoxy(ti.winleft,wherey());
}
else {
if(wherex()==ti.winright-ti.winleft+1) {
sdl_draw_char(sch,vstat.curs_col,vstat.curs_row,TRUE);
gotoxy(ti.winleft,ti.cury+1);
}
else {
sdl_draw_char(sch,vstat.curs_col,vstat.curs_row,TRUE);
gotoxy(ti.curx+1,ti.cury);
}
}
break;
}
return(ch);
}
/* Called from main thread only */
void sdl_gotoxy(int x, int y)
{
if((x-1 != vstat.curs_col) || (y-1 !=vstat.curs_row)) {
vstat.curs_row=y-1;
vstat.curs_col=x-1;
sdl_user_func(SDL_USEREVENT_UPDATERECT,0,0,0,0);
}
}
/* Called from main thread only */
void sdl_gettextinfo(struct text_info *info)
{
info->currmode=vstat.mode;
info->screenheight=vstat.rows;
info->screenwidth=vstat.cols;
info->curx=sdl_wherex();
info->cury=sdl_wherey();
info->attribute=vstat.currattr;
}
/* Called from main thread only */
void sdl_setcursortype(int type)
{
switch(type) {
case _NOCURSOR:
vstat.curs_start=0xff;
vstat.curs_end=0;
break;
case _SOLIDCURSOR:
vstat.curs_start=0;
vstat.curs_end=vstat.charheight-1;
break;
default:
vstat.curs_start = vstat.default_curs_start;
}
/* Called from main thread only */
int sdl_getch(void)
{
int ch;
ch=sdl_keybuf[sdl_key++];
if(sdl_pending_mousekeys) {
sdl_keybuf[sdl_keynext++]=CIO_KEY_MOUSE & 0xff;
sdl.SemPost(sdl_key_pending);
sdl_keybuf[sdl_keynext++]=CIO_KEY_MOUSE >> 8;
sdl.SemPost(sdl_key_pending);
sdl_pending_mousekeys--;
}
return(ch);
}
/* Called from main thread only */
int sdl_getche(void)
{
int ch;
while(1) {
ch=sdl_getch();
if(ch) {
putch(ch);
return(ch);
}
sdl_getch();
}
}
/* Called from main thread only */
void sdl_textmode(int mode)
{
sdl_init_mode(mode);
}
/* Called from main thread only (Passes Event) */
int sdl_setname(const char *name)
{
sdl_user_func(SDL_USEREVENT_SETNAME,name);
return(0);
}
/* Called from main thread only (Passes Event) */
int sdl_seticon(const void *icon, unsigned long size)
{
sdl_user_func(SDL_USEREVENT_SETICON,icon,size);
return(0);
}
/* Called from main thread only (Passes Event) */
int sdl_settitle(const char *title)
{
sdl_user_func(SDL_USEREVENT_SETTITLE,title);
return(0);
}
int sdl_showmouse(void)
{
sdl_user_func(SDL_USEREVENT_SHOWMOUSE);
return(1);
}
int sdl_hidemouse(void)
{
sdl_user_func(SDL_USEREVENT_HIDEMOUSE);
int sdl_loadfont(char *filename)
{
int retval;
retval=sdl_user_func_ret(SDL_USEREVENT_LOADFONT,filename);
return(retval);
}
int sdl_setfont(int font, int force)
{
int changemode=0;
int newmode=-1;
if(font < 0 || font>(sizeof(conio_fontdata)/sizeof(struct conio_font_data_struct)-2))
return(-1);
if(conio_fontdata[font].eight_by_sixteen!=NULL)
newmode=C80;
else if(conio_fontdata[font].eight_by_fourteen!=NULL)
newmode=C80X28;
else if(conio_fontdata[font].eight_by_eight!=NULL)
newmode=C80X50;
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
switch(vstat.charheight) {
case 8:
if(conio_fontdata[font].eight_by_eight==NULL) {
if(force)
return(-1);
else
changemode=1;
}
break;
case 14:
if(conio_fontdata[font].eight_by_fourteen==NULL) {
if(force)
return(-1);
else
changemode=1;
}
break;
case 16:
if(conio_fontdata[font].eight_by_sixteen==NULL) {
if(force)
return(-1);
else
changemode=1;
}
break;
}
if(changemode && newmode==-1)
return(-1);
sdl_current_font=font;
if(changemode)
sdl_init_mode(3);
return(sdl_user_func_ret(SDL_USEREVENT_LOADFONT,NULL));
}
int sdl_getfont(void)
{
return(sdl_current_font);
}
/* Called from event thread only */
void sdl_add_key(unsigned int keyval)
{
if(keyval==0xa600) {
fullscreen=!fullscreen;
cio_api.mode=fullscreen?CIOLIB_MODE_SDL_FULLSCREEN:CIOLIB_MODE_SDL;

deuce
committed
sdl_user_func(SDL_USEREVENT_SETVIDMODE,vstat.charwidth*vstat.cols, vstat.charheight*vstat.rows);
return;
}
if(keyval <= 0xffff) {
if(sdl_keynext+1==sdl_key) {
sdl_beep();
return;
}
if((sdl_keynext+2==sdl_key) && keyval > 0xff) {
if(keyval==CIO_KEY_MOUSE)
sdl_pending_mousekeys++;
else
sdl_beep();
return;
}
sdl_keybuf[sdl_keynext++]=keyval & 0xff;
if(keyval>0xff) {
sdl_keybuf[sdl_keynext++]=keyval >> 8;
}
}
/* Called from event thread only */
int sdl_load_font(char *filename)
{
static char current_filename[MAX_PATH];
unsigned char *font;
unsigned int fontsize;
int fw;
int fh;
int ch;
int x;
int y;
int charrow;
int charcol;
SDL_Rect r;
FILE *fontfile;
if(sdl_current_font==-99 || sdl_current_font>(sizeof(conio_fontdata)/sizeof(struct conio_font_data_struct)-2)) {
for(x=0; conio_fontdata[x].desc != NULL; x++) {
if(!strcmp(conio_fontdata[x].desc, "Codepage 437 English")) {
sdl_current_font=x;
break;
}
}
if(conio_fontdata[x].desc==NULL)
sdl_current_font=0;
if(sdl_current_font==-1)
filename=current_filename;
else if(conio_fontdata[sdl_current_font].desc==NULL)
return(-1);
fh=vstat.charheight;
fw=vstat.charwidth/8+(vstat.charwidth%8?1:0);
fontsize=fw*fh*256*sizeof(unsigned char);
if((font=(unsigned char *)malloc(fontsize))==NULL) {
return(-1);
if(filename != NULL) {
if(flength(filename)!=fontsize) {
sdl.mutexV(sdl_vstatlock);
free(font);
return(-1);
}
if((fontfile=fopen(filename,"rb"))==NULL) {
sdl.mutexV(sdl_vstatlock);
free(font);
return(-1);
}
if(fread(font, 1, fontsize, fontfile)!=fontsize) {
free(font);
fclose(fontfile);
return(-1);
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
}
fclose(fontfile);
sdl_current_font=-1;
if(filename != current_filename)
SAFECOPY(current_filename,filename);
}
else {
switch(vstat.charwidth) {
case 8:
switch(vstat.charheight) {
case 8:
if(conio_fontdata[sdl_current_font].eight_by_eight==NULL) {
sdl.mutexV(sdl_vstatlock);
free(font);
return(-1);
}
memcpy(font, conio_fontdata[sdl_current_font].eight_by_eight, fontsize);
break;
case 14:
if(conio_fontdata[sdl_current_font].eight_by_fourteen==NULL) {
sdl.mutexV(sdl_vstatlock);
free(font);
return(-1);
}
memcpy(font, conio_fontdata[sdl_current_font].eight_by_fourteen, fontsize);
break;
case 16:
if(conio_fontdata[sdl_current_font].eight_by_sixteen==NULL) {
sdl.mutexV(sdl_vstatlock);
free(font);
return(-1);
}
memcpy(font, conio_fontdata[sdl_current_font].eight_by_sixteen, fontsize);
break;
default:
sdl.mutexV(sdl_vstatlock);
free(font);
return(-1);
}
break;
default:
sdl.mutexV(sdl_vstatlock);
free(font);
return(-1);
}
}
if(sdl_font!=NULL)
sdl_font=sdl.CreateRGBSurface(SDL_SWSURFACE, vstat.charwidth*vstat.scaling, vstat.charheight*256*vstat.scaling, 8, 0, 0, 0, 0);
if(sdl_font == NULL) {
free(font);
return(-1);
}
else {
for(ch=0; ch<256; ch++) {
for(charrow=0; charrow<vstat.charheight; charrow++) {
for(charcol=0; charcol<vstat.charwidth; charcol++) {
if(font[(ch*vstat.charheight+charrow)*fw+(charcol/8)] & (0x80 >> (charcol%8))) {
r.x=charcol*vstat.scaling;
r.y=(ch*vstat.charheight+charrow)*vstat.scaling;
r.w=vstat.scaling;
r.h=vstat.scaling;
}
}
}
}
free(font);
lastfg=-1;
lastbg=-1;
return(0);
}
/* Called from events thread only */
int sdl_setup_colours(SDL_Surface *surf, int xor)
{
int i;
int ret=0;
SDL_Color co[16];
for(i=0; i<16; i++) {
co[i^xor].r=dac_default[vstat.palette[i]].red;
co[i^xor].g=dac_default[vstat.palette[i]].green;
co[i^xor].b=dac_default[vstat.palette[i]].blue;
sdl.mutexV(sdl_vstatlock);
sdl.SetColors(surf, co, 0, 16);
return(ret);
}
/* Called from events thread only */
void sdl_draw_cursor(void)
{
SDL_Rect src;
SDL_Rect dst;
int x;
int y;
if(vstat.blink && vstat.curs_start<=vstat.curs_end) {
dst.x=0;
dst.y=0;
src.x=vstat.curs_col*vstat.charwidth*vstat.scaling;
src.y=(vstat.curs_row*vstat.charheight+vstat.curs_start)*vstat.scaling;
src.w=dst.w=vstat.charwidth*vstat.scaling;
src.h=dst.h=(vstat.curs_end-vstat.curs_start+1)*vstat.scaling;
sdl_setup_colours(sdl_cursor, 0);
sdl_setup_colours(sdl_cursor, vstat.currattr&0x07);
lastcursor_x=vstat.curs_col;
lastcursor_y=vstat.curs_row;
}
}
/* Called from event thread */
/* ONLY Called from sdl_full_screen_redraw() which holds the mutex... */
int sdl_draw_one_char(unsigned short sch, unsigned int x, unsigned int y, struct video_stats *vs)
{
SDL_Color co;
SDL_Rect src;
SDL_Rect dst;
unsigned char ch;
ch=(sch >> 8) & 0x0f;
if(lastfg!=ch) {
co.r=dac_default[vs->palette[ch]].red;
co.g=dac_default[vs->palette[ch]].green;
co.b=dac_default[vs->palette[ch]].blue;
lastfg=ch;
}
ch=(sch >> 12) & 0x07;
if(lastbg!=ch) {
co.r=dac_default[vs->palette[ch]].red;
co.g=dac_default[vs->palette[ch]].green;
co.b=dac_default[vs->palette[ch]].blue;
lastbg=ch;
}
dst.x=x*vs->charwidth*vs->scaling;
dst.y=y*vs->charheight*vs->scaling;
dst.w=vs->charwidth*vs->scaling;
dst.h=vs->charheight*vs->scaling;
src.x=0;
src.w=vs->charwidth*vs->scaling;
src.h=vs->charheight*vs->scaling;
src.y=vs->charheight*vs->scaling;
ch=sch & 0xff;
if((sch >>15) && !(vs->blink))
src.y *= ' ';
else
src.y *= ch;
if(sdl_font != NULL)
}
/* Called from event thread only, */
{
static int last_blink;
int x;
int y;
unsigned int pos;
unsigned short *p;
static unsigned short *vmemcopies[2]={ NULL, NULL };
static SDL_Rect *rects=NULL;
static int this_new=0;
static unsigned short *last_vmem=NULL;
int rcount=0;
static struct video_stats vs;
int redraw_cursor=0;
int lastlineupdated=0;
int lastcharupdated=0;
if(vs.cols!=vstat.cols || vs.rows != vstat.rows || vmemcopies[0]==NULL || vmemcopies[1]==NULL || rects==NULL) {
FREE_AND_NULL(vmemcopies[0]);
if((vmemcopies[0]=(unsigned short *)malloc(vstat.cols*vstat.rows*sizeof(unsigned short)))==NULL) {
sdl.mutexV(sdl_vstatlock);
return(-1);
}
FREE_AND_NULL(vmemcopies[1]);
if((vmemcopies[1]=(unsigned short *)malloc(vstat.cols*vstat.rows*sizeof(unsigned short)))==NULL) {
sdl.mutexV(sdl_vstatlock);
return(-1);
}
FREE_AND_NULL(rects);
if((rects=(SDL_Rect *)malloc(sizeof(SDL_Rect)*vstat.cols*vstat.rows))==NULL) {
sdl.mutexV(sdl_vstatlock);
return(-1);
}
}
this_new = (this_new+1) % 2;
newvmem=vmemcopies[this_new];
memcpy(&vs, &vstat, sizeof(vs));
memcpy(newvmem, vs.vmem, vs.cols*vs.rows*sizeof(unsigned short));
sdl_updated=1;
/* Redraw all chars */
pos=0;
if(last_vmem==NULL)
force=1;
if(last_blink != vs.blink
|| lastcursor_x!=vs.curs_col
|| lastcursor_y!=vs.curs_row)
redraw_cursor=1;
for(y=0;y<vs.rows;y++) {
for(x=0;x<vs.cols;x++) {
|| (last_vmem[pos] != newvmem[pos])
|| (last_blink != vs.blink && newvmem[pos]>>15)
|| (redraw_cursor && ((lastcursor_x==x && lastcursor_y==y) || (vs.curs_col==x && vs.curs_row==y)))
sdl_draw_one_char(newvmem[pos],x,y,&vs);
if(lastcharupdated) {
rects[rcount-1].w+=vs.charwidth*vs.scaling;
lastcharupdated++;
}
else {
rects[rcount].x=x*vs.charwidth*vs.scaling;
rects[rcount].y=y*vs.charheight*vs.scaling;
rects[rcount].w=vs.charwidth*vs.scaling;
rects[rcount++].h=vs.charheight*vs.scaling;
lastcharupdated++;
}
if(!redraw_cursor && x==vs.curs_col && y==vs.curs_row)
redraw_cursor=1;
else
lastcharupdated=0;
pos++;
}
if(lastcharupdated==vs.cols) {
if(lastlineupdated) {
rcount--;
rects[rcount-1].h+=vs.charheight*vs.scaling;
}
else
lastlineupdated=1;
}
else
lastlineupdated=0;
lastcharupdated=0;
last_blink=vs.blink;
last_vmem=newvmem;
}
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
unsigned int cp437_convert(unsigned int unicode)
{
switch(unicode) {
case 0x00c7:
return(0x80);
case 0x00fc:
return(0x81);
case 0x00e9:
return(0x82);
case 0x00e2:
return(0x83);
case 0x00e4:
return(0x84);
case 0x00e0:
return(0x85);
case 0x00e5:
return(0x86);
case 0x00e7:
return(0x87);
case 0x00ea:
return(0x88);
case 0x00eb:
return(0x89);
case 0x00e8:
return(0x8a);
case 0x00ef:
return(0x8b);
case 0x00ee:
return(0x8c);
case 0x00ec:
return(0x8d);
case 0x00c4:
return(0x8e);
case 0x00c5:
return(0x8f);
case 0x00c9:
return(0x90);
case 0x00e6:
return(0x91);
case 0x00c6:
return(0x92);
case 0x00f4:
return(0x93);
case 0x00f6:
return(0x94);
case 0x00f2:
return(0x95);
case 0x00fb:
return(0x96);
case 0x00f9:
return(0x97);
case 0x00ff:
return(0x98);
case 0x00d6:
return(0x99);
case 0x00dc:
return(0x9a);
case 0x00a2:
return(0x9b);
case 0x00a3:
return(0x9c);
case 0x00a5:
return(0x9d);
case 0x20a7:
return(0x9e);
case 0x0192:
return(0x9f);
case 0x00e1:
return(0xa0);
case 0x00ed:
return(0xa1);
case 0x00f3:
return(0xa2);
case 0x00fa:
return(0xa3);
case 0x00f1:
return(0xa4);
case 0x00d1:
return(0xa5);
case 0x00aa:
return(0xa6);
case 0x00ba:
return(0xa7);
case 0x00bf:
return(0xa8);
case 0x2310:
return(0xa9);
case 0x00ac:
return(0xaa);
case 0x00bd:
return(0xab);
case 0x00bc:
return(0xac);
case 0x00a1:
return(0xad);
case 0x00ab:
return(0xae);
case 0x00bb:
return(0xaf);
case 0x2591:
return(0xb0);
case 0x2592:
return(0xb1);
case 0x2593:
return(0xb2);
case 0x2502:
return(0xb3);
case 0x2524:
return(0xb4);
case 0x2561:
return(0xb5);
case 0x2562:
return(0xb6);
case 0x2556:
return(0xb7);
case 0x2555:
return(0xb8);
case 0x2563:
return(0xb9);
case 0x2551:
return(0xba);
case 0x2557:
return(0xbb);
case 0x255d:
return(0xbc);
case 0x255c:
return(0xbd);
case 0x255b:
return(0xbe);
case 0x2510:
return(0xbf);
case 0x2514:
return(0xc0);
case 0x2534:
return(0xc1);
case 0x252c:
return(0xc2);
case 0x251c:
return(0xc3);
case 0x2500:
return(0xc4);
case 0x253c:
return(0xc5);
case 0x255e:
return(0xc6);
case 0x255f:
return(0xc7);
case 0x255a:
return(0xc8);
case 0x2554:
return(0xc9);
case 0x2569:
return(0xca);
case 0x2566:
return(0xcb);
case 0x2560:
return(0xcc);
case 0x2550:
return(0xcd);
case 0x256c:
return(0xce);
case 0x2567:
return(0xcf);
case 0x2568:
return(0xd0);
case 0x2564:
return(0xd1);
case 0x2565:
return(0xd2);
case 0x2559:
return(0xd3);
case 0x2558:
return(0xd4);
case 0x2552:
return(0xd5);
case 0x2553:
return(0xd6);
case 0x256b:
return(0xd7);
case 0x256a:
return(0xd8);
case 0x2518:
return(0xd9);
case 0x250c:
return(0xda);
case 0x2588:
return(0xdb);
case 0x2584:
return(0xdc);
case 0x258c:
return(0xdd);
case 0x2590:
return(0xde);
case 0x2580:
return(0xdf);
case 0x03b1:
return(0xe0);
case 0x00df:
return(0xe1);
case 0x0393:
return(0xe2);
case 0x03c0:
return(0xe3);
case 0x03a3:
return(0xe4);
case 0x03c3:
return(0xe5);
case 0x00b5:
return(0xe6);
case 0x03c4:
return(0xe7);
case 0x03a6:
return(0xe8);
case 0x0398:
return(0xe9);
case 0x03a9:
return(0xea);
case 0x03b4:
return(0xeb);
case 0x221e:
return(0xec);
case 0x03c6:
return(0xed);
case 0x03b5:
return(0xee);
case 0x2229:
return(0xef);
case 0x2261:
return(0xf0);
case 0x00b1:
return(0xf1);
case 0x2265:
return(0xf2);
case 0x2264:
return(0xf3);
case 0x2320:
return(0xf4);
case 0x2321:
return(0xf5);
case 0x00f7:
return(0xf6);
case 0x2248:
return(0xf7);
case 0x00b0:
return(0xf8);
case 0x2219:
return(0xf9);
case 0x00b7:
return(0xfa);
case 0x221a:
return(0xfb);
case 0x207f:
return(0xfc);
case 0x00b2:
return(0xfd);
case 0x25a0:
return(0xfe);
case 0x00a0:
return(0xff);
}
return(0x01ffff);
}
/* Called from event thread only */
unsigned int sdl_get_char_code(unsigned int keysym, unsigned int mod, unsigned int unicode)
keysym=SDLK_BACKSPACE;
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
for(i=0;sdl_keyval[i].keysym;i++) {
if(sdl_keyval[i].keysym==keysym) {
if(mod & KMOD_CTRL)
expect=sdl_keyval[i].ctrl;
else if(mod & KMOD_SHIFT)
expect=sdl_keyval[i].shift;
else
expect=sdl_keyval[i].key;
/* "Extended" syms are always right */
if(!unicode)
return(expect);
if(sdl_keyval[i].key > 255)
return(expect);
/*
* If we don't know that this key can
* return the unicode translation, then
* we're not right and this is prolly
* an AltGr sequence.
*/
if(mod & (KMOD_META|KMOD_ALT)) {
if(unicode==expect)
return(sdl_keyval[i].alt);
return(0x0001ffff);
return(cp437_convert(unicode));
}
/* Mouse event/keyboard thread */
{
while(1) {
if(mouse_wait())
sdl_add_key(CIO_KEY_MOUSE);
}
}
/* Event Thread */
int sdl_video_event_thread(void *data)
{
SDL_Event ev;
while(1) {
if(sdl.WaitEvent(&ev)==1) {
switch (ev.type) {
case SDL_ACTIVEEVENT: /* Focus change */
break;
case SDL_KEYDOWN: /* Keypress */
sdl_add_key(sdl_get_char_code(ev.key.keysym.sym, ev.key.keysym.mod, ev.key.keysym.unicode));
break;
sdl.mutexP(sdl_vstatlock);
ciomouse_gotevent(CIOLIB_MOUSE_MOVE,ev.motion.x/(vstat.charwidth*vstat.scaling)+1,ev.motion.y/(vstat.charheight*vstat.scaling)+1);
sdl.mutexV(sdl_vstatlock);
case SDL_MOUSEBUTTONDOWN:
if(!ciolib_mouse_initialized)
break;
switch(ev.button.button) {
case SDL_BUTTON_LEFT:
sdl.mutexP(sdl_vstatlock);
ciomouse_gotevent(CIOLIB_BUTTON_PRESS(1),ev.button.x/(vstat.charwidth*vstat.scaling)+1,ev.button.y/(vstat.charheight*vstat.scaling)+1);
sdl.mutexV(sdl_vstatlock);
break;
case SDL_BUTTON_MIDDLE:
sdl.mutexP(sdl_vstatlock);
ciomouse_gotevent(CIOLIB_BUTTON_PRESS(2),ev.button.x/(vstat.charwidth*vstat.scaling)+1,ev.button.y/(vstat.charheight*vstat.scaling)+1);
sdl.mutexV(sdl_vstatlock);
break;
case SDL_BUTTON_RIGHT:
sdl.mutexP(sdl_vstatlock);
ciomouse_gotevent(CIOLIB_BUTTON_PRESS(3),ev.button.x/(vstat.charwidth*vstat.scaling)+1,ev.button.y/(vstat.charheight*vstat.scaling)+1);
sdl.mutexV(sdl_vstatlock);
break;
break;
case SDL_MOUSEBUTTONUP:
if(!ciolib_mouse_initialized)
break;
switch(ev.button.button) {
case SDL_BUTTON_LEFT:
sdl.mutexP(sdl_vstatlock);
ciomouse_gotevent(CIOLIB_BUTTON_RELEASE(1),ev.button.x/(vstat.charwidth*vstat.scaling)+1,ev.button.y/(vstat.charheight*vstat.scaling)+1);
sdl.mutexV(sdl_vstatlock);
break;
case SDL_BUTTON_MIDDLE:
sdl.mutexP(sdl_vstatlock);
ciomouse_gotevent(CIOLIB_BUTTON_RELEASE(2),ev.button.x/(vstat.charwidth*vstat.scaling)+1,ev.button.y/(vstat.charheight*vstat.scaling)+1);
sdl.mutexV(sdl_vstatlock);
break;
case SDL_BUTTON_RIGHT:
sdl.mutexP(sdl_vstatlock);
ciomouse_gotevent(CIOLIB_BUTTON_RELEASE(3),ev.button.x/(vstat.charwidth*vstat.scaling)+1,ev.button.y/(vstat.charheight*vstat.scaling)+1);
sdl.mutexV(sdl_vstatlock);
break;
}
break;
case SDL_QUIT:
return(sdl_exitcode);
case SDL_VIDEORESIZE:
if(ev.resize.w > 0 && ev.resize.h > 0) {
sdl.mutexP(sdl_vstatlock);
vstat.scaling=(int)(ev.resize.w/(vstat.charwidth*vstat.cols));
if(vstat.scaling < 1)
vstat.scaling=1;

deuce
committed
vstat.charwidth*vstat.cols*vstat.scaling
,vstat.charheight*vstat.rows*vstat.scaling

deuce
committed
);

deuce
committed
else

deuce
committed
vstat.charwidth*vstat.cols*vstat.scaling
,vstat.charheight*vstat.rows*vstat.scaling
,8

deuce
committed
);
if(!strcmp(driver,"Quartz"))
sdl_using_quartz=TRUE;
}
sdl_cursor=sdl.CreateRGBSurface(SDL_SWSURFACE, vstat.charwidth*vstat.scaling, vstat.charheight*vstat.scaling, 8, 0, 0, 0, 0);
/* Update font. */
sdl_load_font(NULL);
sdl_setup_colours(win,0);
}
else if(sdl_init_good) {
ev.type=SDL_QUIT;
sdl_exitcode=1;
sdl.mutexV(sdl_vstatlock);
}
break;
case SDL_VIDEOEXPOSE:
break;
case SDL_USEREVENT: {
/* Tell SDL to do various stuff... */
switch(ev.user.code) {
case SDL_USEREVENT_QUIT:
sdl_ufunc_retval=0;
sdl.SemPost(sdl_ufunc_ret);
case SDL_USEREVENT_LOADFONT:
sdl_ufunc_retval=sdl_load_font((char *)ev.user.data1);
FREE_AND_NULL(ev.user.data1);
sdl.SemPost(sdl_ufunc_ret);
break;
case SDL_USEREVENT_SETNAME:
sdl.WM_SetCaption((char *)ev.user.data1,(char *)ev.user.data1);
free(ev.user.data1);
break;
case SDL_USEREVENT_SETICON:
if(sdl_icon != NULL)
sdl.FreeSurface(sdl_icon);
sdl_icon=sdl.CreateRGBSurfaceFrom(ev.user.data1
, *(unsigned long *)ev.user.data2
, *(unsigned long *)ev.user.data2
, 32
, *(unsigned long *)ev.user.data2*4
, *(DWORD *)"\377\0\0\0"
, *(DWORD *)"\0\377\0\0"
, *(DWORD *)"\0\0\377\0"
, *(DWORD *)"\0\0\0\377"
);
sdl.WM_SetIcon(sdl_icon,NULL);
free(ev.user.data2);
break;
case SDL_USEREVENT_SETTITLE:
sdl.WM_SetCaption((char *)ev.user.data1,NULL);
free(ev.user.data1);
break;
case SDL_USEREVENT_SETVIDMODE:
sdl.mutexP(sdl_vstatlock);
if(fullscreen)
win=sdl.SetVideoMode(
vstat.charwidth*vstat.cols*vstat.scaling
,vstat.charheight*vstat.rows*vstat.scaling
,8
);
else
win=sdl.SetVideoMode(
vstat.charwidth*vstat.cols*vstat.scaling
,vstat.charheight*vstat.rows*vstat.scaling
,8
);
if(win!=NULL) {
#if (defined(__MACH__) && defined(__APPLE__))
char driver[16];
#endif
vstat.scaling=(int)(win->w/(vstat.charwidth*vstat.cols));
if(vstat.scaling < 1)
vstat.scaling=1;
sdl_setup_colours(win,0);
if(sdl_cursor!=NULL)
sdl.FreeSurface(sdl_cursor);
sdl_cursor=sdl.CreateRGBSurface(SDL_SWSURFACE, vstat.charwidth*vstat.scaling, vstat.charheight*vstat.scaling, 8, 0, 0, 0, 0);
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
else if(sdl_init_good) {
ev.type=SDL_QUIT;
sdl_exitcode=1;
sdl.PeepEvents(&ev, 1, SDL_ADDEVENT, 0xffffffff);
}
free(ev.user.data1);
free(ev.user.data2);
sdl.mutexV(sdl_vstatlock);
break;
case SDL_USEREVENT_HIDEMOUSE:
sdl.ShowCursor(SDL_DISABLE);
break;
case SDL_USEREVENT_SHOWMOUSE:
sdl.ShowCursor(SDL_ENABLE);
break;
case SDL_USEREVENT_INIT:
if(!sdl_init_good) {
if(sdl.WasInit(SDL_INIT_VIDEO)==SDL_INIT_VIDEO) {
if(win != NULL) {
sdl.EnableUNICODE(1);
sdl.EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
blinker_thread=sdl.CreateThread(sdl_blinker_thread, NULL);
mouse_thread=sdl.CreateThread(sdl_mouse_thread, NULL);
case SDL_USEREVENT_COPY:
#if (defined(__MACH__) && defined(__APPLE__))
if(sdl_using_quartz) {
ScrapRef scrap;
sdl.mutexP(sdl_copybuf_mutex);
if(sdl_copybuf!=NULL) {
if(!ClearCurrentScrap()) { /* purge the current contents of the scrap. */
if(!GetCurrentScrap(&scrap)) { /* obtain a reference to the current scrap. */
PutScrapFlavor(scrap, kScrapFlavorTypeText, kScrapFlavorMaskTranslated /* kScrapFlavorMaskNone */, strlen(sdl_copybuf), sdl_copybuf); /* write the data to the scrap */
}
}
}
FREE_AND_NULL(sdl_copybuf);
sdl.mutexV(sdl_copybuf_mutex);
break;
}
#endif
#if !defined(NO_X) && defined(__unix__)
if(sdl_x11available && sdl_using_x11()) {
SDL_SysWMinfo wmi;
SDL_VERSION(&(wmi.version));
sdl.GetWMInfo(&wmi);
sdl_x11.XSetSelectionOwner(wmi.info.x11.display, CONSOLE_CLIPBOARD, wmi.info.x11.window, CurrentTime);
break;
}
#endif
case SDL_USEREVENT_PASTE:
#if (defined(__MACH__) && defined(__APPLE__))
if(sdl_using_quartz) {
ScrapRef scrap;
UInt32 fl;
Size scraplen;
FREE_AND_NULL(sdl_pastebuf);
if(!GetCurrentScrap(&scrap)) { /* obtain a reference to the current scrap. */
if(!GetScrapFlavorFlags(scrap, kScrapFlavorTypeText, &fl) && (fl & kScrapFlavorMaskTranslated)) {
if(!GetScrapFlavorSize(scrap, kScrapFlavorTypeText, &scraplen)) {
sdl_pastebuf=(char *)malloc(scraplen+1);
if(sdl_pastebuf!=NULL) {
if(GetScrapFlavorData(scrap, kScrapFlavorTypeText, &scraplen, sdl_pastebuf)) {
FREE_AND_NULL(sdl_pastebuf);
}
sdl.SemPost(sdl_pastebuf_set);
sdl.SemWait(sdl_pastebuf_copied);
break;
#if !defined(NO_X) && defined(__unix__)
if(sdl_x11available && sdl_using_x11()) {
Window sowner=None;
SDL_SysWMinfo wmi;
SDL_VERSION(&(wmi.version));
sowner=sdl_x11.XGetSelectionOwner(wmi.info.x11.display, CONSOLE_CLIPBOARD);
if(sowner==wmi.info.x11.window) {
/* Get your own primary selection */
if(sdl_copybuf==NULL) {
FREE_AND_NULL(sdl_pastebuf);
}
else
sdl_pastebuf=(unsigned char *)malloc(strlen(sdl_copybuf)+1);
if(sdl_pastebuf!=NULL)
strcpy(sdl_pastebuf,sdl_copybuf);
/* Set paste buffer */
sdl.SemPost(sdl_pastebuf_set);
sdl.SemWait(sdl_pastebuf_copied);
FREE_AND_NULL(sdl_pastebuf);
}
else if(sowner!=None) {
sdl_x11.XConvertSelection(wmi.info.x11.display, CONSOLE_CLIPBOARD, XA_STRING, None, wmi.info.x11.window, CurrentTime);
FREE_AND_NULL(sdl_pastebuf);
sdl.SemPost(sdl_pastebuf_set);
sdl.SemWait(sdl_pastebuf_copied);
}
#else
break;
#endif
}
break;
}
case SDL_SYSWMEVENT: /* ToDo... This is where Copy/Paste needs doing */
#if !defined(NO_X) && defined(__unix__)
if(sdl_x11available && sdl_using_x11()) {
XEvent *e;
e=&ev.syswm.msg->event.xevent;
switch(e->type) {
case SelectionClear: {
XSelectionClearEvent *req;
req=&(e->xselectionclear);
sdl.mutexP(sdl_copybuf_mutex);
if(req->selection==CONSOLE_CLIPBOARD) {
FREE_AND_NULL(sdl_copybuf);
sdl.mutexV(sdl_copybuf_mutex);
break;
}
case SelectionNotify: {
int format=0;
unsigned long len, bytes_left, dummy;
Atom type;
XSelectionEvent *req;
SDL_SysWMinfo wmi;
SDL_VERSION(&(wmi.version));
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
sdl.GetWMInfo(&wmi);
req=&(e->xselection);
if(req->requestor!=wmi.info.x11.window)
break;
sdl_x11.XGetWindowProperty(wmi.info.x11.display, wmi.info.x11.window, req->property, 0, 0, 0, AnyPropertyType, &type, &format, &len, &bytes_left, (unsigned char **)(&sdl_pastebuf));
if(bytes_left > 0 && format==8)
sdl_x11.XGetWindowProperty(wmi.info.x11.display, wmi.info.x11.window, req->property,0,bytes_left,0,AnyPropertyType,&type,&format,&len,&dummy,(unsigned char **)&sdl_pastebuf);
else {
FREE_AND_NULL(sdl_pastebuf);
}
/* Set paste buffer */
sdl.SemPost(sdl_pastebuf_set);
sdl.SemWait(sdl_pastebuf_copied);
if(sdl_pastebuf!=NULL) {
sdl_x11.XFree(sdl_pastebuf);
sdl_pastebuf=NULL;
}
break;
}
case SelectionRequest: {
XSelectionRequestEvent *req;
XEvent respond;
req=&(e->xselectionrequest);
sdl.mutexP(sdl_copybuf_mutex);
if(sdl_copybuf==NULL) {
respond.xselection.property=None;
2026
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054
2055
2056
2057
}
else {
if(req->target==XA_STRING) {
sdl_x11.XChangeProperty(req->display, req->requestor, req->property, XA_STRING, 8, PropModeReplace, (unsigned char *)sdl_copybuf, strlen(sdl_copybuf));
respond.xselection.property=req->property;
}
else
respond.xselection.property=None;
}
sdl.mutexV(sdl_copybuf_mutex);
respond.xselection.type=SelectionNotify;
respond.xselection.display=req->display;
respond.xselection.requestor=req->requestor;
respond.xselection.selection=req->selection;
respond.xselection.target=req->target;
respond.xselection.time=req->time;
sdl_x11.XSendEvent(req->display,req->requestor,0,0,&respond);
break;
}
} /* switch */
} /* usingx11 */
#endif
/* Ignore this stuff */
case SDL_JOYAXISMOTION:
case SDL_JOYBALLMOTION:
case SDL_JOYHATMOTION:
case SDL_JOYBUTTONDOWN:
case SDL_JOYBUTTONUP:
default:
break;
}
}
}
}
}
int sdl_initciolib(int mode)
{
return(-1);
if(init_sdl_video()==-1)
return(-1);
sdl_key_pending=sdl.SDL_CreateSemaphore(0);
sdl_init_complete=sdl.SDL_CreateSemaphore(0);
sdl_ufunc_ret=sdl.SDL_CreateSemaphore(0);
sdl_updlock=sdl.SDL_CreateMutex();
sdl_keylock=sdl.SDL_CreateMutex();
sdl_vstatlock=sdl.SDL_CreateMutex();
sdl_ufunc_lock=sdl.SDL_CreateMutex();
#if !defined(NO_X) && defined(__unix__)
sdl_pastebuf_set=sdl.SDL_CreateSemaphore(0);
sdl_pastebuf_copied=sdl.SDL_CreateSemaphore(0);
sdl_copybuf_mutex=sdl.SDL_CreateMutex();
#endif
run_sdl_drawing_thread(sdl_video_event_thread, exit_sdl_con);
return(sdl_init(mode));
}