Пример #1
0
void Ctrl::GetWorkArea(Array<Rect>& rc)
{
	GuiLock __;
	GdkScreen *s = gdk_screen_get_default();
	int n = gdk_screen_get_n_monitors(s);
	rc.Clear();
	Vector<int> netwa;
	for(int i = 0; i < n; i++) {
		GdkRectangle rr;
		Rect r;
#if GTK_CHECK_VERSION (3, 3, 5) // U++ does not work with gtk3 yet, but be prepared
		gdk_screen_get_monitor_workarea(s, i, &rr);
		r = RectC(r.x, r.y, r.width, r.height);
#else
		gdk_screen_get_monitor_geometry (s, i, &rr);
		r = RectC(rr.x, rr.y, rr.width, rr.height);
	#ifdef GDK_WINDOWING_X11
		if(i == 0)
			netwa = GetPropertyInts(gdk_screen_get_root_window(gdk_screen_get_default()),
			                        "_NET_WORKAREA");
		if(netwa.GetCount())
			r = r & RectC(netwa[0], netwa[1], netwa[2], netwa[3]);
	#endif
#endif
		rc.Add(r);
	}
}
Пример #2
0
static void
gs_manager_create_windows_for_screen (GSManager *manager,
                                      GdkScreen *screen)
{
        int       n_monitors;
        int       i;

        g_return_if_fail (manager != NULL);
        g_return_if_fail (GS_IS_MANAGER (manager));
        g_return_if_fail (GDK_IS_SCREEN (screen));

        g_object_ref (manager);
        g_object_ref (screen);

        n_monitors = gdk_screen_get_n_monitors (screen);

        gs_debug ("Creating %d windows for screen %d", n_monitors, gdk_screen_get_number (screen));

        for (i = 0; i < n_monitors; i++) {
                gs_manager_create_window_for_monitor (manager, screen, i);
        }

        g_object_unref (screen);
        g_object_unref (manager);
}
Пример #3
0
void UScreen::Refresh()
{
  LOG_DEBUG(logger) << "Screen geometry changed";

  nux::Geometry last_geo;
  monitors_.clear();
  primary_ = gdk_screen_get_primary_monitor(screen_);
  int monitors = gdk_screen_get_n_monitors(screen_);

  for (int i = 0; i < monitors; ++i)
  {
    GdkRectangle rect = { 0 };
    gdk_screen_get_monitor_geometry(screen_, i, &rect);

    float scale = gdk_screen_get_monitor_scale_factor(screen_, i);
    nux::Geometry geo(rect.x*scale, rect.y*scale, rect.width*scale, rect.height*scale);

    // Check for mirrored displays
    if (geo == last_geo)
      continue;

    last_geo = geo;
    monitors_.push_back(geo);

    LOG_DEBUG(logger) << "Monitor " << i << " has geometry " << geo.x << "x"
                      << geo.y << "x" << geo.width << "x" << geo.height;
  }

  changed.emit(primary_, monitors_);
}
Пример #4
0
static void
toggle_fullscreen (GtkWidget *item, PlayerAV *self)
{
    GdkRectangle rect;
    GdkScreen *screen = gdk_screen_get_default ();
    gint num = gdk_screen_get_n_monitors (screen);

    if (self->priv->monitor >= num) {
        self->priv->monitor = num-1;
    }

    if (!self->priv->fullscreen) {
        gdk_screen_get_monitor_geometry (screen, self->priv->monitor, &rect);

        gtk_widget_show_all (self->priv->fs_win);
        self->priv->fullscreen = TRUE;
        gtk_window_fullscreen (GTK_WINDOW (self->priv->fs_win));
        gtk_window_move (GTK_WINDOW (self->priv->fs_win), rect.x, rect.y);
    } else {
        gtk_widget_hide (self->priv->fs_win);
        self->priv->fullscreen = FALSE;
    }

    player_av_set_video_destination (PLAYER (self), NULL);
}
//borrowed from gtk
static gint get_monitor_at_window(MetaWindow* window)
{
    gint num_monitors, i, area = 0, screen_num = -1;
    GdkRectangle win_rect;

    GdkScreen* screen = gdk_screen_get_default();

    meta_window_get_outer_rect(window, (MetaRectangle*)&win_rect);
    num_monitors = gdk_screen_get_n_monitors (screen);

    for (i=0; i<num_monitors; i++) {
        GdkRectangle tmp_monitor, intersect;

        gdk_screen_get_monitor_geometry (screen, i, &tmp_monitor);
        gdk_rectangle_intersect (&win_rect, &tmp_monitor, &intersect);

        if (intersect.width * intersect.height > area) { 
            area = intersect.width * intersect.height;
            screen_num = i;
        }
    }
    if (screen_num >= 0)
        return screen_num;
    else
        return get_nearest_monitor (screen,
                win_rect.x + win_rect.width / 2,
                win_rect.y + win_rect.height / 2);
}
Пример #6
0
void MultiMon_Construct()
{
  // detect multiple monitors

  GdkScreen* screen = gdk_display_get_default_screen(gdk_display_get_default());
  gint m = gdk_screen_get_n_monitors(screen);
  globalOutputStream() << "default screen has " << m << " monitors\n";
  for(int j = 0; j != m; ++j)
  {
    GdkRectangle geom;
    gdk_screen_get_monitor_geometry(screen, j, &geom);
    globalOutputStream() << "monitor " << j << " geometry: " << geom.x << ", " << geom.y << ", " << geom.width << ", " << geom.height << "\n";
    if(j == 0)
    {
      // I am making the assumption that monitor 0 is always the primary monitor on win32. Tested on WinXP with gtk+-2.4.
      primaryMonitor = geom;
    }
  }

  if(m > 1)
  {
    g_multimon_globals.m_bStartOnPrimMon = true;
  }

  GlobalPreferenceSystem().registerPreference("StartOnPrimMon", BoolImportStringCaller(g_multimon_globals.m_bStartOnPrimMon), BoolExportStringCaller(g_multimon_globals.m_bStartOnPrimMon));
  GlobalPreferenceSystem().registerPreference("NoSysMenuPopups", BoolImportStringCaller(g_Multimon_enableSysMenuPopups.m_latched), BoolExportStringCaller(g_Multimon_enableSysMenuPopups.m_latched));

  g_Multimon_enableSysMenuPopups.useLatched();

  PreferencesDialog_addInterfacePreferences(FreeCaller1<PreferencesPage&, MultiMonitor_constructPreferences>());
}
Пример #7
0
/* Set monitor index this object belongs to and to monitor */
static void _xfdashboard_window_tracker_monitor_set_index(XfdashboardWindowTrackerMonitor *self, gint inIndex)
{
	XfdashboardWindowTrackerMonitorPrivate		*priv;

	g_return_if_fail(XFDASHBOARD_IS_WINDOW_TRACKER_MONITOR(self));
	g_return_if_fail(inIndex>=0);
	g_return_if_fail(inIndex<gdk_screen_get_n_monitors(self->priv->screen));

	priv=self->priv;

	/* Freeze notification */
	g_object_freeze_notify(G_OBJECT(self));

	/* Set value if changed */
	if(priv->monitorIndex!=inIndex)
	{
		/* Set value */
		priv->monitorIndex=inIndex;

		/* Update primary monitor flag */
		_xfdashboard_window_tracker_monitor_update_primary(self);

		/* Update geometry of monitor */
		_xfdashboard_window_tracker_monitor_update_geometry(self);
	}

	/* Thaw notification */
	g_object_thaw_notify(G_OBJECT(self));
}
Пример #8
0
/**
 * shell_global_get_primary_monitor:
 * @global: the #ShellGlobal
 *
 * Gets the bounding box of the primary monitor (the one that the
 * panel is on).
 *
 * Return value: the bounding box of the primary monitor
 */
GdkRectangle *
shell_global_get_primary_monitor (ShellGlobal  *global)
{
  GdkScreen *screen = gdk_screen_get_default ();
  GdkRectangle rect;
  gint i, primary = 0;
  gchar *output_name = NULL;
  gint num_monitors = gdk_screen_get_n_monitors (screen);

  for (i = 0; i < num_monitors; i++)
    {
      /* Prefer the laptop's internal screen if present */
      output_name = gdk_screen_get_monitor_plug_name (screen, i);
      if (output_name)
        {
          gboolean is_lvds = g_ascii_strncasecmp (output_name, "LVDS", 4) == 0;
          g_free (output_name);
          if (is_lvds)
            {
              primary = i;
              break;
            }
        }
    }

  gdk_screen_get_monitor_geometry (screen, primary, &rect);

  return g_boxed_copy (GDK_TYPE_RECTANGLE, &rect);
}
Пример #9
0
/**
 * gdk_screen_get_monitor_at_point:
 * @screen: a #GdkScreen.
 * @x: the x coordinate in the virtual screen.
 * @y: the y coordinate in the virtual screen.
 *
 * Returns the monitor number in which the point (@x,@y) is located.
 *
 * Returns: the monitor number in which the point (@x,@y) lies, or
 *   a monitor close to (@x,@y) if the point is not in any monitor.
 *
 * Since: 2.2
 **/
gint 
gdk_screen_get_monitor_at_point (GdkScreen *screen,
				 gint       x,
				 gint       y)
{
  gint num_monitors, i;
  
  g_return_val_if_fail (GDK_IS_SCREEN (screen), -1);

  num_monitors = gdk_screen_get_n_monitors (screen);
  
  for (i=0;i<num_monitors;i++)
    {
      GdkRectangle monitor;
      
      gdk_screen_get_monitor_geometry (screen, i, &monitor);

      if (x >= monitor.x &&
          x < monitor.x + monitor.width &&
          y >= monitor.y &&
          y < (monitor.y + monitor.height))
        return i;
    }

  return get_nearest_monitor (screen, x, y);
}
Пример #10
0
/* Update monitor geometry */
static void _xfdashboard_window_tracker_monitor_update_geometry(XfdashboardWindowTrackerMonitor *self)
{
	XfdashboardWindowTrackerMonitorPrivate		*priv;
	GdkRectangle								geometry;

	g_return_if_fail(XFDASHBOARD_IS_WINDOW_TRACKER_MONITOR(self));

	priv=self->priv;

	/* Check if monitor is valid */
	if(priv->monitorIndex>=gdk_screen_get_n_monitors(priv->screen)) return;

	/* Get monitor geometry */
	gdk_screen_get_monitor_geometry(priv->screen, priv->monitorIndex, &geometry);

	/* Set value if changed */
	if(geometry.x!=priv->geometry.x ||
		geometry.y!=priv->geometry.y ||
		geometry.width!=priv->geometry.width ||
		geometry.height!=priv->geometry.height)
	{
		/* Set value */
		priv->geometry.x=geometry.x;
		priv->geometry.y=geometry.y;
		priv->geometry.width=geometry.width;
		priv->geometry.height=geometry.height;

		/* Emit signal */
		g_signal_emit(self, XfdashboardWindowTrackerMonitorSignals[SIGNAL_GEOMETRY_CHANGED], 0);
		g_debug("Monitor %d moved to %d,%d and resized to %dx%d",
					priv->monitorIndex,
					priv->geometry.x, priv->geometry.y,
					priv->geometry.width, priv->geometry.height);
	}
}
Пример #11
0
static GdkPixbuf* get_screenshot ()
{
  GdkWindow *root_window = gdk_get_default_root_window ();
  gint x, y;
  gint swidth, sheight;

  guint m_offset_x = 0, m_offset_y = 0;
  gint monitors = gdk_screen_get_n_monitors (gdk_screen_get_default ());
  if (monitors > 1) {
    gint px = 0, py = 0;
    gdk_display_get_pointer (gdk_display_get_default (), NULL, &px, &py, NULL);
    gint current_monitor = gdk_screen_get_monitor_at_point (gdk_screen_get_default (), px, py);
    for (int i = 0; i < current_monitor; i++) {
      GdkRectangle mon_rect;
      gdk_screen_get_monitor_geometry (gdk_screen_get_default (), i, &mon_rect);
      m_offset_x += mon_rect.width;
      m_offset_y += mon_rect.height;
    }
  }

  gdk_drawable_get_size (root_window, &swidth, &sheight);
  gdk_window_get_origin (root_window, &x, &y);

  if (swidth <= m_offset_x)
    m_offset_x = 0;
  if (sheight <= m_offset_y)
    m_offset_y = 0;

  return gdk_pixbuf_get_from_drawable (NULL, root_window, NULL,
				       x + options.screenshot_offset_x + m_offset_x,
				       y + options.screenshot_offset_y + m_offset_y,
				       0, 0,
				       swidth - options.screenshot_offset_x - m_offset_x,
				       sheight - options.screenshot_offset_y - m_offset_y);
}
Пример #12
0
/**
 * gdk_screen_get_monitor_at_window:
 * @screen: a #GdkScreen.
 * @window: a #GdkWindow
 * @returns: the monitor number in which most of @window is located,
 *           or if @window does not intersect any monitors, a monitor,
 *           close to @window.
 *
 * Returns the number of the monitor in which the largest area of the 
 * bounding rectangle of @window resides.
 *
 * Since: 2.2
 **/
gint 
gdk_screen_get_monitor_at_window (GdkScreen      *screen,
				  GdkWindow	 *window)
{
  gint num_monitors, i, area = 0, screen_num = -1;
  GdkRectangle win_rect;

  g_return_val_if_fail (GDK_IS_SCREEN (screen), -1);

  gdk_window_get_geometry (window, &win_rect.x, &win_rect.y, &win_rect.width,
			   &win_rect.height, NULL);
  gdk_window_get_origin (window, &win_rect.x, &win_rect.y);
  num_monitors = gdk_screen_get_n_monitors (screen);
  
  for (i=0;i<num_monitors;i++)
    {
      GdkRectangle tmp_monitor, intersect;
      
      gdk_screen_get_monitor_geometry (screen, i, &tmp_monitor);
      gdk_rectangle_intersect (&win_rect, &tmp_monitor, &intersect);
      
      if (intersect.width * intersect.height > area)
	{ 
	  area = intersect.width * intersect.height;
	  screen_num = i;
	}
    }
  if (screen_num >= 0)
    return screen_num;
  else
    return get_nearest_monitor (screen,
				win_rect.x + win_rect.width / 2,
				win_rect.y + win_rect.height / 2);
}
Пример #13
0
static void on_screen_monitors_changed(GdkScreen* screen, NotifyDaemon* daemon)
{
	NotifyScreen* nscreen;
	int screen_num;
	int n_monitors;
	int i;

	screen_num = gdk_screen_get_number(screen);
	nscreen = daemon->priv->screens[screen_num];

	n_monitors = gdk_screen_get_n_monitors(screen);

	if (n_monitors > nscreen->n_stacks)
	{
		/* grow */
		nscreen->stacks = g_renew(NotifyStack *, nscreen->stacks, n_monitors);

		/* add more stacks */
		for (i = nscreen->n_stacks; i < n_monitors; i++)
		{
			create_stack_for_monitor(daemon, screen, i);
		}

		nscreen->n_stacks = n_monitors;
	}
Пример #14
0
gboolean
myScreenComputeSize (ScreenInfo *screen_info)
{
    gint num_monitors, i;
    gint width, height;
    GdkRectangle monitor;
    gboolean changed;

    g_return_val_if_fail (screen_info != NULL, FALSE);
    g_return_val_if_fail (GDK_IS_SCREEN (screen_info->gscr), FALSE);
    TRACE ("entering myScreenComputeSize");

    width = 0;
    height = 0;
    num_monitors = gdk_screen_get_n_monitors (screen_info->gscr);

    if (num_monitors == 0)
    {
        return FALSE;
    }

    for (i = 0; i < num_monitors; i++)
    {
        gdk_screen_get_monitor_geometry (screen_info->gscr, i, &monitor);
        width = MAX (monitor.x + monitor.width, width);
        height = MAX (monitor.y + monitor.height, height);
    }

    changed = ((screen_info->width != width) | (screen_info->height != height));
    screen_info->width = width;
    screen_info->height = height;
    TRACE ("myScreenComputeSize(): width=%i, height=%i", width, height);

    return changed;
}
Пример #15
0
gint update_monitors_num()
{
    GdkScreen* screen = gdk_screen_get_default();
    if (screen == NULL) {
        return 0;
    }
    return gdk_screen_get_n_monitors(screen);
}
Пример #16
0
static gboolean
layout_changed (NemoDesktopManager *manager)
{
    gint n_monitors = 0;
    gint x_primary = 0;
    gboolean show_desktop_on_primary = FALSE;
    gboolean show_desktop_on_remaining = FALSE;

    manager->update_layout_idle_id = 0;

    close_all_windows (manager);

    gchar *pref = g_settings_get_string (nemo_desktop_preferences, NEMO_PREFERENCES_DESKTOP_LAYOUT);

    if (g_strcmp0 (pref, "") == 0) {
        g_settings_set_string (nemo_desktop_preferences, NEMO_PREFERENCES_DESKTOP_LAYOUT, DESKTOPS_DEFAULT);
        g_free (pref);
        layout_changed (manager);
        return FALSE;
    }

    gchar **pref_split = g_strsplit (pref, "::", 2);

    if (g_strv_length (pref_split) != 2) {
        g_settings_set_string (nemo_desktop_preferences, NEMO_PREFERENCES_DESKTOP_LAYOUT, DESKTOPS_DEFAULT);
        g_free (pref);
        g_strfreev (pref_split);
        layout_changed (manager);
        return FALSE;;
    }

    n_monitors = gdk_screen_get_n_monitors (manager->screen);
    x_primary = gdk_screen_get_primary_monitor (manager->screen);

    show_desktop_on_primary = g_strcmp0 (pref_split[0], "true") == 0;
    show_desktop_on_remaining = g_strcmp0 (pref_split[1], "true") == 0;

    manager->desktop_on_primary_only = show_desktop_on_primary && !show_desktop_on_remaining;

    gint i = 0;
    gboolean primary_set = FALSE;

    for (i = 0; i < n_monitors; i++) {
        if (i == x_primary) {
            create_new_desktop_window (manager, i, show_desktop_on_primary, show_desktop_on_primary);
            primary_set = primary_set || show_desktop_on_primary;
        } else if (!nemo_desktop_utils_get_monitor_cloned (i, x_primary)) {
            gboolean set_layout_primary = !primary_set && !show_desktop_on_primary && show_desktop_on_remaining;
            create_new_desktop_window (manager, i, set_layout_primary, show_desktop_on_remaining);
            primary_set = primary_set || set_layout_primary;
        }
    }

    g_free (pref);
    g_strfreev (pref_split);

    return FALSE;
}
Пример #17
0
/* useful */
static void _panel_reset(Panel * panel, GdkRectangle * rect)
{
	gdk_screen_get_monitor_geometry(panel->screen, (panel->prefs.monitor > 0
				&& panel->prefs.monitor
				< gdk_screen_get_n_monitors(panel->screen))
			? panel->prefs.monitor : 0, rect);
	panel->root_height = rect->height;
	panel->root_width = rect->width;
}
Пример #18
0
gboolean
myScreenComputeSize (ScreenInfo *screen_info)
{
    gint num_monitors, i;
    gint width, height;
    GdkRectangle monitor;
    gboolean changed;

    g_return_val_if_fail (screen_info != NULL, FALSE);
    g_return_val_if_fail (GDK_IS_SCREEN (screen_info->gscr), FALSE);
    TRACE ("entering myScreenComputeSize");

    width = 0;
    height = 0;
    num_monitors = gdk_screen_get_n_monitors (screen_info->gscr);

    if (num_monitors == 0)
    {
        return FALSE;
    }

    for (i = 0; i < num_monitors; i++)
    {
        gdk_screen_get_monitor_geometry (screen_info->gscr, i, &monitor);
        width = MAX (monitor.x + monitor.width, width);
        height = MAX (monitor.y + monitor.height, height);
    }

    screen_info->logical_width = gdk_screen_get_width (screen_info->gscr);
    screen_info->logical_height = gdk_screen_get_height (screen_info->gscr);
    if ((width != screen_info->logical_width) || (height != screen_info->logical_height))
    {
        g_warning ("output size (%dx%d) and logical screen size (%dx%d) do not match",
                   width, height, screen_info->logical_width, screen_info->logical_height);
    }

    /* Keep the smallest size between what we computed and the
     * reported size for the screen.
     */
    if (width == 0 || width > screen_info->logical_width)
    {
        width = screen_info->logical_width;
    }

    if (height == 0 || height > screen_info->logical_height)
    {
        height = screen_info->logical_height;
    }

    changed = ((screen_info->width != width) | (screen_info->height != height));
    screen_info->width = width;
    screen_info->height = height;
    TRACE ("myScreenComputeSize(): width=%i, height=%i", width, height);

    return changed;
}
Пример #19
0
/**
 * gdk_screen_get_monitor_height_mm:
 * @screen: a #GdkScreen
 * @monitor_num: number of the monitor, between 0 and gdk_screen_get_n_monitors (screen)
 *
 * Gets the height in millimeters of the specified monitor.
 *
 * Returns: the height of the monitor, or -1 if not available
 *
 * Since: 2.14
 */
gint
gdk_screen_get_monitor_height_mm (GdkScreen *screen,
                                  gint       monitor_num)
{
  g_return_val_if_fail (GDK_IS_SCREEN (screen), -1);
  g_return_val_if_fail (monitor_num >= 0, -1);
  g_return_val_if_fail (monitor_num < gdk_screen_get_n_monitors (screen), -1);

  return GDK_SCREEN_GET_CLASS (screen)->get_monitor_height_mm (screen, monitor_num);
}
Пример #20
0
/**
 * gdk_screen_get_monitor_plug_name:
 * @screen: a #GdkScreen
 * @monitor_num: number of the monitor, between 0 and gdk_screen_get_n_monitors (screen)
 *
 * Returns the output name of the specified monitor.
 * Usually something like VGA, DVI, or TV, not the actual
 * product name of the display device.
 *
 * Returns: (nullable): a newly-allocated string containing the name
 *   of the monitor, or %NULL if the name cannot be determined
 *
 * Since: 2.14
 */
gchar *
gdk_screen_get_monitor_plug_name (GdkScreen *screen,
				  gint       monitor_num)
{
  g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
  g_return_val_if_fail (monitor_num >= 0, NULL);
  g_return_val_if_fail (monitor_num < gdk_screen_get_n_monitors (screen), NULL);

  return GDK_SCREEN_GET_CLASS (screen)->get_monitor_plug_name (screen, monitor_num);
}
Пример #21
0
/**
 * xfce_workspace_set_workspace_num:
 * @workspace: An #XfceWorkspace.
 * @GdkScreen: screen the workspace is on.
 *
 * Updates the backdrops to correctly display the right settings since GTK/GDK
 * uses monitor numbers rather than names.
 **/
void
xfce_workspace_monitors_changed(XfceWorkspace *workspace,
                                GdkScreen *gscreen)
{
    guint i;
    guint n_monitors;
    GdkVisual *vis = NULL;

    TRACE("entering");

    vis = gdk_screen_get_rgba_visual(gscreen);
    if(vis == NULL)
        vis = gdk_screen_get_system_visual(gscreen);

    if(workspace->priv->nbackdrops > 0 &&
       xfce_workspace_get_xinerama_stretch(workspace)) {
        /* When spanning screens we only need one backdrop */
        n_monitors = 1;
    } else {
        n_monitors = gdk_screen_get_n_monitors(gscreen);
    }

    /* Remove all backdrops so that the correct monitor is added/removed and
     * things stay in the correct order */
    xfce_workspace_remove_backdrops(workspace);

    /* Allocate space for the backdrops and their color properties so they
     * can correctly be removed */
    workspace->priv->backdrops = g_realloc(workspace->priv->backdrops,
                                           sizeof(XfceBackdrop *) * n_monitors);
    workspace->priv->first_color_id = g_realloc(workspace->priv->first_color_id,
                                                sizeof(gulong) * n_monitors);
    workspace->priv->second_color_id = g_realloc(workspace->priv->second_color_id,
                                                 sizeof(gulong) * n_monitors);

    for(i = 0; i < n_monitors; ++i) {
        DBG("Adding workspace %d backdrop %d", workspace->priv->workspace_num, i);

        workspace->priv->backdrops[i] = xfce_backdrop_new(vis);
        xfce_workspace_connect_backdrop_settings(workspace,
                                               workspace->priv->backdrops[i],
                                               i);
        g_signal_connect(G_OBJECT(workspace->priv->backdrops[i]),
                         "changed",
                         G_CALLBACK(backdrop_changed_cb), workspace);
        g_signal_connect(G_OBJECT(workspace->priv->backdrops[i]),
                         "cycle",
                         G_CALLBACK(backdrop_cycle_cb),
                         workspace);
        g_signal_connect(G_OBJECT(workspace->priv->backdrops[i]),
                         "ready",
                         G_CALLBACK(backdrop_changed_cb), workspace);
    }
    workspace->priv->nbackdrops = n_monitors;
}
Пример #22
0
static void
on_screen_monitors_changed (GdkScreen *screen,
                            GSManager *manager)
{
        GSList *l;
        int     n_monitors;
        int     n_windows;
        int     i;

        n_monitors = gdk_screen_get_n_monitors (screen);
        n_windows = g_slist_length (manager->priv->windows);

        gs_debug ("Monitors changed for screen %d: num=%d",
                  gdk_screen_get_number (screen),
                  n_monitors);

        if (n_monitors > n_windows) {

                /* add more windows */
                for (i = n_windows; i < n_monitors; i++) {
                        gs_manager_create_window_for_monitor (manager, screen, i);
                }
        } else {

                gdk_x11_grab_server ();

                /* remove the extra windows */
                l = manager->priv->windows;
                while (l != NULL) {
                        GdkScreen *this_screen;
                        int        this_monitor;
                        GSList    *next = l->next;

                        this_screen = gs_window_get_screen (GS_WINDOW (l->data));
                        this_monitor = gs_window_get_monitor (GS_WINDOW (l->data));
                        if (this_screen == screen && this_monitor >= n_monitors) {
                                gs_window_destroy (GS_WINDOW (l->data));
                                manager->priv->windows = g_slist_delete_link (manager->priv->windows, l);
                        }
                        l = next;
                }

                gdk_flush ();
                gdk_x11_ungrab_server ();
        }

	for (l = manager->priv->windows; l != NULL; l = l->next) {
		GdkScreen *this_screen;

		this_screen = gs_window_get_screen (GS_WINDOW (l->data));
		if (this_screen == screen) {
			gtk_widget_queue_resize (GTK_WIDGET (l->data));
		}
	}
}
Пример #23
0
int main(int argc, char *argv[])
{
	GdkScreen *screen;
	gint width, height;
	gint index;
	gint point_1, point_2;
	gint mm_height, mm_width;
	GdkRectangle rect0, rect1;
	GdkWindow * wind;

	gtk_init(&argc, &argv);
	g_type_init();
	screen = gdk_screen_get_default();
	gint number = gdk_screen_get_n_monitors(screen);
	
	width = gdk_screen_get_width(screen);
	height = gdk_screen_get_height(screen);

	if(number > 1 )
	{
		index = gdk_screen_get_primary_monitor(screen);
		
		point_1 = gdk_screen_get_monitor_at_point(screen , 20, 20);
		point_2 = gdk_screen_get_monitor_at_point(screen , 2700, 20);

		printf("number is %d\n width %d\t height %d\n primary monitor index %d\n", number, width, height, index);

		printf("point1 is in monitor %d\n", point_1);
		printf("point2 is in monitor %d\n", point_2);
/*
		mm_height = gdk_screen_get_monitor_height_mm (screen, 0);
		printf("monitor0 height  %d\n", mm_height);
		mm_height = gdk_screen_get_monitor_height_mm (screen, 1);
		printf("monitor1 height  %d\n", mm_height);
		
		mm_width = gdk_screen_get_monitor_width_mm (screen, 0);
		printf("monitor0 width  %d\n", mm_width);
		mm_width = gdk_screen_get_monitor_width_mm (screen, 1);
		printf("monitor1 width  %d\n", mm_width);
*/
		gdk_screen_get_monitor_geometry(screen, 0, &rect0);
		printf("monitor0 rect.x %d rect.y %d\n rect.width %d rect.weight %d\n", rect0.x, rect0.y, rect0.width, rect0.height);
		
		gdk_screen_get_monitor_geometry(screen, 1, &rect1);
		printf("monitor1 rect.x %d rect.y %d\n rect.width %d rect.weight %d\n", rect1.x, rect1.y, rect1.width, rect1.height);

		wind = gdk_screen_get_active_window(screen);
		gint monitor = gdk_screen_get_monitor_at_window(screen, wind);
		printf("active window at monitor   %d\n", monitor);

	}
    else{
		printf("sorry, only one monitor! \n");
    }
}
Пример #24
0
/**
 * gdk_screen_get_monitor_workarea:
 * @screen: a #GdkScreen
 * @monitor_num: the monitor number
 * @dest: (out) (allow-none): a #GdkRectangle to be filled with
 *     the monitor workarea
 *
 * Retrieves the #GdkRectangle representing the size and position of
 * the “work area” on a monitor within the entire screen area. The returned
 * geometry is in ”application pixels”, not in ”device pixels” (see
 * gdk_screen_get_monitor_scale_factor()).
 *
 * The work area should be considered when positioning menus and
 * similar popups, to avoid placing them below panels, docks or other
 * desktop components.
 *
 * Note that not all backends may have a concept of workarea. This
 * function will return the monitor geometry if a workarea is not
 * available, or does not apply.
 *
 * Monitor numbers start at 0. To obtain the number of monitors of
 * @screen, use gdk_screen_get_n_monitors().
 *
 * Since: 3.4
 */
void
gdk_screen_get_monitor_workarea (GdkScreen    *screen,
                                 gint          monitor_num,
                                 GdkRectangle *dest)
{
  g_return_if_fail (GDK_IS_SCREEN (screen));
  g_return_if_fail (monitor_num >= 0);
  g_return_if_fail (monitor_num < gdk_screen_get_n_monitors (screen));

  GDK_SCREEN_GET_CLASS (screen)->get_monitor_workarea (screen, monitor_num, dest);
}
Пример #25
0
/** Get information about each screen.
*/
void getScreens(screens *scrinfo)
{
	GdkScreen *screen = gdk_screen_get_default();
	gint nmon = gdk_screen_get_n_monitors(screen);
	scrinfo->screens = (oRectangle*) malloc(sizeof(oRectangle)*nmon);
	scrinfo->amount=nmon;

	for(int i=0; i < nmon; i++)
	{
		gdk_screen_get_monitor_geometry(screen, i, &scrinfo->screens[i]);
	}
}
Пример #26
0
static gboolean
player_av_button_press (GtkWidget *da, GdkEventButton *event, PlayerAV *self)
{
    GdkRectangle rect;
    GdkScreen *screen = gdk_screen_get_default ();
    gint num = gdk_screen_get_n_monitors (screen);

    if (self->priv->monitor >= num) {
        self->priv->monitor = num-1;
    }

    if (event->button == 3) {
        GtkWidget *item;
        GtkWidget *menu = gtk_menu_new ();

        item = gtk_menu_item_new_with_label ("Toggle Fullscreen");
        gtk_menu_append (GTK_MENU (menu), item);
        g_signal_connect (item, "activate", G_CALLBACK (toggle_fullscreen), self);

        gtk_menu_append (GTK_MENU (menu), gtk_separator_menu_item_new ());

        GSList *group = NULL;
        gint i;

        for (i = 0; i < num; i++) {
            gdk_screen_get_monitor_geometry (screen, i, &rect);
            gchar *str = g_strdup_printf ("%d: %dx%d", i+1, rect.width, rect.height);
            item = gtk_radio_menu_item_new_with_label (group, str);
            g_free (str);
            group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (item));

            if (i == self->priv->monitor) {
                gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item), TRUE);
            }

            gtk_menu_append (GTK_MENU (menu), item);
            g_signal_connect (item, "activate", G_CALLBACK (on_pick_screen), self);
        }

        gtk_menu_append (GTK_MENU (menu), gtk_separator_menu_item_new ());

        gtk_widget_show_all (menu);

        gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL,
                        event->button, event->time);
    } else if (event->type == GDK_2BUTTON_PRESS) {
        toggle_fullscreen (NULL, self);
    }

    return FALSE;
}
Пример #27
0
void getScreens(screens *scrinfo){
    GdkScreen *screen = gdk_screen_get_default();
    gint nmon = gdk_screen_get_n_monitors(screen);
    scrinfo->screens = (oRectangle*) malloc(sizeof(oRectangle)*nmon);
    scrinfo->amount=nmon;
    for(int i=0; i < nmon; i++){
        GdkRectangle rect;
        gdk_screen_get_monitor_geometry(screen, i, &rect);
        scrinfo->screens[i].x=rect.x;
        scrinfo->screens[i].y=rect.y;
        scrinfo->screens[i].width=rect.width;
        scrinfo->screens[i].height=rect.height;
    }
}
char *iupdrvGetGlobal(const char *name)
{
  if (iupStrEqual(name, "VIRTUALSCREEN"))
  {
    GdkScreen *screen = gdk_screen_get_default();
    GdkWindow *root = gdk_screen_get_root_window(gdk_screen_get_default());
    int x = 0;
    int y = 0;
    int w = gdk_screen_get_width(screen); 
    int h = gdk_screen_get_height(screen);
    gdk_window_get_root_origin(root, &x, &y);
    return iupStrReturnStrf("%d %d %d %d", x, y, w, h);
  }
  if (iupStrEqual(name, "MONITORSINFO"))
  {
    int i;
    GdkScreen *screen = gdk_screen_get_default();
    int monitors_count = gdk_screen_get_n_monitors(screen);
    char *str = iupStrGetMemory(monitors_count*50);
    char* pstr = str;
    GdkRectangle rect;

    for (i=0; i < monitors_count; i++)
    {
      gdk_screen_get_monitor_geometry(screen, i, &rect);
      pstr += sprintf(pstr, "%d %d %d %d\n", rect.x, rect.y, rect.width, rect.height);
    }

    return str;
  }
  if (iupStrEqual(name, "TRUECOLORCANVAS"))
  {
    return iupStrReturnBoolean(gdk_visual_get_best_depth() > 8);
  }
  if (iupStrEqual(name, "UTF8MODE"))
  {
    return iupStrReturnBoolean(iupgtkStrGetUTF8Mode());
  }
  if (iupStrEqual(name, "UTF8AUTOCONVERT"))
  {
    return iupStrReturnBoolean(!iupgtkStrGetUTF8Mode());
  }
  if (iupStrEqual(name, "SHOWMENUIMAGES"))
  {
    gboolean menu_images;
    g_object_get (gtk_settings_get_default (), "gtk-menu-images", &menu_images, NULL);
    return iupStrReturnBoolean(menu_images);
  }
  return NULL;
}
int iupdrvCheckMainScreen(int *w, int *h)
{
  GdkScreen *screen = gdk_screen_get_default();
  int monitors_count = gdk_screen_get_n_monitors(screen);
  if (monitors_count > 1)
  {
    GdkRectangle rect;
    gdk_screen_get_monitor_geometry(screen, gdk_screen_get_monitor_at_point(screen, 0, 0), &rect);
    *w = rect.width;
    *h = rect.height;
    return 1;
  }
  return 0;
}
Пример #30
0
gboolean
myScreenRebuildMonitorIndex (ScreenInfo *screen_info)
{
    gint i, j, num_monitors, previous_num_monitors;
    GdkRectangle monitor, previous;
    gboolean cloned;

    g_return_val_if_fail (screen_info != NULL, FALSE);
    TRACE ("entering myScreenRebuildMonitorIndex");

    previous_num_monitors = screen_info->num_monitors;
    screen_info->num_monitors = 0;

    if (screen_info->monitors_index)
    {
        g_array_free (screen_info->monitors_index, TRUE);
    }
    screen_info->monitors_index = g_array_new (FALSE, TRUE, sizeof (guint));

    /* GDK already sorts monitors for us, for "cloned" monitors, sort
     * the bigger ones first (giving preference to taller monitors
     * over wider monitors)
     */
    num_monitors = gdk_screen_get_n_monitors (screen_info->gscr);
    for (i = 0; i < num_monitors; i++)
    {
        gdk_screen_get_monitor_geometry (screen_info->gscr, i, &monitor);
        cloned = FALSE;
        for (j = 0; j < (gint) screen_info->monitors_index->len; j++)
        {
            gdk_screen_get_monitor_geometry (screen_info->gscr, j, &previous);
            if ((previous.x == monitor.x) && (previous.y == monitor.y))
            {
                cloned = TRUE;
            }
        }
        if (!cloned)
        {
            screen_info->num_monitors++;
            g_array_append_val (screen_info->monitors_index , i);
        }
    }

    TRACE ("Physical monitor reported.: %i", num_monitors);
    TRACE ("Logical views found.......: %i", screen_info->num_monitors);

    return (screen_info->num_monitors != previous_num_monitors);
}