static cairo_t * gdk_cairo_create (GdkDrawable *drawable) { int width, height; cairo_t *cr = NULL; cairo_surface_t *surface = NULL; GdkVisual *visual = gdk_drawable_get_visual (drawable); gdk_drawable_get_size (drawable, &width, &height); if (visual) surface = cairo_xlib_surface_create (GDK_DRAWABLE_XDISPLAY (drawable), GDK_DRAWABLE_XID (drawable), GDK_VISUAL_XVISUAL (visual), width, height); else if (gdk_drawable_get_depth (drawable) == 1) surface = cairo_xlib_surface_create_for_bitmap (GDK_PIXMAP_XDISPLAY (drawable), GDK_PIXMAP_XID (drawable), GDK_SCREEN_XSCREEN (gdk_drawable_get_screen (drawable)), width, height); else { g_warning ("Using Cairo rendering requires the drawable argument to\n" "have a specified colormap. All windows have a colormap,\n" "however, pixmaps only have colormap by default if they\n" "were created with a non-NULL window argument. Otherwise\n" "a colormap must be set on them with " "gdk_drawable_set_colormap"); return NULL; } if (surface) { cr = cairo_create (surface); cairo_surface_destroy (surface); } return cr; }
EggTrayIcon * egg_tray_icon_new_for_screen (GdkScreen *screen, const char *name) { g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL); return egg_tray_icon_new_for_xscreen (GDK_SCREEN_XSCREEN (screen), name); }
static inline void wx_gdk_screen_get_monitor_workarea(GdkScreen* screen, int monitor, GdkRectangle* dest) { #if GTK_CHECK_VERSION(3,4,0) if (gtk_check_version(3,4,0) == NULL) gdk_screen_get_monitor_workarea(screen, monitor, dest); else #endif { gdk_screen_get_monitor_geometry(screen, monitor, dest); #ifdef GDK_WINDOWING_X11 #ifdef __WXGTK3__ if (GDK_IS_X11_SCREEN(screen)) #endif { GdkRectangle rect = { 0 }; wxGetWorkAreaX11(GDK_SCREEN_XSCREEN(screen), rect.x, rect.y, rect.width, rect.height); // in case _NET_WORKAREA result is too large if (rect.width && rect.height) gdk_rectangle_intersect(dest, &rect, dest); } #endif // GDK_WINDOWING_X11 } }
void xstuff_change_workspace (GtkWindow *window, int new_space) { XEvent xev; Window xwindow; Display *gdk_display; Screen *screen; gdk_display = GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()); xwindow = GDK_WINDOW_XID (GDK_WINDOW (gtk_widget_get_window (GTK_WIDGET (window)))); screen = GDK_SCREEN_XSCREEN (gtk_widget_get_screen (GTK_WIDGET (window))); xev.xclient.type = ClientMessage; xev.xclient.serial = 0; xev.xclient.send_event = True; xev.xclient.display = gdk_display; xev.xclient.window = xwindow; xev.xclient.message_type = xstuff_atom_get ("_NET_WM_DESKTOP"); xev.xclient.format = 32; xev.xclient.data.l[0] = new_space; xev.xclient.data.l[1] = 0; xev.xclient.data.l[2] = 0; XSendEvent (gdk_display, RootWindowOfScreen (screen), False, SubstructureRedirectMask | SubstructureNotifyMask, &xev); }
gboolean egg_tray_manager_check_running (GdkScreen *screen) { g_return_val_if_fail (GDK_IS_SCREEN (screen), FALSE); return egg_tray_manager_check_running_xscreen (GDK_SCREEN_XSCREEN (screen)); }
// ----------------------------------------------------------------------------- int g_workspace_count() { DEBUGLOGB; #if _USEGTK #if _USEWKSPACE int ret = wnck_screen_get_workspace_count(wnck_screen_get_default()); #else // _USEWKSPACE #if GTK_CHECK_VERSION(3,0,0) Screen* xscreen = gdk_x11_screen_get_xscreen(gdk_screen_get_default()); #else Screen* xscreen = GDK_SCREEN_XSCREEN(gdk_screen_get_default()); #endif int ret = _wncki_screen_get_workspace_count(xscreen); #endif // _USEWKSPACE #else // _USEGTK int ret = 1; #endif // _USEGTK DEBUGLOGE; return ret; }
// ----------------------------------------------------------------------------- void g_window_workspace(GtkWidget* pWidget, int space) { DEBUGLOGB; #if !_USEWKSPACE #if GTK_CHECK_VERSION(3,0,0) Screen* xscreen = gdk_x11_screen_get_xscreen(gdk_screen_get_default()); Window xwindow = gdk_x11_window_get_xid(gtk_widget_get_window(pWidget)); #else Screen* xscreen = GDK_SCREEN_XSCREEN(gdk_screen_get_default()); Window xwindow = GDK_WINDOW_XWINDOW(gtk_widget_get_window(pWidget)); #endif _wncki_change_workspace(xscreen, xwindow, space); #else // !_USEWKSPACE WnckScreen* screen = wnck_screen_get_default(); if( screen ) { DEBUGLOGS("got default screen"); wnck_screen_force_update(screen); DEBUGLOGP("sticky is off and workspace is %d\n", space); WnckWindow* window = wnck_window_get(gdk_x11_drawable_get_xid(gtk_widget_get_window(pWidget))); if( window && !wnck_window_is_pinned(window) ) { DEBUGLOGS("got non-pinned window"); WnckWorkspace* trgtWrk = wnck_screen_get_workspace (screen, space); WnckWorkspace* actvWrk = wnck_screen_get_active_workspace(screen); if( trgtWrk && actvWrk && trgtWrk != actvWrk ) { DEBUGLOGS("got target workspace is diff from current so moving window to target"); wnck_window_move_to_workspace(window, trgtWrk); } } #ifdef _DEBUGLOG else { DEBUGLOGP("WnckWindow for clock window is%svalid\n", window ? " " : " NOT "); guint xw1 = GDK_WINDOW_XWINDOW (gtk_widget_get_window(pWidget)); guint xw2 = gdk_x11_drawable_get_xid(gtk_widget_get_window(pWidget)); DEBUGLOGP("X11 XID1 for clock window is %d\n", (int)xw1); DEBUGLOGP("X11 XID2 for clock window is %d\n", (int)xw2); } #endif } #endif // !_USEWKSPACE DEBUGLOGE; }
gboolean egg_tray_manager_manage_screen (EggTrayManager *manager, GdkScreen *screen) { g_return_val_if_fail (GDK_IS_SCREEN (screen), FALSE); g_return_val_if_fail (manager->screen == NULL, FALSE); return egg_tray_manager_manage_xscreen (manager, GDK_SCREEN_XSCREEN (screen)); }
gboolean egg_tray_manager_check_running (GdkScreen *screen) { g_return_val_if_fail (GDK_IS_SCREEN (screen), FALSE); #ifdef GDK_WINDOWING_X11 return egg_tray_manager_check_running_xscreen (GDK_SCREEN_XSCREEN (screen)); #else return FALSE; #endif }
GdkPixbuf* meta_gdk_pixbuf_get_from_pixmap (GdkPixbuf *dest, Pixmap xpixmap, int src_x, int src_y, int dest_x, int dest_y, int width, int height) { cairo_surface_t *surface; Display *display; Window root_return; int x_ret, y_ret; unsigned int w_ret, h_ret, bw_ret, depth_ret; XWindowAttributes attrs; GdkPixbuf *retval; display = GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()); if (!XGetGeometry (display, xpixmap, &root_return, &x_ret, &y_ret, &w_ret, &h_ret, &bw_ret, &depth_ret)) return NULL; if (depth_ret == 1) { surface = cairo_xlib_surface_create_for_bitmap (display, xpixmap, GDK_SCREEN_XSCREEN (gdk_screen_get_default ()), w_ret, h_ret); } else { if (!XGetWindowAttributes (display, root_return, &attrs)) return NULL; surface = cairo_xlib_surface_create (display, xpixmap, attrs.visual, w_ret, h_ret); } retval = gdk_pixbuf_get_from_surface (surface, src_x, src_y, width, height); cairo_surface_destroy (surface); return retval; }
gboolean egg_tray_manager_manage_screen (EggTrayManager *manager, GdkScreen *screen) { g_return_val_if_fail (GDK_IS_SCREEN (screen), FALSE); g_return_val_if_fail (manager->screen == NULL, FALSE); #ifdef GDK_WINDOWING_X11 return egg_tray_manager_manage_xscreen (manager, GDK_SCREEN_XSCREEN (screen)); #else return FALSE; #endif }
Ogre::String getWindowHandleString(GtkWidget *widget) { Ogre::String handle; // GTK_WIDGET_SET_FLAGS(widget, GTK_REALIZED); gtk_widget_realize(widget); GdkWindow *parent = gtk_widget_get_parent_window(widget); // gdk_window_show(parent); #if defined(__WIN32__) || defined(_WIN32) handle = Ogre::StringConverter::toString((unsigned long) GDK_WINDOW_HWND(parent)); #else // #elif defined(__WXGTK__) GdkDisplay* display = gdk_drawable_get_display(GDK_DRAWABLE(parent)); Display *xdisplay = GDK_DISPLAY_XDISPLAY(display); XSync(xdisplay, false); GdkScreen* screen = gdk_drawable_get_screen(GDK_DRAWABLE(parent)); Screen *xscreen = GDK_SCREEN_XSCREEN(screen); int screen_number = XScreenNumberOfScreen(xscreen); // XID xid_parent = GDK_WINDOW_XWINDOW(parent); // "parentWindowHandle" // handle = // Ogre::StringConverter::toString(reinterpret_cast<unsigned long>(xdisplay)) + ":" + // Ogre::StringConverter::toString(static_cast<unsigned int>(screen_number)) + ":" + // Ogre::StringConverter::toString(static_cast<unsigned long>(xid_parent)); handle = Ogre::StringConverter::toString(static_cast<unsigned long>(GDK_WINDOW_XID(parent))); #endif // dunno what MacOS needs - you tell me return handle; }
static gboolean na_tray_manager_manage_screen_x11 (NaTrayManager *manager, GdkScreen *screen) { GdkDisplay *display; Screen *xscreen; GtkWidget *invisible; char *selection_atom_name; guint32 timestamp; g_return_val_if_fail (NA_IS_TRAY_MANAGER (manager), FALSE); g_return_val_if_fail (manager->screen == NULL, FALSE); /* If there's already a manager running on the screen * we can't create another one. */ #if 0 if (na_tray_manager_check_running_screen_x11 (screen)) return FALSE; #endif manager->screen = screen; display = gdk_screen_get_display (screen); xscreen = GDK_SCREEN_XSCREEN (screen); invisible = gtk_invisible_new_for_screen (screen); gtk_widget_realize (invisible); gtk_widget_add_events (invisible, GDK_PROPERTY_CHANGE_MASK | GDK_STRUCTURE_MASK); selection_atom_name = g_strdup_printf ("_NET_SYSTEM_TRAY_S%d", gdk_screen_get_number (screen)); manager->selection_atom = gdk_atom_intern (selection_atom_name, FALSE); g_free (selection_atom_name); manager->invisible = invisible; g_object_ref (G_OBJECT (manager->invisible)); na_tray_manager_set_orientation_property (manager); na_tray_manager_set_visual_property (manager); timestamp = gdk_x11_get_server_time (invisible->window); /* Check if we could set the selection owner successfully */ if (gdk_selection_owner_set_for_display (display, invisible->window, manager->selection_atom, timestamp, TRUE)) { XClientMessageEvent xev; GdkAtom opcode_atom; GdkAtom message_data_atom; xev.type = ClientMessage; xev.window = RootWindowOfScreen (xscreen); xev.message_type = gdk_x11_get_xatom_by_name_for_display (display, "MANAGER"); xev.format = 32; xev.data.l[0] = timestamp; xev.data.l[1] = gdk_x11_atom_to_xatom_for_display (display, manager->selection_atom); xev.data.l[2] = GDK_WINDOW_XWINDOW (invisible->window); xev.data.l[3] = 0; /* manager specific data */ xev.data.l[4] = 0; /* manager specific data */ XSendEvent (GDK_DISPLAY_XDISPLAY (display), RootWindowOfScreen (xscreen), False, StructureNotifyMask, (XEvent *)&xev); opcode_atom = gdk_atom_intern ("_NET_SYSTEM_TRAY_OPCODE", FALSE); manager->opcode_atom = gdk_x11_atom_to_xatom_for_display (display, opcode_atom); message_data_atom = gdk_atom_intern ("_NET_SYSTEM_TRAY_MESSAGE_DATA", FALSE); /* Add a window filter */ #if 0 /* This is for when we lose the selection of _NET_SYSTEM_TRAY_Sx */ g_signal_connect (invisible, "selection-clear-event", G_CALLBACK (na_tray_manager_selection_clear_event), manager); #endif /* This is for SYSTEM_TRAY_REQUEST_DOCK and SelectionClear */ gdk_window_add_filter (invisible->window, na_tray_manager_window_filter, manager); /* This is for SYSTEM_TRAY_BEGIN_MESSAGE and SYSTEM_TRAY_CANCEL_MESSAGE */ gdk_display_add_client_message_filter (display, opcode_atom, na_tray_manager_handle_client_message_opcode, manager); /* This is for _NET_SYSTEM_TRAY_MESSAGE_DATA */ gdk_display_add_client_message_filter (display, message_data_atom, na_tray_manager_handle_client_message_message_data, manager); return TRUE; } else { gtk_widget_destroy (invisible); g_object_unref (invisible); manager->invisible = NULL; manager->screen = NULL; return FALSE; } }
static gboolean poll_for_idleness (void *data) { HippoIdleMonitor *monitor = data; int i; int n_screens; unsigned long idle_time; gboolean was_idle; idle_time = G_MAXINT; n_screens = gdk_display_get_n_screens(monitor->display); for (i = 0; i < n_screens; ++i) { int result; GdkScreen *screen; screen = gdk_display_get_screen(monitor->display, i); result = XScreenSaverQueryInfo(GDK_DISPLAY_XDISPLAY(monitor->display), GDK_SCREEN_XSCREEN(screen)->root, monitor->info); if (result == 0) { g_warning("Failed to get idle time from screensaver extension"); break; } /* monitor->info->idle is time in milliseconds since last user interaction event */ idle_time = MIN(monitor->info->idle, idle_time); } was_idle = monitor->currently_idle; /* If the idle time has gone down, there must have been activity since we last checked */ if (idle_time < monitor->last_idle) { monitor->activity_time = get_time(); monitor->currently_idle = FALSE; } else { /* If no activity, see how long ago it was and count ourselves idle * if it's been a short while. We keep this idle really short, since it * simply results in keeping bubbles up; we want to do this if people * just look away for a minute, really. It can be "more aggressive" * about idle detection than a screensaver would be. */ GTime now = get_time(); if (now < monitor->activity_time) { /* clock went backward... just "catch up" * then wait until the idle timeout expires again */ monitor->activity_time = now; } else if ((now - monitor->activity_time) > 120) { /* 120 = 2 minutes */ monitor->currently_idle = TRUE; } } monitor->last_idle = idle_time; if (was_idle != monitor->currently_idle) { (* monitor->func) (monitor->currently_idle, monitor->data); } if (hippo_data_cache_get_application_usage_enabled(monitor->cache) && !monitor->currently_idle) { update_application_info(monitor); } return TRUE; }