Ejemplo n.º 1
0
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;
	}
}
Ejemplo n.º 2
0
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);
}
Ejemplo n.º 3
0
Archivo: fbxkb.c Proyecto: kba/fbxkb
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();
}
Ejemplo n.º 4
0
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 ();
}
Ejemplo n.º 6
0
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 ();
}
Ejemplo n.º 7
0
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;
}
Ejemplo n.º 8
0
// 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();
}
Ejemplo n.º 9
0
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();
}
Ejemplo n.º 10
0
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);
    }
}
Ejemplo n.º 11
0
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);
}
Ejemplo n.º 12
0
/**
 * 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);
}
Ejemplo n.º 13
0
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);
	}
}
Ejemplo n.º 14
0
/* 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;
}
Ejemplo n.º 15
0
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);
}
Ejemplo n.º 16
0
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);
    }
}
Ejemplo n.º 17
0
/* 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);
}
Ejemplo n.º 18
0
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);
}
Ejemplo n.º 19
0
// 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();
}
Ejemplo n.º 20
0
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;
}
Ejemplo n.º 21
0
/**
 * 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);
}
Ejemplo n.º 22
0
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 (&current_config, xkl_engine);
		gkbd_keyboard_config_init (&current_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);
}
Ejemplo n.º 25
0
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;
}
Ejemplo n.º 26
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;
}
Ejemplo n.º 27
0
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);
}
Ejemplo n.º 28
0
Archivo: pager.c Proyecto: g7/fbpanel
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);
}
Ejemplo n.º 29
0
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);
}
Ejemplo n.º 30
0
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();
}