ibool MGLAPI XWIN8_initDriver(void *data,MGLDC *dc,int driverId,int modeId,ulong hwnd,
int virtualX,int virtualY,int numBuffers,ibool stereo,int refreshRate)
/****************************************************************************
*
* Function: WDCI8_initDriver
* Parameters: dc - Device context.
* Returns: True if the device was correctly initialised.
*
* Description: Initialises the device driver, and starts the specified
* graphics mode. This is also where we fill in all of the
* vectors in the device context to initialise our device
* context properly.
*
****************************************************************************/
{
Screen *scr;
Window wnd;
char *buf;
XSetWindowAttributes xswa;
dc->mi = XWIN8_modes[modeId - grSVGA_640x480x256];
dc->deviceType = MGL_WINDOWED_DEVICE;
g_state.d.hardwareCursor = false;
dc->v = &g_state;
dc->wm.xwindc.dpy = globalDisplay;
dc->wm.xwindc.scr = scr = DefaultScreenOfDisplay(globalDisplay);
dc->wm.xwindc.gc = DefaultGCOfScreen(scr);
xswa.background_pixel = BlackPixel(globalDisplay,XScreenNumberOfScreen(scr));
xswa.backing_store = Always;
dc->wm.xwindc.wnd = wnd = XCreateWindow(globalDisplay, RootWindowOfScreen(scr), 0,0, dc->mi.xRes+1, dc->mi.yRes+1,
0, CopyFromParent, CopyFromParent, CopyFromParent,
CWBackPixel | CWBackingStore, &xswa
);
buf = MGL_malloc((dc->mi.xRes+1) * (dc->mi.yRes+1));
dc->wm.xwindc.img = XCreateImage(globalDisplay, DefaultVisualOfScreen(scr),
8, ZPixmap, 0, NULL, dc->mi.xRes+1, dc->mi.yRes+1, 8, 0);
dc->wm.xwindc.img->data = buf;
XInitImage(dc->wm.xwindc.img);
// Sets up the private colormap
dc->wm.xwindc.hpal = xswa.colormap = XCreateColormap(globalDisplay, wnd, DefaultVisualOfScreen(scr), AllocAll);
XChangeWindowAttributes(globalDisplay, wnd, CWColormap, &xswa);
XMapRaised(globalDisplay, wnd);
XClearWindow(globalDisplay, wnd);
XStoreName(globalDisplay, wnd, "MGL [Unix/X11 8 bit Display]");
XWIN_initInternal(dc);
dc->r.realizePalette = XWIN8_realizePalette;
dc->r.getDefaultPalette = XWIN8_getDefaultPalette;
dc->r.putImage = XWIN8_putImage;
return true;
}
// Return XFontStruct for given font name NAME
XFontStruct *FontTable::operator[](const string& name)
{
int i = hash(name.chars());
while (table[i].font != 0 && name != table[i].name)
{
assert (i < MAX_FONTS); // Too many fonts
i = (i >= MAX_FONTS) ? 0 : i + 1;
}
if (table[i].font == 0 && name != table[i].name)
{
// Insert new font
table[i].name = name;
table[i].font = XLoadQueryFont(_display, name.chars());
if (table[i].font == 0)
{
std::cerr << "Warning: Could not load font \"" << name << "\"";
// Try default font
GC default_gc =
DefaultGCOfScreen(DefaultScreenOfDisplay(_display));
XGCValues gc_values;
if (XGetGCValues(_display, default_gc, GCFont, &gc_values))
{
const Font& font_id = gc_values.font;
XFontStruct *font = XQueryFont(_display, font_id);
if (font != 0)
{
std::cerr << ", using default font instead\n";
table[i].font = font;
}
}
}
if (table[i].font == 0)
{
// Try "fixed" font
XFontStruct *font = XLoadQueryFont(_display, "fixed");
if (font != 0)
{
std::cerr << ", using font \"fixed\" instead\n";
table[i].font = font;
}
}
if (table[i].font == 0)
std::cerr << "\n";
}
return table[i].font;
}
static PyObject *
tkwin_CopyArea(TkWinObject * self, PyObject * args)
{
PyObject *destobj, *gcobj;
Drawable dest;
GC gc;
int src_x, src_y, dest_x, dest_y;
unsigned int width, height;
if (!PyArg_ParseTuple(args, "OOiiiiii", &destobj, &gcobj, &src_x,
&src_y, &width, &height, &dest_x, &dest_y))
return NULL;
if (TkWin_Check(destobj))
{
if (Tk_IsMapped(self->tkwin))
dest = Tk_WindowId(((TkWinObject*) destobj)->tkwin);
else
{
Py_INCREF(Py_None);
return Py_None;
}
}
else if (PaxPixmap_Check(destobj))
{
dest = PaxPixmap_AsPixmap(destobj);
}
else
{
PyErr_SetString(PyExc_RuntimeError, "bad arguments");
return NULL;
}
if (gcobj == Py_None)
gc = DefaultGCOfScreen(Tk_Screen(self->tkwin));
else
{
gc = PaxGC_AsGC(gcobj);
if (PyErr_Occurred())
return NULL;
}
XCopyArea(Tk_Display(self->tkwin), Tk_WindowId(self->tkwin),
dest, gc, src_x, src_y, width, height, dest_x, dest_y);
Py_INCREF(Py_None);
return Py_None;
}
LispObj *
Lisp_XDefaultGCOfScreen(LispBuiltin *builtin)
/*
x-default-gc-of-screen screen
*/
{
LispObj *screen;
screen = ARGUMENT(0);
if (!CHECKO(screen, x11Screen_t))
LispDestroy("%s: cannot convert %s to Screen*",
STRFUN(builtin), STROBJ(screen));
return (OPAQUE(DefaultGCOfScreen((Screen*)(screen->data.opaque.data)),
x11GC_t));
}
static PyObject *
pixmap_CopyPlane(PaxPixmapObject *self, PyObject *args)
{
PyObject *destobj, *gcobj;
Tk_Window w = NULL;
Drawable dest;
GC gc;
int src_x, src_y, dest_x, dest_y;
unsigned int width, height;
unsigned long plane;
if (!PyArg_ParseTuple(args, "OOiiiiiii", &destobj, &gcobj, &src_x,
&src_y, &width, &height, &dest_x, &dest_y, &plane))
return NULL;
if (TkWin_Check(destobj))
{
w = TkWin_AsTkWindow(destobj);
dest = Tk_WindowId(w);
}
else if (PaxPixmap_Check(destobj))
{
dest = PaxPixmap_AsPixmap(destobj);
}
else
{
PyErr_SetString(PyExc_RuntimeError, "bad arguments");
return NULL;
}
if (gcobj == Py_None && w)
gc = DefaultGCOfScreen(Tk_Screen(w));
else
{
gc = PaxGC_AsGC(gcobj);
if (PyErr_Occurred())
return NULL;
}
XCopyPlane(self->display, self->pixmap, dest, gc, src_x, src_y,
width, height, dest_x, dest_y, plane);
Py_INCREF(Py_None);
return Py_None;
}
void S9xInitDisplay (int argc, char **argv)
{
GUI.display = XOpenDisplay(NULL);
if (GUI.display == NULL)
FatalError("Failed to connect to X server.");
GUI.screen = DefaultScreenOfDisplay(GUI.display);
GUI.screen_num = XScreenNumberOfScreen(GUI.screen);
GUI.visual = DefaultVisualOfScreen(GUI.screen);
XVisualInfo plate, *matches;
int count;
plate.visualid = XVisualIDFromVisual(GUI.visual);
matches = XGetVisualInfo(GUI.display, VisualIDMask, &plate, &count);
if (!count)
FatalError("Your X Window System server is unwell!");
GUI.depth = matches[0].depth;
if ((GUI.depth != 15 && GUI.depth != 16 && GUI.depth != 24) || (matches[0].c_class != TrueColor))
FatalError("Requiers 15, 16, 24 or 32-bit color depth supporting TrueColor.");
GUI.red_shift = ffs(matches[0].red_mask) - 1;
GUI.green_shift = ffs(matches[0].green_mask) - 1;
GUI.blue_shift = ffs(matches[0].blue_mask) - 1;
GUI.red_size = matches[0].red_mask >> GUI.red_shift;
GUI.green_size = matches[0].green_mask >> GUI.green_shift;
GUI.blue_size = matches[0].blue_mask >> GUI.blue_shift;
if (GUI.depth == 16 && GUI.green_size == 63)
GUI.green_shift++;
XFree(matches);
switch (GUI.depth)
{
default:
case 32:
case 24:
S9xSetRenderPixelFormat(RGB555);
GUI.pixel_format = 555;
break;
case 16:
if (GUI.red_size != GUI.green_size || GUI.blue_size != GUI.green_size)
{
// 565 format
if (GUI.green_shift > GUI.blue_shift && GUI.green_shift > GUI.red_shift)
S9xSetRenderPixelFormat(GBR565);
else
if (GUI.red_shift > GUI.blue_shift)
S9xSetRenderPixelFormat(RGB565);
else
S9xSetRenderPixelFormat(BGR565);
GUI.pixel_format = 565;
break;
}
// FALL ...
case 15:
if (GUI.green_shift > GUI.blue_shift && GUI.green_shift > GUI.red_shift)
S9xSetRenderPixelFormat(GBR555);
else
if (GUI.red_shift > GUI.blue_shift)
S9xSetRenderPixelFormat(RGB555);
else
S9xSetRenderPixelFormat(BGR555);
GUI.pixel_format = 555;
break;
}
S9xBlitFilterInit();
S9xBlit2xSaIFilterInit();
S9xBlitHQ2xFilterInit();
XSetWindowAttributes attrib;
memset(&attrib, 0, sizeof(attrib));
attrib.background_pixel = BlackPixelOfScreen(GUI.screen);
attrib.colormap = XCreateColormap(GUI.display, RootWindowOfScreen(GUI.screen), GUI.visual, AllocNone);
GUI.window = XCreateWindow(GUI.display, RootWindowOfScreen(GUI.screen),
(WidthOfScreen(GUI.screen) - SNES_WIDTH * 2) / 2, (HeightOfScreen(GUI.screen) - SNES_HEIGHT_EXTENDED * 2) / 2,
SNES_WIDTH * 2, SNES_HEIGHT_EXTENDED * 2, 0, GUI.depth, InputOutput, GUI.visual, CWBackPixel | CWColormap, &attrib);
static XColor bg, fg;
static char data[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
Pixmap bitmap;
bitmap = XCreateBitmapFromData(GUI.display, GUI.window, data, 8, 8);
GUI.point_cursor = XCreatePixmapCursor(GUI.display, bitmap, bitmap, &fg, &bg, 0, 0);
XDefineCursor(GUI.display, GUI.window, GUI.point_cursor);
GUI.cross_hair_cursor = XCreateFontCursor(GUI.display, XC_crosshair);
GUI.gc = DefaultGCOfScreen(GUI.screen);
XSizeHints Hints;
XWMHints WMHints;
memset((void *) &Hints, 0, sizeof(XSizeHints));
memset((void *) &WMHints, 0, sizeof(XWMHints));
Hints.flags = PSize | PMinSize | PMaxSize;
Hints.min_width = Hints.max_width = Hints.base_width = SNES_WIDTH * 2;
Hints.min_height = Hints.max_height = Hints.base_height = SNES_HEIGHT_EXTENDED * 2;
WMHints.input = True;
WMHints.flags = InputHint;
XSetWMHints(GUI.display, GUI.window, &WMHints);
XSetWMNormalHints(GUI.display, GUI.window, &Hints);
XSelectInput(GUI.display, GUI.window, FocusChangeMask | ExposureMask | KeyPressMask | KeyReleaseMask | StructureNotifyMask | ButtonPressMask | ButtonReleaseMask);
XMapRaised(GUI.display, GUI.window);
XClearWindow(GUI.display, GUI.window);
SetupImage();
switch (GUI.depth)
{
default:
case 32:
GUI.bytes_per_pixel = 4;
break;
case 24:
if (GUI.image->bits_per_pixel == 24)
GUI.bytes_per_pixel = 3;
else
GUI.bytes_per_pixel = 4;
break;
case 15:
case 16:
GUI.bytes_per_pixel = 2;
break;
}
}
$NetBSD$
--- EMULib/LibUnix.c.orig 2012-12-20 12:25:35.000000000 +0000
+++ EMULib/LibUnix.c
@@ -12,6 +12,8 @@
/*************************************************************/
#include "EMULib.h"
+#include <unistd.h>
+#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
@@ -142,7 +144,7 @@ int ShowVideo(void)
else
#endif
XPutImage(Dsp,Wnd,DefaultGCOfScreen(Scr),VideoImg->XImg,VideoX,VideoY,(XSize-VideoW)>>1,(YSize-VideoH)>>1,VideoW,VideoH);
- return;
+ return 0;
}
/* Scale video buffer into OutImg */
@@ -159,6 +161,7 @@ int ShowVideo(void)
else
#endif
XPutImage(Dsp,Wnd,DefaultGCOfScreen(Scr),OutImg.XImg,0,0,0,0,XSize,YSize);
+ return 0;
}
/** GetJoystick() ********************************************/
ibool MGLAPI XWINDC_initDriver(void *data,MGLDC *dc,int driverId,int modeId,ulong hwnd,
int virtualX,int virtualY,int numBuffers,ibool stereo,int refreshRate)
/****************************************************************************
*
* Function: XWINDC_initDriver
* Parameters: dc - Device context.
* Returns: True if the device was correctly initialised.
*
* Description: Initialises the device driver, and starts the specified
* graphics mode. This is also where we fill in all of the
* vectors in the device context to initialise our device
* context properly.
*
****************************************************************************/
{
Screen *scr;
XSetWindowAttributes xswa;
Display *dpy = dc->wm.xwindc.dpy;
XVisualInfo *visinfo, vis;
int nvis, npfv;
Window root;
int x,y;
unsigned int w,h, bw, d;
XPixmapFormatValues *pfv;
_MGL_initInternal();
dc->deviceType = MGL_WINDOWED_DEVICE;
dc->xInch = dc->yInch = 0;
g_state.d.hardwareCursor = false;
dc->v = &g_state;
dc->v->m.refCount++;
dc->wm.xwindc.scr = scr = DefaultScreenOfDisplay(dpy);
dc->wm.xwindc.gc = DefaultGCOfScreen(scr);
xswa.background_pixel = BlackPixel(dpy,XScreenNumberOfScreen(scr));
xswa.backing_store = Always;
dc->wm.xwindc.wnd = hwnd;
XGetGeometry(dpy, hwnd, &root, &x, &y, &w, &h, &bw, &d);
dc->mi.xRes = w;
dc->mi.yRes = h;
dc->mi.maxPage = 0;
dc->mi.bytesPerLine = 0;
dc->mi.pageSize = 0;
dc->surface = NULL;
dc->mi.bitsPerPixel = dc->wm.xwindc.depth = d;
vis.visualid = XVisualIDFromVisual(DefaultVisual(dpy, XScreenNumberOfScreen(scr)));
visinfo = XGetVisualInfo(dpy, VisualIDMask, &vis, &nvis);
pfv = XListPixmapFormats(dpy, &npfv);
switch (d) {
case 8: dc->mi.maxColor = 0xFFUL; break;
case 15: dc->mi.maxColor = 0x7FFFUL; dc->pf= _MGL_pixelFormats[pfRGB555]; break;
case 16: dc->mi.maxColor = 0xFFFFUL; dc->pf= _MGL_pixelFormats[visinfo->green_mask==0x7e0 ? pfRGB565 : pfRGB555]; break;
case 24: {
int i;
dc->mi.maxColor = 0xFFFFFFUL;
for(i=0; i<npfv; i++)
if(pfv[i].depth == 24) break;
if(pfv[i].bits_per_pixel==32){
dc->mi.bitsPerPixel = 32;
dc->pf= _MGL_pixelFormats[pfARGB32];
}else
dc->pf= _MGL_pixelFormats[pfRGB24];
break;
}
case 32: dc->mi.maxColor = 0xFFFFFFFFUL; dc->pf= _MGL_pixelFormats[pfARGB32]; break;
}
XFree(visinfo);
if(d == 8){
// Set up the private colormap if necesary
dc->wm.xwindc.hpal = xswa.colormap = XCreateColormap(dpy, hwnd, DefaultVisualOfScreen(scr), AllocAll);
XChangeWindowAttributes(dpy, hwnd, CWColormap, &xswa);
}
XMapRaised(dpy, hwnd);
XClearWindow(dpy, hwnd);
XWIN_initInternal(dc);
dc->v->w.destroy = destroyDC;
dc->r.realizePalette = XWIN_realizePalette;
dc->r.getDefaultPalette = XWIN_getDefaultPalette;
dc->r.putImage = XWIN_putImage;
return true;
}
GC XDefaultGCOfScreen(Screen *s)
{
return (DefaultGCOfScreen(s));
}
