698 lines
25 KiB
C
698 lines
25 KiB
C
/*
|
|
* mooui/moowindow.c
|
|
*
|
|
* Copyright (C) 2004-2005 by Yevgen Muntyan <muntyan@math.tamu.edu>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* See COPYING file that comes with this distribution.
|
|
*/
|
|
|
|
#include "mooui/moowindow.h"
|
|
#include "mooui/moouiobject-impl.h"
|
|
#include "mooui/mooshortcutsprefs.h"
|
|
#include "mooui/mootoggleaction.h"
|
|
#include "mooui/moomenuaction.h"
|
|
#include "mooutils/mooprefs.h"
|
|
#include "mooutils/moomarshals.h"
|
|
#include "mooutils/moocompat.h"
|
|
#include "mooutils/moostock.h"
|
|
#include <gtk/gtk.h>
|
|
|
|
|
|
#define PREFS_REMEMBER_SIZE "window/remember_size"
|
|
#define PREFS_WIDTH "window/width"
|
|
#define PREFS_HEIGHT "window/height"
|
|
#define PREFS_MAXIMIZED "window/maximized"
|
|
#define PREFS_SHOW_TOOLBAR "window/show_toolbar"
|
|
#define PREFS_SHOW_MENUBAR "window/show_menubar"
|
|
#define PREFS_TOOLBAR_STYLE "window/toolbar_style"
|
|
|
|
|
|
inline static const char *setting (MooWindow *window, const char *s)
|
|
{
|
|
static char *string = NULL;
|
|
const char *id = moo_ui_object_get_id (MOO_UI_OBJECT (window));
|
|
|
|
g_free (string);
|
|
|
|
if (id)
|
|
return string = g_strdup_printf ("%s/%s", id, s);
|
|
else
|
|
return string = g_strdup (s);
|
|
}
|
|
|
|
static void init_prefs (MooWindow *window);
|
|
static GtkToolbarStyle get_toolbar_style (MooWindow *window);
|
|
|
|
|
|
struct _MooWindowPrivate {
|
|
guint save_size_id;
|
|
char *toolbar_ui_name;
|
|
char *menubar_ui_name;
|
|
};
|
|
|
|
|
|
static void moo_window_class_init (MooWindowClass *klass);
|
|
GObject *moo_window_constructor (GType type,
|
|
guint n_props,
|
|
GObjectConstructParam *props);
|
|
|
|
static void moo_window_init (MooWindow *window);
|
|
static void moo_window_finalize (GObject *object);
|
|
|
|
static void moo_window_set_property (GObject *object,
|
|
guint prop_id,
|
|
const GValue *value,
|
|
GParamSpec *pspec);
|
|
static void moo_window_get_property (GObject *object,
|
|
guint prop_id,
|
|
GValue *value,
|
|
GParamSpec *pspec);
|
|
|
|
static gboolean moo_window_delete_event (GtkWidget *widget,
|
|
GdkEventAny *event);
|
|
|
|
static gboolean moo_window_save_size (MooWindow *window);
|
|
|
|
static void moo_window_shortcuts_prefs_dialog (MooWindow *window);
|
|
|
|
static void moo_window_show_menubar_toggled (MooWindow *window,
|
|
gboolean show);
|
|
static void moo_window_show_toolbar_toggled (MooWindow *window,
|
|
gboolean show);
|
|
|
|
static GtkMenuItem *moo_window_create_toolbar_style_menu (MooWindow *window);
|
|
|
|
|
|
enum {
|
|
PROP_0,
|
|
PROP_ACCEL_GROUP,
|
|
PROP_MENUBAR_UI_NAME,
|
|
PROP_TOOLBAR_UI_NAME,
|
|
PROP_UI_OBJECT_NAME,
|
|
PROP_UI_OBJECT_ID,
|
|
PROP_UI_OBJECT_XML,
|
|
PROP_UI_OBJECT_ACTIONS
|
|
};
|
|
|
|
enum {
|
|
CLOSE,
|
|
LAST_SIGNAL
|
|
};
|
|
|
|
|
|
static guint signals[LAST_SIGNAL] = {0};
|
|
|
|
|
|
/* MOO_TYPE_WINDOW */
|
|
static gpointer moo_window_parent_class = NULL;
|
|
GType moo_window_get_type (void)
|
|
{
|
|
static GType type = 0;
|
|
if (!type)
|
|
{
|
|
static const GTypeInfo info = {
|
|
sizeof (MooWindowClass),
|
|
(GBaseInitFunc) NULL,
|
|
(GBaseFinalizeFunc) NULL,
|
|
(GClassInitFunc) moo_window_class_init,
|
|
(GClassFinalizeFunc) NULL,
|
|
NULL, /* class_data */
|
|
sizeof (MooWindow),
|
|
0, /* n_preallocs */
|
|
(GInstanceInitFunc) moo_window_init,
|
|
NULL /* value_table */
|
|
};
|
|
|
|
static const GInterfaceInfo iface_info = {
|
|
NULL,
|
|
NULL,
|
|
NULL
|
|
};
|
|
|
|
type = g_type_register_static (GTK_TYPE_WINDOW, "MooWindow",
|
|
&info, (GTypeFlags) 0);
|
|
|
|
g_type_add_interface_static (type,
|
|
MOO_TYPE_UI_OBJECT,
|
|
&iface_info);
|
|
}
|
|
return type;
|
|
}
|
|
|
|
|
|
static void moo_window_class_init (MooWindowClass *klass)
|
|
{
|
|
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
|
|
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
|
|
|
|
moo_window_parent_class = g_type_class_peek_parent (klass);
|
|
|
|
gobject_class->constructor = moo_window_constructor;
|
|
gobject_class->finalize = moo_window_finalize;
|
|
gobject_class->set_property = moo_window_set_property;
|
|
gobject_class->get_property = moo_window_get_property;
|
|
|
|
widget_class->delete_event = moo_window_delete_event;
|
|
|
|
moo_ui_object_class_init (gobject_class, "MooWindow", "Window");
|
|
|
|
moo_ui_object_class_new_action (gobject_class,
|
|
"id", "ConfigureShortcuts",
|
|
"name", "Configure Shortcuts",
|
|
"label", "Configure _Shortcuts...",
|
|
"tooltip", "Configure _Shortcuts...",
|
|
"icon-stock-id", MOO_STOCK_KEYBOARD,
|
|
"closure::callback", moo_window_shortcuts_prefs_dialog,
|
|
NULL);
|
|
|
|
moo_ui_object_class_new_action (gobject_class,
|
|
"action-type::", MOO_TYPE_TOGGLE_ACTION,
|
|
"id", "ShowToolbar",
|
|
"name", "Show Toolbar",
|
|
"label", "Show Toolbar",
|
|
"tooltip", "Show Toolbar",
|
|
"toggled-callback", moo_window_show_toolbar_toggled,
|
|
NULL);
|
|
|
|
moo_ui_object_class_new_action (gobject_class,
|
|
"action-type::", MOO_TYPE_TOGGLE_ACTION,
|
|
"id", "ShowMenubar",
|
|
"name", "Show Menubar",
|
|
"label", "Show Menubar",
|
|
"tooltip", "Show Menubar",
|
|
"toggled-callback", moo_window_show_menubar_toggled,
|
|
NULL);
|
|
|
|
moo_ui_object_class_new_action (gobject_class,
|
|
"action-type::", MOO_TYPE_MENU_ACTION,
|
|
"id", "ToolbarStyle",
|
|
"name", "Toolbar Style",
|
|
"create-menu-func", moo_window_create_toolbar_style_menu,
|
|
NULL);
|
|
|
|
g_object_class_install_property (gobject_class,
|
|
PROP_ACCEL_GROUP,
|
|
g_param_spec_object ("accel-group",
|
|
"accel-group",
|
|
"accel-group",
|
|
GTK_TYPE_ACCEL_GROUP,
|
|
G_PARAM_READABLE));
|
|
|
|
g_object_class_install_property (gobject_class,
|
|
PROP_MENUBAR_UI_NAME,
|
|
g_param_spec_string ("menubar-ui-name",
|
|
"menubar-ui-name",
|
|
"menubar-ui-name",
|
|
NULL,
|
|
G_PARAM_READWRITE));
|
|
|
|
g_object_class_install_property (gobject_class,
|
|
PROP_TOOLBAR_UI_NAME,
|
|
g_param_spec_string ("toolbar-ui-name",
|
|
"toolbar-ui-name",
|
|
"toolbar-ui-name",
|
|
NULL,
|
|
G_PARAM_READWRITE));
|
|
|
|
g_object_class_install_property (gobject_class,
|
|
PROP_UI_OBJECT_NAME,
|
|
g_param_spec_string ("ui-object-name",
|
|
"ui-object-name",
|
|
"ui-object-name",
|
|
NULL,
|
|
G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
|
|
|
|
g_object_class_install_property (gobject_class,
|
|
PROP_UI_OBJECT_ID,
|
|
g_param_spec_string ("ui-object-id",
|
|
"ui-object-id",
|
|
"ui-object-id",
|
|
NULL,
|
|
G_PARAM_READABLE));
|
|
|
|
g_object_class_install_property (gobject_class,
|
|
PROP_UI_OBJECT_ACTIONS,
|
|
g_param_spec_object ("ui-object-actions",
|
|
"ui-object-actions",
|
|
"ui-object-actions",
|
|
MOO_TYPE_ACTION_GROUP,
|
|
G_PARAM_READABLE));
|
|
|
|
g_object_class_install_property (gobject_class,
|
|
PROP_UI_OBJECT_XML,
|
|
g_param_spec_object ("ui-object-xml",
|
|
"ui-object-xml",
|
|
"ui-object-xml",
|
|
MOO_TYPE_UI_XML,
|
|
G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
|
|
|
|
signals[CLOSE] =
|
|
g_signal_new ("close",
|
|
G_OBJECT_CLASS_TYPE (klass),
|
|
G_SIGNAL_RUN_LAST,
|
|
G_STRUCT_OFFSET (MooWindowClass, close),
|
|
g_signal_accumulator_true_handled, NULL,
|
|
_moo_marshal_BOOL__VOID,
|
|
G_TYPE_BOOLEAN, 0);
|
|
}
|
|
|
|
|
|
GObject *moo_window_constructor (GType type,
|
|
guint n_props,
|
|
GObjectConstructParam *props)
|
|
{
|
|
GtkWidget *vbox;
|
|
MooActionGroup *actions;
|
|
MooWindow *window;
|
|
|
|
GObject *object =
|
|
G_OBJECT_CLASS(moo_window_parent_class)->constructor (type, n_props, props);
|
|
|
|
moo_ui_object_init (MOO_UI_OBJECT (object));
|
|
|
|
window = MOO_WINDOW (object);
|
|
|
|
init_prefs (window);
|
|
|
|
window->accel_group = gtk_accel_group_new ();
|
|
gtk_window_add_accel_group (GTK_WINDOW (window),
|
|
window->accel_group);
|
|
|
|
window->tooltips = gtk_tooltips_new ();
|
|
g_object_ref (window->tooltips);
|
|
gtk_object_sink (GTK_OBJECT (window->tooltips));
|
|
|
|
vbox = gtk_vbox_new (FALSE, 0);
|
|
gtk_widget_show (vbox);
|
|
gtk_container_add (GTK_CONTAINER (window), vbox);
|
|
window->menubar = gtk_menu_bar_new ();
|
|
gtk_box_pack_start (GTK_BOX (vbox), window->menubar, FALSE, FALSE, 0);
|
|
window->toolbar = gtk_toolbar_new ();
|
|
gtk_box_pack_start (GTK_BOX (vbox), window->toolbar, FALSE, FALSE, 0);
|
|
window->vbox = gtk_vbox_new (FALSE, 0);
|
|
gtk_box_pack_start (GTK_BOX (vbox), window->vbox, TRUE, TRUE, 0);
|
|
window->statusbar = gtk_statusbar_new ();
|
|
gtk_box_pack_start (GTK_BOX (vbox), window->statusbar, FALSE, FALSE, 0);
|
|
gtk_statusbar_set_has_resize_grip (GTK_STATUSBAR (window->statusbar), FALSE);
|
|
|
|
actions = moo_ui_object_get_actions (MOO_UI_OBJECT (window));
|
|
moo_action_group_set_accel_group (actions, window->accel_group);
|
|
moo_action_group_set_tooltips (actions, window->tooltips);
|
|
|
|
g_signal_connect (window, "notify::toolbar-ui-name",
|
|
G_CALLBACK (moo_window_update_ui), NULL);
|
|
g_signal_connect (window, "notify::menubar-ui-name",
|
|
G_CALLBACK (moo_window_update_ui), NULL);
|
|
g_signal_connect (window, "notify::ui-object-xml",
|
|
G_CALLBACK (moo_window_update_ui), NULL);
|
|
|
|
moo_window_update_ui (window);
|
|
|
|
if (moo_prefs_get_bool (setting (window, PREFS_REMEMBER_SIZE)))
|
|
{
|
|
int width = moo_prefs_get_int (setting (window, PREFS_WIDTH));
|
|
int height = moo_prefs_get_int (setting (window, PREFS_HEIGHT));
|
|
|
|
gtk_window_set_default_size (GTK_WINDOW (window), width, height);
|
|
|
|
if (moo_prefs_get_bool (setting (window, PREFS_MAXIMIZED)))
|
|
gtk_window_maximize (GTK_WINDOW (window));
|
|
}
|
|
|
|
g_signal_connect (window, "configure-event",
|
|
G_CALLBACK (moo_window_save_size), NULL);
|
|
|
|
return object;
|
|
}
|
|
|
|
|
|
static void moo_window_init (MooWindow *window)
|
|
{
|
|
window->priv = g_new0 (MooWindowPrivate, 1);
|
|
}
|
|
|
|
|
|
static void moo_window_finalize (GObject *object)
|
|
{
|
|
MooWindow *window = MOO_WINDOW(object);
|
|
|
|
g_free (window->priv->menubar_ui_name);
|
|
g_free (window->priv->toolbar_ui_name);
|
|
|
|
if (window->accel_group)
|
|
g_object_unref (window->accel_group);
|
|
if (window->tooltips)
|
|
g_object_unref (window->tooltips);
|
|
|
|
if (window->priv->save_size_id)
|
|
g_source_remove (window->priv->save_size_id);
|
|
window->priv->save_size_id = 0;
|
|
|
|
g_free (window->priv);
|
|
|
|
G_OBJECT_CLASS (moo_window_parent_class)->finalize (object);
|
|
}
|
|
|
|
|
|
static gboolean moo_window_delete_event (GtkWidget *widget,
|
|
G_GNUC_UNUSED GdkEventAny *event)
|
|
{
|
|
gboolean result = FALSE;
|
|
g_signal_emit_by_name (widget, "close", &result);
|
|
return result;
|
|
}
|
|
|
|
|
|
static gboolean save_size (MooWindow *window)
|
|
{
|
|
window->priv->save_size_id = 0;
|
|
|
|
if (MOO_IS_WINDOW (window) && GTK_WIDGET_REALIZED (window))
|
|
{
|
|
GdkWindowState state;
|
|
state = gdk_window_get_state (GTK_WIDGET(window)->window);
|
|
moo_prefs_set_bool (setting (window, PREFS_MAXIMIZED),
|
|
state & GDK_WINDOW_STATE_MAXIMIZED);
|
|
|
|
if (!(state & GDK_WINDOW_STATE_MAXIMIZED))
|
|
{
|
|
int width, height;
|
|
gtk_window_get_size (GTK_WINDOW (window), &width, &height);
|
|
moo_prefs_set_int (setting (window, PREFS_WIDTH), width);
|
|
moo_prefs_set_int (setting (window, PREFS_HEIGHT), height);
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
static gboolean moo_window_save_size (MooWindow *window)
|
|
{
|
|
if (!window->priv->save_size_id)
|
|
window->priv->save_size_id =
|
|
g_idle_add ((GSourceFunc)save_size, window);
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
gboolean moo_window_close (MooWindow *window)
|
|
{
|
|
gboolean result = FALSE;
|
|
g_signal_emit_by_name (window, "close", &result);
|
|
if (!result)
|
|
{
|
|
gtk_widget_destroy (GTK_WIDGET (window));
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
|
|
static void moo_window_set_property (GObject *object,
|
|
guint prop_id,
|
|
const GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
const char *name = NULL;
|
|
MooWindow *window = MOO_WINDOW (object);
|
|
MooUIObject *ui_obj = MOO_UI_OBJECT (object);
|
|
|
|
switch (prop_id)
|
|
{
|
|
case PROP_TOOLBAR_UI_NAME:
|
|
name = g_value_get_string (value);
|
|
g_free (window->priv->toolbar_ui_name);
|
|
window->priv->toolbar_ui_name = name ? g_strdup (name) : g_strdup ("");
|
|
g_object_notify (object, "toolbar-ui-name");
|
|
break;
|
|
|
|
case PROP_MENUBAR_UI_NAME:
|
|
name = g_value_get_string (value);
|
|
g_free (window->priv->menubar_ui_name);
|
|
window->priv->menubar_ui_name = name ? g_strdup (name) : g_strdup ("");
|
|
g_object_notify (object, "menubar-ui-name");
|
|
break;
|
|
|
|
case PROP_UI_OBJECT_NAME:
|
|
if (g_value_get_string (value))
|
|
_moo_ui_object_set_name_impl (ui_obj,
|
|
g_value_get_string (value));
|
|
break;
|
|
|
|
case PROP_UI_OBJECT_XML:
|
|
if (g_value_get_object (value))
|
|
_moo_ui_object_set_ui_xml_impl (ui_obj,
|
|
g_value_get_object (value));
|
|
break;
|
|
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void moo_window_get_property (GObject *object,
|
|
guint prop_id,
|
|
GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
MooWindow *window = MOO_WINDOW (object);
|
|
MooUIObject *ui_obj = MOO_UI_OBJECT (object);
|
|
|
|
switch (prop_id)
|
|
{
|
|
case PROP_ACCEL_GROUP:
|
|
g_value_set_object (value,
|
|
window->accel_group);
|
|
break;
|
|
|
|
case PROP_TOOLBAR_UI_NAME:
|
|
g_value_set_string (value,
|
|
window->priv->toolbar_ui_name);
|
|
break;
|
|
|
|
case PROP_MENUBAR_UI_NAME:
|
|
g_value_set_string (value,
|
|
window->priv->menubar_ui_name);
|
|
break;
|
|
|
|
case PROP_UI_OBJECT_NAME:
|
|
g_value_set_string (value,
|
|
_moo_ui_object_get_name_impl (ui_obj));
|
|
break;
|
|
|
|
case PROP_UI_OBJECT_ID:
|
|
g_value_set_string (value,
|
|
_moo_ui_object_get_id_impl (ui_obj));
|
|
break;
|
|
|
|
case PROP_UI_OBJECT_XML:
|
|
g_value_set_object (value,
|
|
_moo_ui_object_get_ui_xml_impl (ui_obj));
|
|
break;
|
|
|
|
case PROP_UI_OBJECT_ACTIONS:
|
|
g_value_set_object (value,
|
|
_moo_ui_object_get_actions_impl (ui_obj));
|
|
break;
|
|
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
void moo_window_update_ui (MooWindow *window)
|
|
{
|
|
MooUIXML *xml;
|
|
MooAction *show_toolbar, *show_menubar;
|
|
GtkToolbarStyle style;
|
|
|
|
g_return_if_fail (MOO_IS_WINDOW (window));
|
|
|
|
xml = moo_ui_object_get_ui_xml (MOO_UI_OBJECT (window));
|
|
|
|
if (window->priv->menubar_ui_name && window->priv->menubar_ui_name[0] &&
|
|
moo_ui_xml_has_widget (xml, window->priv->menubar_ui_name))
|
|
{
|
|
moo_ui_xml_update_widget (xml, window->menubar,
|
|
window->priv->menubar_ui_name,
|
|
moo_ui_object_get_actions (MOO_UI_OBJECT (window)),
|
|
window->accel_group, window->tooltips);
|
|
show_menubar =
|
|
moo_action_group_get_action (moo_ui_object_get_actions (MOO_UI_OBJECT (window)),
|
|
"ShowMenubar");
|
|
moo_toggle_action_set_active (MOO_TOGGLE_ACTION (show_menubar),
|
|
moo_prefs_get_bool (setting (window, PREFS_SHOW_MENUBAR)));
|
|
}
|
|
else
|
|
{
|
|
gtk_widget_hide (window->menubar);
|
|
}
|
|
|
|
if (window->priv->toolbar_ui_name && window->priv->toolbar_ui_name[0] &&
|
|
moo_ui_xml_has_widget (xml, window->priv->toolbar_ui_name))
|
|
{
|
|
moo_ui_xml_update_widget (xml, window->toolbar,
|
|
window->priv->toolbar_ui_name,
|
|
moo_ui_object_get_actions (MOO_UI_OBJECT (window)),
|
|
window->accel_group, window->tooltips);
|
|
|
|
show_toolbar =
|
|
moo_action_group_get_action (moo_ui_object_get_actions (MOO_UI_OBJECT (window)),
|
|
"ShowToolbar");
|
|
moo_toggle_action_set_active (MOO_TOGGLE_ACTION (show_toolbar),
|
|
moo_prefs_get_bool (setting (window, PREFS_SHOW_TOOLBAR)));
|
|
|
|
style = get_toolbar_style (window);
|
|
gtk_toolbar_set_style (GTK_TOOLBAR (MOO_WINDOW(window)->toolbar), style);
|
|
}
|
|
else
|
|
{
|
|
gtk_widget_hide (window->toolbar);
|
|
}
|
|
}
|
|
|
|
|
|
static void moo_window_shortcuts_prefs_dialog (MooWindow *window)
|
|
{
|
|
moo_shortcuts_prefs_dialog_run (
|
|
moo_ui_object_get_actions (MOO_UI_OBJECT (window)),
|
|
GTK_WIDGET (window));
|
|
}
|
|
|
|
|
|
static void moo_window_show_toolbar_toggled (MooWindow *window,
|
|
gboolean show)
|
|
{
|
|
if (show != GTK_WIDGET_VISIBLE (window->toolbar))
|
|
{
|
|
if (show) gtk_widget_show (window->toolbar);
|
|
else gtk_widget_hide (window->toolbar);
|
|
moo_prefs_set_bool (setting (window, PREFS_SHOW_TOOLBAR), show);
|
|
}
|
|
}
|
|
|
|
|
|
static void moo_window_show_menubar_toggled (MooWindow *window,
|
|
gboolean show)
|
|
{
|
|
if (show != GTK_WIDGET_VISIBLE (window->menubar))
|
|
{
|
|
if (show) gtk_widget_show (window->menubar);
|
|
else gtk_widget_hide (window->menubar);
|
|
moo_prefs_set_bool (setting (window, PREFS_SHOW_MENUBAR), show);
|
|
}
|
|
}
|
|
|
|
|
|
static void window_destroyed (GObject *menuitem,
|
|
gpointer window);
|
|
static void toolbar_style_menu_destroyed (GObject *window,
|
|
gpointer menuitem)
|
|
{
|
|
g_object_weak_unref (window, (GWeakNotify)window_destroyed, menuitem);
|
|
}
|
|
static void window_destroyed (GObject *menuitem,
|
|
gpointer window)
|
|
{
|
|
g_object_weak_unref (menuitem, (GWeakNotify)toolbar_style_menu_destroyed, window);
|
|
gtk_widget_destroy (GTK_WIDGET (menuitem));
|
|
}
|
|
|
|
|
|
static void toolbar_style_toggled (GtkCheckMenuItem *item,
|
|
MooWindow *window)
|
|
{
|
|
GtkToolbarStyle style;
|
|
|
|
if (!gtk_check_menu_item_get_active (item))
|
|
return;
|
|
|
|
style = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (item),
|
|
"moo_window_toolbar_style"));
|
|
gtk_toolbar_set_style (GTK_TOOLBAR (window->toolbar), style);
|
|
moo_prefs_set_enum (setting (window, PREFS_TOOLBAR_STYLE),
|
|
GTK_TYPE_TOOLBAR_STYLE, style);
|
|
}
|
|
|
|
|
|
static GtkMenuItem *moo_window_create_toolbar_style_menu (MooWindow *window)
|
|
{
|
|
GtkWidget *item;
|
|
GSList *group = NULL;
|
|
GtkWidget *items[3];
|
|
GtkMenuShell *menu;
|
|
guint i;
|
|
GtkToolbarStyle style;
|
|
|
|
const char *labels[3] = {
|
|
"_Icons Only",
|
|
"_Labels Only",
|
|
"Icons _and Labels"
|
|
};
|
|
|
|
item = gtk_menu_item_new_with_mnemonic ("Toolbar _Style");
|
|
|
|
menu = GTK_MENU_SHELL (gtk_menu_new ());
|
|
for (i = 0; i < 3; ++i) {
|
|
items[i] = gtk_radio_menu_item_new_with_mnemonic (group, labels[i]);
|
|
group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (items[i]));
|
|
gtk_menu_shell_append (menu, items[i]);
|
|
g_object_set_data (G_OBJECT (items[i]), "moo_window_toolbar_style", GINT_TO_POINTER (i));
|
|
}
|
|
gtk_widget_show_all (GTK_WIDGET (menu));
|
|
gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), GTK_WIDGET (menu));
|
|
|
|
style = get_toolbar_style (window);
|
|
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (items[style]), TRUE);
|
|
|
|
for (i = 0; i < 3; ++i) {
|
|
g_signal_connect (items[i], "toggled",
|
|
G_CALLBACK (toolbar_style_toggled), window);
|
|
}
|
|
|
|
g_object_weak_ref (G_OBJECT (window), (GWeakNotify)window_destroyed, item);
|
|
g_object_weak_ref (G_OBJECT (item), (GWeakNotify)toolbar_style_menu_destroyed, window);
|
|
|
|
return GTK_MENU_ITEM (item);
|
|
}
|
|
|
|
|
|
static void init_prefs (MooWindow *window)
|
|
{
|
|
moo_prefs_new_key_bool (setting (window, PREFS_REMEMBER_SIZE), TRUE);
|
|
moo_prefs_new_key_bool (setting (window, PREFS_MAXIMIZED), FALSE);
|
|
moo_prefs_new_key_int (setting (window, PREFS_WIDTH), -1);
|
|
moo_prefs_new_key_int (setting (window, PREFS_HEIGHT), -1);
|
|
moo_prefs_new_key_bool (setting (window, PREFS_SHOW_TOOLBAR), TRUE);
|
|
moo_prefs_new_key_bool (setting (window, PREFS_SHOW_MENUBAR), TRUE);
|
|
moo_prefs_new_key (setting (window, PREFS_TOOLBAR_STYLE),
|
|
GTK_TYPE_TOOLBAR_STYLE, NULL);
|
|
}
|
|
|
|
|
|
static GtkToolbarStyle get_toolbar_style (MooWindow *window)
|
|
{
|
|
GtkSettings *settings = gtk_widget_get_settings (GTK_WIDGET (window));
|
|
GtkToolbarStyle style;
|
|
|
|
g_return_val_if_fail (settings != NULL, 0);
|
|
|
|
g_object_get (settings, "gtk-toolbar-style", &style, NULL);
|
|
if (moo_prefs_get (setting (window, PREFS_TOOLBAR_STYLE)))
|
|
style = moo_prefs_get_int (setting (window, PREFS_TOOLBAR_STYLE));
|
|
|
|
return style;
|
|
}
|