static int32_t init_kb(void)
{
if (!ppb_input_event_interface) {
ppb_input_event_interface =
(PPB_InputEvent *) NaCl_GetInterface(PPB_INPUT_EVENT_INTERFACE);
}
ppb_keyboard_event_interface =
(PPB_KeyboardInputEvent *) NaCl_GetInterface(
PPB_KEYBOARD_INPUT_EVENT_INTERFACE);
if (!ppb_input_event_interface) {
DEBUG_LOG("Could not acquire PPB_InputEvent interface.\n");
return 0;
}
if (!ppb_keyboard_event_interface) {
DEBUG_LOG("Could not acquire PPB_KeyboardInputEvent interface.\n");
return 0;
}
inputdevice_release_all_keys ();
reset_hotkeys ();
return 1;
}
static void graphics_subinit (void)
{
XSetWindowAttributes wattr;
XClassHint classhint;
XWMHints *hints;
unsigned long valuemask;
dgamode = screen_is_picasso ? currprefs.gfx_pfullscreen : currprefs.gfx_afullscreen;
dgamode = dgamode && dgaavail;
wattr.background_pixel = /*black.pixel*/0;
wattr.backing_store = Always;
wattr.backing_planes = bitdepth;
wattr.border_pixmap = None;
wattr.border_pixel = /*black.pixel*/0;
wattr.colormap = cmap;
valuemask = (CWEventMask | CWBackPixel | CWBorderPixel
| CWBackingStore | CWBackingPlanes | CWColormap);
if (dgamode) {
wattr.event_mask = DGA_EVENTMASK;
wattr.override_redirect = 1;
valuemask |= CWOverrideRedirect;
} else
wattr.event_mask = EVENTMASK;
XSync (display, 0);
delete_win = XInternAtom(display, "WM_DELETE_WINDOW", False);
mywin = XCreateWindow (display, rootwin, 0, 0, current_width, current_height,
0, bitdepth, InputOutput, vis, valuemask, &wattr);
XSetWMProtocols (display, mywin, &delete_win, 1);
XSync (display, 0);
XStoreName (display, mywin, PACKAGE_NAME);
XSetIconName (display, mywin, PACKAGE_NAME);
/* set class hint */
classhint.res_name = (char *)"UAE";
classhint.res_class = (char *)"UAEScreen";
XSetClassHint(display, mywin, &classhint);
hints = XAllocWMHints();
/* Set window group leader to self to become an application
* that can be hidden by e.g. WindowMaker.
* Would be more useful if we could find out what the
* (optional) GTK+ window ID is :-/ */
hints->window_group = mywin;
hints->flags = WindowGroupHint;
XSetWMHints(display, mywin, hints);
XMapRaised (display, mywin);
XSync (display, 0);
mygc = XCreateGC (display, mywin, 0, 0);
if (dgamode) {
#ifdef USE_DGA_EXTENSION
enter_dga_mode ();
/*setuid(getuid());*/
picasso_vidinfo.rowbytes = fb_width * picasso_vidinfo.pixbytes;
#endif
} else {
get_image (current_width, current_height, &ami_dinfo);
if (screen_is_picasso) {
get_image (current_width, current_height, &pic_dinfo);
picasso_vidinfo.rowbytes = pic_dinfo.ximg->bytes_per_line;
}
}
picasso_vidinfo.extra_mem = 1;
gfxvidinfo.flush_screen = x11_flush_screen;
gfxvidinfo.lockscr = x11_lock;
gfxvidinfo.unlockscr = x11_unlock;
if (need_dither) {
gfxvidinfo.maxblocklines = 0;
gfxvidinfo.rowbytes = gfxvidinfo.pixbytes * currprefs.gfx_width_win;
gfxvidinfo.linemem = malloc (gfxvidinfo.rowbytes);
gfxvidinfo.flush_line = x11_flush_line_dither;
} else if (! dgamode) {
gfxvidinfo.emergmem = 0;
gfxvidinfo.linemem = 0;
gfxvidinfo.bufmem = (uae_u8 *)ami_dinfo.image_mem;
gfxvidinfo.rowbytes = ami_dinfo.ximg->bytes_per_line;
if (currprefs.x11_use_low_bandwidth) {
write_log ("Doing low-bandwidth output.\n");
gfxvidinfo.maxblocklines = 0;
gfxvidinfo.rowbytes = ami_dinfo.ximg->bytes_per_line;
gfxvidinfo.linemem = malloc (gfxvidinfo.rowbytes);
if (shmavail && currprefs.x11_use_mitshm) {
switch (gfxvidinfo.pixbytes) {
case 4 : gfxvidinfo.flush_line = x11_flush_line_lbw_32bit_mitshm; break;
case 2 : gfxvidinfo.flush_line = x11_flush_line_lbw_16bit_mitshm; break;
default : gfxvidinfo.flush_line = x11_flush_line_lbw_8bit_mitshm; break;
}
} else {
switch (gfxvidinfo.pixbytes) {
case 4 : gfxvidinfo.flush_line = x11_flush_line_lbw_32bit; break;
case 2 : gfxvidinfo.flush_line = x11_flush_line_lbw_16bit; break;
default : gfxvidinfo.flush_line = x11_flush_line_lbw_8bit; break;
}
}
} else {
gfxvidinfo.maxblocklines = MAXBLOCKLINES_MAX;
if (shmavail && currprefs.x11_use_mitshm)
gfxvidinfo.flush_block = x11_flush_block_mitshm;
else
gfxvidinfo.flush_block = x11_flush_block;
}
}
if (visualInfo.VI_CLASS != TrueColor && ! screen_is_picasso) {
int i;
for (i = 0; i < 256; i++)
XStoreColor (display, cmap, parsed_xcolors + i);
}
#ifdef USE_DGA_EXTENSION
if (dgamode) {
dga_colormap_installed = 0;
XF86DGAInstallColormap (display, screen, cmap2);
XF86DGAInstallColormap (display, screen, cmap);
}
#endif
if (! dgamode) {
if (!currprefs.hide_cursor)
XDefineCursor (display, mywin, xhairCursor);
else
XDefineCursor (display, mywin, blankCursor);
cursorOn = 1;
}
mousehack = !dgamode;
if (screen_is_picasso) {
picasso_has_invalid_lines = 0;
picasso_invalid_start = picasso_vidinfo.height + 1;
picasso_invalid_stop = -1;
memset (picasso_invalid_lines, 0, sizeof picasso_invalid_lines);
} else
reset_drawing ();
inwindow = 0;
inputdevice_release_all_keys ();
reset_hotkeys ();
}
void handle_events (void)
{
for (;;) {
XEvent event;
#if 0
if (! XCheckMaskEvent (display, eventmask, &event))
break;
#endif
if (! XPending (display))
break;
XNextEvent (display, &event);
switch (event.type) {
case KeyPress:
case KeyRelease: {
int state = (event.type == KeyPress);
if (currprefs.map_raw_keys) {
unsigned int keycode = ((XKeyEvent *)&event)->keycode;
unsigned int ievent;
if ((ievent = match_hotkey_sequence (keycode, state)))
handle_hotkey_event (ievent, state);
else
inputdevice_translatekeycode (0, keycode, state);
} else {
KeySym keysym;
int index = 0;
int ievent, amiga_keycode;
do {
keysym = XLookupKeysym ((XKeyEvent *)&event, index);
if ((ievent = match_hotkey_sequence (keysym, state))) {
handle_hotkey_event (ievent, state);
break;
} else
if ((amiga_keycode = xkeysym2amiga (keysym)) >= 0) {
inputdevice_do_keyboard (amiga_keycode, state);
break;
}
index++;
} while (keysym != NoSymbol);
}
break;
}
case ButtonPress:
case ButtonRelease: {
int state = (event.type == ButtonPress);
int buttonno = -1;
switch ((int)((XButtonEvent *)&event)->button) {
case 1: buttonno = 0; break;
case 2: buttonno = 2; break;
case 3: buttonno = 1; break;
/* buttons 4 and 5 report mousewheel events */
case 4: if (state) record_key (0x7a << 1); break;
case 5: if (state) record_key (0x7b << 1); break;
}
if (buttonno >=0)
setmousebuttonstate(0, buttonno, state);
break;
}
case MotionNotify:
if (dgamode) {
int tx = ((XMotionEvent *)&event)->x_root;
int ty = ((XMotionEvent *)&event)->y_root;
setmousestate (0, 0, tx, 0);
setmousestate (0, 1, ty, 0);
} else if (grabbed) {
int realmove = 0;
int tx, ty,ttx,tty;
tx = ((XMotionEvent *)&event)->x;
ty = ((XMotionEvent *)&event)->y;
if (! event.xmotion.send_event) {
setmousestate( 0,0,tx-oldx,0);
setmousestate( 0,1,ty-oldy,0);
realmove = 1;
#undef ABS
#define ABS(a) (((a)<0) ? -(a) : (a) )
if (ABS(current_width / 2 - tx) > 3 * current_width / 8
|| ABS(current_height / 2 - ty) > 3 * current_height / 8)
{
#undef ABS
XEvent event;
ttx = current_width / 2;
tty = current_height / 2;
event.type = MotionNotify;
event.xmotion.display = display;
event.xmotion.window = mywin;
event.xmotion.x = ttx;
event.xmotion.y = tty;
XSendEvent (display, mywin, False,
PointerMotionMask, &event);
XWarpPointer (display, None, mywin, 0, 0, 0, 0, ttx, tty);
}
} else {
tx=event.xmotion.x;
ty=event.xmotion.y;
}
oldx = tx;
oldy = ty;
} else if (inwindow) {
int tx = ((XMotionEvent *)&event)->x;
int ty = ((XMotionEvent *)&event)->y;
setmousestate(0,0,tx,1);
setmousestate(0,1,ty,1);
if (! cursorOn && !currprefs.hide_cursor) {
XDefineCursor(display, mywin, xhairCursor);
cursorOn = 1;
}
gettimeofday(&lastMotionTime, NULL);
}
break;
case EnterNotify:
{
int tx = ((XCrossingEvent *)&event)->x;
int ty = ((XCrossingEvent *)&event)->y;
setmousestate(0,0,tx,1);
setmousestate(0,1,ty,1);
}
inwindow = 1;
break;
case LeaveNotify:
inwindow = 0;
break;
case FocusIn:
if (! autorepeatoff)
XAutoRepeatOff (display);
autorepeatoff = 1;
break;
case FocusOut:
if (autorepeatoff)
XAutoRepeatOn (display);
autorepeatoff = 0;
inputdevice_release_all_keys ();
break;
case Expose:
refresh_necessary = 1;
break;
case ClientMessage:
if (((Atom)event.xclient.data.l[0]) == delete_win) {
uae_stop ();
}
break;
}
}
#if defined PICASSO96
if (! dgamode) {
if (screen_is_picasso && refresh_necessary) {
DO_PUTIMAGE (pic_dinfo.ximg, 0, 0, 0, 0,
picasso_vidinfo.width, picasso_vidinfo.height);
XFlush (display);
refresh_necessary = 0;
memset (picasso_invalid_lines, 0, sizeof picasso_invalid_lines);
} else if (screen_is_picasso && picasso_has_invalid_lines) {
int i;
int strt = -1;
picasso_invalid_lines[picasso_vidinfo.height] = 0;
for (i = picasso_invalid_start; i < picasso_invalid_stop + 2; i++) {
if (picasso_invalid_lines[i]) {
picasso_invalid_lines[i] = 0;
if (strt != -1)
continue;
strt = i;
} else {
if (strt == -1)
continue;
DO_PUTIMAGE (pic_dinfo.ximg, 0, strt, 0, strt,
picasso_vidinfo.width, i - strt);
strt = -1;
}
}
XFlush (display);
if (strt != -1)
abort ();
}
}
picasso_has_invalid_lines = 0;
picasso_invalid_start = picasso_vidinfo.height + 1;
picasso_invalid_stop = -1;
#endif
if (! dgamode) {
if (! screen_is_picasso && refresh_necessary) {
DO_PUTIMAGE (ami_dinfo.ximg, 0, 0, 0, 0, current_width, current_height);
refresh_necessary = 0;
}
if (cursorOn && !currprefs.hide_cursor) {
struct timeval now;
int diff;
gettimeofday(&now, NULL);
diff = (now.tv_sec - lastMotionTime.tv_sec) * 1000000 +
(now.tv_usec - lastMotionTime.tv_usec);
if (diff > 1000000) {
XDefineCursor (display, mywin, blankCursor);
cursorOn = 0;
}
}
}
}
static int viewport_setup(void) {
intptr_t width, height, format, rowbytes, pixbytes;
intptr_t rb = 0, gb = 0, bb = 0, ab = 0;
intptr_t rs = 0, gs = 0, bs = 0, as = 0;
printf("creating bitmap\n");
bitmap = glgfx_bitmap_create(glgfx_bitmap_attr_width, bm_width,
glgfx_bitmap_attr_height, bm_height,
glgfx_bitmap_attr_format, bm_format,
glgfx_tag_end);
if (bitmap == NULL) {
return 0;
}
printf("created bitmap %d %d format %08lx\n", bm_width, bm_height, bm_format);
uint32_t* buffer;
if ((buffer = glgfx_bitmap_lock(bitmap, false, true, glgfx_tag_end)) != NULL) {
int x, y;
for (y = 0; y < bm_height; y += 1) {
for (x = 0; x < bm_width; x += 1) {
buffer[x+y*bm_width] = glgfx_pixel_create_a8b8g8r8(y*255/bm_height, 0, x*255/bm_width, 128);
}
}
if (glgfx_bitmap_unlock(bitmap, glgfx_tag_end)) {
printf("updated bitmap\n");
}
}
glgfx_bitmap_getattr(bitmap, glgfx_bitmap_attr_width, &width);
glgfx_bitmap_getattr(bitmap, glgfx_bitmap_attr_height, &height);
glgfx_bitmap_getattr(bitmap, glgfx_bitmap_attr_format, &format);
glgfx_bitmap_getattr(bitmap, glgfx_bitmap_attr_bytesperrow, &rowbytes);
glgfx_pixel_getattr(format, glgfx_pixel_attr_bytesperpixel, &pixbytes);
glgfx_pixel_getattr(format, glgfx_pixel_attr_redbits, &rb);
glgfx_pixel_getattr(format, glgfx_pixel_attr_greenbits, &gb);
glgfx_pixel_getattr(format, glgfx_pixel_attr_bluebits, &bb);
glgfx_pixel_getattr(format, glgfx_pixel_attr_alphabits, &ab);
glgfx_pixel_getattr(format, glgfx_pixel_attr_redshift, &rs);
glgfx_pixel_getattr(format, glgfx_pixel_attr_greenshift, &gs);
glgfx_pixel_getattr(format, glgfx_pixel_attr_blueshift, &bs);
glgfx_pixel_getattr(format, glgfx_pixel_attr_alphashift, &as);
alloc_colors64k(rb, gb, bb, rs, gs, bs, ab, as, ((1 << ab) - 1), 0 /* byte swap? */ );
// Set up callback functions
gfxvidinfo.flush_line = _flush_line;
gfxvidinfo.flush_block = _flush_block;
gfxvidinfo.flush_screen = _flush_screen;
gfxvidinfo.flush_clear_screen = _flush_clear_screen;
gfxvidinfo.lockscr = _lockscr;
gfxvidinfo.unlockscr = _unlockscr;
#ifdef PICASSO96
if (!screen_is_picasso) {
#endif
gfxvidinfo.width = width;
gfxvidinfo.height = height;
gfxvidinfo.pixbytes = pixbytes;
gfxvidinfo.rowbytes = rowbytes;
gfxvidinfo.bufmem = NULL;
gfxvidinfo.emergmem = malloc(rowbytes);
gfxvidinfo.maxblocklines = height;
// gfxvidinfo.maxblocklines = 0;
gfxvidinfo.linemem = NULL;
reset_drawing ();
#ifdef PICASSO96
}
else {
picasso_has_invalid_lines = 0;
picasso_invalid_start = height + 1;
picasso_invalid_stop = -1;
picasso_vidinfo.width = width;
picasso_vidinfo.height = height;
picasso_vidinfo.depth = rb + gb + bb + ab;
picasso_vidinfo.pixbytes = pixbytes;
picasso_vidinfo.rowbytes = rowbytes;
picasso_vidinfo.extra_mem = 1;
p96_buffer = malloc(width*height*pixbytes);
p96_bytes_per_row = width*pixbytes;
memset (picasso_invalid_lines, 0, sizeof picasso_invalid_lines);
}
#endif
if (fullscreen) {
rasinfo = glgfx_viewport_addbitmap(viewport, bitmap,
glgfx_rasinfo_attr_x, 0,
glgfx_rasinfo_attr_y, 0,
glgfx_rasinfo_attr_width, real_width,
glgfx_rasinfo_attr_height, real_height,
glgfx_tag_end);
}
else {
rasinfo = glgfx_viewport_addbitmap(viewport, bitmap,
glgfx_rasinfo_attr_x, (real_width - bm_width) / 2,
glgfx_rasinfo_attr_y, (real_height - bm_height) / 2,
glgfx_rasinfo_attr_width, width,
glgfx_rasinfo_attr_height, height,
glgfx_tag_end);
}
if (rasinfo == NULL) {
return 0;
}
inputdevice_release_all_keys();
reset_hotkeys();
printf("viewport_setup -> 1\n");
return 1;
}
