#include #include #include #include "allegro5/allegro.h" #include "allegro5/allegro_x.h" #include "allegro5/internal/aintern_x.h" #include "allegro5/internal/aintern_xdisplay.h" #include "allegro5/internal/aintern_xsystem.h" #include "allegro5/internal/aintern_xwindow.h" #ifdef ALLEGRO_RASPBERRYPI #include "allegro5/internal/aintern_raspberrypi.h" #define ALLEGRO_SYSTEM_XGLX ALLEGRO_SYSTEM_RASPBERRYPI #define ALLEGRO_DISPLAY_XGLX ALLEGRO_DISPLAY_RASPBERRYPI #endif ALLEGRO_DEBUG_CHANNEL("xwindow") #define X11_ATOM(x) XInternAtom(x11, #x, False); void _al_xwin_set_size_hints(ALLEGRO_DISPLAY *d, int x_off, int y_off) { ALLEGRO_SYSTEM_XGLX *system = (void *)al_get_system_driver(); ALLEGRO_DISPLAY_XGLX *glx = (void *)d; XSizeHints *sizehints; XWMHints *wmhints; XClassHint *classhints; int w, h; sizehints = XAllocSizeHints(); sizehints->flags = 0; #ifdef ALLEGRO_RASPBERRYPI int x, y; _al_raspberrypi_get_screen_info(&x, &y, &w, &h); #else w = d->w; h = d->h; #endif /* Do not force the size of the window on resizeable or fullscreen windows */ /* on fullscreen windows, it confuses most X Window Managers */ if (!(d->flags & ALLEGRO_RESIZABLE) && !(d->flags & ALLEGRO_FULLSCREEN)) { sizehints->flags |= PMinSize | PMaxSize | PBaseSize; sizehints->min_width = sizehints->max_width = sizehints->base_width = w; sizehints->min_height = sizehints->max_height = sizehints->base_height = h; } /* Constrain the window if needed. */ if (d->use_constraints && (d->flags & ALLEGRO_RESIZABLE) && (d->min_w > 0 || d->min_h > 0 || d->max_w > 0 || d->max_h > 0)) { sizehints->flags |= PMinSize | PMaxSize | PBaseSize; sizehints->min_width = (d->min_w > 0) ? d->min_w : 0; sizehints->min_height = (d->min_h > 0) ? d->min_h : 0; sizehints->max_width = (d->max_w > 0) ? d->max_w : INT_MAX; sizehints->max_height = (d->max_h > 0) ? d->max_h : INT_MAX; sizehints->base_width = w; sizehints->base_height = h; } // Tell WMs to respect our chosen position, otherwise the x_off/y_off // positions passed to XCreateWindow will be ignored by most WMs. if (x_off != INT_MAX && y_off != INT_MAX) { ALLEGRO_DEBUG("Force window position to %d, %d.\n", x_off, y_off); sizehints->flags |= PPosition; sizehints->x = x_off; sizehints->y = y_off; } if (d->flags & ALLEGRO_FULLSCREEN) { /* kwin will improperly layer a panel over our window on a second display without this. * some other Size flags may cause glitches with various WMs, but this seems to be ok * with metacity and kwin. As noted in xdpy_create_display, compiz is just broken. */ sizehints->flags |= PBaseSize; sizehints->base_width = w; sizehints->base_height = h; } /* Setup the input hints so we get keyboard input */ wmhints = XAllocWMHints(); wmhints->input = True; wmhints->flags = InputHint; ALLEGRO_PATH *exepath = al_get_standard_path(ALLEGRO_EXENAME_PATH); /* Setup the class hints so we can get an icon (AfterStep) * We must use the executable filename here. */ classhints = XAllocClassHint(); classhints->res_name = strdup(al_get_path_basename(exepath)); classhints->res_class = strdup(al_get_path_basename(exepath)); /* Set the size, input and class hints, and define WM_CLIENT_MACHINE and WM_LOCALE_NAME */ XSetWMProperties(system->x11display, glx->window, NULL, NULL, NULL, 0, sizehints, wmhints, classhints); free(classhints->res_name); free(classhints->res_class); XFree(sizehints); XFree(wmhints); XFree(classhints); al_destroy_path(exepath); } void _al_xwin_reset_size_hints(ALLEGRO_DISPLAY *d) { ALLEGRO_SYSTEM_XGLX *system = (void *)al_get_system_driver(); ALLEGRO_DISPLAY_XGLX *glx = (void *)d; XSizeHints *hints; hints = XAllocSizeHints(); hints->flags = PMinSize | PMaxSize; hints->min_width = 0; hints->min_height = 0; // FIXME: Is there a way to remove/reset max dimensions? hints->max_width = 32768; hints->max_height = 32768; XSetWMNormalHints(system->x11display, glx->window, hints); XFree(hints); } /* Note: The system mutex must be locked (exactly once) before * calling this as we call _al_display_xglx_await_resize. */ void _al_xwin_set_fullscreen_window(ALLEGRO_DISPLAY *display, int value) { ALLEGRO_SYSTEM_XGLX *system = (void *)al_get_system_driver(); ALLEGRO_DISPLAY_XGLX *glx = (ALLEGRO_DISPLAY_XGLX *)display; Display *x11 = system->x11display; #ifndef ALLEGRO_RASPBERRYPI int old_resize_count = glx->resize_count; #endif ALLEGRO_DEBUG("Toggling _NET_WM_STATE_FULLSCREEN hint: %d\n", value); XEvent xev; xev.xclient.type = ClientMessage; xev.xclient.serial = 0; xev.xclient.send_event = True; xev.xclient.message_type = X11_ATOM(_NET_WM_STATE); xev.xclient.window = glx->window; xev.xclient.format = 32; // Note: It seems 0 is not reliable except when mapping a window - // 2 is all we need though. xev.xclient.data.l[0] = value; /* 0 = off, 1 = on, 2 = toggle */ xev.xclient.data.l[1] = X11_ATOM(_NET_WM_STATE_FULLSCREEN); xev.xclient.data.l[2] = 0; xev.xclient.data.l[3] = 1; /* 1 = normal application source */ xev.xclient.data.l[4] = 0; XSendEvent( x11, #if !defined ALLEGRO_RASPBERRYPI RootWindowOfScreen(ScreenOfDisplay(x11, glx->xscreen)), #else RootWindowOfScreen(ScreenOfDisplay(x11, DefaultScreen(x11))), #endif False, SubstructureRedirectMask | SubstructureNotifyMask, &xev); #if !defined ALLEGRO_RASPBERRYPI if (value == 2) { /* Only wait for a resize if toggling. */ _al_display_xglx_await_resize(display, old_resize_count, true); } #endif } void _al_xwin_set_above(ALLEGRO_DISPLAY *display, int value) { ALLEGRO_SYSTEM_XGLX *system = (void *)al_get_system_driver(); ALLEGRO_DISPLAY_XGLX *glx = (ALLEGRO_DISPLAY_XGLX *)display; Display *x11 = system->x11display; ALLEGRO_DEBUG("Toggling _NET_WM_STATE_ABOVE hint: %d\n", value); XEvent xev; xev.xclient.type = ClientMessage; xev.xclient.serial = 0; xev.xclient.send_event = True; xev.xclient.message_type = X11_ATOM(_NET_WM_STATE); xev.xclient.window = glx->window; xev.xclient.format = 32; // Note: It seems 0 is not reliable except when mapping a window - // 2 is all we need though. xev.xclient.data.l[0] = value; /* 0 = off, 1 = on, 2 = toggle */ xev.xclient.data.l[1] = X11_ATOM(_NET_WM_STATE_ABOVE); xev.xclient.data.l[2] = 0; xev.xclient.data.l[3] = 0; xev.xclient.data.l[4] = 1; XSendEvent(x11, DefaultRootWindow(x11), False, SubstructureRedirectMask | SubstructureNotifyMask, &xev); } void _al_xwin_set_frame(ALLEGRO_DISPLAY *display, bool frame_on) { ALLEGRO_SYSTEM_XGLX *system = (void *)al_get_system_driver(); ALLEGRO_DISPLAY_XGLX *glx = (ALLEGRO_DISPLAY_XGLX *)display; Display *x11 = system->x11display; Atom hints; #if 1 /* This code is taken from the GDK sources. So it works perfectly in Gnome, * no idea if it will work anywhere else. X11 documentation itself only * describes a way how to make the window completely unmanaged, but that * would also require special care in the event handler. */ hints = XInternAtom(x11, "_MOTIF_WM_HINTS", True); if (hints) { struct { unsigned long flags; unsigned long functions; unsigned long decorations; long input_mode; unsigned long status; } motif = {2, 0, frame_on, 0, 0}; XChangeProperty(x11, glx->window, hints, hints, 32, PropModeReplace, (void *)&motif, sizeof motif / 4); if (frame_on) display->flags &= ~ALLEGRO_FRAMELESS; else display->flags |= ALLEGRO_FRAMELESS; } #endif } /* Helper to set a window icon. We use the _NET_WM_ICON property which is * supported by modern window managers. * * The old method is XSetWMHints but the (antiquated) ICCCM talks about 1-bit * pixmaps. For colour icons, perhaps you're supposed use the icon_window, * and draw the window yourself? */ static bool xdpy_set_icon_inner(Display *x11display, Window window, ALLEGRO_BITMAP *bitmap, int prop_mode) { int w, h; int data_size; unsigned long *data; /* Yes, unsigned long, even on 64-bit platforms! */ ALLEGRO_LOCKED_REGION *lr; bool ret; w = al_get_bitmap_width(bitmap); h = al_get_bitmap_height(bitmap); data_size = 2 + w * h; data = al_malloc(data_size * sizeof(data[0])); if (!data) return false; lr = al_lock_bitmap(bitmap, ALLEGRO_PIXEL_FORMAT_ANY_WITH_ALPHA, ALLEGRO_LOCK_READONLY); if (lr) { int x, y; ALLEGRO_COLOR c; unsigned char r, g, b, a; Atom _NET_WM_ICON; data[0] = w; data[1] = h; for (y = 0; y < h; y++) { for (x = 0; x < w; x++) { c = al_get_pixel(bitmap, x, y); al_unmap_rgba(c, &r, &g, &b, &a); data[2 + y*w + x] = ((unsigned long)a << 24) | ((unsigned long)r << 16) | ((unsigned long)g << 8) | (unsigned long)b; } } _NET_WM_ICON = XInternAtom(x11display, "_NET_WM_ICON", False); XChangeProperty(x11display, window, _NET_WM_ICON, XA_CARDINAL, 32, prop_mode, (unsigned char *)data, data_size); al_unlock_bitmap(bitmap); ret = true; } else { ret = false; } al_free(data); return ret; } void _al_xwin_set_icons(ALLEGRO_DISPLAY *d, int num_icons, ALLEGRO_BITMAP *bitmaps[]) { ALLEGRO_SYSTEM_XGLX *system = (ALLEGRO_SYSTEM_XGLX *)al_get_system_driver(); ALLEGRO_DISPLAY_XGLX *glx = (ALLEGRO_DISPLAY_XGLX *)d; int prop_mode = PropModeReplace; int i; _al_mutex_lock(&system->lock); for (i = 0; i < num_icons; i++) { if (xdpy_set_icon_inner(system->x11display, glx->window, bitmaps[i], prop_mode)) { prop_mode = PropModeAppend; } } _al_mutex_unlock(&system->lock); } /* Note: The system mutex must be locked (exactly once) before * calling this as we call _al_display_xglx_await_resize. */ void _al_xwin_maximize(ALLEGRO_DISPLAY *display, bool maximized) { #ifndef ALLEGRO_RASPBERRYPI if (!!(display->flags & ALLEGRO_MAXIMIZED) == maximized) return; ALLEGRO_SYSTEM_XGLX *system = (void *)al_get_system_driver(); ALLEGRO_DISPLAY_XGLX *glx = (ALLEGRO_DISPLAY_XGLX *)display; Display *x11 = system->x11display; int old_resize_count = glx->resize_count; XEvent xev; xev.xclient.type = ClientMessage; xev.xclient.serial = 0; xev.xclient.send_event = True; xev.xclient.message_type = X11_ATOM(_NET_WM_STATE); xev.xclient.window = glx->window; xev.xclient.format = 32; xev.xclient.data.l[0] = maximized ? 1 : 0; xev.xclient.data.l[1] = X11_ATOM(_NET_WM_STATE_MAXIMIZED_HORZ); xev.xclient.data.l[2] = X11_ATOM(_NET_WM_STATE_MAXIMIZED_VERT); xev.xclient.data.l[3] = 0; XSendEvent( x11, RootWindowOfScreen(ScreenOfDisplay(x11, glx->xscreen)), False, SubstructureRedirectMask | SubstructureNotifyMask, &xev); _al_display_xglx_await_resize(display, old_resize_count, true); #endif } void _al_xwin_check_maximized(ALLEGRO_DISPLAY *display) { #ifndef ALLEGRO_RASPBERRYPI ALLEGRO_SYSTEM_XGLX *system = (void *)al_get_system_driver(); ALLEGRO_DISPLAY_XGLX *glx = (ALLEGRO_DISPLAY_XGLX *)display; Display *x11 = system->x11display; Atom type; Atom horz = X11_ATOM(_NET_WM_STATE_MAXIMIZED_HORZ); Atom vert = X11_ATOM(_NET_WM_STATE_MAXIMIZED_VERT); Atom property = X11_ATOM(_NET_WM_STATE); int format; int maximized = 0; unsigned long n, remaining, i, *p32; unsigned char *p8 = NULL; if (XGetWindowProperty(x11, glx->window, property, 0, INT_MAX, False, AnyPropertyType, &type, &format, &n, &remaining, &p8) != Success) { return; } p32 = (unsigned long *)p8; for (i = 0; i < n; i++) { if (p32[i] == horz) maximized |= 1; if (p32[i] == vert) maximized |= 2; } XFree(p8); display->flags &= ~ALLEGRO_MAXIMIZED; if (maximized == 3) display->flags |= ALLEGRO_MAXIMIZED; #endif } /* Function: al_get_x_window_id */ XID al_get_x_window_id(ALLEGRO_DISPLAY *display) { ASSERT(display != NULL); return ((ALLEGRO_DISPLAY_XGLX*)display)->window; } // Note: this only seems to work after the window has been mapped void _al_xwin_get_borders(ALLEGRO_DISPLAY *display) { ALLEGRO_DISPLAY_XGLX *glx = (ALLEGRO_DISPLAY_XGLX *)display; ALLEGRO_SYSTEM_XGLX *system = (void *)al_get_system_driver(); Display *x11 = system->x11display; Atom type; int format; unsigned long nitems, bytes_after; unsigned char *property; Atom frame_extents = X11_ATOM(_NET_FRAME_EXTENTS); if (XGetWindowProperty(x11, glx->window, frame_extents, 0, 16, 0, XA_CARDINAL, &type, &format, &nitems, &bytes_after, &property) == Success) { if (type != None && nitems == 4) { glx->border_left = (int)((long *)property)[0]; glx->border_right = (int)((long *)property)[1]; glx->border_top = (int)((long *)property)[2]; glx->border_bottom = (int)((long *)property)[3]; glx->borders_known = true; ALLEGRO_DEBUG("_NET_FRAME_EXTENTS: %d %d %d %d\n", glx->border_left, glx->border_top, glx->border_right, glx->border_bottom); } else { ALLEGRO_DEBUG("Unexpected _NET_FRAME_EXTENTS format: nitems=%lu\n", nitems); } XFree(property); } else { ALLEGRO_DEBUG("Could not read _NET_FRAME_EXTENTS\n"); } } /* vim: set sts=3 sw=3 et: */