#include "gdk/gdk.h"
#include "gdk/gdkkeysyms.h"
+#include "gtkintl.h"
+
#include "gtkprivate.h"
#include "gtkrc.h"
#include "gtkwindow.h"
#include "gtkbindings.h"
#include "gtkkeyhash.h"
#include "gtkmain.h"
+#include "gtkmnemonichash.h"
#include "gtkiconfactory.h"
-#include "gtkintl.h"
+#include "gtkicontheme.h"
#include "gtkmarshalers.h"
#include "gtkplug.h"
+#include "gtkalias.h"
+
+#ifdef GDK_WINDOWING_X11
+#include "x11/gdkx.h"
+#endif
enum {
SET_FOCUS,
PROP_DEFAULT_HEIGHT,
PROP_DESTROY_WITH_PARENT,
PROP_ICON,
+ PROP_ICON_NAME,
PROP_SCREEN,
PROP_TYPE_HINT,
PROP_SKIP_TASKBAR_HINT,
PROP_SKIP_PAGER_HINT,
+ PROP_URGENCY_HINT,
PROP_ACCEPT_FOCUS,
PROP_FOCUS_ON_MAP,
PROP_DECORATED,
+ PROP_DELETABLE,
PROP_GRAVITY,
+ PROP_TRANSIENT_FOR,
/* Readonly properties */
PROP_IS_ACTIVE,
GList *icon_list;
GdkPixmap *icon_pixmap;
GdkPixmap *icon_mask;
+ gchar *icon_name;
guint realized : 1;
guint using_default_icon : 1;
guint using_parent_icon : 1;
+ guint using_themed_icon : 1;
} GtkWindowIconInfo;
typedef struct {
GtkWindowLastGeometryInfo last;
};
-typedef struct _GtkWindowMnemonic GtkWindowMnemonic;
-
-struct _GtkWindowMnemonic {
- GtkWindow *window;
- guint keyval;
-
- GSList *targets;
-};
-
#define GTK_WINDOW_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_WINDOW, GtkWindowPrivate))
typedef struct _GtkWindowPrivate GtkWindowPrivate;
struct _GtkWindowPrivate
{
+ GtkMnemonicHash *mnemonic_hash;
+
guint above_initially : 1;
guint below_initially : 1;
guint fullscreen_initially : 1;
guint skips_taskbar : 1;
guint skips_pager : 1;
+ guint urgent : 1;
guint accept_focus : 1;
guint focus_on_map : 1;
+ guint deletable : 1;
+ guint transient_parent_group : 1;
+
+ guint reset_type_hint : 1;
+ GdkWindowTypeHint type_hint;
};
-static void gtk_window_class_init (GtkWindowClass *klass);
-static void gtk_window_init (GtkWindow *window);
static void gtk_window_dispose (GObject *object);
static void gtk_window_destroy (GtkObject *object);
static void gtk_window_finalize (GObject *object);
GtkAllocation *allocation);
static gint gtk_window_event (GtkWidget *widget,
GdkEvent *event);
+static gboolean gtk_window_map_event (GtkWidget *widget,
+ GdkEventAny *event);
static gboolean gtk_window_frame_event (GtkWindow *window,
GdkEvent *event);
static gint gtk_window_configure_event (GtkWidget *widget,
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,
- GdkRectangle *area);
-static gint gtk_window_expose (GtkWidget *widget,
- GdkEventExpose *event);
+static void gtk_window_paint (GtkWidget *widget,
+ GdkRectangle *area);
+static gint gtk_window_expose (GtkWidget *widget,
+ GdkEventExpose *event);
static void gtk_window_unset_transient_for (GtkWindow *window);
static void gtk_window_transient_parent_realized (GtkWidget *parent,
GtkWidget *window);
gint height,
gboolean is_geometry);
+static void update_themed_icon (GtkIconTheme *theme,
+ GtkWindow *window);
+static GList *icon_list_from_theme (GtkWidget *widget,
+ const gchar *name);
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 void gtk_window_on_composited_changed (GdkScreen *screen,
+ GtkWindow *window);
static GSList *toplevel_list = NULL;
-static GHashTable *mnemonic_hash_table = NULL;
-static GtkBinClass *parent_class = NULL;
static guint window_signals[LAST_SIGNAL] = { 0 };
static GList *default_icon_list = NULL;
+static gchar *default_icon_name = NULL;
static guint default_icon_serial = 0;
static gboolean disable_startup_notification = FALSE;
static gboolean sent_startup_notification = FALSE;
+static GQuark quark_gtk_embedded = 0;
+static GQuark quark_gtk_window_key_hash = 0;
+static GQuark quark_gtk_window_default_icon_pixmap = 0;
+static GQuark quark_gtk_window_icon_info = 0;
+
static void gtk_window_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec);
-static guint
-mnemonic_hash (gconstpointer key)
-{
- const GtkWindowMnemonic *k;
- guint h;
-
- k = (GtkWindowMnemonic *)key;
-
- h = (gulong) k->window;
- h ^= k->keyval << 16;
- h ^= k->keyval >> 16;
-
- return h;
-}
-
-static gboolean
-mnemonic_equal (gconstpointer a, gconstpointer b)
-{
- const GtkWindowMnemonic *ka;
- const GtkWindowMnemonic *kb;
-
- ka = (GtkWindowMnemonic *)a;
- kb = (GtkWindowMnemonic *)b;
-
- return
- (ka->window == kb->window) &&
- (ka->keyval == kb->keyval);
-}
-
-GType
-gtk_window_get_type (void)
-{
- static GType window_type = 0;
-
- if (!window_type)
- {
- static const GTypeInfo window_info =
- {
- sizeof (GtkWindowClass),
- NULL, /* base_init */
- NULL, /* base_finalize */
- (GClassInitFunc) gtk_window_class_init,
- NULL, /* class_finalize */
- NULL, /* class_data */
- sizeof (GtkWindow),
- 0, /* n_preallocs */
- (GInstanceInitFunc) gtk_window_init,
- };
-
- window_type = g_type_register_static (GTK_TYPE_BIN, "GtkWindow",
- &window_info, 0);
- }
-
- return window_type;
-}
+G_DEFINE_TYPE (GtkWindow, gtk_window, GTK_TYPE_BIN)
static void
add_tab_bindings (GtkBindingSet *binding_set,
widget_class = (GtkWidgetClass*) klass;
container_class = (GtkContainerClass*) klass;
- parent_class = g_type_class_peek_parent (klass);
-
- mnemonic_hash_table = g_hash_table_new (mnemonic_hash, mnemonic_equal);
+ quark_gtk_embedded = g_quark_from_static_string ("gtk-embedded");
+ quark_gtk_window_key_hash = g_quark_from_static_string ("gtk-window-key-hash");
+ quark_gtk_window_default_icon_pixmap = g_quark_from_static_string ("gtk-window-default-icon-pixmap");
+ quark_gtk_window_icon_info = g_quark_from_static_string ("gtk-window-icon-info");
gobject_class->dispose = gtk_window_dispose;
gobject_class->finalize = gtk_window_finalize;
widget_class->show = gtk_window_show;
widget_class->hide = gtk_window_hide;
widget_class->map = gtk_window_map;
+ widget_class->map_event = gtk_window_map_event;
widget_class->unmap = gtk_window_unmap;
widget_class->realize = gtk_window_realize;
widget_class->unrealize = gtk_window_unrealize;
P_("The type of the window"),
GTK_TYPE_WINDOW_TYPE,
GTK_WINDOW_TOPLEVEL,
- G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
+ GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
/* Regular Props */
g_object_class_install_property (gobject_class,
PROP_TITLE,
P_("Window Title"),
P_("The title of the window"),
NULL,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_ROLE,
P_("Window Role"),
P_("Unique identifier for the window to be used when restoring a session"),
NULL,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_ALLOW_SHRINK,
- g_param_spec_boolean ("allow_shrink",
+ g_param_spec_boolean ("allow-shrink",
P_("Allow Shrink"),
/* xgettext:no-c-format */
P_("If TRUE, the window has no mimimum size. Setting this to TRUE is 99% of the time a bad idea"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_ALLOW_GROW,
- g_param_spec_boolean ("allow_grow",
+ g_param_spec_boolean ("allow-grow",
P_("Allow Grow"),
P_("If TRUE, users can expand the window beyond its minimum size"),
TRUE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_RESIZABLE,
P_("Resizable"),
P_("If TRUE, users can resize the window"),
TRUE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_MODAL,
P_("Modal"),
P_("If TRUE, the window is modal (other windows are not usable while this one is up)"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_WIN_POS,
- g_param_spec_enum ("window_position",
+ g_param_spec_enum ("window-position",
P_("Window Position"),
P_("The initial position of the window"),
GTK_TYPE_WINDOW_POSITION,
GTK_WIN_POS_NONE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_DEFAULT_WIDTH,
- g_param_spec_int ("default_width",
+ g_param_spec_int ("default-width",
P_("Default Width"),
P_("The default width of the window, used when initially showing the window"),
-1,
G_MAXINT,
-1,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_DEFAULT_HEIGHT,
- g_param_spec_int ("default_height",
+ g_param_spec_int ("default-height",
P_("Default Height"),
P_("The default height of the window, used when initially showing the window"),
-1,
G_MAXINT,
-1,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_DESTROY_WITH_PARENT,
- g_param_spec_boolean ("destroy_with_parent",
+ g_param_spec_boolean ("destroy-with-parent",
P_("Destroy with Parent"),
P_("If this window should be destroyed when the parent is destroyed"),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_ICON,
P_("Icon"),
P_("Icon for this window"),
GDK_TYPE_PIXBUF,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
+
+ /**
+ * GtkWindow:icon-name:
+ *
+ * The :icon-name property specifies the name of the themed icon to
+ * use as the window icon. See #GtkIconTheme for more details.
+ *
+ * Since: 2.6
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_ICON_NAME,
+ g_param_spec_string ("icon-name",
+ P_("Icon Name"),
+ P_("Name of the themed icon for this window"),
+ NULL,
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_SCREEN,
P_("Screen"),
P_("The screen where this window will be displayed"),
GDK_TYPE_SCREEN,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_IS_ACTIVE,
- g_param_spec_boolean ("is_active",
+ g_param_spec_boolean ("is-active",
P_("Is Active"),
P_("Whether the toplevel is the current active window"),
FALSE,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
g_object_class_install_property (gobject_class,
PROP_HAS_TOPLEVEL_FOCUS,
- g_param_spec_boolean ("has_toplevel_focus",
+ g_param_spec_boolean ("has-toplevel-focus",
P_("Focus in Toplevel"),
P_("Whether the input focus is within this GtkWindow"),
FALSE,
- G_PARAM_READABLE));
+ GTK_PARAM_READABLE));
g_object_class_install_property (gobject_class,
PROP_TYPE_HINT,
- g_param_spec_enum ("type_hint",
+ g_param_spec_enum ("type-hint",
P_("Type hint"),
P_("Hint to help the desktop environment understand what kind of window this is and how to treat it."),
GDK_TYPE_WINDOW_TYPE_HINT,
GDK_WINDOW_TYPE_HINT_NORMAL,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_SKIP_TASKBAR_HINT,
- g_param_spec_boolean ("skip_taskbar_hint",
+ g_param_spec_boolean ("skip-taskbar-hint",
P_("Skip taskbar"),
P_("TRUE if the window should not be in the task bar."),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_SKIP_PAGER_HINT,
- g_param_spec_boolean ("skip_pager_hint",
+ g_param_spec_boolean ("skip-pager-hint",
P_("Skip pager"),
P_("TRUE if the window should not be in the pager."),
FALSE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
+
+ g_object_class_install_property (gobject_class,
+ PROP_URGENCY_HINT,
+ g_param_spec_boolean ("urgency-hint",
+ P_("Urgent"),
+ P_("TRUE if the window should be brought to the user's attention."),
+ FALSE,
+ GTK_PARAM_READWRITE));
/**
* GtkWindow:accept-focus-hint:
*/
g_object_class_install_property (gobject_class,
PROP_ACCEPT_FOCUS,
- g_param_spec_boolean ("accept_focus",
+ g_param_spec_boolean ("accept-focus",
P_("Accept focus"),
P_("TRUE if the window should receive the input focus."),
TRUE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
* GtkWindow:focus-on-map-hint:
*/
g_object_class_install_property (gobject_class,
PROP_FOCUS_ON_MAP,
- g_param_spec_boolean ("focus_on_map",
+ g_param_spec_boolean ("focus-on-map",
P_("Focus on map"),
P_("TRUE if the window should receive the input focus when mapped."),
TRUE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
/**
* GtkWindow:decorated:
P_("Decorated"),
P_("Whether the window should be decorated by the window manager"),
TRUE,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
+
+ /**
+ * GtkWindow:deletable:
+ *
+ * Whether the window frame should have a close button.
+ *
+ * Since: 2.10
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_DELETABLE,
+ g_param_spec_boolean ("deletable",
+ P_("Deletable"),
+ P_("Whether the window frame should have a close button"),
+ TRUE,
+ GTK_PARAM_READWRITE));
+
/**
* GtkWindow:gravity:
P_("The window gravity of the window"),
GDK_TYPE_GRAVITY,
GDK_GRAVITY_NORTH_WEST,
- G_PARAM_READWRITE));
+ GTK_PARAM_READWRITE));
+
+
+ /**
+ * GtkWindow:transient-for:
+ *
+ * The transient parent of the window. See gtk_window_set_transient_for() for
+ * more details about transient windows.
+ *
+ * Since: 2.10
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_TRANSIENT_FOR,
+ g_param_spec_object ("transient-for",
+ P_("Transient for Window"),
+ P_("The transient parent of the dialog"),
+ GTK_TYPE_WINDOW,
+ GTK_PARAM_READWRITE| G_PARAM_CONSTRUCT));
window_signals[SET_FOCUS] =
- g_signal_new ("set_focus",
+ g_signal_new (I_("set_focus"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkWindowClass, set_focus),
GTK_TYPE_WIDGET);
window_signals[FRAME_EVENT] =
- g_signal_new ("frame_event",
+ g_signal_new (I_("frame_event"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(GtkWindowClass, frame_event),
GDK_TYPE_EVENT);
window_signals[ACTIVATE_FOCUS] =
- g_signal_new ("activate_focus",
+ g_signal_new (I_("activate_focus"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkWindowClass, activate_focus),
0);
window_signals[ACTIVATE_DEFAULT] =
- g_signal_new ("activate_default",
+ g_signal_new (I_("activate_default"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkWindowClass, activate_default),
0);
window_signals[MOVE_FOCUS] =
- g_signal_new ("move_focus",
+ g_signal_new (I_("move_focus"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkWindowClass, move_focus),
GTK_TYPE_DIRECTION_TYPE);
window_signals[KEYS_CHANGED] =
- g_signal_new ("keys_changed",
+ g_signal_new (I_("keys_changed"),
G_TYPE_FROM_CLASS (gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkWindowClass, keys_changed),
priv->accept_focus = TRUE;
priv->focus_on_map = TRUE;
+ priv->deletable = TRUE;
+ priv->type_hint = GDK_WINDOW_TYPE_HINT_NORMAL;
colormap = _gtk_widget_peek_colormap ();
if (colormap)
gtk_widget_set_colormap (GTK_WIDGET (window), colormap);
- g_object_ref (window);
- gtk_object_sink (GTK_OBJECT (window));
+ g_object_ref_sink (window);
window->has_user_ref_count = TRUE;
toplevel_list = g_slist_prepend (toplevel_list, window);
gtk_decorated_window_init (window);
- g_signal_connect (window,
- "event",
- G_CALLBACK (gtk_window_event),
- NULL);
+ g_signal_connect (window->screen, "composited_changed",
+ G_CALLBACK (gtk_window_on_composited_changed), window);
}
static void
case PROP_RESIZABLE:
window->allow_grow = g_value_get_boolean (value);
gtk_widget_queue_resize (GTK_WIDGET (window));
- g_object_notify (G_OBJECT (window), "allow_grow");
+ g_object_notify (G_OBJECT (window), "allow-grow");
break;
case PROP_MODAL:
gtk_window_set_modal (window, g_value_get_boolean (value));
gtk_window_set_icon (window,
g_value_get_object (value));
break;
+ case PROP_ICON_NAME:
+ gtk_window_set_icon_name (window, g_value_get_string (value));
+ break;
case PROP_SCREEN:
gtk_window_set_screen (window, g_value_get_object (value));
break;
gtk_window_set_skip_pager_hint (window,
g_value_get_boolean (value));
break;
+ case PROP_URGENCY_HINT:
+ gtk_window_set_urgency_hint (window,
+ g_value_get_boolean (value));
+ break;
case PROP_ACCEPT_FOCUS:
gtk_window_set_accept_focus (window,
g_value_get_boolean (value));
case PROP_DECORATED:
gtk_window_set_decorated (window, g_value_get_boolean (value));
break;
+ case PROP_DELETABLE:
+ gtk_window_set_deletable (window, g_value_get_boolean (value));
+ break;
case PROP_GRAVITY:
gtk_window_set_gravity (window, g_value_get_enum (value));
break;
+ case PROP_TRANSIENT_FOR:
+ gtk_window_set_transient_for (window, g_value_get_object (value));
+ break;
default:
break;
}
GParamSpec *pspec)
{
GtkWindow *window;
+ GtkWindowPrivate *priv;
window = GTK_WINDOW (object);
-
+ priv = GTK_WINDOW_GET_PRIVATE (window);
+
switch (prop_id)
{
GtkWindowGeometryInfo *info;
case PROP_ICON:
g_value_set_object (value, gtk_window_get_icon (window));
break;
+ case PROP_ICON_NAME:
+ g_value_set_string (value, gtk_window_get_icon_name (window));
+ break;
case PROP_SCREEN:
g_value_set_object (value, window->screen);
break;
g_value_set_boolean (value, window->has_toplevel_focus);
break;
case PROP_TYPE_HINT:
- g_value_set_enum (value,
- window->type_hint);
+ g_value_set_enum (value, priv->type_hint);
break;
case PROP_SKIP_TASKBAR_HINT:
g_value_set_boolean (value,
g_value_set_boolean (value,
gtk_window_get_skip_pager_hint (window));
break;
+ case PROP_URGENCY_HINT:
+ g_value_set_boolean (value,
+ gtk_window_get_urgency_hint (window));
+ break;
case PROP_ACCEPT_FOCUS:
g_value_set_boolean (value,
gtk_window_get_accept_focus (window));
case PROP_DECORATED:
g_value_set_boolean (value, gtk_window_get_decorated (window));
break;
+ case PROP_DELETABLE:
+ g_value_set_boolean (value, gtk_window_get_deletable (window));
+ break;
case PROP_GRAVITY:
g_value_set_enum (value, gtk_window_get_gravity (window));
break;
+ case PROP_TRANSIENT_FOR:
+ g_value_set_object (value, gtk_window_get_transient_for (window));
+ break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
if (old_default_widget)
- g_object_notify (G_OBJECT (old_default_widget), "has_default");
+ g_object_notify (G_OBJECT (old_default_widget), "has-default");
if (default_widget)
{
- g_object_notify (G_OBJECT (default_widget), "has_default");
+ g_object_notify (G_OBJECT (default_widget), "has-default");
g_object_unref (default_widget);
}
}
window->allow_grow = (allow_grow != FALSE);
g_object_freeze_notify (G_OBJECT (window));
- g_object_notify (G_OBJECT (window), "allow_shrink");
- g_object_notify (G_OBJECT (window), "allow_grow");
+ g_object_notify (G_OBJECT (window), "allow-shrink");
+ g_object_notify (G_OBJECT (window), "allow-grow");
g_object_notify (G_OBJECT (window), "resizable");
g_object_thaw_notify (G_OBJECT (window));
{
GtkWindow *window;
- GDK_THREADS_ENTER ();
window = GTK_WINDOW (data);
if (window->keys_changed_handler)
}
g_signal_emit (window, window_signals[KEYS_CHANGED], 0);
- GDK_THREADS_LEAVE ();
return FALSE;
}
gtk_window_notify_keys_changed (GtkWindow *window)
{
if (!window->keys_changed_handler)
- window->keys_changed_handler = g_idle_add (handle_keys_changed, window);
+ window->keys_changed_handler = gdk_threads_add_idle (handle_keys_changed, window);
}
/**
_gtk_accel_group_detach (accel_group, G_OBJECT (window));
}
+static GtkMnemonicHash *
+gtk_window_get_mnemonic_hash (GtkWindow *window,
+ gboolean create)
+{
+ GtkWindowPrivate *private = GTK_WINDOW_GET_PRIVATE (window);
+ if (!private->mnemonic_hash && create)
+ private->mnemonic_hash = _gtk_mnemonic_hash_new ();
+
+ return private->mnemonic_hash;
+}
+
/**
* gtk_window_add_mnemonic:
* @window: a #GtkWindow
guint keyval,
GtkWidget *target)
{
- GtkWindowMnemonic key;
- GtkWindowMnemonic *mnemonic;
-
g_return_if_fail (GTK_IS_WINDOW (window));
g_return_if_fail (GTK_IS_WIDGET (target));
-
- key.window = window;
- key.keyval = keyval;
- mnemonic = g_hash_table_lookup (mnemonic_hash_table, &key);
- if (mnemonic)
- {
- g_return_if_fail (g_slist_find (mnemonic->targets, target) == NULL);
- mnemonic->targets = g_slist_append (mnemonic->targets, target);
- }
- else
- {
- mnemonic = g_new (GtkWindowMnemonic, 1);
- *mnemonic = key;
- mnemonic->targets = g_slist_prepend (NULL, target);
- g_hash_table_insert (mnemonic_hash_table, mnemonic, mnemonic);
- }
+ _gtk_mnemonic_hash_add (gtk_window_get_mnemonic_hash (window, TRUE),
+ keyval, target);
gtk_window_notify_keys_changed (window);
}
guint keyval,
GtkWidget *target)
{
- GtkWindowMnemonic key;
- GtkWindowMnemonic *mnemonic;
-
g_return_if_fail (GTK_IS_WINDOW (window));
g_return_if_fail (GTK_IS_WIDGET (target));
- key.window = window;
- key.keyval = keyval;
- mnemonic = g_hash_table_lookup (mnemonic_hash_table, &key);
-
- g_return_if_fail (mnemonic && g_slist_find (mnemonic->targets, target) != NULL);
-
- mnemonic->targets = g_slist_remove (mnemonic->targets, target);
- if (mnemonic->targets == NULL)
- {
- g_hash_table_remove (mnemonic_hash_table, mnemonic);
- g_free (mnemonic);
- }
+ _gtk_mnemonic_hash_remove (gtk_window_get_mnemonic_hash (window, TRUE),
+ keyval, target);
gtk_window_notify_keys_changed (window);
}
guint keyval,
GdkModifierType modifier)
{
- GtkWindowMnemonic key;
- GtkWindowMnemonic *mnemonic;
- GSList *list;
- GtkWidget *widget, *chosen_widget;
- gboolean overloaded;
-
g_return_val_if_fail (GTK_IS_WINDOW (window), FALSE);
- if (window->mnemonic_modifier != (modifier & gtk_accelerator_get_default_mod_mask ()))
- return FALSE;
-
- key.window = window;
- key.keyval = keyval;
- mnemonic = g_hash_table_lookup (mnemonic_hash_table, &key);
-
- if (!mnemonic)
- return FALSE;
-
- overloaded = FALSE;
- chosen_widget = NULL;
- list = mnemonic->targets;
- while (list)
- {
- widget = GTK_WIDGET (list->data);
-
- if (GTK_WIDGET_IS_SENSITIVE (widget) &&
- GTK_WIDGET_DRAWABLE (widget) &&
- gdk_window_is_viewable (widget->window))
- {
- if (chosen_widget)
- {
- overloaded = TRUE;
- break;
- }
- else
- chosen_widget = widget;
- }
- list = g_slist_next (list);
- }
-
- if (chosen_widget)
- {
- /* For round robin we put the activated entry on
- * the end of the list after activation
- */
- mnemonic->targets = g_slist_remove (mnemonic->targets, chosen_widget);
- mnemonic->targets = g_slist_append (mnemonic->targets, chosen_widget);
+ if (window->mnemonic_modifier == (modifier & gtk_accelerator_get_default_mod_mask ()))
+ {
+ GtkMnemonicHash *mnemonic_hash = gtk_window_get_mnemonic_hash (window, FALSE);
+ if (mnemonic_hash)
+ return _gtk_mnemonic_hash_activate (mnemonic_hash, keyval);
+ }
- return gtk_widget_mnemonic_activate (chosen_widget, overloaded);
- }
return FALSE;
}
window->position = position;
- g_object_notify (G_OBJECT (window), "window_position");
+ g_object_notify (G_OBJECT (window), "window-position");
}
/**
g_return_if_fail (GTK_IS_WINDOW (window));
- embedded_windows = g_object_get_data (G_OBJECT (window), "gtk-embedded");
+ embedded_windows = g_object_get_qdata (G_OBJECT (window), quark_gtk_embedded);
if (embedded_windows)
- g_object_steal_qdata (G_OBJECT (window),
- g_quark_from_static_string ("gtk-embedded"));
+ g_object_steal_qdata (G_OBJECT (window), quark_gtk_embedded);
embedded_windows = g_list_prepend (embedded_windows,
GUINT_TO_POINTER (xid));
- g_object_set_data_full (G_OBJECT (window), "gtk-embedded",
- embedded_windows,
- embedded_windows ?
- (GDestroyNotify) g_list_free : NULL);
+ g_object_set_qdata_full (G_OBJECT (window), quark_gtk_embedded,
+ embedded_windows,
+ embedded_windows ?
+ (GDestroyNotify) g_list_free : NULL);
}
void
g_return_if_fail (GTK_IS_WINDOW (window));
- embedded_windows = g_object_get_data (G_OBJECT (window), "gtk-embedded");
+ embedded_windows = g_object_get_qdata (G_OBJECT (window), quark_gtk_embedded);
if (embedded_windows)
- g_object_steal_qdata (G_OBJECT (window),
- g_quark_from_static_string ("gtk-embedded"));
+ g_object_steal_qdata (G_OBJECT (window), quark_gtk_embedded);
node = g_list_find (embedded_windows, GUINT_TO_POINTER (xid));
if (node)
g_list_free_1 (node);
}
- g_object_set_data_full (G_OBJECT (window), "gtk-embedded",
- embedded_windows,
- embedded_windows ?
- (GDestroyNotify) g_list_free : NULL);
+ g_object_set_qdata_full (G_OBJECT (window), quark_gtk_embedded,
+ embedded_windows,
+ embedded_windows ?
+ (GDestroyNotify) g_list_free : NULL);
}
void
gtk_window_set_focus (window, NULL);
gtk_window_set_default (window, NULL);
- G_OBJECT_CLASS (parent_class)->dispose (object);
+ G_OBJECT_CLASS (gtk_window_parent_class)->dispose (object);
}
static void
{
if (GTK_WIDGET_REALIZED (window))
gdk_property_delete (window->window,
- gdk_atom_intern ("WM_TRANSIENT_FOR", FALSE));
+ gdk_atom_intern_static_string ("WM_TRANSIENT_FOR"));
}
static void
static void
gtk_window_unset_transient_for (GtkWindow *window)
{
+ GtkWindowPrivate *priv = GTK_WINDOW_GET_PRIVATE (window);
+
if (window->transient_parent)
{
+ if (priv->transient_parent_group)
+ gtk_window_group_remove_window (window->group,
+ window);
+
g_signal_handlers_disconnect_by_func (window->transient_parent,
gtk_window_transient_parent_realized,
window);
disconnect_parent_destroyed (window);
window->transient_parent = NULL;
+ priv->transient_parent_group = FALSE;
}
}
gtk_window_set_transient_for (GtkWindow *window,
GtkWindow *parent)
{
+ GtkWindowPrivate *priv = GTK_WINDOW_GET_PRIVATE (window);
+
g_return_if_fail (GTK_IS_WINDOW (window));
g_return_if_fail (parent == NULL || GTK_IS_WINDOW (parent));
g_return_if_fail (window != parent);
-
if (window->transient_parent)
{
if (GTK_WIDGET_REALIZED (window) &&
}
window->transient_parent = parent;
-
+
if (parent)
{
g_signal_connect (parent, "destroy",
GTK_WIDGET_REALIZED (parent))
gtk_window_transient_parent_realized (GTK_WIDGET (parent),
GTK_WIDGET (window));
+
+ if (parent->group)
+ {
+ gtk_window_group_add_window (parent->group, window);
+ priv->transient_parent_group = TRUE;
+ }
}
}
gtk_window_set_type_hint (GtkWindow *window,
GdkWindowTypeHint hint)
{
+ GtkWindowPrivate *priv;
+
g_return_if_fail (GTK_IS_WINDOW (window));
g_return_if_fail (!GTK_WIDGET_VISIBLE (window));
- window->type_hint = hint;
+
+ priv = GTK_WINDOW_GET_PRIVATE (window);
+
+ if (hint < GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU)
+ window->type_hint = hint;
+ else
+ window->type_hint = GDK_WINDOW_TYPE_HINT_NORMAL;
+
+ priv->reset_type_hint = TRUE;
+ priv->type_hint = hint;
}
/**
GdkWindowTypeHint
gtk_window_get_type_hint (GtkWindow *window)
{
+ GtkWindowPrivate *priv;
+
g_return_val_if_fail (GTK_IS_WINDOW (window), GDK_WINDOW_TYPE_HINT_NORMAL);
- return window->type_hint;
+ priv = GTK_WINDOW_GET_PRIVATE (window);
+
+ return priv->type_hint;
}
/**
if (GTK_WIDGET_REALIZED (window))
gdk_window_set_skip_taskbar_hint (GTK_WIDGET (window)->window,
priv->skips_taskbar);
- g_object_notify (G_OBJECT (window), "skip_taskbar_hint");
+ g_object_notify (G_OBJECT (window), "skip-taskbar-hint");
}
}
if (GTK_WIDGET_REALIZED (window))
gdk_window_set_skip_pager_hint (GTK_WIDGET (window)->window,
priv->skips_pager);
- g_object_notify (G_OBJECT (window), "skip_pager_hint");
+ g_object_notify (G_OBJECT (window), "skip-pager-hint");
}
}
return priv->skips_pager;
}
+/**
+ * gtk_window_set_urgency_hint:
+ * @window: a #GtkWindow
+ * @setting: %TRUE to mark this window as urgent
+ *
+ * Windows may set a hint asking the desktop environment to draw
+ * the users attention to the window. This function sets this hint.
+ *
+ * Since: 2.8
+ **/
+void
+gtk_window_set_urgency_hint (GtkWindow *window,
+ gboolean setting)
+{
+ GtkWindowPrivate *priv;
+
+ g_return_if_fail (GTK_IS_WINDOW (window));
+
+ priv = GTK_WINDOW_GET_PRIVATE (window);
+
+ setting = setting != FALSE;
+
+ if (priv->urgent != setting)
+ {
+ priv->urgent = setting;
+ if (GTK_WIDGET_REALIZED (window))
+ gdk_window_set_urgency_hint (GTK_WIDGET (window)->window,
+ priv->urgent);
+ g_object_notify (G_OBJECT (window), "urgency-hint");
+ }
+}
+
+/**
+ * gtk_window_get_urgency_hint:
+ * @window: a #GtkWindow
+ *
+ * Gets the value set by gtk_window_set_urgency_hint()
+ *
+ * Return value: %TRUE if window is urgent
+ *
+ * Since: 2.8
+ **/
+gboolean
+gtk_window_get_urgency_hint (GtkWindow *window)
+{
+ GtkWindowPrivate *priv;
+
+ g_return_val_if_fail (GTK_IS_WINDOW (window), FALSE);
+
+ priv = GTK_WINDOW_GET_PRIVATE (window);
+
+ return priv->urgent;
+}
+
/**
* gtk_window_set_accept_focus:
* @window: a #GtkWindow
if (GTK_WIDGET_REALIZED (window))
gdk_window_set_accept_focus (GTK_WIDGET (window)->window,
priv->accept_focus);
- g_object_notify (G_OBJECT (window), "accept_focus");
+ g_object_notify (G_OBJECT (window), "accept-focus");
}
}
if (GTK_WIDGET_REALIZED (window))
gdk_window_set_focus_on_map (GTK_WIDGET (window)->window,
priv->focus_on_map);
- g_object_notify (G_OBJECT (window), "focus_on_map");
+ g_object_notify (G_OBJECT (window), "focus-on-map");
}
}
window->destroy_with_parent = setting;
- g_object_notify (G_OBJECT (window), "destroy_with_parent");
+ g_object_notify (G_OBJECT (window), "destroy-with-parent");
}
/**
return window->decorated;
}
+/**
+ * gtk_window_set_deletable:
+ * @window: a #GtkWindow
+ * @setting: %TRUE to decorate the window as deletable
+ *
+ * By default, windows have a close button in the window frame. Some
+ * <link linkend="gtk-X11-arch">window managers</link> allow GTK+ to
+ * disable this button. If you set the deletable property to %FALSE
+ * using this function, GTK+ will do its best to convince the window
+ * manager not to show a close button. Depending on the system, this
+ * function may not have any effect when called on a window that is
+ * already visible, so you should call it before calling gtk_window_show().
+ *
+ * On Windows, this function always works, since there's no window manager
+ * policy involved.
+ *
+ * Since: 2.10
+ */
+void
+gtk_window_set_deletable (GtkWindow *window,
+ gboolean setting)
+{
+ GtkWindowPrivate *priv;
+
+ g_return_if_fail (GTK_IS_WINDOW (window));
+
+ priv = GTK_WINDOW_GET_PRIVATE (window);
+
+ setting = setting != FALSE;
+
+ if (setting == priv->deletable)
+ return;
+
+ priv->deletable = setting;
+
+ if (GTK_WIDGET (window)->window)
+ {
+ if (priv->deletable)
+ gdk_window_set_functions (GTK_WIDGET (window)->window,
+ GDK_FUNC_ALL);
+ else
+ gdk_window_set_functions (GTK_WIDGET (window)->window,
+ GDK_FUNC_ALL | GDK_FUNC_CLOSE);
+ }
+
+ g_object_notify (G_OBJECT (window), "deletable");
+}
+
+/**
+ * gtk_window_get_deletable:
+ * @window: a #GtkWindow
+ *
+ * Returns whether the window has been set to have a close button
+ * via gtk_window_set_deletable().
+ *
+ * Return value: %TRUE if the window has been set to have a close button
+ *
+ * Since: 2.10
+ **/
+gboolean
+gtk_window_get_deletable (GtkWindow *window)
+{
+ GtkWindowPrivate *priv;
+
+ g_return_val_if_fail (GTK_IS_WINDOW (window), TRUE);
+
+ priv = GTK_WINDOW_GET_PRIVATE (window);
+
+ return priv->deletable;
+}
+
static GtkWindowIconInfo*
get_icon_info (GtkWindow *window)
{
- return g_object_get_data (G_OBJECT (window),
- "gtk-window-icon-info");
+ return g_object_get_qdata (G_OBJECT (window), quark_gtk_window_icon_info);
}
+static void
+free_icon_info (GtkWindowIconInfo *info)
+{
+ g_free (info->icon_name);
+ g_slice_free (GtkWindowIconInfo, info);
+}
+
+
static GtkWindowIconInfo*
ensure_icon_info (GtkWindow *window)
{
if (info == NULL)
{
- info = g_new0 (GtkWindowIconInfo, 1);
- g_object_set_data_full (G_OBJECT (window),
- "gtk-window-icon-info",
+ info = g_slice_new0 (GtkWindowIconInfo);
+ g_object_set_qdata_full (G_OBJECT (window),
+ quark_gtk_window_icon_info,
info,
- g_free);
+ (GDestroyNotify)free_icon_info);
}
return info;
static ScreenIconInfo *
get_screen_icon_info (GdkScreen *screen)
{
- ScreenIconInfo *info = g_object_get_data (G_OBJECT (screen),
- "gtk-window-default-icon-pixmap");
+ ScreenIconInfo *info = g_object_get_qdata (G_OBJECT (screen),
+ quark_gtk_window_default_icon_pixmap);
if (!info)
{
- info = g_new0 (ScreenIconInfo, 1);
- g_object_set_data (G_OBJECT (screen), "gtk-window-default-icon-pixmap", info);
+ info = g_slice_new0 (ScreenIconInfo);
+ g_object_set_qdata (G_OBJECT (screen),
+ quark_gtk_window_default_icon_pixmap, info);
}
if (info->serial != default_icon_serial)
}
}
+static GList *
+icon_list_from_theme (GtkWidget *widget,
+ const gchar *name)
+{
+ GList *list;
+
+ GtkIconTheme *icon_theme;
+ GdkPixbuf *icon;
+ gint *sizes;
+ gint i;
+
+ icon_theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (widget));
+
+ sizes = gtk_icon_theme_get_icon_sizes (icon_theme, name);
+
+ list = NULL;
+ for (i = 0; sizes[i]; i++)
+ {
+ /* FIXME
+ * We need an EWMH extension to handle scalable icons
+ * by passing their name to the WM. For now just use a
+ * fixed size of 48.
+ */
+ if (sizes[i] == -1)
+ icon = gtk_icon_theme_load_icon (icon_theme, name,
+ 48, 0, NULL);
+ else
+ icon = gtk_icon_theme_load_icon (icon_theme, name,
+ sizes[i], 0, NULL);
+ if (icon)
+ list = g_list_append (list, icon);
+ }
+
+ g_free (sizes);
+
+ return list;
+}
+
+
static void
gtk_window_realize_icon (GtkWindow *window)
{
GtkWidget *widget;
GtkWindowIconInfo *info;
GList *icon_list;
-
+
widget = GTK_WIDGET (window);
g_return_if_fail (widget->window != NULL);
info->using_default_icon = FALSE;
info->using_parent_icon = FALSE;
+ info->using_themed_icon = FALSE;
icon_list = info->icon_list;
-
+
+ /* Look up themed icon */
+ if (icon_list == NULL && info->icon_name)
+ {
+ icon_list = icon_list_from_theme (widget, info->icon_name);
+ if (icon_list)
+ info->using_themed_icon = TRUE;
+ }
+
/* Inherit from transient parent */
if (icon_list == NULL && window->transient_parent)
{
if (icon_list)
info->using_default_icon = TRUE;
}
+
+ /* Look up themed icon */
+ if (icon_list == NULL && default_icon_name)
+ {
+ icon_list = icon_list_from_theme (widget, default_icon_name);
+ info->using_default_icon = TRUE;
+ info->using_themed_icon = TRUE;
+ }
gdk_window_set_icon_list (widget->window, icon_list);
info->icon_mask);
info->realized = TRUE;
+
+ if (info->using_themed_icon)
+ {
+ GtkIconTheme *icon_theme;
+
+ g_list_foreach (icon_list, (GFunc) g_object_unref, NULL);
+ g_list_free (icon_list);
+
+ icon_theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (GTK_WIDGET (window)));
+ g_signal_connect (icon_theme, "changed",
+ G_CALLBACK (update_themed_icon), window);
+ }
}
static void
gtk_window_unrealize_icon (GtkWindow *window)
{
GtkWindowIconInfo *info;
- GtkWidget *widget;
- widget = GTK_WIDGET (window);
-
info = get_icon_info (window);
if (info == NULL)
info->icon_pixmap = NULL;
info->icon_mask = NULL;
+ if (info->using_themed_icon)
+ {
+ GtkIconTheme *icon_theme;
+
+ icon_theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (GTK_WIDGET (window)));
+
+ g_signal_handlers_disconnect_by_func (icon_theme, update_themed_icon, window);
+ }
+
/* We don't clear the properties on the window, just figure the
* window is going away.
*/
info->realized = FALSE;
+
}
/**
if (info->icon_list == list) /* check for NULL mostly */
return;
+ g_list_foreach (list,
+ (GFunc) g_object_ref, NULL);
+
g_list_foreach (info->icon_list,
(GFunc) g_object_unref, NULL);
g_list_free (info->icon_list);
info->icon_list = g_list_copy (list);
- g_list_foreach (info->icon_list,
- (GFunc) g_object_ref, NULL);
g_object_notify (G_OBJECT (window), "icon");
/* We could try to update our transient children, but I don't think
* it's really worth it. If we did it, the best way would probably
- * be to have children connect to notify::icon_list
+ * be to have children connect to notify::icon-list
*/
}
g_return_val_if_fail (GTK_IS_WINDOW (window), NULL);
- info = get_icon_info (window);
+ info = get_icon_info (window);
+
+ if (info)
+ return g_list_copy (info->icon_list);
+ else
+ return NULL;
+}
+
+/**
+ * gtk_window_set_icon:
+ * @window: a #GtkWindow
+ * @icon: icon image, or %NULL
+ *
+ * Sets up the icon representing a #GtkWindow. This icon is used when
+ * the window is minimized (also known as iconified). Some window
+ * managers or desktop environments may also place it in the window
+ * frame, or display it in other contexts.
+ *
+ * The icon should be provided in whatever size it was naturally
+ * drawn; that is, don't scale the image before passing it to
+ * GTK+. Scaling is postponed until the last minute, when the desired
+ * final size is known, to allow best quality.
+ *
+ * If you have your icon hand-drawn in multiple sizes, use
+ * gtk_window_set_icon_list(). Then the best size will be used.
+ *
+ * This function is equivalent to calling gtk_window_set_icon_list()
+ * with a 1-element list.
+ *
+ * See also gtk_window_set_default_icon_list() to set the icon
+ * for all windows in your application in one go.
+ **/
+void
+gtk_window_set_icon (GtkWindow *window,
+ GdkPixbuf *icon)
+{
+ GList *list;
+
+ g_return_if_fail (GTK_IS_WINDOW (window));
+ g_return_if_fail (icon == NULL || GDK_IS_PIXBUF (icon));
+
+ list = NULL;
+
+ if (icon)
+ list = g_list_append (list, icon);
+
+ gtk_window_set_icon_list (window, list);
+ g_list_free (list);
+}
+
+
+static void
+update_themed_icon (GtkIconTheme *icon_theme,
+ GtkWindow *window)
+{
+ g_object_notify (G_OBJECT (window), "icon");
+
+ gtk_window_unrealize_icon (window);
+
+ if (GTK_WIDGET_REALIZED (window))
+ gtk_window_realize_icon (window);
+}
+
+/**
+ * gtk_window_set_icon_name:
+ * @window: a #GtkWindow
+ * @name: the name of the themed icon
+ *
+ * Sets the icon for the window from a named themed icon. See
+ * the docs for #GtkIconTheme for more details.
+ *
+ * Note that this has nothing to do with the WM_ICON_NAME
+ * property which is mentioned in the ICCCM.
+ *
+ * Since: 2.6
+ */
+void
+gtk_window_set_icon_name (GtkWindow *window,
+ const gchar *name)
+{
+ GtkWindowIconInfo *info;
+ gchar *tmp;
+
+ g_return_if_fail (GTK_IS_WINDOW (window));
+
+ info = ensure_icon_info (window);
+
+ tmp = info->icon_name;
+ info->icon_name = g_strdup (name);
+ g_free (tmp);
+
+ g_list_foreach (info->icon_list, (GFunc) g_object_unref, NULL);
+ g_list_free (info->icon_list);
+ info->icon_list = NULL;
+
+ update_themed_icon (NULL, window);
- if (info)
- return g_list_copy (info->icon_list);
- else
- return NULL;
+ g_object_notify (G_OBJECT (window), "icon-name");
}
/**
- * gtk_window_set_icon:
+ * gtk_window_get_icon_name:
* @window: a #GtkWindow
- * @icon: icon image, or %NULL
- *
- * Sets up the icon representing a #GtkWindow. This icon is used when
- * the window is minimized (also known as iconified). Some window
- * managers or desktop environments may also place it in the window
- * frame, or display it in other contexts.
- *
- * The icon should be provided in whatever size it was naturally
- * drawn; that is, don't scale the image before passing it to
- * GTK+. Scaling is postponed until the last minute, when the desired
- * final size is known, to allow best quality.
*
- * If you have your icon hand-drawn in multiple sizes, use
- * gtk_window_set_icon_list(). Then the best size will be used.
+ * Returns the name of the themed icon for the window,
+ * see gtk_window_set_icon_name().
*
- * This function is equivalent to calling gtk_window_set_icon_list()
- * with a 1-element list.
+ * Returns: the icon name or %NULL if the window has
+ * no themed icon
*
- * See also gtk_window_set_default_icon_list() to set the icon
- * for all windows in your application in one go.
- **/
-void
-gtk_window_set_icon (GtkWindow *window,
- GdkPixbuf *icon)
+ * Since: 2.6
+ */
+G_CONST_RETURN gchar *
+gtk_window_get_icon_name (GtkWindow *window)
{
- GList *list;
-
- g_return_if_fail (GTK_IS_WINDOW (window));
- g_return_if_fail (icon == NULL || GDK_IS_PIXBUF (icon));
+ GtkWindowIconInfo *info;
- list = NULL;
+ g_return_val_if_fail (GTK_IS_WINDOW (window), NULL);
- if (icon)
- list = g_list_append (list, icon);
-
- gtk_window_set_icon_list (window, list);
- g_list_free (list);
+ info = ensure_icon_info (window);
+
+ return info->icon_name;
}
/**
*/
default_icon_serial++;
+ g_list_foreach (list,
+ (GFunc) g_object_ref, NULL);
+
g_list_foreach (default_icon_list,
(GFunc) g_object_unref, NULL);
g_list_free (default_icon_list);
default_icon_list = g_list_copy (list);
- g_list_foreach (default_icon_list,
- (GFunc) g_object_ref, NULL);
/* Update all toplevels */
toplevels = gtk_window_list_toplevels ();
g_list_free (list);
}
+/**
+ * gtk_window_set_default_icon_name:
+ * @name: the name of the themed icon
+ *
+ * Sets an icon to be used as fallback for windows that haven't
+ * had gtk_window_set_icon_list() called on them from a named
+ * themed icon, see gtk_window_set_icon_name().
+ *
+ * Since: 2.6
+ **/
+void
+gtk_window_set_default_icon_name (const gchar *name)
+{
+ GList *tmp_list;
+ GList *toplevels;
+
+ /* Update serial so we don't used cached pixmaps/masks
+ */
+ default_icon_serial++;
+
+ g_free (default_icon_name);
+ default_icon_name = g_strdup (name);
+
+ g_list_foreach (default_icon_list,
+ (GFunc) g_object_unref, NULL);
+
+ g_list_free (default_icon_list);
+ default_icon_list = NULL;
+
+ /* Update all toplevels */
+ toplevels = gtk_window_list_toplevels ();
+ tmp_list = toplevels;
+ while (tmp_list != NULL)
+ {
+ GtkWindowIconInfo *info;
+ GtkWindow *w = tmp_list->data;
+
+ info = get_icon_info (w);
+ if (info && info->using_default_icon && info->using_themed_icon)
+ {
+ gtk_window_unrealize_icon (w);
+ if (GTK_WIDGET_REALIZED (w))
+ gtk_window_realize_icon (w);
+ }
+
+ tmp_list = tmp_list->next;
+ }
+ g_list_free (toplevels);
+}
+
/**
* gtk_window_set_default_icon_from_file:
* @filename: location of icon file
info->default_width = width;
- g_object_notify (G_OBJECT (window), "default_width");
+ g_object_notify (G_OBJECT (window), "default-width");
}
if (change_height)
info->default_height = height;
- g_object_notify (G_OBJECT (window), "default_height");
+ g_object_notify (G_OBJECT (window), "default-height");
}
g_object_thaw_notify (G_OBJECT (window));
gint *height)
{
gint w, h;
- GtkWidget *widget;
g_return_if_fail (GTK_IS_WINDOW (window));
- widget = GTK_WIDGET (window);
-
if (width == NULL && height == NULL)
return;
* reference point. So, to place a window in the bottom right corner
* you would first set gravity to south east, then write:
* <literal>gtk_window_move (window, gdk_screen_width () - window_width,
- * gdk_screen_height () - window_height)</literal>.
+ * gdk_screen_height () - window_height)</literal> (note that this
+ * example does not take multi-head scenarios into account).
*
* The Extended Window Manager Hints specification at <ulink
- * url="http://www.freedesktop.org/standards/wm-spec">
- * http://www.freedesktop.org/standards/wm-spec</ulink> has a
+ * url="http://www.freedesktop.org/Standards/wm-spec">
+ * http://www.freedesktop.org/Standards/wm-spec</ulink> has a
* nice table of gravities in the "implementation notes" section.
*
* The gtk_window_get_position() documentation may also be relevant.
- *
- **/
+ */
void
gtk_window_move (GtkWindow *window,
gint x,
gtk_window_free_key_hash (window);
- GTK_OBJECT_CLASS (parent_class)->destroy (object);
-}
-
-static gboolean
-gtk_window_mnemonic_hash_remove (gpointer key,
- gpointer value,
- gpointer user)
-{
- GtkWindowMnemonic *mnemonic = key;
- GtkWindow *window = user;
-
- if (mnemonic->window == window)
- {
- if (mnemonic->targets)
- {
- gchar *name = gtk_accelerator_name (mnemonic->keyval, 0);
-
- g_warning ("mnemonic \"%s\" wasn't removed for widget (%p)",
- name, mnemonic->targets->data);
- g_free (name);
- }
- g_slist_free (mnemonic->targets);
- g_free (mnemonic);
-
- return TRUE;
- }
- return FALSE;
+ GTK_OBJECT_CLASS (gtk_window_parent_class)->destroy (object);
}
static void
gtk_window_finalize (GObject *object)
{
GtkWindow *window = GTK_WINDOW (object);
+ GtkMnemonicHash *mnemonic_hash;
g_free (window->title);
g_free (window->wmclass_name);
g_free (window->wmclass_class);
g_free (window->wm_role);
- g_hash_table_foreach_remove (mnemonic_hash_table,
- gtk_window_mnemonic_hash_remove,
- window);
+ mnemonic_hash = gtk_window_get_mnemonic_hash (window, FALSE);
+ if (mnemonic_hash)
+ _gtk_mnemonic_hash_free (mnemonic_hash);
+
if (window->geometry_info)
{
if (window->geometry_info->widget)
window->keys_changed_handler = 0;
}
- G_OBJECT_CLASS (parent_class)->finalize (object);
+ if (window->screen)
+ {
+ g_signal_handlers_disconnect_by_func (window->screen,
+ gtk_window_on_composited_changed, window);
+ }
+
+ G_OBJECT_CLASS (gtk_window_parent_class)->finalize (object);
}
static void
/* Try to make sure that we have some focused widget
*/
-#ifdef GDK_WINDOWING_X11
if (!window->focus_widget && !GTK_IS_PLUG (window))
-#else
- if (!window->focus_widget)
-#endif
gtk_window_move_focus (window, GTK_DIR_TAB_FORWARD);
if (window->modal)
window->need_default_size = FALSE;
window->need_default_position = FALSE;
+ if (priv->reset_type_hint)
+ {
+ /* We should only reset the type hint when the application
+ * used gtk_window_set_type_hint() to change the hint.
+ * Some applications use X directly to change the properties;
+ * in that case, we shouldn't overwrite what they did.
+ */
+ gdk_window_set_type_hint (widget->window, priv->type_hint);
+ priv->reset_type_hint = FALSE;
+ }
+
gdk_window_show (widget->window);
if (window->frame)
}
}
+static gboolean
+gtk_window_map_event (GtkWidget *widget,
+ GdkEventAny *event)
+{
+ if (!GTK_WIDGET_MAPPED (widget))
+ {
+ /* we should be be unmapped, but are getting a MapEvent, this may happen
+ * to toplevel XWindows if mapping was intercepted by a window manager
+ * and an unmap request occoured while the MapRequestEvent was still
+ * being handled. we work around this situaiton here by re-requesting
+ * the window being unmapped. more details can be found in:
+ * http://bugzilla.gnome.org/show_bug.cgi?id=316180
+ */
+ gdk_window_hide (widget->window);
+ }
+ return FALSE;
+}
+
static void
gtk_window_unmap (GtkWidget *widget)
{
}
state = gdk_window_get_state (widget->window);
- window->iconify_initially = state & GDK_WINDOW_STATE_ICONIFIED;
- window->maximize_initially = state & GDK_WINDOW_STATE_MAXIMIZED;
- window->stick_initially = state & GDK_WINDOW_STATE_STICKY;
- priv->above_initially = state & GDK_WINDOW_STATE_ABOVE;
- priv->below_initially = state & GDK_WINDOW_STATE_BELOW;
+ window->iconify_initially = (state & GDK_WINDOW_STATE_ICONIFIED) != 0;
+ window->maximize_initially = (state & GDK_WINDOW_STATE_MAXIMIZED) != 0;
+ window->stick_initially = (state & GDK_WINDOW_STATE_STICKY) != 0;
+ priv->above_initially = (state & GDK_WINDOW_STATE_ABOVE) != 0;
+ priv->below_initially = (state & GDK_WINDOW_STATE_BELOW) != 0;
}
static void
GdkWindow *parent_window;
GdkWindowAttr attributes;
gint attributes_mask;
+ GtkWindowPrivate *priv;
window = GTK_WINDOW (widget);
+ priv = GTK_WINDOW_GET_PRIVATE (window);
+
/* ensure widget tree is properly size allocated */
if (widget->allocation.x == -1 &&
widget->allocation.y == -1 &&
attributes_mask = GDK_WA_X | GDK_WA_Y;
parent_window = window->frame;
+
+ g_signal_connect (window,
+ "event",
+ G_CALLBACK (gtk_window_event),
+ NULL);
}
else
{
if (!window->decorated)
gdk_window_set_decorations (widget->window, 0);
- gdk_window_set_type_hint (widget->window, window->type_hint);
+ if (!priv->deletable)
+ gdk_window_set_functions (widget->window, GDK_FUNC_ALL | GDK_FUNC_CLOSE);
+ gdk_window_set_type_hint (widget->window, priv->type_hint);
+
if (gtk_window_get_skip_pager_hint (window))
gdk_window_set_skip_pager_hint (widget->window, TRUE);
/* Icons */
gtk_window_unrealize_icon (window);
- (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
+ (* GTK_WIDGET_CLASS (gtk_window_parent_class)->unrealize) (widget);
}
static void
/* 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))
+ GtkMnemonicHash *mnemonic_hash = gtk_window_get_mnemonic_hash (window, FALSE);
+ if (mnemonic_hash && _gtk_mnemonic_hash_lookup (mnemonic_hash, accel_key))
return TRUE;
}
/* Chain up, invokes binding set */
if (!handled)
- handled = GTK_WIDGET_CLASS (parent_class)->key_press_event (widget, event);
+ handled = GTK_WIDGET_CLASS (gtk_window_parent_class)->key_press_event (widget, event);
return handled;
}
/* Chain up, invokes binding set */
if (!handled)
- handled = GTK_WIDGET_CLASS (parent_class)->key_press_event (widget, event);
+ handled = GTK_WIDGET_CLASS (gtk_window_parent_class)->key_release_event (widget, event);
return handled;
}
gtk_widget_event (widget, fevent);
- g_object_notify (G_OBJECT (widget), "has_focus");
+ g_object_notify (G_OBJECT (widget), "has-focus");
g_object_unref (widget);
gdk_event_free (fevent);
}
static GdkAtom atom_rcfiles = GDK_NONE;
+static GdkAtom atom_iconthemes = GDK_NONE;
static void
-gtk_window_read_rcfiles (GtkWidget *widget,
- GdkEventClient *event)
+send_client_message_to_embedded_windows (GtkWidget *widget,
+ GdkAtom message_type)
{
GList *embedded_windows;
- embedded_windows = g_object_get_data (G_OBJECT (widget), "gtk-embedded");
+ embedded_windows = g_object_get_qdata (G_OBJECT (widget), quark_gtk_embedded);
if (embedded_windows)
{
GdkEvent *send_event = gdk_event_new (GDK_CLIENT_EVENT);
for (i = 0; i < 5; i++)
send_event->client.data.l[i] = 0;
send_event->client.data_format = 32;
- send_event->client.message_type = atom_rcfiles;
+ send_event->client.message_type = message_type;
while (embedded_windows)
{
gdk_event_free (send_event);
}
-
- gtk_rc_reparse_all_for_settings (gtk_widget_get_settings (widget), FALSE);
}
static gint
GdkEventClient *event)
{
if (!atom_rcfiles)
- atom_rcfiles = gdk_atom_intern ("_GTK_READ_RCFILES", FALSE);
+ {
+ atom_rcfiles = gdk_atom_intern_static_string ("_GTK_READ_RCFILES");
+ atom_iconthemes = gdk_atom_intern_static_string ("_GTK_LOAD_ICONTHEMES");
+ }
if (event->message_type == atom_rcfiles)
- gtk_window_read_rcfiles (widget, event);
+ {
+ send_client_message_to_embedded_windows (widget, atom_rcfiles);
+ gtk_rc_reparse_all_for_settings (gtk_widget_get_settings (widget), FALSE);
+ }
+
+ if (event->message_type == atom_iconthemes)
+ {
+ send_client_message_to_embedded_windows (widget, atom_iconthemes);
+ _gtk_icon_theme_check_reload (gtk_widget_get_display (widget));
+ }
return FALSE;
}
GtkWidget *focus)
{
GtkWidget *old_focus = window->focus_widget;
- gboolean def_flags = 0;
+ gboolean had_default = FALSE;
+ gboolean focus_had_default = FALSE;
+ gboolean old_focus_had_default = FALSE;
if (old_focus)
{
g_object_ref (old_focus);
g_object_freeze_notify (G_OBJECT (old_focus));
+ old_focus_had_default = GTK_WIDGET_HAS_DEFAULT (old_focus);
}
if (focus)
{
g_object_ref (focus);
g_object_freeze_notify (G_OBJECT (focus));
+ focus_had_default = GTK_WIDGET_HAS_DEFAULT (focus);
}
if (window->default_widget)
- def_flags = GTK_WIDGET_HAS_DEFAULT (window->default_widget);
+ had_default = GTK_WIDGET_HAS_DEFAULT (window->default_widget);
if (window->focus_widget)
{
(window->focus_widget != window->default_widget))
{
GTK_WIDGET_UNSET_FLAGS (window->focus_widget, GTK_HAS_DEFAULT);
-
+ gtk_widget_queue_draw (window->focus_widget);
+
if (window->default_widget)
GTK_WIDGET_SET_FLAGS (window->default_widget, GTK_HAS_DEFAULT);
- }
+ }
window->focus_widget = NULL;
if (window->has_focus)
do_focus_change (old_focus, FALSE);
- g_object_notify (G_OBJECT (old_focus), "is_focus");
+ g_object_notify (G_OBJECT (old_focus), "is-focus");
}
/* The above notifications may have set a new focus widget,
if (window->has_focus)
do_focus_change (window->focus_widget, TRUE);
- g_object_notify (G_OBJECT (window->focus_widget), "is_focus");
+ g_object_notify (G_OBJECT (window->focus_widget), "is-focus");
}
/* If the default widget changed, a redraw will have been queued
* is harmless.
*/
if (window->default_widget &&
- (def_flags != GTK_WIDGET_FLAGS (window->default_widget)))
+ (had_default != GTK_WIDGET_HAS_DEFAULT (window->default_widget)))
gtk_widget_queue_draw (window->default_widget);
-
+
if (old_focus)
{
+ if (old_focus_had_default != GTK_WIDGET_HAS_DEFAULT (old_focus))
+ gtk_widget_queue_draw (old_focus);
+
g_object_thaw_notify (G_OBJECT (old_focus));
g_object_unref (old_focus);
}
if (focus)
{
+ if (focus_had_default != GTK_WIDGET_HAS_DEFAULT (focus))
+ gtk_widget_queue_draw (focus);
+
g_object_thaw_notify (G_OBJECT (focus));
g_object_unref (focus);
}
{
gint base_width = 0;
gint base_height = 0;
+ gint min_width = 0;
+ gint min_height = 0;
gint width_inc = 1;
gint height_inc = 1;
base_width = geometry.base_width;
base_height = geometry.base_height;
}
- else if (flags & GDK_HINT_MIN_SIZE)
+ if (flags & GDK_HINT_MIN_SIZE)
{
- base_width = geometry.min_width;
- base_height = geometry.min_height;
+ min_width = geometry.min_width;
+ min_height = geometry.min_height;
}
if (flags & GDK_HINT_RESIZE_INC)
{
}
if (info->default_width > 0)
- *width = info->default_width * width_inc + base_width;
+ *width = MAX (info->default_width * width_inc + base_width, min_width);
if (info->default_height > 0)
- *height = info->default_height * height_inc + base_height;
+ *height = MAX (info->default_height * height_inc + base_height, min_height);
}
}
else
screen = gtk_window_check_screen (window);
gtk_widget_size_request (widget, NULL);
- gtk_window_compute_configure_request_size (window, &w, &h);
+ gtk_window_compute_configure_request_size (window, (guint *)&w, (guint *)&h);
gtk_window_compute_hints (window, &new_geometry, &new_flags);
gtk_window_constrain_size (window,
parent_widget = (GtkWidget*) window->transient_parent;
pos = get_effective_position (window);
- info = gtk_window_get_geometry_info (window, TRUE);
-
- /* by default, don't change position requested */
- x = info->last.configure_request.x;
- y = info->last.configure_request.y;
+ info = gtk_window_get_geometry_info (window, FALSE);
+ /* by default, don't change position requested */
+ if (info)
+ {
+ x = info->last.configure_request.x;
+ y = info->last.configure_request.y;
+ }
+ else
+ {
+ x = 0;
+ y = 0;
+ }
+
+
if (window->need_default_position)
{
}
} /* if (window->need_default_position) */
- if (window->need_default_position &&
+ if (window->need_default_position && info &&
info->initial_pos_set)
{
x = info->initial_x;
allocation = widget->allocation;
gtk_widget_size_allocate (widget, &allocation);
- gdk_window_process_all_updates ();
+ gdk_window_process_updates (widget->window, TRUE);
gdk_window_configure_finished (widget->window);
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);
+ if (GTK_WIDGET_CLASS (gtk_window_parent_class)->expose_event)
+ return GTK_WIDGET_CLASS (gtk_window_parent_class)->expose_event (widget, event);
return FALSE;
}
* frame_event you can receive all events targeted at the frame.
*
* This function is used by the linux-fb port to implement managed
- * windows, but it could concievably be used by X-programs that
+ * windows, but it could conceivably be used by X-programs that
* want to do their own window decorations.
*
**/
* currently open, and the user chooses Preferences from the menu
* a second time; use gtk_window_present() to move the already-open dialog
* where the user can see it.
+ *
+ * If you are calling this function in response to a user interaction,
+ * it is preferable to use gtk_window_present_with_time().
*
**/
void
gtk_window_present (GtkWindow *window)
+{
+ gtk_window_present_with_time (window, GDK_CURRENT_TIME);
+}
+
+/**
+ * gtk_window_present_with_time:
+ * @window: a #GtkWindow
+ * @timestamp: the timestamp of the user interaction (typically a
+ * button or key press event) which triggered this call
+ *
+ * Presents a window to the user in response to a user interaction.
+ * If you need to present a window without a timestamp, use
+ * gtk_window_present(). See gtk_window_present() for details.
+ *
+ * Since: 2.8
+ **/
+void
+gtk_window_present_with_time (GtkWindow *window,
+ guint32 timestamp)
{
GtkWidget *widget;
gdk_window_show (widget->window);
- /* note that gdk_window_focus() will also move the window to
- * the current desktop, for WM spec compliant window managers.
- */
- gdk_window_focus (widget->window,
- gtk_get_current_event_time ());
+ /* Translate a timestamp of GDK_CURRENT_TIME appropriately */
+ if (timestamp == GDK_CURRENT_TIME)
+ {
+#ifdef GDK_WINDOWING_X11
+ GdkDisplay *display;
+
+ display = gtk_widget_get_display (GTK_WIDGET (window));
+ timestamp = gdk_x11_display_get_user_time (display);
+#else
+ timestamp = gtk_get_current_event_time ();
+#endif
+ }
+
+ gdk_window_focus (widget->window, timestamp);
}
else
{
* on #GtkWidget.
*
* Note that, according to the <ulink
- * url="http://www.freedesktop.org/standards/wm-spec">Extended Window Manager Hints</ulink>
- * specification, the above state is mainly meant for user preferences and should not be used
- * by applications e.g. for drawing attention to their dialogs.
+ * url="http://www.freedesktop.org/Standards/wm-spec">Extended Window
+ * Manager Hints</ulink> specification, the above state is mainly meant
+ * for user preferences and should not be used by applications e.g. for
+ * drawing attention to their dialogs.
*
* Since: 2.4
**/
widget = GTK_WIDGET (window);
priv = GTK_WINDOW_GET_PRIVATE (window);
- priv->above_initially = setting;
+ priv->above_initially = setting != FALSE;
if (setting)
priv->below_initially = FALSE;
* on #GtkWidget.
*
* Note that, according to the <ulink
- * url="http://www.freedesktop.org/standards/wm-spec">Extended Window Manager Hints</ulink>
- * specification, the above state is mainly meant for user preferences and should not be used
- * by applications e.g. for drawing attention to their dialogs.
+ * url="http://www.freedesktop.org/Standards/wm-spec">Extended Window
+ * Manager Hints</ulink> specification, the above state is mainly meant
+ * for user preferences and should not be used by applications e.g. for
+ * drawing attention to their dialogs.
*
* Since: 2.4
**/
widget = GTK_WIDGET (window);
priv = GTK_WINDOW_GET_PRIVATE (window);
- priv->below_initially = setting;
+ priv->below_initially = setting != FALSE;
if (setting)
priv->above_initially = FALSE;
window->screen = screen;
gtk_widget_reset_rc_styles (widget);
if (screen != previous_screen)
- _gtk_widget_propagate_screen_changed (widget, previous_screen);
+ {
+ g_signal_handlers_disconnect_by_func (previous_screen,
+ gtk_window_on_composited_changed, window);
+ g_signal_connect (screen, "composited_changed",
+ G_CALLBACK (gtk_window_on_composited_changed), window);
+
+ _gtk_widget_propagate_screen_changed (widget, previous_screen);
+ _gtk_widget_propagate_composited_changed (widget);
+ }
g_object_notify (G_OBJECT (window), "screen");
if (was_mapped)
gtk_widget_map (widget);
}
+static void
+gtk_window_on_composited_changed (GdkScreen *screen,
+ GtkWindow *window)
+{
+ gtk_widget_queue_draw (GTK_WIDGET (window));
+
+ _gtk_widget_propagate_composited_changed (GTK_WIDGET (window));
+}
+
static GdkScreen *
gtk_window_check_screen (GtkWindow *window)
{
* For real toplevel windows, this is identical to gtk_window_is_active(),
* but for embedded windows, like #GtkPlug, the results will differ.
*
- * Return value: %TRUE if the the input focus is within this GtkWindow
+ * Return value: %TRUE if the input focus is within this GtkWindow
*
* Since: 2.4
**/
if (!window_group_type)
{
- static const GTypeInfo window_group_info =
+ const GTypeInfo window_group_info =
{
sizeof (GtkWindowGroupClass),
NULL, /* base_init */
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GtkWindowGroup),
- 16, /* n_preallocs */
+ 0, /* n_preallocs */
(GInstanceInitFunc) NULL,
};
- window_group_type = g_type_register_static (G_TYPE_OBJECT, "GtkWindowGroup", &window_group_info, 0);
+ window_group_type = g_type_register_static (G_TYPE_OBJECT, I_("GtkWindowGroup"),
+ &window_group_info, 0);
}
return window_group_type;
if (window->group)
gtk_window_group_remove_window (window->group, window);
else
- window_group_cleanup_grabs (_gtk_window_get_group (NULL), window);
+ window_group_cleanup_grabs (gtk_window_get_group (NULL), window);
window->group = window_group;
g_object_unref (window);
}
-/* Return the group for the window or the default group
+/**
+ * gtk_window_get_group:
+ * @window: a #GtkWindow, or %NULL
+ *
+ * Returns the group for @window or the default group, if
+ * @window is %NULL or if @window does not have an explicit
+ * window group.
+ *
+ * Returns: the #GtkWindowGroup for a window or the default group
+ *
+ * Since: 2.10
*/
GtkWindowGroup *
-_gtk_window_get_group (GtkWindow *window)
+gtk_window_get_group (GtkWindow *window)
{
if (window && window->group)
return window->group;
}
}
+/* Return the current grab widget of the given group
+ */
+GtkWidget *
+_gtk_window_group_get_current_grab (GtkWindowGroup *window_group)
+{
+ if (window_group->grabs)
+ return GTK_WIDGET (window_group->grabs->data);
+ return NULL;
+}
/*
Derived from XParseGeometry() in XFree86
* on the window.
*
* <informalexample><programlisting>
+ * #include <gtk/gtk.h>
+ *
+ * static void
+ * fill_with_content (GtkWidget *vbox)
+ * {
+ * /<!-- -->* fill with content... *<!-- -->/
+ * }
+ *
* int
* main (int argc, char *argv[])
* {
- * GtkWidget *window, vbox;
- * GdkGeometry size_hints;
- *
+ * GtkWidget *window, *vbox;
+ * GdkGeometry size_hints = {
+ * 100, 50, 0, 0, 100, 50, 10, 10, 0.0, 0.0, GDK_GRAVITY_NORTH_WEST
+ * };
+ *
* gtk_init (&argc, &argv);
*
* window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
* fill_with_content (vbox);
* gtk_widget_show_all (vbox);
*
- * size_hints = {
- * 100, 50, 0, 0, 100, 50, 10, 10, 0.0, 0.0, GDK_GRAVITY_NORTH_WEST
- * };
- *
* gtk_window_set_geometry_hints (GTK_WINDOW (window),
* window,
* &size_hints,
* fprintf (stderr, "Failed to parse '%s'\n", argv[1]);
* }
*
- * gtk_widget_show_all (window);
- * gtk_main ();
+ * gtk_widget_show_all (window);
+ * gtk_main ();
*
- * return 0;
+ * return 0;
* }
* </programlisting></informalexample>
*
gtk_window_parse_geometry (GtkWindow *window,
const gchar *geometry)
{
- gint result, x, y;
+ gint result, x = 0, y = 0;
guint w, h;
GdkGravity grav;
gboolean size_set, pos_set;
result = gtk_XParseGeometry (geometry, &x, &y, &w, &h);
- if ((result & WidthValue) == 0 ||
- w < 0)
- w = -1;
- if ((result & HeightValue) == 0 ||
- h < 0)
- h = -1;
-
size_set = FALSE;
if ((result & WidthValue) || (result & HeightValue))
{
- gtk_window_set_default_size_internal (window, TRUE, w, TRUE, h, TRUE);
+ gtk_window_set_default_size_internal (window,
+ TRUE, result & WidthValue ? w : -1,
+ TRUE, result & HeightValue ? h : -1,
+ TRUE);
size_set = TRUE;
}
- gtk_window_get_size (window, &w, &h);
+ gtk_window_get_size (window, (gint *)&w, (gint *)&h);
grav = GDK_GRAVITY_NORTH_WEST;
}
static void
-gtk_window_mnemonic_hash_foreach (gpointer key,
- gpointer value,
- gpointer data)
+gtk_window_mnemonic_hash_foreach (guint keyval,
+ GSList *targets,
+ gpointer data)
{
struct {
GtkWindow *window;
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);
+ (*info->func) (info->window, keyval, info->window->mnemonic_modifier, TRUE, info->func_data);
}
void
gpointer func_data)
{
GSList *groups;
+ GtkMnemonicHash *mnemonic_hash;
struct {
GtkWindow *window;
info.func = func;
info.func_data = func_data;
- g_hash_table_foreach (mnemonic_hash_table,
- gtk_window_mnemonic_hash_foreach,
- &info);
+ mnemonic_hash = gtk_window_get_mnemonic_hash (window, FALSE);
+ if (mnemonic_hash)
+ _gtk_mnemonic_hash_foreach (mnemonic_hash,
+ gtk_window_mnemonic_hash_foreach, &info);
groups = gtk_accel_groups_from_object (G_OBJECT (window));
while (groups)
{
guint keyval;
guint modifiers;
- gboolean is_mnemonic;
+ guint is_mnemonic : 1;
};
+static void
+window_key_entry_destroy (gpointer data)
+{
+ g_slice_free (GtkWindowKeyEntry, data);
+}
+
static void
add_to_key_hash (GtkWindow *window,
guint keyval,
{
GtkKeyHash *key_hash = data;
- GtkWindowKeyEntry *entry = g_new (GtkWindowKeyEntry, 1);
+ GtkWindowKeyEntry *entry = g_slice_new (GtkWindowKeyEntry);
entry->keyval = keyval;
entry->modifiers = modifiers;
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");
+ GtkKeyHash *key_hash = g_object_get_qdata (G_OBJECT (window), quark_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 (screen)),
- (GDestroyNotify)g_free);
+ (GDestroyNotify)window_key_entry_destroy);
_gtk_window_keys_foreach (window, add_to_key_hash, key_hash);
- g_object_set_data (G_OBJECT (window), "gtk-window-key-hash", key_hash);
+ g_object_set_qdata (G_OBJECT (window), quark_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");
+ GtkKeyHash *key_hash = g_object_get_qdata (G_OBJECT (window), quark_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);
+ g_object_set_qdata (G_OBJECT (window), quark_gtk_window_key_hash, NULL);
}
}
gtk_window_activate_key (GtkWindow *window,
GdkEventKey *event)
{
- GtkKeyHash *key_hash = g_object_get_data (G_OBJECT (window), "gtk-window-key-hash");
+ GtkKeyHash *key_hash = g_object_get_qdata (G_OBJECT (window), quark_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");
+ key_hash = g_object_get_qdata (G_OBJECT (window), quark_gtk_window_key_hash);
}
if (key_hash)
if (found_entry)
{
+ gboolean enable_mnemonics;
+ gboolean enable_accels;
+
+ g_object_get (gtk_widget_get_settings (GTK_WIDGET (window)),
+ "gtk-enable-mnemonics", &enable_mnemonics,
+ "gtk-enable-accels", &enable_accels,
+ NULL);
+
if (found_entry->is_mnemonic)
- return gtk_window_mnemonic_activate (window, found_entry->keyval, found_entry->modifiers);
+ {
+ if (enable_mnemonics)
+ 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);
+ {
+ if (enable_accels)
+ return gtk_accel_groups_activate (G_OBJECT (window), found_entry->keyval,
+ found_entry->modifiers);
+ }
}
- else
- return FALSE;
+
+ return FALSE;
}
static void
window->is_active = is_active;
window_update_has_focus (window);
- g_object_notify (G_OBJECT (window), "is_active");
+ g_object_notify (G_OBJECT (window), "is-active");
}
}
window->has_toplevel_focus = has_toplevel_focus;
window_update_has_focus (window);
- g_object_notify (G_OBJECT (window), "has_toplevel_focus");
+ g_object_notify (G_OBJECT (window), "has-toplevel-focus");
}
}
* gtk_window_set_auto_startup_notification:
* @setting: %TRUE to automatically do startup notification
*
- * By default, after showing the first #GtkWindow for each #GdkScreen,
- * GTK+ calls gdk_screen_notify_startup_complete(). Call this
- * function to disable the automatic startup notification. You might
- * do this if your first window is a splash screen, and you want to
- * delay notification until after your real main window has been
- * shown, for example.
+ * By default, after showing the first #GtkWindow, GTK+ calls
+ * gdk_notify_startup_complete(). Call this function to disable
+ * the automatic startup notification. You might do this if your
+ * first window is a splash screen, and you want to delay notification
+ * until after your real main window has been shown, for example.
*
* In that example, you would disable startup notification
* temporarily, show your splash screen, then re-enable it so that
{
disable_startup_notification = !setting;
}
+
+#ifdef G_OS_WIN32
+
+#undef gtk_window_set_icon_from_file
+
+gboolean
+gtk_window_set_icon_from_file (GtkWindow *window,
+ const gchar *filename,
+ GError **err)
+{
+ gchar *utf8_filename = g_locale_to_utf8 (filename, -1, NULL, NULL, err);
+ gboolean retval;
+
+ if (utf8_filename == NULL)
+ return FALSE;
+
+ retval = gtk_window_set_icon_from_file_utf8 (window, utf8_filename, err);
+
+ g_free (utf8_filename);
+
+ return retval;
+}
+
+#undef gtk_window_set_default_icon_from_file
+
+gboolean
+gtk_window_set_default_icon_from_file (const gchar *filename,
+ GError **err)
+{
+ gchar *utf8_filename = g_locale_to_utf8 (filename, -1, NULL, NULL, err);
+ gboolean retval;
+
+ if (utf8_filename == NULL)
+ return FALSE;
+
+ retval = gtk_window_set_default_icon_from_file_utf8 (utf8_filename, err);
+
+ g_free (utf8_filename);
+
+ return retval;
+}
+
+#endif
+
+#define __GTK_WINDOW_C__
+#include "gtkaliasdef.c"
projects / ~andy / gtk / blobdiff