static gboolean drw_selection_find_existing (DrwSelection *drw_selection) { Display *xdisplay = GDK_DISPLAY_XDISPLAY(gdk_display_get_default()); Window old; gdk_error_trap_push (); old = XGetSelectionOwner (xdisplay, gdk_x11_get_xatom_by_name (SELECTION_NAME)); if (old) { XSelectInput (xdisplay, old, StructureNotifyMask); drw_selection->owner_window = gdk_x11_window_foreign_new_for_display (gdk_display_get_default (), old); } XSync (xdisplay, False); if (gdk_error_trap_pop () == 0 && drw_selection->owner_window) { gdk_window_add_filter (drw_selection->owner_window, drw_selection_filter, drw_selection); XUngrabServer (xdisplay); return TRUE; } else { if (drw_selection->owner_window) { g_object_unref (drw_selection->owner_window); drw_selection->owner_window = NULL; } return FALSE; } }
void panel_action_protocol_init (void) { GdkDisplay *display; display = gdk_display_get_default (); atom_gnome_panel_action = XInternAtom (GDK_DISPLAY_XDISPLAY (display), "_GNOME_PANEL_ACTION", FALSE); atom_gnome_panel_action_main_menu = XInternAtom (GDK_DISPLAY_XDISPLAY (display), "_GNOME_PANEL_ACTION_MAIN_MENU", FALSE); atom_gnome_panel_action_run_dialog = XInternAtom (GDK_DISPLAY_XDISPLAY (display), "_GNOME_PANEL_ACTION_RUN_DIALOG", FALSE); atom_gnome_panel_action_kill_dialog = XInternAtom (GDK_DISPLAY_XDISPLAY (display), "_GNOME_PANEL_ACTION_KILL_DIALOG", FALSE); /* We'll filter event sent on non-root windows later */ gdk_window_add_filter (NULL, panel_action_protocol_filter, NULL); }
static void init() { int dummy; ENTER; if (!XkbQueryExtension(GDK_DISPLAY(), &dummy, &xkb_event_type, &dummy, &dummy, &dummy)) { ERR("no XKB extension\n"); exit(1); } XSetLocaleModifiers(""); XSetErrorHandler((XErrorHandler) Xerror_handler); dpy = GDK_DISPLAY(); if (chdir(IMGPREFIX)) { ERR("can't chdir to %s\n", IMGPREFIX); exit(1); } if (!(default_flag = get_flag("zz"))) { ERR("can't load default flag image\n"); exit(1); } XkbSelectEventDetails(dpy, XkbUseCoreKbd, XkbStateNotify, XkbAllStateComponentsMask, XkbGroupStateMask); gdk_window_add_filter(NULL, (GdkFilterFunc)filter, NULL); RET(); }
static void avatar_image_add_filter (EmpathyAvatarImage *avatar_image) { Display *display; Window window; gint mask; XWindowAttributes attrs; if (!running_in_x11 ()) return; mask = PropertyChangeMask; window = gdk_x11_get_default_root_xwindow (); display = gdk_x11_get_default_xdisplay (); gdk_error_trap_push (); XGetWindowAttributes (display, window, &attrs); mask |= attrs.your_event_mask; XSelectInput (display, window, mask); gdk_error_trap_pop_ignored (); gdk_window_add_filter (NULL, avatar_image_filter_func, avatar_image); }
void panel_force_quit (GdkScreen *screen, guint time) { GdkGrabStatus status; GdkCursor *cross; GtkWidget *popup; GdkWindow *root; popup = display_popup_window (screen); root = gdk_screen_get_root_window (screen); gdk_window_add_filter (root, (GdkFilterFunc) popup_filter, popup); cross = gdk_cursor_new (GDK_CROSS); status = gdk_pointer_grab (root, FALSE, GDK_BUTTON_PRESS_MASK, NULL, cross, time); gdk_cursor_unref (cross); if (status != GDK_GRAB_SUCCESS) { g_warning ("Pointer grab failed\n"); remove_popup (popup); return; } status = gdk_keyboard_grab (root, FALSE, time); if (status != GDK_GRAB_SUCCESS) { g_warning ("Keyboard grab failed\n"); remove_popup (popup); return; } gdk_flush (); }
static void xfce_keyboard_layout_helper_init (XfceKeyboardLayoutHelper *helper) { /* init */ helper->channel = NULL; /* open the channel */ helper->channel = xfconf_channel_get ("keyboard-layout"); helper->xkb_disable_settings = xfconf_channel_get_bool (helper->channel, "/Default/XkbDisable", TRUE); #ifdef HAVE_LIBXKLAVIER /* monitor channel changes */ g_signal_connect (G_OBJECT (helper->channel), "property-changed", G_CALLBACK (xfce_keyboard_layout_helper_channel_property_changed), helper); helper->engine = xkl_engine_get_instance (GDK_DISPLAY ()); helper->config = xkl_config_rec_new (); xkl_config_rec_get_from_server (helper->config, helper->engine); helper->system_keyboard_model = g_strdup (helper->config->model); gdk_window_add_filter (NULL, (GdkFilterFunc) handle_xevent, helper); g_signal_connect (helper->engine, "X-new-device", G_CALLBACK (xfce_keyboard_layout_reset_xkl_config), helper); xkl_engine_start_listen (helper->engine, XKLL_TRACK_KEYBOARD_STATE); /* load settings */ xfce_keyboard_layout_helper_set_model (helper); xfce_keyboard_layout_helper_set_layout (helper); xfce_keyboard_layout_helper_set_variant (helper); xfce_keyboard_layout_helper_set_grpkey (helper); xfce_keyboard_layout_helper_set_composekey (helper); #endif /* HAVE_LIBXKLAVIER */ xfce_keyboard_layout_helper_process_xmodmap (); }
Win* win_create(void) { Win *w; GdkGeometry g; GtkPolicyType h, v; w = emalloc(sizeof(Win)); w->win = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL)); w->scroll = GTK_SCROLLED_WINDOW(gtk_scrolled_window_new(NULL, NULL)); w->web = WEBKIT_WEB_VIEW(webkit_web_view_new()); w->ignore = w->zoom = FALSE; g.min_width = g.min_height = 1; data.wins = g_list_append(data.wins, w); webkit_web_view_set_full_content_zoom(w->web, TRUE); webkit_web_view_set_zoom_level(w->web, ZOOM); gtk_window_set_geometry_hints(w->win, NULL, &g, GDK_HINT_MIN_SIZE); gtk_window_set_default_size(w->win, WIDTH, HEIGHT); gtk_container_add(GTK_CONTAINER(w->scroll), GTK_WIDGET(w->web)); gtk_container_add(GTK_CONTAINER(w->win), GTK_WIDGET(w->scroll)); gtk_widget_show_all(GTK_WIDGET(w->win)); gdk_window_set_events(GWIN(w), GDK_PROPERTY_CHANGE_MASK); gdk_window_add_filter(GWIN(w), atom_propertynotify, w); event_init(w); h = SHOW_HSCROLL ? GTK_POLICY_AUTOMATIC : GTK_POLICY_NEVER; v = SHOW_VSCROLL ? GTK_POLICY_AUTOMATIC : GTK_POLICY_NEVER; gtk_scrolled_window_set_policy(w->scroll, h, v); gtk_widget_grab_focus(GTK_WIDGET(w->web)); return w; }
// this function will make sure that everything has been initialized. nsresult nsScreenManagerGtk :: EnsureInit() { if (mCachedScreenArray.Count() > 0) return NS_OK; #if GTK_CHECK_VERSION(2,2,0) mRootWindow = gdk_get_default_root_window(); #else mRootWindow = GDK_ROOT_PARENT(); #endif // GTK_CHECK_VERSION(2,2,0) g_object_ref(mRootWindow); // GDK_STRUCTURE_MASK ==> StructureNotifyMask, for ConfigureNotify // GDK_PROPERTY_CHANGE_MASK ==> PropertyChangeMask, for PropertyNotify gdk_window_set_events(mRootWindow, GdkEventMask(gdk_window_get_events(mRootWindow) | GDK_STRUCTURE_MASK | GDK_PROPERTY_CHANGE_MASK)); gdk_window_add_filter(mRootWindow, root_window_event_filter, this); #ifdef MOZ_X11 mNetWorkareaAtom = XInternAtom(GDK_WINDOW_XDISPLAY(mRootWindow), "_NET_WORKAREA", False); #endif return Init(); }
void tray_icon_added (NaTrayManager *manager, Window child, GtkWidget* container) { GdkWindow* wrapper = create_wrapper(gtk_widget_get_window(container), child); if (wrapper == NULL) return; GdkWindow* icon = get_icon_window(wrapper); g_assert(icon != NULL); gdk_window_reparent(wrapper, gtk_widget_get_window(container), 0, gdk_screen_height() - DOCK_HEIGHT); //add this mask so, gdk can handle GDK_SELECTION_CLEAR event to destroy this gdkwindow. gdk_window_set_events(icon, GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_VISIBILITY_NOTIFY_MASK); gdk_window_add_filter(icon, (GdkFilterFunc)monitor_icon_event, wrapper); gdk_window_set_composited(wrapper, TRUE); gdk_window_show(wrapper); char *re_class = NULL; get_wmclass(icon, &re_class, NULL); if (g_strcmp0(re_class, DEEPIN_TRAY_ICON) == 0) { _deepin_tray = wrapper; _deepin_tray_width = CLAMP_WIDTH(gdk_window_get_width(icon)); _update_deepin_try_position(); } else if (g_strcmp0(re_class, FCITX_TRAY_ICON) == 0) { _fcitx_tray = wrapper; _fcitx_tray_width = CLAMP_WIDTH(gdk_window_get_width(icon)); _update_fcitx_try_position(); } else { int width = gdk_window_get_width(icon) * 1.0 / gdk_window_get_height(icon) * DEFAULT_HEIGHT; gdk_window_resize(icon, width, DEFAULT_HEIGHT); g_hash_table_insert(_icons, wrapper, GINT_TO_POINTER(CLAMP_WIDTH(width))); } g_free(re_class); _update_notify_area_width(); }
static void _stage_added (ClutterStageManager *manager, ClutterStage *stage, gpointer data) { Window xid = clutter_x11_get_stage_window (stage); if (xid != None) { XSelectInput (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), xid, StructureNotifyMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask | FocusChangeMask | ExposureMask | KeyPressMask | KeyReleaseMask | EnterWindowMask | LeaveWindowMask | PropertyChangeMask); gdk_window_add_filter (NULL, gdk_to_clutter_event_pump__, GINT_TO_POINTER (xid)); } else { g_signal_connect_after (stage, "realize", G_CALLBACK (_stage_realized), NULL); } }
static void assistive_registry_start (void) { GdkWindow *root; guint tid; root = gdk_get_default_root_window (); if ( ! AT_SPI_IOR) { AT_SPI_IOR = XInternAtom (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), "AT_SPI_IOR", False); } gdk_window_set_events (root, GDK_PROPERTY_CHANGE_MASK); if ( ! assistive_registry_launch ()) { g_warning ("The accessibility registry could not be started."); return; } gdk_window_add_filter (root, filter_watch, NULL); tid = g_timeout_add_seconds (5, filter_timeout, NULL); gtk_main (); gdk_window_remove_filter (root, filter_watch, NULL); g_source_remove (tid); }
/** * shell_global_create_root_pixmap_actor: * @global: a #ShellGlobal * * Creates an actor showing the root window pixmap. * * Return value: (transfer none): a #ClutterActor with the root window pixmap. * The actor is floating, hence (transfer none). */ ClutterActor * shell_global_create_root_pixmap_actor (ShellGlobal *global) { GdkWindow *window; ClutterActor *stage; ClutterColor stage_color; /* The actor created is actually a ClutterClone of global->root_pixmap. */ if (global->root_pixmap == NULL) { global->root_pixmap = clutter_glx_texture_pixmap_new (); clutter_texture_set_repeat (CLUTTER_TEXTURE (global->root_pixmap), TRUE, TRUE); /* The low and medium quality filters give nearest-neighbor resizing. */ clutter_texture_set_filter_quality (CLUTTER_TEXTURE (global->root_pixmap), CLUTTER_TEXTURE_QUALITY_HIGH); /* Initialize to the stage color, since that's what will be seen * in the main view if there's no actual background window. */ stage = mutter_plugin_get_stage (global->plugin); clutter_stage_get_color (CLUTTER_STAGE (stage), &stage_color); clutter_texture_set_from_rgb_data (CLUTTER_TEXTURE (global->root_pixmap), /* ClutterColor has the same layout * as one pixel of RGB(A) data. */ (const guchar *)&stage_color, FALSE, /* w, h, rowstride, bpp, flags */ 1, 1, 3, 3, 0, NULL); /* We can only clone an actor within a stage, so we hide the source * texture then add it to the stage */ clutter_actor_hide (global->root_pixmap); clutter_container_add_actor (CLUTTER_CONTAINER (stage), global->root_pixmap); /* This really should never happen; but just in case... */ g_signal_connect (global->root_pixmap, "destroy", G_CALLBACK (root_pixmap_destroy), global); /* Metacity handles changes to some root window properties in its global * event filter, though not _XROOTPMAP_ID. For all root window property * changes, the global filter returns GDK_FILTER_CONTINUE, so our * window specific filter will be called after the global one. * * Because Metacity is already handling root window property updates, * we don't have to worry about adding the PropertyChange mask to the * root window to get PropertyNotify events. */ window = gdk_get_default_root_window (); gdk_window_add_filter (window, root_window_filter, global); update_root_window_pixmap (global); } return clutter_clone_new (global->root_pixmap); }
static void egg_tray_icon_update_manager_window(EggTrayIcon * icon) { Display *xdisplay; xdisplay = GDK_DISPLAY_XDISPLAY(gtk_widget_get_display(GTK_WIDGET(icon))); if (icon->manager_window != None) { GdkWindow *gdkwin; gdkwin = gdk_window_lookup_for_display(gtk_widget_get_display(GTK_WIDGET(icon)), icon->manager_window); gdk_window_remove_filter(gdkwin, egg_tray_icon_manager_filter, icon); } XGrabServer(xdisplay); icon->manager_window = XGetSelectionOwner(xdisplay, icon->selection_atom); if (icon->manager_window != None) XSelectInput(xdisplay, icon->manager_window, StructureNotifyMask); XUngrabServer(xdisplay); XFlush(xdisplay); if (icon->manager_window != None) { GdkWindow *gdkwin; gdkwin = gdk_window_lookup_for_display(gtk_widget_get_display(GTK_WIDGET(icon)), icon->manager_window); gdk_window_add_filter(gdkwin, egg_tray_icon_manager_filter, icon); /* Send a request that we'd like to dock */ egg_tray_icon_send_dock_request(icon); } }
/* Stolen from xfwm4 and modified. * FALSE on error. Call initModifiers before this. */ static gboolean grabKey(MyKey *key) { Window root; Display *dpy = GDK_DISPLAY(); static gboolean need_init = TRUE; if (need_init) { need_init = FALSE; gdk_window_add_filter(gdk_get_default_root_window(), filter_keys, NULL); } gdk_error_trap_push(); root = GDK_ROOT_WINDOW(); GRAB(key, 0); /* Here we grab all combinations of well known modifiers */ GRAB(key, ScrollLockMask); GRAB(key, NumLockMask); GRAB(key, CapsLockMask); GRAB(key, ScrollLockMask | NumLockMask); GRAB(key, ScrollLockMask | CapsLockMask); GRAB(key, CapsLockMask | NumLockMask); GRAB(key, ScrollLockMask | CapsLockMask | NumLockMask); gdk_flush(); return gdk_error_trap_pop() == Success; }
static void avatar_image_add_filter (EmpathyAvatarImage *avatar_image) { Window window; GdkWindow *gdkwindow; gint mask; mask = PropertyChangeMask; window = GDK_ROOT_WINDOW (); gdkwindow = gdk_xid_table_lookup (window); gdk_error_trap_push (); if (gdkwindow) { XWindowAttributes attrs; XGetWindowAttributes (gdk_display, window, &attrs); mask |= attrs.your_event_mask; } XSelectInput (gdk_display, window, mask); gdk_error_trap_pop (); gdk_window_add_filter (NULL, avatar_image_filter_func, avatar_image); }
void gtk_im_context_set_client_window (GtkIMContext *context, GdkWindow *window) { GtkIMContextClass *klass; g_return_if_fail (GTK_IS_IM_CONTEXT (context)); klass = GTK_IM_CONTEXT_GET_CLASS (context); if (klass->set_client_window) klass->set_client_window (context, window); //below is our interposed codes to save the context to local_context. if(!GDK_IS_WINDOW (window)) return; g_object_set_data(G_OBJECT(context),"window",window); int width = gdk_window_get_width(window); int height = gdk_window_get_height(window); if(width != 0 && height !=0) { gtk_im_context_focus_in(context); local_context = context; } //only add this event_filter when using 'fcitx' immodule. //for xim immodule, this function is as same as original from gtk2. const gchar * immodule = g_getenv("GTK_IM_MODULE"); if(immodule && !strcmp(immodule, "fcitx")) { gdk_window_add_filter (window, event_filter, context); } }
/* on_screen_changed */ static void _on_screen_changed(GtkWidget * widget, GdkScreen * previous, gpointer data) { Close * close = data; GdkWindow * window; GdkEventMask events; #ifdef DEBUG fprintf(stderr, "DEBUG: %s()\n", __func__); #endif close->screen = gtk_widget_get_screen(widget); close->display = gdk_screen_get_display(close->screen); close->root = gdk_screen_get_root_window(close->screen); close->panel = ((window = gtk_widget_get_parent_window(widget)) != NULL) ? GDK_WINDOW_XID(window) : None; events = gdk_window_get_events(close->root); gdk_window_set_events(close->root, events | GDK_PROPERTY_CHANGE_MASK); gdk_window_add_filter(close->root, _on_filter, close); close->atom_active = gdk_x11_get_xatom_by_name_for_display( close->display, "_NET_ACTIVE_WINDOW"); close->atom_close = gdk_x11_get_xatom_by_name_for_display( close->display, "_NET_CLOSE_WINDOW"); _close_do(close); }
void _gdk_x11_xsettings_init (GdkX11Screen *x11_screen) { gdk_window_add_filter (gdk_screen_get_root_window (GDK_SCREEN (x11_screen)), gdk_xsettings_root_window_filter, x11_screen); check_manager_window (x11_screen, FALSE); }
// this function will make sure that everything has been initialized. nsresult nsScreenManagerGtk :: EnsureInit() { if (mCachedScreenArray.Count() > 0) return NS_OK; mRootWindow = gdk_get_default_root_window(); if (!mRootWindow) { // Sometimes we don't initial X (e.g., xpcshell) return NS_OK; } g_object_ref(mRootWindow); // GDK_PROPERTY_CHANGE_MASK ==> PropertyChangeMask, for PropertyNotify gdk_window_set_events(mRootWindow, GdkEventMask(gdk_window_get_events(mRootWindow) | GDK_PROPERTY_CHANGE_MASK)); g_signal_connect(gdk_screen_get_default(), "monitors-changed", G_CALLBACK(monitors_changed), this); #ifdef MOZ_X11 gdk_window_add_filter(mRootWindow, root_window_event_filter, this); if (GDK_IS_X11_DISPLAY(gdk_display_get_default())) mNetWorkareaAtom = XInternAtom(GDK_WINDOW_XDISPLAY(mRootWindow), "_NET_WORKAREA", False); #endif return Init(); }
bool wxNativeContainerWindow::Create(wxNativeContainerWindowHandle win) { wxCHECK( win, false ); if ( !wxTopLevelWindow::Create(NULL, wxID_ANY, "") ) return false; // we need to realize the window first before reparenting it gtk_widget_realize(m_widget); gdk_window_reparent(gtk_widget_get_window(m_widget), win, 0, 0); #ifdef GDK_WINDOWING_X11 // if the native window is destroyed, our own window will be destroyed too // but GTK doesn't expect it and will complain about "unexpectedly // destroyed" GdkWindow, so intercept to DestroyNotify ourselves to fix // this and also destroy the associated C++ object when its window is // destroyed gdk_window_add_filter(gtk_widget_get_window(m_widget), wxNativeContainerWindowFilter, this); #endif // GDK_WINDOWING_X11 // we should be initially visible as we suppose that the native window we // wrap is (we could use gdk_window_is_visible() to test for this but this // doesn't make much sense unless we also react to visibility changes, so // just suppose it's always shown for now) Show(); return true; }
/** * Attaches the key_filter() function as a filter * to the the root window, so it will intercept window events. */ void add_filter(void) { gdk_window_add_filter( gdk_x11_window_foreign_new_for_display( gdk_display_get_default(),GDK_ROOT_WINDOW()), key_filter, NULL); }
static void x11_set_window(CoglOnscreen* onscreen, GdkWindow *window) { cogl_x11_onscreen_set_foreign_window_xid(onscreen, GDK_WINDOW_XID(window), x11_window_update_foreign_event_mask, window); gdk_window_add_filter(window, cogl_gdk_filter, onscreen); }
void csd_keyboard_xkb_init (CsdKeyboardManager * kbd_manager) { Display *display = GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()); sagarmatha_settings_profile_start (NULL); gtk_icon_theme_append_search_path (gtk_icon_theme_get_default (), DATADIR G_DIR_SEPARATOR_S "icons"); manager = kbd_manager; sagarmatha_settings_profile_start ("xkl_engine_get_instance"); xkl_engine = xkl_engine_get_instance (display); sagarmatha_settings_profile_end ("xkl_engine_get_instance"); if (xkl_engine) { inited_ok = TRUE; gkbd_desktop_config_init (¤t_config, xkl_engine); gkbd_keyboard_config_init (¤t_kbd_config, xkl_engine); xkl_engine_backup_names_prop (xkl_engine); csd_keyboard_xkb_analyze_sysconfig (); settings_desktop = g_settings_new (GKBD_DESKTOP_SCHEMA); settings_keyboard = g_settings_new (GKBD_KEYBOARD_SCHEMA); g_signal_connect (settings_desktop, "changed", (GCallback) apply_desktop_settings, NULL); g_signal_connect (settings_keyboard, "changed", (GCallback) apply_xkb_settings, NULL); gdk_window_add_filter (NULL, (GdkFilterFunc) csd_keyboard_xkb_evt_filter, NULL); if (xkl_engine_get_features (xkl_engine) & XKLF_DEVICE_DISCOVERY) g_signal_connect (xkl_engine, "X-new-device", G_CALLBACK (csd_keyboard_new_device), NULL); sagarmatha_settings_profile_start ("xkl_engine_start_listen"); xkl_engine_start_listen (xkl_engine, XKLL_MANAGE_LAYOUTS | XKLL_MANAGE_WINDOW_STATES); sagarmatha_settings_profile_end ("xkl_engine_start_listen"); sagarmatha_settings_profile_start ("apply_desktop_settings"); apply_desktop_settings (); sagarmatha_settings_profile_end ("apply_desktop_settings"); sagarmatha_settings_profile_start ("apply_xkb_settings"); apply_xkb_settings (); sagarmatha_settings_profile_end ("apply_xkb_settings"); } preview_dialogs = g_hash_table_new (g_direct_hash, g_direct_equal); sagarmatha_settings_profile_end (NULL); }
RedirectedXCompositeWindow::RedirectedXCompositeWindow(const IntSize& size, GLContextNeeded needsContext) : m_size(size) , m_window(0) , m_parentWindow(0) , m_pixmap(0) , m_needsContext(needsContext) , m_surface(0) , m_needsNewPixmapAfterResize(false) , m_damage(0) , m_damageNotifyCallback(0) , m_damageNotifyData(0) { Display* display = GDK_DISPLAY_XDISPLAY(gdk_display_get_default()); Screen* screen = DefaultScreenOfDisplay(display); // This is based on code from Chromium: src/content/common/gpu/image_transport_surface_linux.cc XSetWindowAttributes windowAttributes; windowAttributes.override_redirect = True; m_parentWindow = XCreateWindow(display, RootWindowOfScreen(screen), WidthOfScreen(screen) + 1, 0, 1, 1, 0, CopyFromParent, InputOutput, CopyFromParent, CWOverrideRedirect, &windowAttributes); XMapWindow(display, m_parentWindow); windowAttributes.event_mask = StructureNotifyMask; windowAttributes.override_redirect = False; m_window = XCreateWindow(display, m_parentWindow, 0, 0, size.width(), size.height(), 0, CopyFromParent, InputOutput, CopyFromParent, CWEventMask, &windowAttributes); XMapWindow(display, m_window); if (getWindowHashMap().isEmpty()) gdk_window_add_filter(0, reinterpret_cast<GdkFilterFunc>(filterXDamageEvent), 0); getWindowHashMap().add(m_window, this); while (1) { XEvent event; XWindowEvent(display, m_window, StructureNotifyMask, &event); if (event.type == MapNotify && event.xmap.window == m_window) break; } XSelectInput(display, m_window, NoEventMask); XCompositeRedirectWindow(display, m_window, CompositeRedirectManual); m_damage = XDamageCreate(display, m_window, XDamageReportNonEmpty); }
int init_grabber(void) { set_numlockmask(); GdkWindow *gdk_root = gdk_get_default_root_window(); Window x_root = DefaultRootWindow(main_dpy); int i; int error; gdk_window_add_filter(gdk_root, keyevent_filter, NULL); for (i = 0 ; keybinds[i].handler != NULL ; i++) { if (0 != keybinds[i].keycode) { /* now that we have a display, replace KeySym by KeyCode in conf struct */ keybinds[i].keycode = XKeysymToKeycode(main_dpy, keybinds[i].keycode); gdk_error_trap_push(); XGrabKey(main_dpy, keybinds[i].keycode, keybinds[i].mask, x_root, TRUE, GrabModeAsync, GrabModeAsync); if (0 != numlockmask) { XGrabKey(main_dpy, keybinds[i].keycode, numlockmask | keybinds[i].mask, x_root, TRUE, GrabModeAsync, GrabModeAsync); } gdk_flush (); if ((error = gdk_error_trap_pop()) != 0) { if (BadAccess == error) { fprintf(stderr, "[bonnye] Command %s : shortcut already grabbed\n", keybinds[i].name); } else { fprintf(stderr, "[bonnye] Command %s : unknown error %d\n", keybinds[i].name, error); } /* } else { */ /* printf("[bonnye] Grabbing (%d, 0x%x) for %s\n", */ /* keybinds[i].keycode, */ /* keybinds[i].mask, */ /* keybinds[i].name); */ } } } return 0; }
EggTrayIcon * egg_tray_icon_new_for_xscreen (Screen *xscreen, const char *name) { EggTrayIcon *icon; char buffer[256]; GdkWindow *root_window; g_return_val_if_fail (xscreen != NULL, NULL); icon = g_object_new (EGG_TYPE_TRAY_ICON, NULL); gtk_window_set_title (GTK_WINDOW (icon), name); #if HAVE_GTK_MULTIHEAD /* FIXME: this code does not compile, screen is undefined. Now try * getting the GdkScreen from xscreen (:. Dunno how to solve this * (there is prolly some easy way I cant think of right now) */ gtk_plug_construct_for_display (GTK_PLUG (icon), gdk_screen_get_display (screen), 0); #else gtk_plug_construct (GTK_PLUG (icon), 0); #endif gtk_widget_realize (GTK_WIDGET (icon)); /* Now see if there's a manager window around */ g_snprintf (buffer, sizeof (buffer), "_NET_SYSTEM_TRAY_S%d", XScreenNumberOfScreen (xscreen)); icon->selection_atom = XInternAtom (DisplayOfScreen (xscreen), buffer, False); icon->manager_atom = XInternAtom (DisplayOfScreen (xscreen), "MANAGER", False); icon->system_tray_opcode_atom = XInternAtom (DisplayOfScreen (xscreen), "_NET_SYSTEM_TRAY_OPCODE", False); egg_tray_icon_update_manager_window (icon); #if HAVE_GTK_MULTIHEAD root_window = gdk_screen_get_root_window (gtk_widget_get_screen (screen)); #else root_window = gdk_window_lookup (gdk_x11_get_default_root_xwindow ()); #endif /* Add a root window filter so that we get changes on MANAGER */ gdk_window_add_filter (root_window, egg_tray_icon_manager_filter, icon); return icon; }
static void egg_tray_icon_realize (GtkWidget *widget) { EggTrayIcon *icon = EGG_TRAY_ICON (widget); gint screen; Display *xdisplay; char buffer[256]; GdkWindow *root_window; if (GTK_WIDGET_CLASS (parent_class)->realize) GTK_WIDGET_CLASS (parent_class)->realize (widget); make_transparent (widget, NULL); xdisplay = egg_tray_icon_get_x_display(icon); if (xdisplay == NULL) return; #if GTK_CHECK_VERSION(2,1,0) screen = gdk_screen_get_number (gtk_widget_get_screen (widget)); #else screen = XScreenNumberOfScreen (DefaultScreenOfDisplay (gdk_display)); #endif /* Now see if there's a manager window around */ g_snprintf (buffer, sizeof (buffer), "_NET_SYSTEM_TRAY_S%d", screen); icon->selection_atom = XInternAtom (xdisplay, buffer, False); icon->manager_atom = XInternAtom (xdisplay, "MANAGER", False); icon->system_tray_opcode_atom = XInternAtom (xdisplay, "_NET_SYSTEM_TRAY_OPCODE", False); icon->orientation_atom = XInternAtom (xdisplay, "_NET_SYSTEM_TRAY_ORIENTATION", False); egg_tray_icon_update_manager_window (icon, FALSE); egg_tray_icon_send_dock_request (icon); #if GTK_CHECK_VERSION(2,1,0) root_window = gdk_screen_get_root_window (gtk_widget_get_screen (widget)); #else root_window = gdk_window_lookup (gdk_x11_get_default_root_xwindow ()); #endif /* Add a root window filter so that we get changes on MANAGER */ gdk_window_add_filter (root_window, egg_tray_icon_manager_filter, icon); }
static int pager_constructor(plugin_instance *plug) { pager_priv *pg; ENTER; pg = (pager_priv *) plug; #ifdef EXTRA_DEBUG cp = pg; signal(SIGUSR2, sig_usr); #endif pg->htable = g_hash_table_new (g_int_hash, g_int_equal); pg->box = plug->panel->my_box_new(TRUE, 1); gtk_container_set_border_width (GTK_CONTAINER (pg->box), 0); gtk_widget_show(pg->box); gtk_bgbox_set_background(plug->pwid, BG_STYLE, 0, 0); gtk_container_set_border_width (GTK_CONTAINER (plug->pwid), BORDER); gtk_container_add(GTK_CONTAINER(plug->pwid), pg->box); pg->ratio = (gfloat)gdk_screen_width() / (gfloat)gdk_screen_height(); if (plug->panel->orientation == GTK_ORIENTATION_HORIZONTAL) { pg->dah = plug->panel->ah - 2 * BORDER; pg->daw = (gfloat) pg->dah * pg->ratio; } else { pg->daw = plug->panel->aw - 2 * BORDER; pg->dah = (gfloat) pg->daw / pg->ratio; } pg->wallpaper = 1; //pg->scaley = (gfloat)pg->dh / (gfloat)gdk_screen_height(); //pg->scalex = (gfloat)pg->dw / (gfloat)gdk_screen_width(); XCG(plug->xc, "showwallpaper", &pg->wallpaper, enum, bool_enum); if (pg->wallpaper) { pg->fbbg = fb_bg_get_for_display(); DBG("get fbbg %p\n", pg->fbbg); g_signal_connect(G_OBJECT(pg->fbbg), "changed", G_CALLBACK(pager_bg_changed), pg); } pager_rebuild_all(fbev, pg); gdk_window_add_filter(NULL, (GdkFilterFunc)pager_event_filter, pg ); g_signal_connect (G_OBJECT (fbev), "current_desktop", G_CALLBACK (do_net_current_desktop), (gpointer) pg); g_signal_connect (G_OBJECT (fbev), "active_window", G_CALLBACK (do_net_active_window), (gpointer) pg); g_signal_connect (G_OBJECT (fbev), "number_of_desktops", G_CALLBACK (pager_rebuild_all), (gpointer) pg); g_signal_connect (G_OBJECT (fbev), "client_list_stacking", G_CALLBACK (do_net_client_list_stacking), (gpointer) pg); RET(1); }
static void sugar_key_grabber_init(SugarKeyGrabber *grabber) { GdkScreen *screen; screen = gdk_screen_get_default(); grabber->root = gdk_screen_get_root_window(screen); grabber->keys = NULL; gdk_window_add_filter(grabber->root, filter_events, grabber); }
static void icons_build_gui(plugin *p) { icons *ics = (icons *)p->priv; ENTER; g_signal_connect (G_OBJECT (fbev), "client_list", G_CALLBACK (do_net_client_list), (gpointer) ics); gdk_window_add_filter(NULL, (GdkFilterFunc)ics_event_filter, ics ); RET(); }