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;
}
