static void gtk_window_transient_parent_unrealized (GtkWidget *parent,
GtkWidget *window);
+static GdkScreen *gtk_window_check_screen (GtkWindow *window);
+
static GtkWindowGeometryInfo* gtk_window_get_geometry_info (GtkWindow *window,
gboolean create);
g_object_notify (G_OBJECT (window), "window_position");
}
+/**
+ * gtk_window_activate_focus:
+ * @window: a #GtkWindow
+ *
+ * Activates the current focused widget within the window.
+ *
+ * Return value: %TRUE if a widget got activated.
+ **/
gboolean
gtk_window_activate_focus (GtkWindow *window)
{
return window->focus_widget;
}
+/**
+ * gtk_window_activate_default:
+ * @window: a #GtkWindow
+ *
+ * Activates the default widget for the window, unless the current
+ * focused widget has been configured to receive the default action
+ * (see #GTK_RECEIVES_DEFAULT in #GtkWidgetFlags), in which case the
+ * focused widget is activated.
+ *
+ * Return value: %TRUE if a widget got activated.
+ **/
gboolean
gtk_window_activate_default (GtkWindow *window)
{
{
g_return_if_fail (GTK_IS_WINDOW (window));
- window->modal = modal != FALSE;
+ modal = modal != FALSE;
+ if (window->modal == modal)
+ return;
+
+ window->modal = modal;
/* adjust desired modality state */
- if (GTK_WIDGET_VISIBLE (window) && window->modal)
- gtk_grab_add (GTK_WIDGET (window));
- else
- gtk_grab_remove (GTK_WIDGET (window));
+ if (GTK_WIDGET_REALIZED (window))
+ {
+ GtkWidget *widget = GTK_WIDGET (window);
+
+ if (window->modal)
+ gdk_window_set_modal_hint (widget->window, TRUE);
+ else
+ gdk_window_set_modal_hint (widget->window, FALSE);
+ }
+
+ if (GTK_WIDGET_VISIBLE (window))
+ {
+ if (window->modal)
+ gtk_grab_add (GTK_WIDGET (window));
+ else
+ gtk_grab_remove (GTK_WIDGET (window));
+ }
g_object_notify (G_OBJECT (window), "modal");
}
* Windows may set a hint asking the desktop environment not to display
* the window in the task bar. This function toggles this hint.
*
+ * Since: 2.2
**/
void
gtk_window_set_skip_taskbar_hint (GtkWindow *window,
* Gets the value set by gtk_window_set_skip_taskbar_hint()
*
* Return value: %TRUE if window shouldn't be in taskbar
+ *
+ * Since: 2.2
**/
gboolean
gtk_window_get_skip_taskbar_hint (GtkWindow *window)
* switcher that displays a thumbnail representation of the windows
* on the screen.)
*
+ * Since: 2.2
**/
void
gtk_window_set_skip_pager_hint (GtkWindow *window,
* Gets the value set by gtk_window_set_skip_pager_hint().
*
* Return value: %TRUE if window shouldn't be in pager
+ *
+ * Since: 2.2
**/
gboolean
gtk_window_get_skip_pager_hint (GtkWindow *window)
* with a pixbuf created by loading the image from @filename.
*
* Returns: %TRUE if setting the icon succeeded.
+ *
+ * Since: 2.2
**/
gboolean
gtk_window_set_icon_from_file (GtkWindow *window,
* on disk. Warns on failure if @err is %NULL.
*
* Returns: %TRUE if setting the icon succeeded.
+ *
+ * Since: 2.2
**/
gboolean
gtk_window_set_default_icon_from_file (const gchar *filename,
if (gtk_window_get_skip_taskbar_hint (window))
gdk_window_set_skip_taskbar_hint (widget->window, TRUE);
- /* transient_for must be set to allow the modal hint */
- if (window->transient_parent && window->modal)
+ if (window->modal)
gdk_window_set_modal_hint (widget->window, TRUE);
else
gdk_window_set_modal_hint (widget->window, FALSE);
GTK_WIDGET_UNSET_FLAGS (widget, GTK_HAS_FOCUS);
fevent->focus_change.type = GDK_FOCUS_CHANGE;
- fevent->focus_change.window = g_object_ref (widget->window);
+ fevent->focus_change.window = widget->window;
+ if (widget->window)
+ g_object_ref (widget->window);
fevent->focus_change.in = in;
gtk_widget_event (widget, fevent);
}
}
+/**
+ * _gtk_window_unset_focus_and_default:
+ * @window: a #GtkWindow
+ * @widget: a widget inside of @window
+ *
+ * Checks whether the focus and default widgets of @window are
+ * @widget or a descendent of @widget, and if so, unset them.
+ **/
+void
+_gtk_window_unset_focus_and_default (GtkWindow *window,
+ GtkWidget *widget)
+
+{
+ GtkWidget *child;
+
+ if (GTK_CONTAINER (widget->parent)->focus_child == widget)
+ {
+ child = window->focus_widget;
+
+ while (child && child != widget)
+ child = child->parent;
+
+ if (child == widget)
+ gtk_window_set_focus (GTK_WINDOW (window), NULL);
+ }
+
+ child = window->default_widget;
+
+ while (child && child != widget)
+ child = child->parent;
+
+ if (child == widget)
+ gtk_window_set_default (window, NULL);
+}
+
/*********************************
* Functions related to resizing *
*********************************/
* stuff, or we could just be losers and assume you have a row
* or column of monitors.
*/
- return gdk_screen_get_n_monitors (window->screen) / 2;
+ return gdk_screen_get_n_monitors (gtk_window_check_screen (window)) / 2;
}
static int
{
gint px, py;
gint monitor_num;
+ GdkScreen *window_screen;
GdkScreen *pointer_screen;
- gdk_display_get_pointer (gdk_screen_get_display (window->screen),
+ window_screen = gtk_window_check_screen (window);
+ gdk_display_get_pointer (gdk_screen_get_display (window_screen),
&pointer_screen,
&px, &py, NULL);
- if (pointer_screen == window->screen)
- monitor_num = gdk_screen_get_monitor_at_point (window->screen, px, py);
+ if (pointer_screen == window_screen)
+ monitor_num = gdk_screen_get_monitor_at_point (pointer_screen, px, py);
else
monitor_num = -1;
if (monitor_num == -1)
monitor_num = get_center_monitor_of_window (window);
-
- gdk_screen_get_monitor_geometry (window->screen, monitor_num, &monitor);
+
+ gdk_screen_get_monitor_geometry (gtk_window_check_screen (window),
+ monitor_num, &monitor);
*x = (monitor.width - w) / 2 + monitor.x;
*y = (monitor.height - h) / 2 + monitor.y;
GtkWindowPosition pos;
GtkWidget *parent_widget;
GtkWindowGeometryInfo *info;
+ GdkScreen *screen;
int x, y;
widget = GTK_WIDGET (window);
+
+ screen = gtk_window_check_screen (window);
gtk_widget_size_request (widget, NULL);
gtk_window_compute_configure_request_size (window, &w, &h);
g_assert (GTK_WIDGET_MAPPED (parent_widget)); /* established earlier */
if (parent_widget->window != NULL)
- monitor_num = gdk_screen_get_monitor_at_window (window->screen,
+ monitor_num = gdk_screen_get_monitor_at_window (screen,
parent_widget->window);
else
monitor_num = -1;
*/
if (monitor_num >= 0)
{
- gdk_screen_get_monitor_geometry (window->screen, monitor_num, &monitor);
+ gdk_screen_get_monitor_geometry (screen, monitor_num, &monitor);
clamp_window_to_rectangle (&x, &y, w, h, &monitor);
}
}
case GTK_WIN_POS_MOUSE:
{
- gint screen_width = gdk_screen_get_width (window->screen);
- gint screen_height = gdk_screen_get_height (window->screen);
+ gint screen_width = gdk_screen_get_width (screen);
+ gint screen_height = gdk_screen_get_height (screen);
gint monitor_num;
GdkRectangle monitor;
GdkScreen *pointer_screen;
gint px, py;
- gdk_display_get_pointer (gdk_screen_get_display (window->screen),
+ gdk_display_get_pointer (gdk_screen_get_display (screen),
&pointer_screen,
&px, &py, NULL);
- if (pointer_screen == window->screen)
- monitor_num = gdk_screen_get_monitor_at_point (window->screen, px, py);
+ if (pointer_screen == screen)
+ monitor_num = gdk_screen_get_monitor_at_point (screen, px, py);
else
monitor_num = -1;
*/
if (monitor_num >= 0)
{
- gdk_screen_get_monitor_geometry (window->screen, monitor_num, &monitor);
+ gdk_screen_get_monitor_geometry (screen, monitor_num, &monitor);
clamp_window_to_rectangle (&x, &y, w, h, &monitor);
}
}
new_request.width, new_request.height);
}
else
- if (widget->window)
- gdk_window_move_resize (widget->window,
- new_request.x, new_request.y,
- new_request.width, new_request.height);
+ gdk_window_move_resize (widget->window,
+ new_request.x, new_request.y,
+ new_request.width, new_request.height);
}
else /* only size changed */
{
gdk_window_resize (window->frame,
new_request.width + window->frame_left + window->frame_right,
new_request.height + window->frame_top + window->frame_bottom);
- if (widget->window)
- gdk_window_resize (widget->window,
- new_request.width, new_request.height);
+ gdk_window_resize (widget->window,
+ new_request.width, new_request.height);
}
/* Increment the number of have-not-yet-received-notify requests */
* You can track the fullscreen state via the "window_state_event" signal
* on #GtkWidget.
*
+ * Since: 2.2
**/
void
gtk_window_fullscreen (GtkWindow *window)
* You can track the fullscreen state via the "window_state_event" signal
* on #GtkWidget.
*
+ * Since: 2.2
**/
void
gtk_window_unfullscreen (GtkWindow *window)
* Sets the #GdkScreen where the @window is displayed; if
* the window is already mapped, it will be unmapped, and
* then remapped on the new screen.
+ *
+ * Since: 2.2
*/
void
gtk_window_set_screen (GtkWindow *window,
GdkScreen *screen)
{
GtkWidget *widget;
+ GdkScreen *previous_screen;
gboolean was_mapped;
g_return_if_fail (GTK_IS_WINDOW (window));
return;
widget = GTK_WIDGET (window);
-
+
+ previous_screen = window->screen;
was_mapped = GTK_WIDGET_MAPPED (widget);
if (was_mapped)
gtk_widget_unmap (widget);
if (GTK_WIDGET_REALIZED (widget))
gtk_widget_unrealize (widget);
-
+
gtk_window_free_key_hash (window);
window->screen = screen;
gtk_widget_reset_rc_styles (widget);
+ if (screen != previous_screen)
+ _gtk_widget_propagate_screen_changed (widget, previous_screen);
g_object_notify (G_OBJECT (window), "screen");
if (was_mapped)
gtk_widget_map (widget);
}
+static GdkScreen *
+gtk_window_check_screen (GtkWindow *window)
+{
+ if (window->screen)
+ return window->screen;
+ else
+ {
+ g_warning ("Screen for GtkWindow not set; you must always set\n"
+ "a screen for a GtkWindow before using the window");
+ return NULL;
+ }
+}
+
/**
* gtk_window_get_screen:
* @window: a #GtkWindow.
* Returns the #GdkScreen associated with @window.
*
* Return value: a #GdkScreen.
+ *
+ * Since: 2.2
*/
GdkScreen*
gtk_window_get_screen (GtkWindow *window)
guint w, h;
GdkGravity grav;
gboolean size_set, pos_set;
+ GdkScreen *screen;
g_return_val_if_fail (GTK_IS_WINDOW (window), FALSE);
g_return_val_if_fail (geometry != NULL, FALSE);
+
+ screen = gtk_window_check_screen (window);
result = gtk_XParseGeometry (geometry, &x, &y, &w, &h);
if (grav == GDK_GRAVITY_SOUTH_WEST ||
grav == GDK_GRAVITY_SOUTH_EAST)
- y = gdk_screen_get_height (window->screen) - h + y;
+ y = gdk_screen_get_height (screen) - h + y;
if (grav == GDK_GRAVITY_SOUTH_EAST ||
grav == GDK_GRAVITY_NORTH_EAST)
- x = gdk_screen_get_width (window->screen) - w + x;
+ x = gdk_screen_get_width (screen) - w + x;
/* we don't let you put a window offscreen; maybe some people would
* prefer to be able to, but it's kind of a bogus thing to do.
static GtkKeyHash *
gtk_window_get_key_hash (GtkWindow *window)
{
+ GdkScreen *screen = gtk_window_check_screen (window);
GtkKeyHash *key_hash = g_object_get_data (G_OBJECT (window), "gtk-window-key-hash");
+
if (key_hash)
return key_hash;
- key_hash = _gtk_key_hash_new (gdk_keymap_get_for_display (gdk_screen_get_display (window->screen)),
+ key_hash = _gtk_key_hash_new (gdk_keymap_get_for_display (gdk_screen_get_display (screen)),
(GDestroyNotify)g_free);
_gtk_window_keys_foreach (window, add_to_key_hash, key_hash);
g_object_set_data (G_OBJECT (window), "gtk-window-key-hash", key_hash);
* temporarily, show your splash screen, then re-enable it so that
* showing the main window would automatically result in notification.
*
+ * Since: 2.2
**/
void
gtk_window_set_auto_startup_notification (gboolean setting)
projects / ~andy / gtk / blobdiff