#include "gtkwindow.h"
#include "gtkwindow-decorate.h"
#include "gtkbindings.h"
+#include "gtkkeyhash.h"
#include "gtkmain.h"
#include "gtkiconfactory.h"
#include "gtkintl.h"
+#include "gtkmarshalers.h"
enum {
SET_FOCUS,
ACTIVATE_FOCUS,
ACTIVATE_DEFAULT,
MOVE_FOCUS,
+ KEYS_CHANGED,
LAST_SIGNAL
};
* we sent the last configure request.
*/
guint position_constraints_changed : 1;
+
+ /* if true, default_width, height come from gtk_window_parse_geometry,
+ * and thus should be multiplied by the increments and affect the
+ * geometry widget only
+ */
+ guint default_is_geometry : 1;
GtkWindowLastGeometryInfo last;
};
static void gtk_window_real_activate_focus (GtkWindow *window);
static void gtk_window_move_focus (GtkWindow *window,
GtkDirectionType dir);
+static void gtk_window_keys_changed (GtkWindow *window);
static void gtk_window_read_rcfiles (GtkWidget *widget,
GdkEventClient *event);
static void gtk_window_paint (GtkWidget *widget,
gboolean change_width,
gint width,
gboolean change_height,
- gint height);
+ gint height,
+ gboolean is_geometry);
static void gtk_window_realize_icon (GtkWindow *window);
static void gtk_window_unrealize_icon (GtkWindow *window);
+static void gtk_window_notify_keys_changed (GtkWindow *window);
+static GtkKeyHash *gtk_window_get_key_hash (GtkWindow *window);
+static void gtk_window_free_key_hash (GtkWindow *window);
+
static GSList *toplevel_list = NULL;
static GHashTable *mnemonic_hash_table = NULL;
static GtkBinClass *parent_class = NULL;
return window_type;
}
+static void
+add_tab_bindings (GtkBindingSet *binding_set,
+ GdkModifierType modifiers,
+ GtkDirectionType direction)
+{
+ gtk_binding_entry_add_signal (binding_set, GDK_Tab, modifiers,
+ "move_focus", 1,
+ GTK_TYPE_DIRECTION_TYPE, direction);
+ gtk_binding_entry_add_signal (binding_set, GDK_KP_Tab, modifiers,
+ "move_focus", 1,
+ GTK_TYPE_DIRECTION_TYPE, direction);
+}
+
+static void
+add_arrow_bindings (GtkBindingSet *binding_set,
+ guint keysym,
+ GtkDirectionType direction)
+{
+ guint keypad_keysym = keysym - GDK_Left + GDK_KP_Left;
+
+ gtk_binding_entry_add_signal (binding_set, keysym, 0,
+ "move_focus", 1,
+ GTK_TYPE_DIRECTION_TYPE, direction);
+ gtk_binding_entry_add_signal (binding_set, keysym, GDK_CONTROL_MASK,
+ "move_focus", 1,
+ GTK_TYPE_DIRECTION_TYPE, direction);
+ gtk_binding_entry_add_signal (binding_set, keypad_keysym, 0,
+ "move_focus", 1,
+ GTK_TYPE_DIRECTION_TYPE, direction);
+ gtk_binding_entry_add_signal (binding_set, keypad_keysym, GDK_CONTROL_MASK,
+ "move_focus", 1,
+ GTK_TYPE_DIRECTION_TYPE, direction);
+}
+
+
static void
gtk_window_class_init (GtkWindowClass *klass)
{
parent_class = gtk_type_class (gtk_bin_get_type ());
+ mnemonic_hash_table = g_hash_table_new (mnemonic_hash, mnemonic_equal);
+
gobject_class->dispose = gtk_window_dispose;
gobject_class->finalize = gtk_window_finalize;
klass->activate_default = gtk_window_real_activate_default;
klass->activate_focus = gtk_window_real_activate_focus;
klass->move_focus = gtk_window_move_focus;
+ klass->keys_changed = gtk_window_keys_changed;
/* Construct */
g_object_class_install_property (gobject_class,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWindowClass, set_focus),
NULL, NULL,
- gtk_marshal_VOID__OBJECT,
+ _gtk_marshal_VOID__OBJECT,
G_TYPE_NONE, 1,
GTK_TYPE_WIDGET);
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(GtkWindowClass, frame_event),
_gtk_boolean_handled_accumulator, NULL,
- gtk_marshal_BOOLEAN__BOXED,
+ _gtk_marshal_BOOLEAN__BOXED,
G_TYPE_BOOLEAN, 1,
GDK_TYPE_EVENT);
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
GTK_SIGNAL_OFFSET (GtkWindowClass, activate_focus),
NULL, NULL,
- gtk_marshal_VOID__VOID,
+ _gtk_marshal_VOID__VOID,
G_TYPE_NONE,
0);
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
GTK_SIGNAL_OFFSET (GtkWindowClass, activate_default),
NULL, NULL,
- gtk_marshal_VOID__VOID,
+ _gtk_marshal_VOID__VOID,
G_TYPE_NONE,
0);
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
GTK_SIGNAL_OFFSET (GtkWindowClass, move_focus),
NULL, NULL,
- gtk_marshal_VOID__ENUM,
+ _gtk_marshal_VOID__ENUM,
G_TYPE_NONE,
1,
GTK_TYPE_DIRECTION_TYPE);
-
- if (!mnemonic_hash_table)
- mnemonic_hash_table = g_hash_table_new (mnemonic_hash,
- mnemonic_equal);
+
+ window_signals[KEYS_CHANGED] =
+ g_signal_new ("keys_changed",
+ G_OBJECT_CLASS_TYPE (object_class),
+ G_SIGNAL_RUN_FIRST,
+ GTK_SIGNAL_OFFSET (GtkWindowClass, keys_changed),
+ NULL, NULL,
+ gtk_marshal_VOID__VOID,
+ G_TYPE_NONE,
+ 0);
/*
* Key bindings
gtk_binding_entry_add_signal (binding_set, GDK_KP_Enter, 0,
"activate_default", 0);
- gtk_binding_entry_add_signal (binding_set, GDK_Up, 0,
- "move_focus", 1,
- GTK_TYPE_DIRECTION_TYPE, GTK_DIR_UP);
- gtk_binding_entry_add_signal (binding_set, GDK_KP_Up, 0,
- "move_focus", 1,
- GTK_TYPE_DIRECTION_TYPE, GTK_DIR_UP);
-
- gtk_binding_entry_add_signal (binding_set, GDK_Down, 0,
- "move_focus", 1,
- GTK_TYPE_DIRECTION_TYPE, GTK_DIR_DOWN);
- gtk_binding_entry_add_signal (binding_set, GDK_KP_Down, 0,
- "move_focus", 1,
- GTK_TYPE_DIRECTION_TYPE, GTK_DIR_DOWN);
+ add_arrow_bindings (binding_set, GDK_Up, GTK_DIR_UP);
+ add_arrow_bindings (binding_set, GDK_Down, GTK_DIR_DOWN);
+ add_arrow_bindings (binding_set, GDK_Left, GTK_DIR_LEFT);
+ add_arrow_bindings (binding_set, GDK_Right, GTK_DIR_RIGHT);
- gtk_binding_entry_add_signal (binding_set, GDK_Left, 0,
- "move_focus", 1,
- GTK_TYPE_DIRECTION_TYPE, GTK_DIR_LEFT);
- gtk_binding_entry_add_signal (binding_set, GDK_KP_Left, 0,
- "move_focus", 1,
- GTK_TYPE_DIRECTION_TYPE, GTK_DIR_LEFT);
-
- gtk_binding_entry_add_signal (binding_set, GDK_Right, 0,
- "move_focus", 1,
- GTK_TYPE_DIRECTION_TYPE, GTK_DIR_RIGHT);
- gtk_binding_entry_add_signal (binding_set, GDK_KP_Right, 0,
- "move_focus", 1,
- GTK_TYPE_DIRECTION_TYPE, GTK_DIR_RIGHT);
-
- gtk_binding_entry_add_signal (binding_set, GDK_Tab, 0,
- "move_focus", 1,
- GTK_TYPE_DIRECTION_TYPE, GTK_DIR_TAB_FORWARD);
- gtk_binding_entry_add_signal (binding_set, GDK_KP_Tab, 0,
- "move_focus", 1,
- GTK_TYPE_DIRECTION_TYPE, GTK_DIR_TAB_FORWARD);
- gtk_binding_entry_add_signal (binding_set, GDK_ISO_Left_Tab, 0,
- "move_focus", 1,
- GTK_TYPE_DIRECTION_TYPE, GTK_DIR_TAB_FORWARD);
-
- gtk_binding_entry_add_signal (binding_set, GDK_Tab, GDK_SHIFT_MASK,
- "move_focus", 1,
- GTK_TYPE_DIRECTION_TYPE, GTK_DIR_TAB_BACKWARD);
- gtk_binding_entry_add_signal (binding_set, GDK_KP_Tab, GDK_SHIFT_MASK,
- "move_focus", 1,
- GTK_TYPE_DIRECTION_TYPE, GTK_DIR_TAB_BACKWARD);
- gtk_binding_entry_add_signal (binding_set, GDK_ISO_Left_Tab, GDK_SHIFT_MASK,
- "move_focus", 1,
- GTK_TYPE_DIRECTION_TYPE, GTK_DIR_TAB_BACKWARD);
+ add_tab_bindings (binding_set, 0, GTK_DIR_TAB_FORWARD);
+ add_tab_bindings (binding_set, GDK_CONTROL_MASK, GTK_DIR_TAB_FORWARD);
+ add_tab_bindings (binding_set, GDK_SHIFT_MASK, GTK_DIR_TAB_BACKWARD);
+ add_tab_bindings (binding_set, GDK_CONTROL_MASK | GDK_SHIFT_MASK, GTK_DIR_TAB_BACKWARD);
}
static void
case PROP_DEFAULT_WIDTH:
gtk_window_set_default_size_internal (window,
TRUE, g_value_get_int (value),
- FALSE, -1);
+ FALSE, -1, FALSE);
break;
case PROP_DEFAULT_HEIGHT:
gtk_window_set_default_size_internal (window,
FALSE, -1,
- TRUE, g_value_get_int (value));
+ TRUE, g_value_get_int (value), FALSE);
break;
case PROP_DESTROY_WITH_PARENT:
gtk_window_set_destroy_with_parent (window, g_value_get_boolean (value));
* be #GTK_WINDOW_TOPLEVEL. If you're implementing something like a
* popup menu from scratch (which is a bad idea, just use #GtkMenu),
* you might use #GTK_WINDOW_POPUP. #GTK_WINDOW_POPUP is not for
- * dialogs, though in some other toolkits dialogs are called "popups."
+ * dialogs, though in some other toolkits dialogs are called "popups".
* In GTK+, #GTK_WINDOW_POPUP means a pop-up menu or pop-up tooltip.
- * Popup windows are not controlled by the window manager.
+ * On X11, popup windows are not controlled by the <link
+ * linkend="gtk-X11-arch">window manager</link>.
*
* If you simply want an undecorated window (no window borders), use
* gtk_window_set_decorated(), don't use #GTK_WINDOW_POPUP.
* @window: a #GtkWindow
* @title: title of the window
*
- * Sets the title of the #GtkWindow. The title of a window will be displayed in
- * its title bar; on the X Window System, the title bar is rendered by the
- * window manager, so exactly how the title appears to users may vary according
- * to a user's exact configuration. The title should help a user distinguish
- * this window from other windows they may have open. A good title might
- * include the application name and current document filename, for example.
+ * Sets the title of the #GtkWindow. The title of a window will be
+ * displayed in its title bar; on the X Window System, the title bar
+ * is rendered by the <link linkend="gtk-X11-arch">window
+ * manager</link>, so exactly how the title appears to users may vary
+ * according to a user's exact configuration. The title should help a
+ * user distinguish this window from other windows they may have
+ * open. A good title might include the application name and current
+ * document filename, for example.
*
**/
void
* Don't use this function. It sets the X Window System "class" and
* "name" hints for a window. According to the ICCCM, you should
* always set these to the same value for all windows in an
- * application, and GTK sets them to that value by default, so calling
+ * application, and GTK+ sets them to that value by default, so calling
* this function is sort of pointless. However, you may want to call
* gtk_window_set_role() on each window in your application, for the
* benefit of the session manager. Setting the role allows the window
* @window: a #GtkWindow
* @role: unique identifier for the window to be used when restoring a session
*
+ * This function is only useful on X11, not with other GTK+ targets.
+ *
* In combination with the window title, the window role allows a
- * window manager to identify "the same" window when an application is
- * restarted. So for example you might set the "toolbox" role on your
- * app's toolbox window, so that when the user restarts their session,
- * the window manager can put the toolbox back in the same place.
+ * <link linkend="gtk-X11-arch">window manager</link> to identify "the
+ * same" window when an application is restarted. So for example you
+ * might set the "toolbox" role on your app's toolbox window, so that
+ * when the user restarts their session, the window manager can put
+ * the toolbox back in the same place.
*
* If a window already has a unique title, you don't need to set the
* role, since the WM can use the title to identify the window when
/**
* gtk_window_set_focus:
* @window: a #GtkWindow
- * @focus: widget to be the new focus widget
+ * @focus: widget to be the new focus widget, or %NULL to unset
+ * any focus widget for the toplevel window.
*
- * If @focus is not the current focus widget, and is focusable, emits
- * the "set_focus" signal to set @focus as the focus widget for the
- * window. This function is more or less GTK-internal; to focus an
- * entry widget or the like, you should use gtk_widget_grab_focus()
- * instead of this function.
- *
+ * If @focus is not the current focus widget, and is focusable, sets
+ * it as the focus widget for the window. If @focus is %NULL, unsets
+ * the focus widget for this window. To set the focus to a particular
+ * widget in the toplevel, it is usually more convenient to use
+ * gtk_widget_grab_focus() instead of this function.
**/
void
gtk_window_set_focus (GtkWindow *window,
g_return_if_fail (GTK_WIDGET_CAN_FOCUS (focus));
}
+ if (focus)
+ gtk_widget_grab_focus (focus);
+ else
+ _gtk_window_internal_set_focus (window, NULL);
+}
+
+void
+_gtk_window_internal_set_focus (GtkWindow *window,
+ GtkWidget *focus)
+{
+ g_return_if_fail (GTK_IS_WINDOW (window));
+
if ((window->focus_widget != focus) ||
(focus && !GTK_WIDGET_HAS_FOCUS (focus)))
gtk_signal_emit (GTK_OBJECT (window), window_signals[SET_FOCUS], focus);
/**
* gtk_window_set_default:
* @window: a #GtkWindow
- * @default_widget: widget to be the default
+ * @default_widget: widget to be the default, or %NULL to unset the
+ * default widget for the toplevel.
*
* The default widget is the widget that's activated when the user
- * presses Enter in a dialog (for example). This function tells a
- * #GtkWindow about the current default widget; it's really a GTK
- * internal function and you shouldn't need it. Instead, to change the
- * default widget, first set the #GTK_CAN_DEFAULT flag on the widget
- * you'd like to make the default using GTK_WIDGET_SET_FLAGS(), then
- * call gtk_widget_grab_default() to move the default.
- *
+ * presses Enter in a dialog (for example). This function sets or
+ * unsets the default widget for a #GtkWindow about. When setting
+ * (rather than unsetting) the default widget it's generally easier to
+ * call gtk_widget_grab_focus() on the widget. Before making a widget
+ * the default widget, you must set the #GTK_CAN_DEFAULT flag on the
+ * widget you'd like to make the default using GTK_WIDGET_SET_FLAGS().
**/
void
gtk_window_set_default (GtkWindow *window,
if (default_widget)
g_return_if_fail (GTK_WIDGET_CAN_DEFAULT (default_widget));
-
+
if (window->default_widget != default_widget)
{
+ GtkWidget *old_default_widget = NULL;
+
+ if (default_widget)
+ g_object_ref (default_widget);
+
if (window->default_widget)
{
+ old_default_widget = window->default_widget;
+
if (window->focus_widget != window->default_widget ||
!GTK_WIDGET_RECEIVES_DEFAULT (window->default_widget))
GTK_WIDGET_UNSET_FLAGS (window->default_widget, GTK_HAS_DEFAULT);
GTK_WIDGET_SET_FLAGS (window->default_widget, GTK_HAS_DEFAULT);
gtk_widget_queue_draw (window->default_widget);
}
+
+ if (old_default_widget)
+ g_object_notify (G_OBJECT (old_default_widget), "has_default");
+
+ if (default_widget)
+ {
+ g_object_notify (G_OBJECT (default_widget), "has_default");
+ g_object_unref (default_widget);
+ }
}
}
gtk_widget_queue_resize (GTK_WIDGET (window));
}
+static gboolean
+handle_keys_changed (gpointer data)
+{
+ GtkWindow *window;
+
+ GDK_THREADS_ENTER ();
+ window = GTK_WINDOW (data);
+
+ if (window->keys_changed_handler)
+ {
+ gtk_idle_remove (window->keys_changed_handler);
+ window->keys_changed_handler = 0;
+ }
+
+ g_signal_emit (window, window_signals[KEYS_CHANGED], 0);
+ GDK_THREADS_LEAVE ();
+
+ return FALSE;
+}
+
+static void
+gtk_window_notify_keys_changed (GtkWindow *window)
+{
+ if (!window->keys_changed_handler)
+ window->keys_changed_handler = gtk_idle_add (handle_keys_changed, window);
+}
+
+/**
+ * gtk_window_add_accel_group:
+ * @window: window to attach accelerator group to
+ * @accel_group: a #GtkAccelGroup
+ *
+ * Associate @accel_group with @window, such that calling
+ * gtk_accel_groups_activate() on @window will activate accelerators
+ * in @accel_group.
+ **/
void
-gtk_window_add_accel_group (GtkWindow *window,
- GtkAccelGroup *accel_group)
+gtk_window_add_accel_group (GtkWindow *window,
+ GtkAccelGroup *accel_group)
{
g_return_if_fail (GTK_IS_WINDOW (window));
- g_return_if_fail (accel_group != NULL);
+ g_return_if_fail (GTK_IS_ACCEL_GROUP (accel_group));
- gtk_accel_group_attach (accel_group, G_OBJECT (window));
+ _gtk_accel_group_attach (accel_group, G_OBJECT (window));
+ g_signal_connect_object (accel_group, "accel_changed",
+ G_CALLBACK (gtk_window_notify_keys_changed),
+ window, G_CONNECT_SWAPPED);
}
+/**
+ * gtk_window_remove_accel_group:
+ * @window: a #GtkWindow
+ * @accel_group: a #GtkAccelGroup
+ *
+ * Reverses the effects of gtk_window_add_accel_group().
+ **/
void
-gtk_window_remove_accel_group (GtkWindow *window,
- GtkAccelGroup *accel_group)
+gtk_window_remove_accel_group (GtkWindow *window,
+ GtkAccelGroup *accel_group)
{
g_return_if_fail (GTK_IS_WINDOW (window));
- g_return_if_fail (accel_group != NULL);
+ g_return_if_fail (GTK_IS_ACCEL_GROUP (accel_group));
- gtk_accel_group_detach (accel_group, G_OBJECT (window));
+ g_signal_handlers_disconnect_by_func (accel_group,
+ G_CALLBACK (gtk_window_notify_keys_changed),
+ window);
+ _gtk_accel_group_detach (accel_group, G_OBJECT (window));
}
void
if (mnemonic)
{
g_return_if_fail (g_slist_find (mnemonic->targets, target) == NULL);
- mnemonic->targets = g_slist_prepend (mnemonic->targets, target);
+ mnemonic->targets = g_slist_append (mnemonic->targets, target);
}
else
{
mnemonic->targets = g_slist_prepend (NULL, target);
g_hash_table_insert (mnemonic_hash_table, mnemonic, mnemonic);
}
+ gtk_window_notify_keys_changed (window);
}
void
g_hash_table_remove (mnemonic_hash_table, mnemonic);
g_free (mnemonic);
}
+ gtk_window_notify_keys_changed (window);
}
gboolean
return FALSE;
}
+/**
+ * gtk_window_set_mnemonic_modifier:
+ * @window: a #GtkWindow
+ * @modifier: the modifier mask used to activate
+ * mnemonics on this window.
+ *
+ * Sets the mnemonic modifier for this window.
+ **/
void
gtk_window_set_mnemonic_modifier (GtkWindow *window,
GdkModifierType modifier)
g_return_if_fail ((modifier & ~GDK_MODIFIER_MASK) == 0);
window->mnemonic_modifier = modifier;
+ gtk_window_notify_keys_changed (window);
}
/**
return window->mnemonic_modifier;
}
+/**
+ * gtk_window_set_position:
+ * @window: a #GtkWindow.
+ * @position: a position constraint.
+ *
+ * Sets a position constraint for this window. If the old or new
+ * constraint is %GTK_WIN_POS_CENTER_ALWAYS, this will also cause
+ * the window to be repositioned to satisfy the new constraint.
+ **/
void
gtk_window_set_position (GtkWindow *window,
GtkWindowPosition position)
* Retrieves the current focused widget within the window.
* Note that this is the widget that would have the focus
* if the toplevel window focused; if the toplevel window
- * is not focused the GTK_WIDGET_HAS_FOCUS(widget) will
+ * is not focused then <literal>GTK_WIDGET_HAS_FOCUS (widget)</literal> will
* not be %TRUE for the widget.
*
* Return value: the currently focused widget.
* with other windows in the same application. To keep modal dialogs
* on top of main application windows, use
* gtk_window_set_transient_for() to make the dialog transient for the
- * parent; most window managers will then disallow lowering the dialog
- * below the parent.
+ * parent; most <link linkend="gtk-X11-arch">window managers</link>
+ * will then disallow lowering the dialog below the parent.
*
*
**/
* Returns a list of all existing toplevel windows. The widgets
* in the list are not individually referenced. If you want
* to iterate through the list and perform actions involving
- * callbacks that might destroy the widgets, you MUST call
- * g_list_foreach (result, (GFunc)g_object_ref, NULL) first, and
+ * callbacks that might destroy the widgets, you <emphasis>must</emphasis> call
+ * <literal>g_list_foreach (result, (GFunc)g_object_ref, NULL)</literal> first, and
* then unref all the widgets afterwards.
*
* Return value: list of toplevel widgets
static void
gtk_window_dispose (GObject *object)
{
- GtkWindow *window;
-
- g_return_if_fail (GTK_IS_WINDOW (object));
-
- window = GTK_WINDOW (object);
+ GtkWindow *window = GTK_WINDOW (object);
gtk_window_set_focus (window, NULL);
gtk_window_set_default (window, NULL);
* @parent: parent window
*
* Dialog windows should be set transient for the main application
- * window they were spawned from. This allows window managers to
- * e.g. keep the dialog on top of the main window, or center the
- * dialog over the main window. gtk_dialog_new_with_buttons() and
- * other convenience functions in GTK+ will sometimes call
+ * window they were spawned from. This allows <link
+ * linkend="gtk-X11-arch">window managers</link> to e.g. keep the
+ * dialog on top of the main window, or center the dialog over the
+ * main window. gtk_dialog_new_with_buttons() and other convenience
+ * functions in GTK+ will sometimes call
* gtk_window_set_transient_for() on your behalf.
+ *
+ * On Windows, this function will and put the child window
+ * on top of the parent, much as the window manager would have
+ * done on X.
*
**/
void
* @window: a #GtkWindow
* @setting: whether to destroy @window with its transient parent
*
- * If @setting is TRUE, then destroying the transient parent of @window
+ * If @setting is %TRUE, then destroying the transient parent of @window
* will also destroy @window itself. This is useful for dialogs that
* shouldn't persist beyond the lifetime of the main window they're
* associated with, for example.
info->initial_x = 0;
info->initial_y = 0;
info->initial_pos_set = FALSE;
+ info->default_is_geometry = FALSE;
info->position_constraints_changed = FALSE;
info->last.configure_request.x = 0;
info->last.configure_request.y = 0;
{
GtkWindowGeometryInfo *info;
- g_return_if_fail (window != NULL);
+ g_return_if_fail (GTK_IS_WINDOW (window));
+ g_return_if_fail (geometry_widget == NULL || GTK_IS_WIDGET (geometry_widget));
info = gtk_window_get_geometry_info (window, TRUE);
* @setting: %TRUE to decorate the window
*
* By default, windows are decorated with a title bar, resize
- * controls, etc. Some window managers allow GTK+ to disable these
- * decorations, creating a borderless window. If you set the decorated
- * property to %FALSE using this function, GTK+ will do its best to
- * convince the window manager not to decorate the window.
+ * controls, etc. Some <link linkend="gtk-X11-arch">window
+ * managers</link> allow GTK+ to disable these decorations, creating a
+ * borderless window. If you set the decorated property to %FALSE
+ * using this function, GTK+ will do its best to convince the window
+ * manager not to decorate the window.
+ *
+ * On Windows, this function always works, since there's no window manager
+ * policy involved.
*
**/
void
{
GtkWindowIconInfo *info;
+ g_return_val_if_fail (GTK_IS_WINDOW (window), NULL);
+
info = get_icon_info (window);
if (info && info->icon_list)
return GDK_PIXBUF (info->icon_list->data);
gboolean change_width,
gint width,
gboolean change_height,
- gint height)
+ gint height,
+ gboolean is_geometry)
{
GtkWindowGeometryInfo *info;
- g_return_if_fail (GTK_IS_WINDOW (window));
g_return_if_fail (change_width == FALSE || width >= -1);
g_return_if_fail (change_height == FALSE || height >= -1);
g_object_freeze_notify (G_OBJECT (window));
+ info->default_is_geometry = is_geometry != FALSE;
+
if (change_width)
{
if (width == 0)
* For more control over a window's initial size and how resizing works,
* investigate gtk_window_set_geometry_hints().
*
- * A useful feature: if you set the "geometry widget" via
- * gtk_window_set_geometry_hints(), the default size specified by
- * gtk_window_set_default_size() will be the default size of that
- * widget, not of the entire window.
- *
* For some uses, gtk_window_resize() is a more appropriate function.
* gtk_window_resize() changes the current size of the window, rather
* than the size to be used on initial display. gtk_window_resize() always
g_return_if_fail (width >= -1);
g_return_if_fail (height >= -1);
- gtk_window_set_default_size_internal (window, TRUE, width, TRUE, height);
+ gtk_window_set_default_size_internal (window, TRUE, width, TRUE, height, FALSE);
}
/**
/**
* gtk_window_resize:
* @window: a #GtkWindow
- * @width: width to resize the window to
- * @height: height to resize the window to
+ * @width: width in pixels to resize the window to
+ * @height: height in pixels to resize the window to
*
* Resizes the window as if the user had done so, obeying geometry
* constraints. The default geometry constraint is that windows may
* @height: return location for height, or %NULL
*
* Obtains the current size of @window. If @window is not onscreen,
- * it returns the size GTK+ will suggest to the window manager for the
- * initial window size (but this is not reliably the same as the size
- * the window manager will actually select). The size obtained by
+ * it returns the size GTK+ will suggest to the <link
+ * linkend="gtk-X11-arch">window manager</link> for the initial window
+ * size (but this is not reliably the same as the size the window
+ * manager will actually select). The size obtained by
* gtk_window_get_size() is the last size received in a
* #GdkEventConfigure, that is, GTK+ uses its locally-stored size,
* rather than querying the X server for the size. As a result, if you
* "configure_event" on the window and adjust your size-dependent
* state to match the size delivered in the #GdkEventConfigure.
*
- * Note 2: The returned size does NOT include the size of the window
- * manager decorations (aka the window frame or border). Those
- * are not drawn by GTK+ and GTK+ has no reliable method of
- * determining their size.
+ * Note 2: The returned size does <emphasis>not</emphasis> include the
+ * size of the window manager decorations (aka the window frame or
+ * border). Those are not drawn by GTK+ and GTK+ has no reliable
+ * method of determining their size.
*
* Note 3: If you are getting a window size in order to position
* the window onscreen, there may be a better way. The preferred
* way is to simply set the window's semantic type with
* gtk_window_set_type_hint(), which allows the window manager to
* e.g. center dialogs. Also, if you set the transient parent of
- * dialogs with gtk_widget_set_transient_for() window managers
+ * dialogs with gtk_window_set_transient_for() window managers
* will often center the dialog over its parent window. It's
* much preferred to let the window manager handle these
* things rather than doing it yourself, because all apps will
* application cannot.
*
* In any case, if you insist on application-specified window
- * positioning, there's STILL a better way than doing it yourself -
- * gtk_window_set_position() will frequently handle the details
- * for you.
+ * positioning, there's <emphasis>still</emphasis> a better way than
+ * doing it yourself - gtk_window_set_position() will frequently
+ * handle the details for you.
*
**/
void
* @x: X coordinate to move window to
* @y: Y coordinate to move window to
*
- * Asks the window manager to move @window to the given position.
- * Window managers are free to ignore this; most window managers
- * ignore requests for initial window positions (instead using a
- * user-defined placement algorithm) and honor requests after the
- * window has already been shown.
+ * Asks the <link linkend="gtk-X11-arch">window manager</link> to move
+ * @window to the given position. Window managers are free to ignore
+ * this; most window managers ignore requests for initial window
+ * positions (instead using a user-defined placement algorithm) and
+ * honor requests after the window has already been shown.
*
* Note: the position is the position of the gravity-determined
* reference point for the window. The gravity determines two things:
* the bottom-right corner of the window border will be placed at that
* reference point. So, to place a window in the bottom right corner
* you would first set gravity to south east, then write:
- * gtk_window_move (window, gdk_screen_width () - window_width,
- * gdk_screen_height () - window_height).
+ * <literal>gtk_window_move (window, gdk_screen_width () - window_width,
+ * gdk_screen_height () - window_height)</literal>.
*
- * The extended window manager hints specification at
- * http://www.freedesktop.org/standards/wm-spec.html has a nice table
- * of gravities in the "implementation notes" section.
+ * The extended window manager hints specification at <ulink
+ * url="http://www.freedesktop.org/standards/wm-spec.html"
+ * >http://www.freedesktop.org/standards/wm-spec.html</ulink> has a
+ * nice table of gravities in the "implementation notes" section.
*
* The gtk_window_get_position() documentation may also be relevant.
*
* Thus GTK+ is using a "best guess" that works with most
* window managers.
*
- * Moreover, nearly all window managers are broken with respect to
- * their handling of window gravity. So moving a window to its current
- * position as returned by gtk_window_get_position() tends to
- * result in moving the window slightly.
+ * Moreover, nearly all window managers are historically broken with
+ * respect to their handling of window gravity. So moving a window to
+ * its current position as returned by gtk_window_get_position() tends
+ * to result in moving the window slightly. Window managers are
+ * slowly getting better over time.
*
* If a window has gravity #GDK_GRAVITY_STATIC the window manager
* frame is not relevant, and thus gtk_window_get_position() will
static void
gtk_window_destroy (GtkObject *object)
{
- GtkWindow *window;
-
- g_return_if_fail (GTK_IS_WINDOW (object));
-
- window = GTK_WINDOW (object);
+ GtkWindow *window = GTK_WINDOW (object);
if (window->transient_parent)
gtk_window_set_transient_for (window, NULL);
if (window->group)
gtk_window_group_remove_window (window->group, window);
- GTK_OBJECT_CLASS (parent_class)->destroy (object);
+ gtk_window_free_key_hash (window);
+
+ GTK_OBJECT_CLASS (parent_class)->destroy (object);
}
static gboolean
static void
gtk_window_finalize (GObject *object)
{
- GtkWindow *window;
-
- g_return_if_fail (GTK_IS_WINDOW (object));
-
- window = GTK_WINDOW (object);
+ GtkWindow *window = GTK_WINDOW (object);
toplevel_list = g_slist_remove (toplevel_list, window);
&window->geometry_info->widget);
g_free (window->geometry_info);
}
-
+
+ if (window->keys_changed_handler)
+ {
+ gtk_idle_remove (window->keys_changed_handler);
+ window->keys_changed_handler = 0;
+ }
+
G_OBJECT_CLASS (parent_class)->finalize (object);
}
GtkWindow *window = GTK_WINDOW (widget);
GtkContainer *container = GTK_CONTAINER (window);
gboolean need_resize;
-
+
GTK_WIDGET_SET_FLAGS (widget, GTK_VISIBLE);
need_resize = container->need_resize || !GTK_WIDGET_REALIZED (widget);
container->need_resize = FALSE;
-
+
if (need_resize)
{
GtkWindowGeometryInfo *info = gtk_window_get_geometry_info (window, TRUE);
gtk_widget_map (widget);
+ /* Try to make sure that we have some focused widget
+ */
+ if (!window->focus_widget)
+ gtk_window_move_focus (window, GTK_DIR_TAB_FORWARD);
+
if (window->modal)
gtk_grab_add (widget);
}
static void
gtk_window_hide (GtkWidget *widget)
{
- GtkWindow *window;
-
- g_return_if_fail (GTK_IS_WINDOW (widget));
-
- window = GTK_WINDOW (widget);
+ GtkWindow *window = GTK_WINDOW (widget);
GTK_WIDGET_UNSET_FLAGS (widget, GTK_VISIBLE);
gtk_widget_unmap (widget);
static void
gtk_window_map (GtkWidget *widget)
{
- GtkWindow *window;
+ GtkWindow *window = GTK_WINDOW (widget);
GdkWindow *toplevel;
- g_return_if_fail (GTK_IS_WINDOW (widget));
-
GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
- window = GTK_WINDOW (widget);
-
if (window->bin.child &&
GTK_WIDGET_VISIBLE (window->bin.child) &&
!GTK_WIDGET_MAPPED (window->bin.child))
static void
gtk_window_unmap (GtkWidget *widget)
{
- GtkWindow *window;
+ GtkWindow *window = GTK_WINDOW (widget);
GtkWindowGeometryInfo *info;
- window = GTK_WINDOW (widget);
-
GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
if (window->frame)
gdk_window_withdraw (window->frame);
GdkWindowAttr attributes;
gint attributes_mask;
- g_return_if_fail (GTK_IS_WINDOW (widget));
-
window = GTK_WINDOW (widget);
/* ensure widget tree is properly size allocated */
attributes.event_mask = gtk_widget_get_events (widget);
attributes.event_mask |= (GDK_EXPOSURE_MASK |
GDK_KEY_PRESS_MASK |
+ GDK_KEY_RELEASE_MASK |
GDK_ENTER_NOTIFY_MASK |
GDK_LEAVE_NOTIFY_MASK |
GDK_FOCUS_CHANGE_MASK |
GtkWindow *window;
GtkBin *bin;
- g_return_if_fail (GTK_IS_WINDOW (widget));
- g_return_if_fail (requisition != NULL);
-
window = GTK_WINDOW (widget);
bin = GTK_BIN (window);
GtkWindow *window;
GtkAllocation child_allocation;
- g_return_if_fail (GTK_IS_WINDOW (widget));
- g_return_if_fail (allocation != NULL);
-
window = GTK_WINDOW (widget);
widget->allocation = *allocation;
GtkWindow *window;
gboolean return_val;
-
- g_return_val_if_fail (GTK_IS_WINDOW (widget), FALSE);
- g_return_val_if_fail (event != NULL, FALSE);
-
window = GTK_WINDOW (widget);
if (window->frame && (event->any.window == window->frame))
gtk_window_configure_event (GtkWidget *widget,
GdkEventConfigure *event)
{
- GtkWindow *window;
-
- g_return_val_if_fail (GTK_IS_WINDOW (widget), FALSE);
- g_return_val_if_fail (event != NULL, FALSE);
-
- window = GTK_WINDOW (widget);
+ GtkWindow *window = GTK_WINDOW (widget);
/* window->configure_request_count incremented for each
* configure request, and decremented to a min of 0 for
return TRUE;
}
+/* the accel_key and accel_mods fields of the key have to be setup
+ * upon calling this function. it'll then return whether that key
+ * is at all used as accelerator, and if so will OR in the
+ * accel_flags member of the key.
+ */
+gboolean
+_gtk_window_query_nonaccels (GtkWindow *window,
+ guint accel_key,
+ GdkModifierType accel_mods)
+{
+ g_return_val_if_fail (GTK_IS_WINDOW (window), FALSE);
+
+ /* movement keys are considered locked accels */
+ if (!accel_mods)
+ {
+ static const guint bindings[] = {
+ GDK_space, GDK_KP_Space, GDK_Return, GDK_KP_Enter, GDK_Up, GDK_KP_Up, GDK_Down, GDK_KP_Down,
+ GDK_Left, GDK_KP_Left, GDK_Right, GDK_KP_Right, GDK_Tab, GDK_KP_Tab, GDK_ISO_Left_Tab,
+ };
+ guint i;
+
+ for (i = 0; i < G_N_ELEMENTS (bindings); i++)
+ if (bindings[i] == accel_key)
+ return TRUE;
+ }
+
+ /* mnemonics are considered locked accels */
+ if (accel_mods == window->mnemonic_modifier)
+ {
+ GtkWindowMnemonic mkey;
+
+ mkey.window = window;
+ mkey.keyval = accel_key;
+ if (g_hash_table_lookup (mnemonic_hash_table, &mkey))
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
static gint
gtk_window_key_press_event (GtkWidget *widget,
GdkEventKey *event)
{
GtkWindow *window;
+ GtkWidget *focus;
gboolean handled;
- g_return_val_if_fail (GTK_IS_WINDOW (widget), FALSE);
- g_return_val_if_fail (event != NULL, FALSE);
-
window = GTK_WINDOW (widget);
handled = FALSE;
-
- if (window->focus_widget && window->focus_widget != widget &&
- GTK_WIDGET_IS_SENSITIVE (window->focus_widget))
- handled = gtk_widget_event (window->focus_widget, (GdkEvent*) event);
+ /* Check for mnemonics and accelerators
+ */
if (!handled)
- handled = gtk_window_mnemonic_activate (window,
- event->keyval,
- event->state);
+ handled = _gtk_window_activate_key (window, event);
if (!handled)
- handled = gtk_accel_groups_activate (G_OBJECT (window), event->keyval, event->state);
+ {
+ focus = window->focus_widget;
+ if (focus)
+ g_object_ref (focus);
+
+ while (!handled &&
+ focus && focus != widget &&
+ gtk_widget_get_toplevel (focus) == widget)
+ {
+ GtkWidget *parent;
+
+ if (GTK_WIDGET_IS_SENSITIVE (focus))
+ handled = gtk_widget_event (focus, (GdkEvent*) event);
+
+ parent = focus->parent;
+ if (parent)
+ g_object_ref (parent);
+
+ g_object_unref (focus);
+
+ focus = parent;
+ }
+
+ if (focus)
+ g_object_unref (focus);
+ }
/* Chain up, invokes binding set */
if (!handled && GTK_WIDGET_CLASS (parent_class)->key_press_event)
return handled;
}
+static gint
+gtk_window_key_release_event (GtkWidget *widget,
+ GdkEventKey *event)
+{
+ GtkWindow *window;
+ gint handled;
+
+ window = GTK_WINDOW (widget);
+ handled = FALSE;
+ if (window->focus_widget &&
+ window->focus_widget != widget &&
+ GTK_WIDGET_SENSITIVE (window->focus_widget))
+ {
+ handled = gtk_widget_event (window->focus_widget, (GdkEvent*) event);
+ }
+
+ if (!handled && GTK_WIDGET_CLASS (parent_class)->key_release_event)
+ handled = GTK_WIDGET_CLASS (parent_class)->key_release_event (widget, event);
+
+ return handled;
+}
static void
gtk_window_real_activate_default (GtkWindow *window)
gtk_window_set_focus (window, NULL);
}
-static gint
-gtk_window_key_release_event (GtkWidget *widget,
- GdkEventKey *event)
-{
- GtkWindow *window;
- gint handled;
-
- g_return_val_if_fail (GTK_IS_WINDOW (widget), FALSE);
- g_return_val_if_fail (event != NULL, FALSE);
-
- window = GTK_WINDOW (widget);
- handled = FALSE;
- if (window->focus_widget &&
- window->focus_widget != widget &&
- GTK_WIDGET_SENSITIVE (window->focus_widget))
- {
- handled = gtk_widget_event (window->focus_widget, (GdkEvent*) event);
- }
-
- if (!handled && GTK_WIDGET_CLASS (parent_class)->key_release_event)
- handled = GTK_WIDGET_CLASS (parent_class)->key_release_event (widget, event);
-
- return handled;
-}
-
static gint
gtk_window_enter_notify_event (GtkWidget *widget,
GdkEventCrossing *event)
{
- g_return_val_if_fail (GTK_IS_WINDOW (widget), FALSE);
- g_return_val_if_fail (event != NULL, FALSE);
-
return FALSE;
}
gtk_window_leave_notify_event (GtkWidget *widget,
GdkEventCrossing *event)
{
- g_return_val_if_fail (GTK_IS_WINDOW (widget), FALSE);
- g_return_val_if_fail (event != NULL, FALSE);
-
return FALSE;
}
+static void
+do_focus_change (GtkWidget *widget,
+ gboolean in)
+{
+ GdkEventFocus fevent;
+
+ g_object_ref (widget);
+
+ if (in)
+ GTK_WIDGET_SET_FLAGS (widget, GTK_HAS_FOCUS);
+ else
+ GTK_WIDGET_UNSET_FLAGS (widget, GTK_HAS_FOCUS);
+
+ fevent.type = GDK_FOCUS_CHANGE;
+ fevent.window = widget->window;
+ fevent.in = in;
+
+ gtk_widget_event (widget, (GdkEvent*) &fevent);
+
+ g_object_notify (G_OBJECT (widget), "has_focus");
+
+ g_object_unref (widget);
+}
+
static gint
gtk_window_focus_in_event (GtkWidget *widget,
GdkEventFocus *event)
{
GtkWindow *window = GTK_WINDOW (widget);
- GdkEventFocus fevent;
/* It appears spurious focus in events can occur when
* the window is hidden. So we'll just check to see if
if (window->focus_widget &&
window->focus_widget != widget &&
!GTK_WIDGET_HAS_FOCUS (window->focus_widget))
- {
- fevent.type = GDK_FOCUS_CHANGE;
- fevent.window = window->focus_widget->window;
- fevent.in = TRUE;
-
- gtk_widget_event (window->focus_widget, (GdkEvent*) &fevent);
- }
+ do_focus_change (window->focus_widget, TRUE);
}
return FALSE;
GdkEventFocus *event)
{
GtkWindow *window = GTK_WINDOW (widget);
- GdkEventFocus fevent;
window->has_focus = FALSE;
if (window->focus_widget &&
window->focus_widget != widget &&
GTK_WIDGET_HAS_FOCUS (window->focus_widget))
- {
- fevent.type = GDK_FOCUS_CHANGE;
- fevent.window = window->focus_widget->window;
- fevent.in = FALSE;
-
- gtk_widget_event (window->focus_widget, (GdkEvent*) &fevent);
- }
+ do_focus_change (window->focus_widget, FALSE);
return FALSE;
}
gtk_window_client_event (GtkWidget *widget,
GdkEventClient *event)
{
- g_return_val_if_fail (GTK_IS_WINDOW (widget), FALSE);
- g_return_val_if_fail (event != NULL, FALSE);
-
if (!atom_rcfiles)
atom_rcfiles = gdk_atom_intern ("_GTK_READ_RCFILES", FALSE);
static void
gtk_window_check_resize (GtkContainer *container)
{
- GtkWindow *window;
-
- g_return_if_fail (GTK_IS_WINDOW (container));
-
- window = GTK_WINDOW (container);
+ GtkWindow *window = GTK_WINDOW (container);
if (GTK_WIDGET_VISIBLE (container))
gtk_window_move_resize (window);
gtk_window_real_set_focus (GtkWindow *window,
GtkWidget *focus)
{
- GdkEventFocus event;
gboolean def_flags = 0;
- g_return_if_fail (GTK_IS_WINDOW (window));
-
if (window->default_widget)
def_flags = GTK_WIDGET_HAS_DEFAULT (window->default_widget);
}
if (window->has_focus)
- {
- event.type = GDK_FOCUS_CHANGE;
- event.window = window->focus_widget->window;
- event.in = FALSE;
-
- gtk_widget_event (window->focus_widget, (GdkEvent*) &event);
- }
+ do_focus_change (window->focus_widget, FALSE);
}
window->focus_widget = focus;
}
if (window->has_focus)
- {
- event.type = GDK_FOCUS_CHANGE;
- event.window = window->focus_widget->window;
- event.in = TRUE;
-
- gtk_widget_event (window->focus_widget, (GdkEvent*) &event);
- }
+ do_focus_change (window->focus_widget, TRUE);
}
if (window->default_widget &&
if (info)
{
- if (info->default_width > 0)
- *width = info->default_width;
-
- if (info->default_height > 0)
- *height = info->default_height;
+ gint base_width = 0;
+ gint base_height = 0;
+ gint width_inc = 1;
+ gint height_inc = 1;
+
+ if (info->default_is_geometry &&
+ (info->default_width > 0 || info->default_height > 0))
+ {
+ GdkGeometry geometry;
+ guint flags;
+
+ gtk_window_compute_hints (window, &geometry, &flags);
+
+ if (flags & GDK_HINT_BASE_SIZE)
+ {
+ base_width = geometry.base_width;
+ base_height = geometry.base_height;
+ }
+ else if (flags & GDK_HINT_MIN_SIZE)
+ {
+ base_width = geometry.min_width;
+ base_height = geometry.min_height;
+ }
+ if (flags & GDK_HINT_RESIZE_INC)
+ {
+ width_inc = geometry.width_inc;
+ height_inc = geometry.height_inc;
+ }
+ }
+
+ if (info->default_width > 0)
+ *width = info->default_width * width_inc + base_width;
+
+ if (info->default_height > 0)
+ *height = info->default_height * height_inc + base_height;
}
}
else
* or gtk_window_move().
*
* If the configure request has changed, we send off a new one. To
- * ensure GTK invariants are maintained (resize queue does what it
+ * ensure GTK+ invariants are maintained (resize queue does what it
* should), we go ahead and size_allocate the requested size in this
* function.
*
* GTK_RESIZE_IMMEDIATE containers)
*/
info->position_constraints_changed = FALSE;
- window->need_default_position = FALSE;
+ info->initial_pos_set = FALSE;
+ info->resize_width = -1;
+ info->resize_height = -1;
/* for GTK_RESIZE_QUEUE toplevels, we are now awaiting a new
* configure event in response to our resizing request.
GtkWindowGeometryInfo *geometry_info;
GtkRequisition requisition;
- g_return_if_fail (GTK_IS_WINDOW (window));
-
widget = GTK_WIDGET (window);
gtk_widget_get_child_requisition (widget, &requisition);
if (geometry_info && geometry_info->widget)
{
- extra_width = widget->requisition.width - geometry_info->widget->requisition.width;
- extra_height = widget->requisition.height - geometry_info->widget->requisition.height;
+ GtkRequisition child_requisition;
+
+ /* FIXME: This really isn't right. It gets the min size wrong and forces
+ * callers to do horrible hacks like set a huge usize on the child requisition
+ * to get the base size right. We really want to find the answers to:
+ *
+ * - If the geometry widget was infinitely big, how much extra space
+ * would be needed for the stuff around it.
+ *
+ * - If the geometry widget was infinitely small, how big would the
+ * window still have to be.
+ *
+ * Finding these answers would be a bit of a mess here. (Bug #68668)
+ */
+ gtk_widget_get_child_requisition (geometry_info->widget, &child_requisition);
+
+ extra_width = widget->requisition.width - child_requisition.width;
+ extra_height = widget->requisition.height - child_requisition.height;
}
/* We don't want to set GDK_HINT_POS in here, we just set it
gtk_window_expose (GtkWidget *widget,
GdkEventExpose *event)
{
- g_return_val_if_fail (GTK_IS_WINDOW (widget), FALSE);
- g_return_val_if_fail (event != NULL, FALSE);
-
if (!GTK_WIDGET_APP_PAINTABLE (widget))
gtk_window_paint (widget, &event->area);
if (GTK_WIDGET_CLASS (parent_class)->expose_event)
return GTK_WIDGET_CLASS (parent_class)->expose_event (widget, event);
- return TRUE;
+ return FALSE;
}
/**
* you want gtk_window_set_decorated() instead, which tells the window
* manager whether to draw the window border.)
*
- * If this function is called on a window with setting of TRUE, before
+ * If this function is called on a window with setting of %TRUE, before
* it is realized or showed, it will have a "frame" window around
- * widget->window, accessible in window->frame. Using the signal
+ * @window->window, accessible in @window->frame. Using the signal
* frame_event you can recieve all events targeted at the frame.
*
* This function is used by the linux-fb port to implement managed
* @window: a #GtkWindow
*
* Accessor for whether the window has a frame window exterior to
- * widget->window. Gets the value set by gtk_window_set_has_frame ().
+ * @window->window. Gets the value set by gtk_window_set_has_frame ().
*
* Return value: %TRUE if a frame has been added to the window
- * via gtk_widow_has_frame
+ * via gtk_window_set_has_frame().
**/
gboolean
gtk_window_get_has_frame (GtkWindow *window)
* window border drawn by the window manager, which is the normal
* case when using the X Window system.)
*
- * For windows with frames (see #gtk_window_set_has_frame) this function
+ * For windows with frames (see gtk_window_set_has_frame()) this function
* can be used to change the size of the frame border.
**/
void
gint right,
gint bottom)
{
- GtkWidget *widget = GTK_WIDGET (window);
+ GtkWidget *widget;
g_return_if_fail (GTK_IS_WINDOW (window));
+ widget = GTK_WIDGET (window);
+
if (window->frame_left == left &&
window->frame_top == top &&
window->frame_right == right &&
* gtk_window_iconify:
* @window: a #GtkWindow
*
- * Asks to iconify (i.e. minimize) the specified @window. Note that you
- * shouldn't assume the window is definitely iconified afterward,
- * because other entities (e.g. the user or window manager) could
- * deiconify it again, or there may not be a window manager in which
- * case iconification isn't possible, etc. But normally the window
- * will end up iconified. Just don't write code that crashes if not.
+ * Asks to iconify (i.e. minimize) the specified @window. Note that
+ * you shouldn't assume the window is definitely iconified afterward,
+ * because other entities (e.g. the user or <link
+ * linkend="gtk-X11-arch">window manager</link>) could deiconify it
+ * again, or there may not be a window manager in which case
+ * iconification isn't possible, etc. But normally the window will end
+ * up iconified. Just don't write code that crashes if not.
*
* It's permitted to call this function before showing a window,
* in which case the window will be iconified before it ever appears
*
* Asks to deiconify (i.e. unminimize) the specified @window. Note
* that you shouldn't assume the window is definitely deiconified
- * afterward, because other entities (e.g. the user or window manager)
- * could iconify it again before your code which assumes
- * deiconification gets to run.
+ * afterward, because other entities (e.g. the user or <link
+ * linkend="gtk-X11-arch">window manager</link>) could iconify it
+ * again before your code which assumes deiconification gets to run.
*
* You can track iconification via the "window_state_event" signal
* on #GtkWidget.
*
* Asks to stick @window, which means that it will appear on all user
* desktops. Note that you shouldn't assume the window is definitely
- * stuck afterward, because other entities (e.g. the user or window
- * manager) could unstick it again, and some window managers do not
- * support sticking windows. But normally the window will end up
- * stuck. Just don't write code that crashes if not.
+ * stuck afterward, because other entities (e.g. the user or <link
+ * linkend="gtk-X11-arch">window manager</link>) could unstick it
+ * again, and some window managers do not support sticking
+ * windows. But normally the window will end up stuck. Just don't
+ * write code that crashes if not.
*
* It's permitted to call this function before showing a window.
*
* Asks to unstick @window, which means that it will appear on only
* one of the user's desktops. Note that you shouldn't assume the
* window is definitely unstuck afterward, because other entities
- * (e.g. the user or window manager) could stick it again. But
- * normally the window will end up stuck. Just don't write code that
- * crashes if not.
+ * (e.g. the user or <link linkend="gtk-X11-arch">window
+ * manager</link>) could stick it again. But normally the window will
+ * end up stuck. Just don't write code that crashes if not.
*
* You can track stickiness via the "window_state_event" signal
* on #GtkWidget.
*
* Asks to maximize @window, so that it becomes full-screen. Note that
* you shouldn't assume the window is definitely maximized afterward,
- * because other entities (e.g. the user or window manager) could
- * unmaximize it again, and not all window managers support
- * maximization. But normally the window will end up maximized. Just
- * don't write code that crashes if not.
+ * because other entities (e.g. the user or <link
+ * linkend="gtk-X11-arch">window manager</link>) could unmaximize it
+ * again, and not all window managers support maximization. But
+ * normally the window will end up maximized. Just don't write code
+ * that crashes if not.
*
* It's permitted to call this function before showing a window,
* in which case the window will be maximized when it appears onscreen
*
* Asks to unmaximize @window. Note that you shouldn't assume the
* window is definitely unmaximized afterward, because other entities
- * (e.g. the user or window manager) could maximize it again, and not
- * all window managers honor requests to unmaximize. But normally the
- * window will end up unmaximized. Just don't write code that crashes
- * if not.
+ * (e.g. the user or <link linkend="gtk-X11-arch">window
+ * manager</link>) could maximize it again, and not all window
+ * managers honor requests to unmaximize. But normally the window will
+ * end up unmaximized. Just don't write code that crashes if not.
*
* You can track maximization via the "window_state_event" signal
* on #GtkWidget.
*
* Starts resizing a window. This function is used if an application
* has window resizing controls. When GDK can support it, the resize
- * will be done using the standard mechanism for the window manager or
- * windowing system. Otherwise, GDK will try to emulate window
- * resizing, potentially not all that well, depending on the windowing system.
+ * will be done using the standard mechanism for the <link
+ * linkend="gtk-X11-arch">window manager</link> or windowing
+ * system. Otherwise, GDK will try to emulate window resizing,
+ * potentially not all that well, depending on the windowing system.
*
**/
void
*
* (Note: this is a special-purpose function intended for the
* framebuffer port; see gtk_window_set_has_frame(). It will not
- * return the size of the window border drawn by the window manager,
- * which is the normal case when using a windowing system.
- * See gdk_window_get_frame_extents() to get the standard
- * window border extents.)
+ * return the size of the window border drawn by the <link
+ * linkend="gtk-X11-arch">window manager</link>, which is the normal
+ * case when using a windowing system. See
+ * gdk_window_get_frame_extents() to get the standard window border
+ * extents.)
*
* Retrieves the dimensions of the frame window for this toplevel.
* See gtk_window_set_has_frame(), gtk_window_set_frame_dimensions().
* @root_y: Y position where the user clicked to initiate the drag
* @timestamp: timestamp from the click event that initiated the drag
*
- * Starts moving a window. This function is used if an application
- * has window movement grips. When GDK can support it, the window movement
- * will be done using the standard mechanism for the window manager or
- * windowing system. Otherwise, GDK will try to emulate window
- * movement, potentially not all that well, depending on the windowing system.
+ * Starts moving a window. This function is used if an application has
+ * window movement grips. When GDK can support it, the window movement
+ * will be done using the standard mechanism for the <link
+ * linkend="gtk-X11-arch">window manager</link> or windowing
+ * system. Otherwise, GDK will try to emulate window movement,
+ * potentially not all that well, depending on the windowing system.
*
**/
void
/**
* gtk_window_group_new:
*
- * Create a new #GtkWindowGroup object. Grabs added with
- * gtk_window_grab_add() only affect windows within the
- * same #GtkWindowGroup
+ * Creates a new #GtkWindowGroup object. Grabs added with
+ * gtk_grab_add() only affect windows within the same #GtkWindowGroup.
*
- * Return value:
+ * Return value: a new #GtkWindowGroup.
**/
GtkWindowGroup *
gtk_window_group_new (void)
* @window_group: a #GtkWindowGroup
* @window: the #GtkWindow to add
*
- * Add a window to a #GtkWindowGroup.
+ * Adds a window to a #GtkWindowGroup.
**/
void
gtk_window_group_add_window (GtkWindowGroup *window_group,
size_set = FALSE;
if ((result & WidthValue) || (result & HeightValue))
{
- gtk_window_set_default_size (window, w, h);
+ gtk_window_set_default_size_internal (window, TRUE, w, TRUE, h, TRUE);
size_set = TRUE;
}
if ((result & YValue) == 0)
y = 0;
-
+
if (grav == GDK_GRAVITY_SOUTH_WEST ||
grav == GDK_GRAVITY_SOUTH_EAST)
- y = gdk_screen_height () - h;
+ y = gdk_screen_height () - h + y;
if (grav == GDK_GRAVITY_SOUTH_EAST ||
grav == GDK_GRAVITY_NORTH_EAST)
- x = gdk_screen_width () - w;
+ x = gdk_screen_width () - 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.
+ */
if (y < 0)
y = 0;
return result != 0;
}
+
+static void
+gtk_window_mnemonic_hash_foreach (gpointer key,
+ gpointer value,
+ gpointer data)
+{
+ struct {
+ GtkWindow *window;
+ GtkWindowKeysForeachFunc func;
+ gpointer func_data;
+ } *info = data;
+
+ GtkWindowMnemonic *mnemonic = value;
+
+ if (mnemonic->window == info->window)
+ (*info->func) (info->window, mnemonic->keyval, info->window->mnemonic_modifier, TRUE, info->func_data);
+}
+
+void
+_gtk_window_keys_foreach (GtkWindow *window,
+ GtkWindowKeysForeachFunc func,
+ gpointer func_data)
+{
+ GSList *groups;
+
+ struct {
+ GtkWindow *window;
+ GtkWindowKeysForeachFunc func;
+ gpointer func_data;
+ } info;
+
+ info.window = window;
+ info.func = func;
+ info.func_data = func_data;
+
+ g_hash_table_foreach (mnemonic_hash_table,
+ gtk_window_mnemonic_hash_foreach,
+ &info);
+
+ groups = gtk_accel_groups_from_object (G_OBJECT (window));
+ while (groups)
+ {
+ GtkAccelGroup *group = groups->data;
+ gint i;
+
+ for (i = 0; i < group->n_accels; i++)
+ {
+ GtkAccelKey *key = &group->priv_accels[i].key;
+
+ if (key->accel_key)
+ (*func) (window, key->accel_key, key->accel_mods, FALSE, func_data);
+ }
+
+ groups = groups->next;
+ }
+}
+
+static void
+gtk_window_keys_changed (GtkWindow *window)
+{
+ gtk_window_free_key_hash (window);
+ gtk_window_get_key_hash (window);
+}
+
+typedef struct _GtkWindowKeyEntry GtkWindowKeyEntry;
+
+struct _GtkWindowKeyEntry
+{
+ guint keyval;
+ guint modifiers;
+ gboolean is_mnemonic;
+};
+
+static void
+add_to_key_hash (GtkWindow *window,
+ guint keyval,
+ GdkModifierType modifiers,
+ gboolean is_mnemonic,
+ gpointer data)
+{
+ GtkKeyHash *key_hash = data;
+
+ GtkWindowKeyEntry *entry = g_new (GtkWindowKeyEntry, 1);
+
+ entry->keyval = keyval;
+ entry->modifiers = modifiers;
+ entry->is_mnemonic = is_mnemonic;
+
+ /* GtkAccelGroup stores lowercased accelerators. To deal
+ * with this, if <Shift> was specified, uppercase.
+ */
+ if (modifiers & GDK_SHIFT_MASK)
+ {
+ if (keyval == GDK_Tab)
+ keyval = GDK_ISO_Left_Tab;
+ else
+ keyval = gdk_keyval_to_upper (keyval);
+ }
+
+ _gtk_key_hash_add_entry (key_hash, keyval, entry->modifiers, entry);
+}
+
+static GtkKeyHash *
+gtk_window_get_key_hash (GtkWindow *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_default(), (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);
+
+ return key_hash;
+}
+
+static void
+gtk_window_free_key_hash (GtkWindow *window)
+{
+ GtkKeyHash *key_hash = g_object_get_data (G_OBJECT (window), "gtk-window-key-hash");
+ if (key_hash)
+ {
+ _gtk_key_hash_free (key_hash);
+ g_object_set_data (G_OBJECT (window), "gtk-window-key-hash", NULL);
+ }
+}
+
+/**
+ * _gtk_window_activate_key:
+ * @window: a #GtkWindow
+ * @event: a #GdkEventKey
+ *
+ * Activates mnemonics and accelerators for this #GtKWindow
+ *
+ * Return value: %TRUE if a mnemonic or accelerator was found and activated.
+ **/
+gboolean
+_gtk_window_activate_key (GtkWindow *window,
+ GdkEventKey *event)
+{
+ GtkKeyHash *key_hash = g_object_get_data (G_OBJECT (window), "gtk-window-key-hash");
+ GtkWindowKeyEntry *found_entry = NULL;
+
+ if (!key_hash)
+ {
+ gtk_window_keys_changed (window);
+ key_hash = g_object_get_data (G_OBJECT (window), "gtk-window-key-hash");
+ }
+
+ if (key_hash)
+ {
+ GSList *entries = _gtk_key_hash_lookup (key_hash,
+ event->hardware_keycode,
+ event->state & gtk_accelerator_get_default_mod_mask (),
+ event->group);
+ GSList *tmp_list;
+
+ for (tmp_list = entries; tmp_list; tmp_list = tmp_list->next)
+ {
+ GtkWindowKeyEntry *entry = tmp_list->data;
+ if (entry->is_mnemonic)
+ {
+ found_entry = entry;
+ break;
+ }
+ }
+
+ if (!found_entry && entries)
+ found_entry = entries->data;
+
+ g_slist_free (entries);
+ }
+
+ if (found_entry)
+ {
+ if (found_entry->is_mnemonic)
+ return gtk_window_mnemonic_activate (window, found_entry->keyval, found_entry->modifiers);
+ else
+ return gtk_accel_groups_activate (G_OBJECT (window), found_entry->keyval, found_entry->modifiers);
+ }
+ else
+ return FALSE;
+}