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); } }
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); }
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_); }
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); }
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>()); }
/* 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)); }
/** * 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); }
/** * 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); }
/* 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); } }
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); }
/** * 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); }
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; }
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; }
gint update_monitors_num() { GdkScreen* screen = gdk_screen_get_default(); if (screen == NULL) { return 0; } return gdk_screen_get_n_monitors(screen); }
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; }
/* 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; }
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; }
/** * 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); }
/** * 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); }
/** * 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; }
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)); } } }
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"); } }
/** * 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); }
/** 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]); } }
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; }
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; }
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); }