void gimp_popup_show (GimpPopup *popup, GtkWidget *widget) { GdkScreen *screen; GtkRequisition requisition; GtkAllocation allocation; GdkRectangle rect; gint monitor; gint orig_x; gint orig_y; gint x; gint y; g_return_if_fail (GIMP_IS_POPUP (popup)); g_return_if_fail (GTK_IS_WIDGET (widget)); gtk_widget_size_request (GTK_WIDGET (popup), &requisition); gtk_widget_get_allocation (widget, &allocation); gdk_window_get_origin (gtk_widget_get_window (widget), &orig_x, &orig_y); if (! gtk_widget_get_has_window (widget)) { orig_x += allocation.x; orig_y += allocation.y; } screen = gtk_widget_get_screen (widget); monitor = gdk_screen_get_monitor_at_point (screen, orig_x, orig_y); gdk_screen_get_monitor_workarea (screen, monitor, &rect); if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL) { x = orig_x + allocation.width - requisition.width; if (x < rect.x) x -= allocation.width - requisition.width; } else { x = orig_x; if (x + requisition.width > rect.x + rect.width) x += allocation.width - requisition.width; } y = orig_y + allocation.height; if (y + requisition.height > rect.y + rect.height) y = orig_y - requisition.height; gtk_window_set_screen (GTK_WINDOW (popup), screen); gtk_window_set_transient_for (GTK_WINDOW (popup), GTK_WINDOW (gtk_widget_get_toplevel (widget))); gtk_window_move (GTK_WINDOW (popup), x, y); gtk_widget_show (GTK_WIDGET (popup)); }
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 inline void wx_gdk_screen_get_monitor_workarea(GdkScreen* screen, int monitor, GdkRectangle* dest) { #if GTK_CHECK_VERSION(3,4,0) if (gtk_check_version(3,4,0) == NULL) gdk_screen_get_monitor_workarea(screen, monitor, dest); else #endif { gdk_screen_get_monitor_geometry(screen, monitor, dest); #ifdef GDK_WINDOWING_X11 #ifdef __WXGTK3__ if (GDK_IS_X11_SCREEN(screen)) #endif { GdkRectangle rect = { 0 }; wxGetWorkAreaX11(GDK_SCREEN_XSCREEN(screen), rect.x, rect.y, rect.width, rect.height); // in case _NET_WORKAREA result is too large if (rect.width && rect.height) gdk_rectangle_intersect(dest, &rect, dest); } #endif // GDK_WINDOWING_X11 } }
static void get_screenshot_async (CcBackgroundPanel *panel) { CcBackgroundPanelPrivate *priv = panel->priv; gchar *path, *tmpname; const gchar *method_name; GVariant *method_params; GtkWidget *widget; ScreenshotData *data; int primary; data = g_new0 (ScreenshotData, 1); data->panel = panel; widget = WID ("background-desktop-drawingarea"); primary = gdk_screen_get_primary_monitor (gtk_widget_get_screen (widget)); gdk_screen_get_monitor_geometry (gtk_widget_get_screen (widget), primary, &data->monitor_rect); gdk_screen_get_monitor_workarea (gtk_widget_get_screen (widget), primary, &data->workarea_rect); if (calculate_contiguous_workarea (data)) { g_debug ("Capturing only a portion of the screen"); } else { g_debug ("Capturing the whole monitor"); data->whole_monitor = TRUE; data->capture_rect = data->monitor_rect; } g_debug ("Trying to capture rectangle %dx%d (at %d,%d)", data->capture_rect.width, data->capture_rect.height, data->capture_rect.x, data->capture_rect.y); path = g_build_filename (g_get_user_cache_dir (), "gnome-control-center", NULL); g_mkdir_with_parents (path, USER_DIR_MODE); tmpname = g_strdup_printf ("scr-%d.png", g_random_int ()); g_free (panel->priv->screenshot_path); panel->priv->screenshot_path = g_build_filename (path, tmpname, NULL); g_free (path); g_free (tmpname); method_name = "ScreenshotArea"; method_params = g_variant_new ("(iiiibs)", data->capture_rect.x, data->capture_rect.y, data->capture_rect.width, data->capture_rect.height, FALSE, /* flash */ panel->priv->screenshot_path); g_dbus_connection_call (panel->priv->connection, "org.gnome.Shell.Screenshot", "/org/gnome/Shell/Screenshot", "org.gnome.Shell.Screenshot", method_name, method_params, NULL, G_DBUS_CALL_FLAGS_NONE, -1, priv->capture_cancellable, on_screenshot_finished, data); }
/* adapted from gtk/gtkmenubutton.c */ static void menu_position_func (GtkMenu *menu, gint *x, gint *y, gboolean *push_in, GtkWidget *widget) { GtkWidget *toplevel; GtkRequisition menu_req; GdkRectangle monitor; gint monitor_num; GdkScreen *screen; GdkWindow *window; GtkAllocation allocation; /* Set the dropdown menu hint on the toplevel, so the WM can omit the top side * of the shadows. */ toplevel = gtk_widget_get_toplevel (GTK_WIDGET (menu)); gtk_window_set_type_hint (GTK_WINDOW (toplevel), GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU); window = gtk_widget_get_window (widget); screen = gtk_widget_get_screen (GTK_WIDGET (menu)); monitor_num = gdk_screen_get_monitor_at_window (screen, window); if (monitor_num < 0) { monitor_num = 0; } gdk_screen_get_monitor_workarea (screen, monitor_num, &monitor); gtk_widget_get_preferred_size (GTK_WIDGET (menu), &menu_req, NULL); gtk_widget_get_allocation (widget, &allocation); gdk_window_get_origin (window, x, y); *x += allocation.x; *y += allocation.y; if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL) { *x -= MAX (menu_req.width - allocation.width, 0); } else { *x += MAX (allocation.width - menu_req.width, 0); } if ((*y + allocation.height + menu_req.height) <= monitor.y + monitor.height) { *y += allocation.height; } else if ((*y - menu_req.height) >= monitor.y) { *y -= menu_req.height; } else if (monitor.y + monitor.height - (*y + allocation.height) > *y) { *y += allocation.height; } else { *y -= menu_req.height; } *push_in = FALSE; }
/* * Figure out the size of the working area and resize the window to fit into * that. */ static void set_window_geometry(GtkWindow *window, GtkWidget *widget) { GdkScreen *screen; GdkRectangle rect; if ((screen = gdk_screen_get_default()) == NULL) errx(1, "gdk_screen_get_default"); gdk_screen_get_monitor_workarea(screen, 0, &rect); gtk_window_set_default_size(window, rect.width, rect.height); gtk_widget_set_size_request(widget, rect.width, rect.height); gtk_window_move(window, rect.x, rect.y); }
FloatRect screenAvailableRect(Widget* widget) { GtkWidget* container = widget ? GTK_WIDGET(widget->root()->hostWindow()->platformPageClient()) : 0; if (container && !gtk_widget_get_realized(container)) return screenRect(widget); GdkScreen* screen = container ? getScreen(container) : gdk_screen_get_default(); if (!screen) return FloatRect(); gint monitor = container ? gdk_screen_get_monitor_at_window(screen, gtk_widget_get_window(container)) : 0; GdkRectangle workArea; gdk_screen_get_monitor_workarea(screen, monitor, &workArea); return FloatRect(workArea.x, workArea.y, workArea.width, workArea.height); }
static void position_window (CcRRLabeler *labeler, GtkWidget *window, int x, int y) { GdkRectangle workarea; GdkRectangle monitor; int monitor_num; monitor_num = gdk_screen_get_monitor_at_point (labeler->priv->screen, x, y); gdk_screen_get_monitor_workarea (labeler->priv->screen, monitor_num, &workarea); gdk_screen_get_monitor_geometry (labeler->priv->screen, monitor_num, &monitor); gdk_rectangle_intersect (&monitor, &workarea, &workarea); gtk_window_move (GTK_WINDOW (window), workarea.x, workarea.y); }
void uiWindowCenter(uiWindow *w) { gint x, y; GtkAllocation winalloc; GdkWindow *gdkwin; GdkScreen *screen; GdkRectangle workarea; gtk_widget_get_allocation(w->widget, &winalloc); gdkwin = gtk_widget_get_window(w->widget); screen = gdk_window_get_screen(gdkwin); gdk_screen_get_monitor_workarea(screen, gdk_screen_get_monitor_at_window(screen, gdkwin), &workarea); x = (workarea.width - winalloc.width) / 2; y = (workarea.height - winalloc.height) / 2; // TODO move up slightly? see what Mutter or GNOME Shell or GNOME Terminal do(es)? uiWindowSetPosition(w, x, y); }
void wxClientDisplayRect(int* x, int* y, int* width, int* height) { #if wxUSE_LIBHILDON || wxUSE_LIBHILDON2 GdkRectangle rect = { 0, 0, 672, 396 }; #else GdkRectangle rect; GdkWindow* window = gtk_widget_get_window(wxGetRootWindow()); GdkScreen* screen = gdk_window_get_screen(window); int monitor = gdk_screen_get_monitor_at_window(screen, window); gdk_screen_get_monitor_workarea(screen, monitor, &rect); #endif if (x) *x = rect.x; if (y) *y = rect.y; if (width) *width = rect.width; if (height) *height = rect.height; }
/** * cheese_flash_fire: * @flash: a #CheeseFlash * * Fire the flash. */ void cheese_flash_fire (CheeseFlash *flash) { CheeseFlashPrivate *flash_priv; GtkWidget *parent; GdkScreen *screen; GdkRectangle rect, work_rect; int monitor; GtkWindow *flash_window; g_return_if_fail (CHEESE_IS_FLASH (flash)); flash_priv = flash->priv; g_return_if_fail (flash_priv->parent != NULL); flash_window = GTK_WINDOW (flash); if (flash_priv->flash_timeout_tag > 0) g_source_remove (flash_priv->flash_timeout_tag); if (flash_priv->fade_timeout_tag > 0) g_source_remove (flash_priv->fade_timeout_tag); parent = gtk_widget_get_toplevel (flash_priv->parent); screen = gtk_widget_get_screen (parent); monitor = gdk_screen_get_monitor_at_window (screen, gtk_widget_get_window (parent)); gdk_screen_get_monitor_geometry (screen, monitor, &rect); gdk_screen_get_monitor_workarea (screen, monitor, &work_rect); gdk_rectangle_intersect (&work_rect, &rect, &rect); gtk_window_set_transient_for (GTK_WINDOW (flash_window), GTK_WINDOW (parent)); gtk_window_resize (flash_window, rect.width, rect.height); gtk_window_move (flash_window, rect.x, rect.y); gtk_window_set_opacity (flash_window, 1); gtk_widget_show_all (GTK_WIDGET (flash_window)); flash_priv->flash_timeout_tag = g_timeout_add (FLASH_DURATION, cheese_flash_start_fade, (gpointer) flash); }
static void popup_position_func (GtkMenu *menu, gint *x, gint *y, gboolean *push_in, gpointer user_data) { GtkWidget *widget; GtkRequisition req; gint root_x, root_y; GdkScreen *screen; GdkWindow *window; GdkRectangle monitor; gint monitor_num; widget = GTK_WIDGET (user_data); g_return_if_fail (gtk_widget_get_realized (widget)); window = gtk_widget_get_window (widget); screen = gtk_widget_get_screen (widget); monitor_num = gdk_screen_get_monitor_at_window (screen, window); if (monitor_num < 0) monitor_num = 0; gtk_menu_set_monitor (menu, monitor_num); gdk_window_get_origin (window, &root_x, &root_y); gtk_widget_get_preferred_size (GTK_WIDGET (menu), &req, NULL); /* Put corner of menu centered on swatch */ *x = root_x + gtk_widget_get_allocated_width (widget) / 2; *y = root_y + gtk_widget_get_allocated_height (widget) / 2; /* Ensure sanity */ gdk_screen_get_monitor_workarea (screen, monitor_num, &monitor); *x = CLAMP (*x, monitor.x, MAX (monitor.x, monitor.width - req.width)); *y = CLAMP (*y, monitor.y, MAX (monitor.y, monitor.height - req.height)); }
int main (int argc, char **argv) { GtkWidget *window; GdkScreen *screen; int monitor; GdkRectangle rect; GError *error = NULL; char *font = NULL; GtkApplication *application; guint status; GOptionEntry goptions[] = { { "font", 0, 0, G_OPTION_ARG_STRING, &font, N_("Font to start with; ex: 'Serif 27'"), N_("FONT") }, { "version", 0, G_OPTION_FLAG_HIDDEN | G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, option_version_cb, NULL, NULL }, { NULL } }; bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); #ifdef HAVE_GCONF /* GConf uses ORBit2 which need GThread. See bug #565516 */ g_thread_init (NULL); #endif /* Set programme name explicitly (see bug #653115) */ g_set_prgname("gucharmap"); if (!gtk_init_with_args (&argc, &argv, NULL, goptions, GETTEXT_PACKAGE, &error)) { g_printerr ("%s\n", error->message); g_error_free (error); exit (1); } g_set_application_name (_("Character Map")); gtk_window_set_default_icon_name (GUCHARMAP_ICON_NAME); application = gtk_application_new ("org.gnome.Charmap", G_APPLICATION_NON_UNIQUE); g_signal_connect (application, "startup", G_CALLBACK (startup_cb), NULL); g_signal_connect (application, "activate", G_CALLBACK (gucharmap_activate), NULL); g_application_register (G_APPLICATION (application), NULL, NULL); window = gucharmap_window_new (application); screen = gtk_window_get_screen (GTK_WINDOW (window)); monitor = gdk_screen_get_monitor_at_point (screen, 0, 0); #if GTK_CHECK_VERSION (3, 3, 5) gdk_screen_get_monitor_workarea (screen, monitor, &rect); #else gdk_screen_get_monitor_geometry (screen, monitor, &rect); #endif gtk_window_set_default_size (GTK_WINDOW (window), rect.width * 9/16, rect.height * 9/16); if (font) { gucharmap_window_set_font (GUCHARMAP_WINDOW (window), font); g_free (font); } gtk_window_present (GTK_WINDOW (window)); status = g_application_run (G_APPLICATION (application), argc, argv); g_object_unref (application); return status; }
static void on_screenshot_finished (GObject *source, GAsyncResult *res, gpointer user_data) { CcBackgroundPanel *panel = user_data; CcBackgroundPanelPrivate *priv = panel->priv; GError *error; GdkRectangle rect; GtkWidget *widget; GdkPixbuf *pixbuf; cairo_surface_t *surface; cairo_t *cr; int width; int height; error = NULL; g_dbus_connection_call_finish (panel->priv->connection, res, &error); if (error != NULL) { g_debug ("Unable to get screenshot: %s", error->message); g_error_free (error); /* fallback? */ goto out; } pixbuf = gdk_pixbuf_new_from_file (panel->priv->screenshot_path, &error); if (error != NULL) { g_debug ("Unable to use GNOME Shell's builtin screenshot interface: %s", error->message); g_error_free (error); goto out; } width = gdk_pixbuf_get_width (pixbuf); height = gdk_pixbuf_get_height (pixbuf); surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height); cr = cairo_create (surface); gdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0); cairo_paint (cr); g_object_unref (pixbuf); /* clear the workarea */ widget = WID ("background-desktop-drawingarea"); gdk_screen_get_monitor_workarea (gtk_widget_get_screen (widget), 0, &rect); cairo_save (cr); cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR); cairo_rectangle (cr, rect.x, rect.y, rect.width, rect.height); cairo_fill (cr); cairo_restore (cr); g_clear_object (&panel->priv->display_screenshot); panel->priv->display_screenshot = gdk_pixbuf_get_from_surface (surface, 0, 0, width, height); /* remove the temporary file created by the shell */ g_unlink (panel->priv->screenshot_path); g_free (priv->screenshot_path); priv->screenshot_path = NULL; cairo_destroy (cr); cairo_surface_destroy (surface); out: update_display_preview (panel); }
static void gtk_tooltip_position (GtkTooltip *tooltip, GdkDisplay *display, GtkWidget *new_tooltip_widget) { gint x, y, width, height; GdkScreen *screen; gint monitor_num; GdkRectangle monitor; guint cursor_size; GdkRectangle bounds; #define MAX_DISTANCE 32 gtk_widget_realize (GTK_WIDGET (tooltip->current_window)); tooltip->tooltip_widget = new_tooltip_widget; screen = gtk_widget_get_screen (new_tooltip_widget); width = gtk_widget_get_allocated_width (GTK_WIDGET (tooltip->current_window)); height = gtk_widget_get_allocated_height (GTK_WIDGET (tooltip->current_window)); monitor_num = gdk_screen_get_monitor_at_point (screen, tooltip->last_x, tooltip->last_y); gdk_screen_get_monitor_workarea (screen, monitor_num, &monitor); get_bounding_box (new_tooltip_widget, &bounds); /* Position the tooltip */ cursor_size = gdk_display_get_default_cursor_size (display); /* Try below */ x = bounds.x + bounds.width / 2 - width / 2; y = bounds.y + bounds.height + 4; if (y + height <= monitor.y + monitor.height) { if (tooltip->keyboard_mode_enabled) goto found; if (y <= tooltip->last_y + cursor_size + MAX_DISTANCE) { if (tooltip->last_x + cursor_size + MAX_DISTANCE < x) x = tooltip->last_x + cursor_size + MAX_DISTANCE; else if (x + width < tooltip->last_x - MAX_DISTANCE) x = tooltip->last_x - MAX_DISTANCE - width; goto found; } } /* Try above */ x = bounds.x + bounds.width / 2 - width / 2; y = bounds.y - height - 4; if (y >= monitor.y) { if (tooltip->keyboard_mode_enabled) goto found; if (y + height >= tooltip->last_y - MAX_DISTANCE) { if (tooltip->last_x + cursor_size + MAX_DISTANCE < x) x = tooltip->last_x + cursor_size + MAX_DISTANCE; else if (x + width < tooltip->last_x - MAX_DISTANCE) x = tooltip->last_x - MAX_DISTANCE - width; goto found; } } /* Try right FIXME: flip on rtl ? */ x = bounds.x + bounds.width + 4; y = bounds.y + bounds.height / 2 - height / 2; if (x + width <= monitor.x + monitor.width) { if (tooltip->keyboard_mode_enabled) goto found; if (x <= tooltip->last_x + cursor_size + MAX_DISTANCE) { if (tooltip->last_y + cursor_size + MAX_DISTANCE < y) y = tooltip->last_y + cursor_size + MAX_DISTANCE; else if (y + height < tooltip->last_y - MAX_DISTANCE) y = tooltip->last_y - MAX_DISTANCE - height; goto found; } } /* Try left FIXME: flip on rtl ? */ x = bounds.x - width - 4; y = bounds.y + bounds.height / 2 - height / 2; if (x >= monitor.x) { if (tooltip->keyboard_mode_enabled) goto found; if (x + width >= tooltip->last_x - MAX_DISTANCE) { if (tooltip->last_y + cursor_size + MAX_DISTANCE < y) y = tooltip->last_y + cursor_size + MAX_DISTANCE; else if (y + height < tooltip->last_y - MAX_DISTANCE) y = tooltip->last_y - MAX_DISTANCE - height; goto found; } } /* Fallback */ if (tooltip->keyboard_mode_enabled) { x = bounds.x + bounds.width / 2 - width / 2; y = bounds.y + bounds.height + 4; } else { /* At cursor */ x = tooltip->last_x + cursor_size * 3 / 4; y = tooltip->last_y + cursor_size * 3 / 4; } found: /* Show it */ if (tooltip->current_window) { if (x + width > monitor.x + monitor.width) x -= x - (monitor.x + monitor.width) + width; else if (x < monitor.x) x = monitor.x; if (y + height > monitor.y + monitor.height) y -= y - (monitor.y + monitor.height) + height; else if (y < monitor.y) y = monitor.y; if (!tooltip->keyboard_mode_enabled) { /* don't pop up under the pointer */ if (x <= tooltip->last_x && tooltip->last_x < x + width && y <= tooltip->last_y && tooltip->last_y < y + height) y = tooltip->last_y - height - 2; } #ifdef GDK_WINDOWING_WAYLAND /* set the transient parent on the tooltip when running with the Wayland * backend to allow correct positioning of the tooltip windows */ if (GDK_IS_WAYLAND_DISPLAY (display)) { GtkWidget *toplevel; toplevel = gtk_widget_get_toplevel (tooltip->tooltip_widget); if (GTK_IS_WINDOW (toplevel)) gtk_window_set_transient_for (GTK_WINDOW (tooltip->current_window), GTK_WINDOW (toplevel)); } #endif gtk_window_move (GTK_WINDOW (tooltip->current_window), x, y); gtk_widget_show (GTK_WIDGET (tooltip->current_window)); } }
static void menu_position_side_func (GtkMenu *menu, gint *x, gint *y, gboolean *push_in, GtkMenuButton *menu_button) { GtkMenuButtonPrivate *priv = menu_button->priv; GtkAllocation allocation; GtkAllocation menu_allocation; GtkWidget *widget = GTK_WIDGET (menu_button); GdkRectangle monitor; gint monitor_num; GdkScreen *screen; GdkWindow *window; GtkAlign align; GtkTextDirection direction; window = gtk_widget_get_window (widget); direction = gtk_widget_get_direction (widget); align = gtk_widget_get_valign (GTK_WIDGET (menu)); screen = gtk_widget_get_screen (GTK_WIDGET (menu)); monitor_num = gdk_screen_get_monitor_at_window (screen, window); if (monitor_num < 0) monitor_num = 0; gdk_screen_get_monitor_workarea (screen, monitor_num, &monitor); gdk_window_get_origin (gtk_button_get_event_window (GTK_BUTTON (menu_button)), x, y); gtk_widget_get_allocation (widget, &allocation); gtk_widget_get_allocation (priv->menu, &menu_allocation); if ((priv->arrow_type == GTK_ARROW_RIGHT && direction == GTK_TEXT_DIR_LTR) || (priv->arrow_type == GTK_ARROW_LEFT && direction == GTK_TEXT_DIR_RTL)) { if (*x + allocation.width + menu_allocation.width <= monitor.x + monitor.width) *x += allocation.width; else *x -= menu_allocation.width; } else { if (*x - menu_allocation.width >= monitor.x) *x -= menu_allocation.width; else *x += allocation.width; } /* treat the default align value like START */ if (align == GTK_ALIGN_FILL) align = GTK_ALIGN_START; if (align == GTK_ALIGN_CENTER) *y -= (menu_allocation.height - allocation.height) / 2; else if (align == GTK_ALIGN_END) *y -= menu_allocation.height - allocation.height; *push_in = FALSE; }
static void menu_position_up_down_func (GtkMenu *menu, gint *x, gint *y, gboolean *push_in, GtkMenuButton *menu_button) { GtkMenuButtonPrivate *priv = menu_button->priv; GtkWidget *widget = GTK_WIDGET (menu_button); GtkWidget *toplevel; GtkTextDirection direction; GdkRectangle monitor; gint monitor_num; GdkScreen *screen; GdkWindow *window; GtkAllocation menu_allocation, allocation, arrow_allocation; GtkAlign align; /* In the common case the menu button is showing a dropdown menu, set the * corresponding type hint on the toplevel, so the WM can omit the top side * of the shadows. */ if (priv->arrow_type == GTK_ARROW_DOWN) { toplevel = gtk_widget_get_toplevel (priv->menu); gtk_window_set_type_hint (GTK_WINDOW (toplevel), GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU); } align = gtk_widget_get_halign (priv->menu); direction = gtk_widget_get_direction (widget); window = gtk_widget_get_window (priv->align_widget ? priv->align_widget : widget); screen = gtk_widget_get_screen (GTK_WIDGET (menu)); monitor_num = gdk_screen_get_monitor_at_window (screen, window); if (monitor_num < 0) monitor_num = 0; gdk_screen_get_monitor_workarea (screen, monitor_num, &monitor); gtk_widget_get_allocation (priv->align_widget ? priv->align_widget : widget, &allocation); gtk_widget_get_allocation (widget, &arrow_allocation); gtk_widget_get_allocation (priv->menu, &menu_allocation); gdk_window_get_origin (window, x, y); *x += allocation.x; *y += allocation.y; /* treat the default align value like START */ if (align == GTK_ALIGN_FILL) align = GTK_ALIGN_START; if (align == GTK_ALIGN_CENTER) *x -= (menu_allocation.width - allocation.width) / 2; else if ((align == GTK_ALIGN_START && direction == GTK_TEXT_DIR_LTR) || (align == GTK_ALIGN_END && direction == GTK_TEXT_DIR_RTL)) *x += MAX (allocation.width - menu_allocation.width, 0); else if (menu_allocation.width > allocation.width) *x -= menu_allocation.width - allocation.width; if (priv->arrow_type == GTK_ARROW_UP && *y - menu_allocation.height >= monitor.y) { *y -= menu_allocation.height; } else { if ((*y + arrow_allocation.height + menu_allocation.height) <= monitor.y + monitor.height) *y += arrow_allocation.height; else if ((*y - menu_allocation.height) >= monitor.y) *y -= menu_allocation.height; else if (monitor.y + monitor.height - (*y + arrow_allocation.height) > *y) *y += arrow_allocation.height; else *y -= menu_allocation.height; } *push_in = FALSE; }
static void gtk_popup_button_popup_real (GtkPopupButton *popup_button, GdkDevice *device) { GtkPopupButtonPrivate *priv = popup_button->priv; GtkAllocation button_allocation, dock_allocation; GdkScreen *screen; gint monitor_num; GdkRectangle monitor; GtkWidget *toplevel; GdkDevice *keyboard, *pointer; guint32 time; gint x, y; g_return_if_fail (GTK_IS_POPUP_BUTTON (popup_button)); g_return_if_fail (GDK_IS_DEVICE (device)); if (!gtk_widget_get_realized (GTK_WIDGET (popup_button))) return; if (gtk_widget_get_mapped (priv->dock)) return; if (priv->grab_pointer && priv->grab_keyboard) return; time = gtk_get_current_event_time (); if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD) { keyboard = device; pointer = gdk_device_get_associated_device (device); } else { pointer = device; keyboard = gdk_device_get_associated_device (device); } toplevel = gtk_widget_get_toplevel (GTK_WIDGET (popup_button)); if (GTK_IS_WINDOW (toplevel)) gtk_window_group_add_window (gtk_window_get_group (GTK_WINDOW (toplevel)), GTK_WINDOW (priv->dock)); /* positioning */ gtk_widget_show (priv->dock); gtk_widget_get_allocation (GTK_WIDGET (popup_button), &button_allocation); gdk_window_get_root_coords (gtk_widget_get_window (GTK_WIDGET (popup_button)), button_allocation.x, button_allocation.y, &x, &y); gtk_widget_get_allocation (GTK_WIDGET (priv->dock), &dock_allocation); x = (x + button_allocation.width / 2) - (dock_allocation.width / 2); y = y - dock_allocation.height; GdkWindow *window = window = gtk_widget_get_window (GTK_WIDGET (popup_button)); screen = gtk_widget_get_screen (GTK_WIDGET (priv->dock)); monitor_num = gdk_screen_get_monitor_at_window (screen, window); gdk_screen_get_monitor_workarea (screen, monitor_num, &monitor); if (x < monitor.x) x = monitor.x; else if (x + dock_allocation.width > monitor.x + monitor.width) x = monitor.x + monitor.width - dock_allocation.width; gtk_window_move (GTK_WINDOW (priv->dock), x, y); /* grabbing */ gtk_widget_grab_focus (priv->dock); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (popup_button), TRUE); if (gdk_device_grab (pointer, gtk_widget_get_window (priv->dock), GDK_OWNERSHIP_WINDOW, TRUE, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK, NULL, time) != GDK_GRAB_SUCCESS) { gtk_device_grab_remove (priv->dock, pointer); gtk_widget_hide (priv->dock); return; } if (gdk_device_grab (keyboard, gtk_widget_get_window (priv->dock), GDK_OWNERSHIP_WINDOW, TRUE, GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK, NULL, time) != GDK_GRAB_SUCCESS) { gdk_device_ungrab (pointer, time); gtk_device_grab_remove (priv->dock, pointer); gtk_widget_hide (priv->dock); return; } gtk_device_grab_add (priv->dock, pointer, TRUE); priv->grab_pointer = pointer; priv->grab_keyboard = keyboard; }
void rdp_connect(GtkButton *connect, gpointer erdp) { /*get the string info*/ GtkEntry *rip = (GtkEntry *) find_child(erdp, "address"); GtkEntry *ruser = (GtkEntry *) find_child(erdp, "user"); GtkEntry *rpass = (GtkEntry *) find_child(erdp, "pass"); GtkEntry *arguments = (GtkEntry *) find_child(erdp, "arguments"); GtkCheckButton *fullscreen = (GtkCheckButton *) find_child(erdp, "fullscreen"); GtkCheckButton *decorations = (GtkCheckButton *) find_child(erdp, "decorations"); GtkCheckButton *smartscaling = (GtkCheckButton *) find_child(erdp, "smartscaling"); GtkCheckButton *sound = (GtkCheckButton *) find_child(erdp, "sound"); GtkCheckButton *clipboard = (GtkCheckButton *) find_child(erdp, "clipboard"); GtkCheckButton *homedir = (GtkCheckButton *) find_child(erdp, "homedir"); char *xfreerdp = find_executable("xfreerdp"); printf("Xfreerdp path: %s\n", xfreerdp); /*format my strings correctly*/ char *fip = g_strconcat("/v:", gtk_entry_get_text(rip), NULL); char *fuser = g_strconcat("/u:", gtk_entry_get_text(ruser), NULL); char *fpass = g_strconcat("/p:", gtk_entry_get_text(rpass), NULL); /*check to see if the connection is valid*/ if(check_connect(fip, fuser, fpass) != TRUE) { return; } /*check what options to add to rdp from the options tickboxes*/ char **opts = malloc(sizeof(char *)); opts[0] = NULL; opts = add_opt(&opts, xfreerdp); opts = add_opt(&opts, "/cert-ignore"); opts = add_opt(&opts, "/auto-reconnect"); opts = add_opt(&opts, fip); opts = add_opt(&opts, fuser); opts = add_opt(&opts, fpass); if(gtk_toggle_button_get_active((GtkToggleButton*)fullscreen) == TRUE) { opts = add_opt(&opts, "/f"); } if(gtk_toggle_button_get_active((GtkToggleButton*)decorations) == TRUE) { opts = add_opt(&opts, "/disp"); opts = add_opt(&opts, "/fonts"); opts = add_opt(&opts, "/aero"); opts = add_opt(&opts, "/window-drag"); opts = add_opt(&opts, "/menu-anims"); } if(gtk_toggle_button_get_active((GtkToggleButton*)smartscaling) == TRUE) { GdkRectangle *workarea = g_new(GdkRectangle, 1); GdkScreen *screen = gdk_screen_get_default(); gint monitor = gdk_screen_get_primary_monitor(screen); gdk_screen_get_monitor_workarea(screen, monitor, workarea); int width = workarea->width; int height = workarea->height; char sizebuff[32]; snprintf(sizebuff, 31, "/size:%dx%d", width, height); opts = add_opt(&opts, sizebuff); snprintf(sizebuff, 31, "/smart-sizing:%dx%d", width, height); opts = add_opt(&opts, sizebuff); } if(gtk_toggle_button_get_active((GtkToggleButton*)sound) == TRUE) { opts = add_opt(&opts, "/sound"); } if(gtk_toggle_button_get_active((GtkToggleButton*)clipboard) == TRUE) { opts = add_opt(&opts, "/clipboard"); } if(gtk_toggle_button_get_active((GtkToggleButton*)homedir) == TRUE) { opts = add_opt(&opts, "/home-drive"); } /* add the user specified options. We do no error checking */ char *argtext = strdup(gtk_entry_get_text(arguments)); char *argbuff = strtok(argtext, " "); while(argbuff != NULL) { opts = add_opt(&opts, argbuff); strtok(NULL, " "); } /*and call xfreerdp*/ int i; printf("Calling: "); for(i=0; opts[i] != NULL; i++) { if(strncmp(opts[i], "/p:", 3) == 0) { printf("/p:**** "); continue; } printf("%s ", opts[i]); } printf("\n"); execv(xfreerdp, opts); /*code never gets here*/ return; }
/** * gimp_session_info_apply_geometry: * @info: * @screen: * @current_monitor: * * Apply the geometry stored in the session info object to the * associated widget. **/ void gimp_session_info_apply_geometry (GimpSessionInfo *info, GdkScreen *screen, gint current_monitor, gboolean apply_stored_monitor) { GdkRectangle rect; GdkRectangle work_rect; gchar geom[32]; gint monitor; gint width; gint height; g_return_if_fail (GIMP_IS_SESSION_INFO (info)); g_return_if_fail (GTK_IS_WINDOW (info->p->widget)); g_return_if_fail (GDK_IS_SCREEN (screen)); monitor = current_monitor; if (apply_stored_monitor) { gint n_monitors; n_monitors = gdk_screen_get_n_monitors (screen); if (info->p->monitor != DEFAULT_MONITOR && info->p->monitor < n_monitors) { monitor = info->p->monitor; } else { monitor = gdk_screen_get_primary_monitor (screen); } } gdk_screen_get_monitor_geometry (screen, monitor, &rect); gdk_screen_get_monitor_workarea (screen, monitor, &work_rect); info->p->x += rect.x; info->p->y += rect.y; if (gimp_session_info_get_remember_size (info) && info->p->width > 0 && info->p->height > 0) { width = info->p->width; height = info->p->height; } else { GtkRequisition requisition; gtk_widget_size_request (info->p->widget, &requisition); width = requisition.width; height = requisition.height; } info->p->x = CLAMP (info->p->x, work_rect.x, work_rect.x + work_rect.width - width); info->p->y = CLAMP (info->p->y, work_rect.y, work_rect.y + work_rect.height - height); if (info->p->right_align && info->p->bottom_align) { g_strlcpy (geom, "-0-0", sizeof (geom)); } else if (info->p->right_align) { g_snprintf (geom, sizeof (geom), "-0%+d", info->p->y); } else if (info->p->bottom_align) { g_snprintf (geom, sizeof (geom), "%+d-0", info->p->x); } else { g_snprintf (geom, sizeof (geom), "%+d%+d", info->p->x, info->p->y); } gtk_window_parse_geometry (GTK_WINDOW (info->p->widget), geom); if (gimp_session_info_get_remember_size (info) && info->p->width > 0 && info->p->height > 0) { gtk_window_set_default_size (GTK_WINDOW (info->p->widget), info->p->width, info->p->height); } /* Window managers and windowing systems suck. They have their own * ideas about WM standards and when it's appropriate to honor * user/application-set window positions and when not. Therefore, * use brute force and "manually" position dialogs whenever they * are shown. This is important especially for transient dialogs, * because window managers behave even "smarter" then... */ if (GTK_IS_DIALOG (info->p->widget)) g_signal_connect (info->p->widget, "show", G_CALLBACK (gimp_session_info_dialog_show), info); }
int main (int argc, char **argv) { GtkWidget *window; GdkScreen *screen; int monitor; GdkRectangle rect; GError *error = NULL; char *font = NULL; char **remaining = NULL; GtkApplication *application; guint status; GOptionEntry goptions[] = { { "font", 0, 0, G_OPTION_ARG_STRING, &font, N_("Font to start with; ex: 'Serif 27'"), N_("FONT") }, { "version", 0, G_OPTION_FLAG_HIDDEN | G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, option_version_cb, NULL, NULL }, { "print", 'p', 0, G_OPTION_ARG_CALLBACK, option_print_cb, "Print characters in string", "STRING" }, { G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_STRING_ARRAY, &remaining, NULL, N_("[STRING…]") }, { NULL } }; bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); /* Not interested in silly debug spew polluting the journal, bug #749195 */ if (g_getenv ("G_ENABLE_DIAGNOSTIC") == NULL) g_setenv ("G_ENABLE_DIAGNOSTIC", "0", TRUE); /* Set programme name explicitly (see bug #653115) */ g_set_prgname("gucharmap"); if (!gtk_init_with_args (&argc, &argv, NULL, goptions, GETTEXT_PACKAGE, &error)) { g_printerr ("%s\n", error->message); g_error_free (error); exit (1); } g_set_application_name (_("Character Map")); gtk_window_set_default_icon_name (GUCHARMAP_ICON_NAME); application = gtk_application_new ("org.gnome.Charmap", G_APPLICATION_NON_UNIQUE); g_signal_connect (application, "startup", G_CALLBACK (startup_cb), NULL); g_signal_connect (application, "activate", G_CALLBACK (gucharmap_activate), NULL); g_application_register (G_APPLICATION (application), NULL, NULL); /* Gucharmap doesn't work right with the dark theme, see #741939. * Apparently this got fixed in gtk+ some time before 3.22, so * only work around this on older versions. */ if (gtk_check_version (3, 22, 0) != NULL /* < 3.22.0 */) g_object_set (gtk_settings_get_default (), "gtk-application-prefer-dark-theme", FALSE, NULL); window = gucharmap_window_new (application); screen = gtk_window_get_screen (GTK_WINDOW (window)); monitor = gdk_screen_get_monitor_at_point (screen, 0, 0); #if GTK_CHECK_VERSION (3, 3, 5) gdk_screen_get_monitor_workarea (screen, monitor, &rect); #else gdk_screen_get_monitor_geometry (screen, monitor, &rect); #endif gtk_window_set_default_size (GTK_WINDOW (window), rect.width * 9/16, rect.height * 9/16); if (font) { gucharmap_window_set_font (GUCHARMAP_WINDOW (window), font); g_free (font); } gtk_window_present (GTK_WINDOW (window)); if (remaining) { char *str = g_strjoinv (" ", remaining); gucharmap_window_search (GUCHARMAP_WINDOW (window), str); g_free (str); g_strfreev (remaining); } status = g_application_run (G_APPLICATION (application), argc, argv); g_object_unref (application); return status; }