Example #1
0
void
_gdk_x11_screen_set_window_scale (GdkX11Screen *x11_screen,
				  gint          scale)
{
  GList *toplevels, *l;
  GdkWindow *root;

  if (x11_screen->window_scale == scale)
    return;

  x11_screen->window_scale = scale;

  root = x11_screen->root_window;
  GDK_WINDOW_IMPL_X11 (root->impl)->window_scale = scale;

  toplevels = gdk_screen_get_toplevel_windows (GDK_SCREEN (x11_screen));

  for (l = toplevels; l != NULL; l = l->next)
    {
      GdkWindow *window = l->data;

      _gdk_x11_window_set_window_scale (window, scale);
    }

  g_signal_emit_by_name (GDK_SCREEN (x11_screen), "monitors-changed");
}
Example #2
0
void
_gdk_x11_screen_set_window_scale (GdkX11Screen *x11_screen,
				  gint          scale)
{
  GdkX11Display *x11_display = GDK_X11_DISPLAY (x11_screen->display);
  GList *toplevels, *l;
  GdkWindow *root;
  int i;

  if (x11_screen->window_scale == scale)
    return;

  x11_screen->window_scale = scale;

  root = x11_screen->root_window;
  GDK_WINDOW_IMPL_X11 (root->impl)->window_scale = scale;

  toplevels = gdk_screen_get_toplevel_windows (GDK_SCREEN (x11_screen));

  for (l = toplevels; l != NULL; l = l->next)
    {
      GdkWindow *window = l->data;

      _gdk_x11_window_set_window_scale (window, scale);
    }

  for (i = 0; i < x11_display->monitors->len; i++)
    {
      GdkMonitor *monitor = GDK_MONITOR (x11_display->monitors->pdata[i]);

      gdk_monitor_set_scale_factor (monitor, scale);
    }

  g_signal_emit_by_name (GDK_SCREEN (x11_screen), "monitors-changed");
}
Example #3
0
static void
gdk_x11_screen_dispose (GObject *object)
{
  GdkX11Screen *x11_screen = GDK_X11_SCREEN (object);
  int i;

  for (i = 0; i < 32; ++i)
    {
      if (x11_screen->subwindow_gcs[i])
        {
          XFreeGC (x11_screen->xdisplay, x11_screen->subwindow_gcs[i]);
          x11_screen->subwindow_gcs[i] = 0;
        }
    }

  _gdk_x11_screen_events_uninit (GDK_SCREEN (object));

  if (x11_screen->root_window)
    _gdk_window_destroy (x11_screen->root_window, TRUE);

  G_OBJECT_CLASS (gdk_x11_screen_parent_class)->dispose (object);

  x11_screen->xdisplay = NULL;
  x11_screen->xscreen = NULL;
  x11_screen->screen_num = -1;
  x11_screen->xroot_window = None;
  x11_screen->wmspec_check_window = None;
}
Example #4
0
static void
drive_poll_for_media_cb (GObject      *source_object,
			 GAsyncResult *res,
			 gpointer      user_data)
{
	GdkScreen *screen;
	GError    *error;
	char      *primary;
	char      *name;

	error = NULL;
	if (!g_drive_poll_for_media_finish (G_DRIVE (source_object),
					    res, &error)) {
		if (error->code != G_IO_ERROR_FAILED_HANDLED) {
			screen = GDK_SCREEN (user_data);

			name = g_drive_get_name (G_DRIVE (source_object));
			primary = g_strdup_printf (_("Unable to scan %s for media changes"),
						   name);
			g_free (name);
			panel_error_dialog (NULL, screen,
					    "cannot_scan_drive", TRUE,
					    primary, error->message);
			g_free (primary);
		}
		g_error_free (error);
	}

	//FIXME: should we mount the volume and activate the root of the new
	//mount?
}
Example #5
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);
}
Example #6
0
static VALUE
rg_find_window(int argc, VALUE *argv, VALUE self)
{
    VALUE drag_window, x_root, y_root;
    GdkWindow *dest_window;
    GdkDragProtocol prot;

    if (argc == 3) {
        rb_scan_args(argc, argv, "30", &drag_window, &x_root, &y_root);
        gdk_drag_find_window(_SELF(self),
                             GDK_WINDOW(RVAL2GOBJ(drag_window)), 
                             NUM2INT(x_root), NUM2INT(y_root),
                             &dest_window, &prot);
    } else {
        VALUE screen;
        rb_scan_args(argc, argv, "40", &drag_window, &screen, &x_root, &y_root);
        gdk_drag_find_window_for_screen(_SELF(self),
                                        GDK_WINDOW(RVAL2GOBJ(drag_window)), 
                                        GDK_SCREEN(RVAL2GOBJ(screen)),
                                        NUM2INT(x_root), NUM2INT(y_root),
                                        &dest_window, &prot);
    }

    return rb_ary_new3(2, GOBJ2RVAL(dest_window), 
                       GENUM2RVAL(prot, GDK_TYPE_DRAG_PROTOCOL));
}
Example #7
0
int
clip_GTK_INVISIBLENEWFORSCREEN(ClipMachine * ClipMachineMemory)
{
   ClipVar  *cv = _clip_spar(ClipMachineMemory, 1);

   C_object *cscreen = _fetch_cobject(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2));

   C_widget *cwid = NULL;

   GtkWidget *wid;

   CHECKOPT(1, MAP_type_of_ClipVarType);
   CHECKCOBJ(cscreen, GDK_IS_SCREEN(cscreen->object));

   wid = gtk_invisible_new_for_screen(GDK_SCREEN(cscreen->object));
   if (!wid)
      goto err;

   cwid = _register_widget(ClipMachineMemory, wid, cv);
   _clip_mclone(ClipMachineMemory, RETPTR(ClipMachineMemory), &cwid->obj);

   return 0;
 err:
   return 1;
}
Example #8
0
static void
gtk_timeline_set_property (GObject      *object,
                           guint         prop_id,
                           const GValue *value,
                           GParamSpec   *pspec)
{
  GtkTimeline *timeline;

  timeline = GTK_TIMELINE (object);

  switch (prop_id)
    {
    case PROP_FPS:
      _gtk_timeline_set_fps (timeline, g_value_get_uint (value));
      break;
    case PROP_DURATION:
      _gtk_timeline_set_duration (timeline, g_value_get_uint (value));
      break;
    case PROP_LOOP:
      _gtk_timeline_set_loop (timeline, g_value_get_boolean (value));
      break;
    case PROP_DIRECTION:
      _gtk_timeline_set_direction (timeline, g_value_get_enum (value));
      break;
    case PROP_SCREEN:
      _gtk_timeline_set_screen (timeline,
                                GDK_SCREEN (g_value_get_object (value)));
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
    }
}
Example #9
0
static void
gdk_screen_finalize (GObject *object)
{
  GdkScreen *screen = GDK_SCREEN (object);

  if (screen->font_options)
      cairo_font_options_destroy (screen->font_options);

  G_OBJECT_CLASS (gdk_screen_parent_class)->finalize (object);
}
Example #10
0
static int lglext_config_new_by_mode_for_screen(lua_State* L)
{
	luaL_checktype(L, 1, LUA_TUSERDATA);
	luaL_checktype(L, 2, LUA_TNUMBER);
	Object* obj = lua_touserdata(L, 1);

	GdkGLConfig* ptr = gdk_gl_config_new_by_mode_for_screen(
		GDK_SCREEN(obj->pointer), lua_tointeger(L, 2));
	object_new(L, ptr, TRUE);

	return 1;
}
static VALUE
rg_s_get_default(int argc, VALUE *argv, G_GNUC_UNUSED VALUE self)
{
    VALUE screen;
    GdkScreen* gscreen;

    rb_scan_args(argc, argv, "01", &screen);

    if (NIL_P(screen)){
        gscreen = gdk_screen_get_default();
    } else {
        gscreen = GDK_SCREEN(RVAL2GOBJ(screen));
    }
    return GOBJ2RVAL(gdk_pango_renderer_get_default(gscreen));
}
Example #12
0
static void
gdk_gix_screen_finalize (GObject *object)
{
  GdkScreenGix *screen_gix = GDK_SCREEN_GIX (object);

  if (screen_gix->root_window)
    g_object_unref (screen_gix->root_window);

  /* Visual Part */
  g_object_unref (system_visual);
  
  deinit_multihead (GDK_SCREEN (object));

  G_OBJECT_CLASS (_gdk_screen_gix_parent_class)->finalize (object);
}
Example #13
0
int
clip_GTK_ICONTHEMESETSCREEN(ClipMachine * cm)
{
        C_object *cicon   = _fetch_co_arg(cm);
        C_object *cscreen = _fetch_cobject(cm, _clip_spar(cm, 2));

	CHECKCOBJ(cicon, GTK_IS_ICON_THEME(cicon->object));
	CHECKCOBJ(cscreen, GDK_IS_SCREEN(cscreen->object));

	gtk_icon_theme_set_screen(GTK_ICON_THEME(cicon->object),
		GDK_SCREEN(cscreen->object));

	return 0;
err:
	return 1;
}
Example #14
0
int
clip_GTK_INVISIBLESETSCREEN(ClipMachine * ClipMachineMemory)
{
   C_widget *cinvis = _fetch_cw_arg(ClipMachineMemory);

   C_object *cscreen = _fetch_cobject(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2));

   CHECKCWID(cinvis, GTK_IS_INVISIBLE);
   CHECKCOBJ(cscreen, GDK_IS_SCREEN(cscreen->object));

   gtk_invisible_set_screen(GTK_INVISIBLE(cinvis->widget), GDK_SCREEN(cscreen->object));

   return 0;
 err:
   return 1;
}
Example #15
0
/**
 * thunar_util_parse_parent:
 * @parent        : a #GtkWidget, a #GdkScreen or %NULL.
 * @window_return : return location for the toplevel #GtkWindow or
 *                  %NULL.
 *
 * Determines the screen for the @parent and returns that #GdkScreen.
 * If @window_return is not %NULL, the pointer to the #GtkWindow is
 * placed into it, or %NULL if the window could not be determined.
 *
 * Return value: the #GdkScreen for the @parent.
 **/
GdkScreen*
thunar_util_parse_parent (gpointer    parent,
                          GtkWindow **window_return)
{
  GdkScreen *screen;
  GtkWidget *window = NULL;

  _thunar_return_val_if_fail (parent == NULL || GDK_IS_SCREEN (parent) || GTK_IS_WIDGET (parent), NULL);

  /* determine the proper parent */
  if (parent == NULL)
    {
      /* just use the default screen then */
      screen = gdk_screen_get_default ();
    }
  else if (GDK_IS_SCREEN (parent))
    {
      /* yep, that's a screen */
      screen = GDK_SCREEN (parent);
    }
  else
    {
      /* parent is a widget, so let's determine the toplevel window */
      window = gtk_widget_get_toplevel (GTK_WIDGET (parent));
      if (window != NULL
          && gtk_widget_is_toplevel (window))
        {
          /* make sure the toplevel window is shown */
          gtk_widget_show_now (window);
        }
      else
        {
          /* no toplevel, not usable then */
          window = NULL;
        }

      /* determine the screen for the widget */
      screen = gtk_widget_get_screen (GTK_WIDGET (parent));
    }

  /* check if we should return the window */
  if (G_LIKELY (window_return != NULL))
    *window_return = (GtkWindow *) window;

  return screen;
}
Example #16
0
static VALUE
gdkpango_s_context_get(int argc, VALUE *argv, VALUE self)
{
    VALUE screen, ret;
    rb_scan_args(argc, argv, "01", &screen);
    if (NIL_P(screen)){
        ret = GOBJ2RVAL(gdk_pango_context_get());
    } else {
#if GTK_CHECK_VERSION(2,2,0)
        ret = GOBJ2RVAL(gdk_pango_context_get_for_screen(GDK_SCREEN(RVAL2GOBJ(screen))));
#else
        rb_warn("Gdk::Pango.context_get: Not supported arguments in GTK+-2.0.x.");
        ret = GOBJ2RVAL(gdk_pango_context_get());
#endif
    }
    return ret;
}
Example #17
0
void
_gdk_x11_xsettings_finish (GdkX11Screen *x11_screen)
{
  gdk_window_remove_filter (gdk_screen_get_root_window (GDK_SCREEN (x11_screen)), gdk_xsettings_root_window_filter, x11_screen);
  if (x11_screen->xsettings_manager_window)
    {
      gdk_window_remove_filter (x11_screen->xsettings_manager_window, gdk_xsettings_manager_window_filter, x11_screen);
      g_object_unref (x11_screen->xsettings_manager_window);
      x11_screen->xsettings_manager_window = NULL;
    }
  
  if (x11_screen->xsettings)
    {
      g_hash_table_unref (x11_screen->xsettings);
      x11_screen->xsettings = NULL;
    }
}
Example #18
0
static void
gdk_xsettings_notify (GdkX11Screen     *x11_screen,
                      const char       *name,
		      GdkSettingAction  action)
{
  GdkEvent new_event;

  if (!g_str_has_prefix (name, "gtk-"))
    return;

  new_event.type = GDK_SETTING;
  new_event.setting.window = gdk_screen_get_root_window (GDK_SCREEN (x11_screen));
  new_event.setting.send_event = FALSE;
  new_event.setting.action = action;
  new_event.setting.name = (char*) name;

  gdk_event_put (&new_event);
}
static VALUE
rg_initialize(int argc, VALUE *argv, VALUE self)
{
    VALUE screen;
    GdkScreen* gscreen;

    rb_scan_args(argc, argv, "01", &screen);

    if (NIL_P(screen)){
        gscreen = gdk_screen_get_default();
    } else {
        gscreen = GDK_SCREEN(RVAL2GOBJ(screen));
    }

    G_INITIALIZE(self, gdk_pango_renderer_new(gscreen));

    return Qnil;
}
Example #20
0
static VALUE
rg_initialize(int argc, VALUE *argv, VALUE self)
{
    VALUE screen;

    rb_scan_args(argc, argv, "01", &screen);

    if (argc == 0){
        RBGTK_INITIALIZE(self, gtk_invisible_new());
    } else {
#if GTK_CHECK_VERSION(2,2,0)
        RBGTK_INITIALIZE(self, gtk_invisible_new_for_screen(
                             GDK_SCREEN(RVAL2GOBJ(screen))));
#else
        rb_raise(rb_eArgError, "GTK+-2.2 feature. GTK+-2.0.x doesn't support this.");
#endif
    }
    return Qnil;
}
Example #21
0
static void
gdk_screen_set_property (GObject      *object,
			 guint         prop_id,
			 const GValue *value,
			 GParamSpec   *pspec)
{
  GdkScreen *screen = GDK_SCREEN (object);

  switch (prop_id)
    {
    case PROP_FONT_OPTIONS:
      gdk_screen_set_font_options (screen, g_value_get_pointer (value));
      break;
    case PROP_RESOLUTION:
      gdk_screen_set_resolution (screen, g_value_get_double (value));
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
    }
}
Example #22
0
static void
gdk_x11_screen_finalize (GObject *object)
{
  GdkX11Screen *x11_screen = GDK_X11_SCREEN (object);
  gint          i;

  if (x11_screen->root_window)
    g_object_unref (x11_screen->root_window);

  /* Visual Part */
  for (i = 0; i < x11_screen->nvisuals; i++)
    g_object_unref (x11_screen->visuals[i]);
  g_free (x11_screen->visuals);
  g_hash_table_destroy (x11_screen->visual_hash);

  g_free (x11_screen->window_manager_name);

  deinit_multihead (GDK_SCREEN (object));
  
  G_OBJECT_CLASS (gdk_x11_screen_parent_class)->finalize (object);
}
Example #23
0
int
clip_GTK_ICONTHEMEGETFORSCREEN(ClipMachine * cm)
{
        C_object *cscreen = _fetch_co_arg(cm);
        C_object *cicon;
        GtkIconTheme *icon;

	CHECKCOBJ(cscreen, GDK_IS_SCREEN(cscreen->object));

	icon = gtk_icon_theme_get_for_screen(GDK_SCREEN(cscreen->object));

	if (icon)
	{
		cicon = _list_get_cobject(cm,icon);
		if (!cicon) cicon = _register_object(cm,icon,GTK_TYPE_ICON_THEME,NULL,NULL);
		if (cicon) _clip_mclone(cm,RETPTR(cm),&cicon->obj);
	}

	return 0;
err:
	return 1;
}
Example #24
0
static void
gdk_screen_dispose (GObject *object)
{
  GdkScreen *screen = GDK_SCREEN (object);
  gint i;

  for (i = 0; i < 32; ++i)
    {
      if (screen->exposure_gcs[i])
        {
          g_object_unref (screen->exposure_gcs[i]);
          screen->exposure_gcs[i] = NULL;
        }

      if (screen->normal_gcs[i])
        {
          g_object_unref (screen->normal_gcs[i]);
          screen->normal_gcs[i] = NULL;
        }
    }

  G_OBJECT_CLASS (gdk_screen_parent_class)->dispose (object);
}
Example #25
0
static VALUE
rg_set_screen(VALUE self, VALUE screen)
{
    gtk_recent_manager_set_screen(_SELF(self), GDK_SCREEN(RVAL2GOBJ(screen)));
    return self;
}
Example #26
0
static VALUE
rg_s_get_for_screen(G_GNUC_UNUSED VALUE self, VALUE screen)
{
    return GOBJ2RVAL(gtk_recent_manager_get_for_screen(GDK_SCREEN(RVAL2GOBJ(screen))));
}
Example #27
0
static VALUE
it_set_screen(VALUE self, VALUE screen)
{
    gtk_icon_theme_set_screen(_SELF(self), GDK_SCREEN(RVAL2GOBJ(screen)));
    return self;
}
Example #28
0
static VALUE
it_get_for_screen(VALUE self, VALUE screen)
{
    return GOBJ2RVAL(gtk_icon_theme_get_for_screen(GDK_SCREEN(RVAL2GOBJ(screen))));
}
Example #29
0
static void
fetch_net_wm_check_window (GdkScreen *screen)
{
  GdkX11Screen *x11_screen;
  GdkDisplay *display;
  Atom type;
  gint format;
  gulong n_items;
  gulong bytes_after;
  guchar *data;
  Window *xwindow;
  GTimeVal tv;
  gint error;

  x11_screen = GDK_X11_SCREEN (screen);
  display = x11_screen->display;

  g_return_if_fail (GDK_X11_DISPLAY (display)->trusted_client);
  
  g_get_current_time (&tv);

  if (ABS  (tv.tv_sec - x11_screen->last_wmspec_check_time) < 15)
    return; /* we've checked recently */

  x11_screen->last_wmspec_check_time = tv.tv_sec;

  data = NULL;
  XGetWindowProperty (x11_screen->xdisplay, x11_screen->xroot_window,
		      gdk_x11_get_xatom_by_name_for_display (display, "_NET_SUPPORTING_WM_CHECK"),
		      0, G_MAXLONG, False, XA_WINDOW, &type, &format,
		      &n_items, &bytes_after, &data);
  
  if (type != XA_WINDOW)
    {
      if (data)
        XFree (data);
      return;
    }

  xwindow = (Window *)data;

  if (x11_screen->wmspec_check_window == *xwindow)
    {
      XFree (xwindow);
      return;
    }

  gdk_x11_display_error_trap_push (display);

  /* Find out if this WM goes away, so we can reset everything. */
  XSelectInput (x11_screen->xdisplay, *xwindow, StructureNotifyMask);

  error = gdk_x11_display_error_trap_pop (display);
  if (!error)
    {
      x11_screen->wmspec_check_window = *xwindow;
      x11_screen->need_refetch_net_supported = TRUE;
      x11_screen->need_refetch_wm_name = TRUE;

      /* Careful, reentrancy */
      _gdk_x11_screen_window_manager_changed (GDK_SCREEN (x11_screen));
    }
  else if (error == BadWindow)
    {
      /* Leftover property, try again immediately, new wm may be starting up */
      x11_screen->last_wmspec_check_time = 0;
    }

  XFree (xwindow);
}
Example #30
0
static VALUE
rg_set_screen(VALUE self, VALUE screen)
{
    gtk_menu_set_screen(_SELF(self), GDK_SCREEN(RVAL2GOBJ(screen)));
    return self;
}