void
ide_editor_frame_actions_init (IdeEditorFrame *self)
{
GSimpleActionGroup *group;
GAction *action;
g_assert (IDE_IS_EDITOR_FRAME (self));
group = g_simple_action_group_new ();
g_action_map_add_action_entries (G_ACTION_MAP (group), IdeEditorFrameActions,
G_N_ELEMENTS (IdeEditorFrameActions), self);
gtk_widget_insert_action_group (GTK_WIDGET (self), "frame", G_ACTION_GROUP (group));
g_object_unref (group);
group = g_simple_action_group_new ();
g_action_map_add_action_entries (G_ACTION_MAP (group), IdeEditorFrameSearchActions,
G_N_ELEMENTS (IdeEditorFrameSearchActions), self);
/* Disable replace and replace-all by default; they should only be enabled
* when the corresponding operations would make sense.
*/
action = g_action_map_lookup_action (G_ACTION_MAP (group), "replace");
g_simple_action_set_enabled (G_SIMPLE_ACTION (action), FALSE);
action = g_action_map_lookup_action (G_ACTION_MAP (group), "replace-all");
g_simple_action_set_enabled (G_SIMPLE_ACTION (action), FALSE);
gtk_widget_insert_action_group (GTK_WIDGET (self->search_frame), "search-entry", G_ACTION_GROUP (group));
g_object_unref (group);
}
void
ide_editor_view_actions_init (IdeEditorView *self)
{
g_autoptr(GSimpleActionGroup) group = NULL;
group = g_simple_action_group_new ();
g_action_map_add_action_entries (G_ACTION_MAP (group), IdeEditorViewActions,
G_N_ELEMENTS (IdeEditorViewActions), self);
gtk_widget_insert_action_group (GTK_WIDGET (self), "view", G_ACTION_GROUP (group));
gtk_widget_insert_action_group (GTK_WIDGET (self->tweak_widget), "view", G_ACTION_GROUP (group));
#define WATCH_PROPERTY(name) \
G_STMT_START { \
g_signal_connect (self->frame1->source_view, \
"notify::"name, \
G_CALLBACK (ide_editor_view_actions_source_view_notify), \
group); \
g_object_notify (G_OBJECT (self->frame1->source_view), name); \
} G_STMT_END
WATCH_PROPERTY ("auto-indent");
WATCH_PROPERTY ("highlight-current-line");
WATCH_PROPERTY ("insert-spaces-instead-of-tabs");
WATCH_PROPERTY ("show-line-numbers");
WATCH_PROPERTY ("show-right-margin");
WATCH_PROPERTY ("smart-backspace");
WATCH_PROPERTY ("tab-width");
#undef WATCH_PROPERTY
}
static void
gb_preferences_switch_update_settings (GbPreferencesSwitch *self)
{
g_assert (GB_IS_PREFERENCES_SWITCH (self));
if ((self->settings != NULL) && (self->settings_schema_key != NULL))
{
GSimpleActionGroup *group;
GAction *action;
gchar *name;
action = g_settings_create_action (self->settings, self->settings_schema_key);
group = g_simple_action_group_new ();
g_action_map_add_action (G_ACTION_MAP (group), G_ACTION (action));
gtk_widget_insert_action_group (GTK_WIDGET (self), "settings", G_ACTION_GROUP (group));
g_object_unref (action);
name = g_strdup_printf ("settings.%s", self->settings_schema_key);
if (self->is_radio)
{
gtk_actionable_set_action_name (GTK_ACTIONABLE (self->settings_radio), name);
gtk_actionable_set_action_name (GTK_ACTIONABLE (self->settings_switch), NULL);
}
else
{
gtk_actionable_set_action_name (GTK_ACTIONABLE (self->settings_radio), NULL);
gtk_actionable_set_action_name (GTK_ACTIONABLE (self->settings_switch), name);
}
g_free (name);
}
}
void
gb_project_tree_actions_init (GbProjectTree *self)
{
g_autoptr(GSettings) settings = NULL;
g_autoptr(GSettings) tree_settings = NULL;
g_autoptr(GSimpleActionGroup) actions = NULL;
g_autoptr(GAction) action = NULL;
g_autoptr(GVariant) show_icons = NULL;
actions = g_simple_action_group_new ();
settings = g_settings_new ("org.gtk.Settings.FileChooser");
action = g_settings_create_action (settings, "sort-directories-first");
g_action_map_add_action (G_ACTION_MAP (actions), action);
g_action_map_add_action_entries (G_ACTION_MAP (actions),
GbProjectTreeActions,
G_N_ELEMENTS (GbProjectTreeActions),
self);
gtk_widget_insert_action_group (GTK_WIDGET (self),
"project-tree",
G_ACTION_GROUP (actions));
tree_settings = g_settings_new ("org.gnome.builder.project-tree");
show_icons = g_settings_get_value (tree_settings, "show-icons");
action_set (G_ACTION_GROUP (actions), "show-icons",
"state", show_icons,
NULL);
gb_project_tree_actions_update (self);
}
static gboolean
geyes_applet_fill (PanelApplet *applet)
{
EyesApplet *eyes_applet;
GSimpleActionGroup *action_group;
GAction *action;
gchar *ui_path;
panel_applet_set_flags (applet, PANEL_APPLET_EXPAND_MINOR);
eyes_applet = create_eyes (applet);
eyes_applet->settings = panel_applet_settings_new (applet, GEYES_PREFS_SCHEMA);
eyes_applet->timeout_id = g_timeout_add (
UPDATE_TIMEOUT, (GSourceFunc) timer_cb, eyes_applet);
action_group = g_simple_action_group_new ();
g_action_map_add_action_entries (G_ACTION_MAP (action_group),
geyes_applet_menu_actions,
G_N_ELEMENTS (geyes_applet_menu_actions),
eyes_applet);
ui_path = g_build_filename (GEYES_MENU_UI_DIR, "geyes-applet-menu.xml", NULL);
panel_applet_setup_menu_from_file (eyes_applet->applet,
ui_path, action_group,
GETTEXT_PACKAGE);
g_free (ui_path);
gtk_widget_insert_action_group (GTK_WIDGET (applet), "geyes",
G_ACTION_GROUP (action_group));
action = g_action_map_lookup_action (G_ACTION_MAP (action_group), "preferences");
g_object_bind_property (applet, "locked-down",
action, "enabled",
G_BINDING_DEFAULT|G_BINDING_INVERT_BOOLEAN|G_BINDING_SYNC_CREATE);
g_object_unref (action_group);
gtk_widget_set_tooltip_text (GTK_WIDGET (eyes_applet->applet), _("Eyes"));
set_atk_name_description (GTK_WIDGET (eyes_applet->applet), _("Eyes"),
_("The eyes look in the direction of the mouse pointer"));
g_signal_connect (eyes_applet->vbox,
"destroy",
G_CALLBACK (destroy_cb),
eyes_applet);
gtk_widget_show_all (GTK_WIDGET (eyes_applet->applet));
/* setup here and not in create eyes so the destroy signal is set so
* that when there is an error within loading the theme
* we can emit this signal */
if (properties_load (eyes_applet) == FALSE)
return FALSE;
setup_eyes (eyes_applet);
return TRUE;
}
static GSimpleActionGroup *
create_action_group(ReaderWindowPrivate *priv)
{
GSimpleActionGroup *actions = g_simple_action_group_new();
gboolean side_pane = cainteoir_settings_get_boolean(priv->settings, "index", "visible", TRUE);
priv->index_pane_action = g_simple_action_new_stateful("side-pane", nullptr, g_variant_new_boolean(side_pane));
g_action_map_add_action(G_ACTION_MAP(actions), G_ACTION(priv->index_pane_action));
g_signal_connect(priv->index_pane_action, "activate", G_CALLBACK(on_index_pane_toggle_action), priv);
priv->open_action = g_simple_action_new("open", nullptr);
g_action_map_add_action(G_ACTION_MAP(actions), G_ACTION(priv->open_action));
g_signal_connect(priv->open_action, "activate", G_CALLBACK(on_open_file_action), priv);
priv->play_stop_action = g_simple_action_new("play-stop", nullptr);
g_action_map_add_action(G_ACTION_MAP(actions), G_ACTION(priv->play_stop_action));
g_signal_connect(priv->play_stop_action, "activate", G_CALLBACK(on_play_stop_action), priv);
priv->record_action = g_simple_action_new("record", nullptr);
g_action_map_add_action(G_ACTION_MAP(actions), G_ACTION(priv->record_action));
g_signal_connect(priv->record_action, "activate", G_CALLBACK(on_record_action), priv);
return actions;
}
static void
gt_twitch_chat_view_init(GtTwitchChatView* self)
{
GtTwitchChatViewPrivate* priv = gt_twitch_chat_view_get_instance_private(self);
gtk_widget_init_template(GTK_WIDGET(self));
priv->action_group = g_simple_action_group_new();
priv->dark_theme_action = g_property_action_new("dark-theme", self, "dark-theme");
g_action_map_add_action(G_ACTION_MAP(priv->action_group), G_ACTION(priv->dark_theme_action));
priv->chat_css_provider = gtk_css_provider_new();
gtk_style_context_add_provider(gtk_widget_get_style_context(GTK_WIDGET(self)),
GTK_STYLE_PROVIDER(priv->chat_css_provider),
GTK_STYLE_PROVIDER_PRIORITY_USER);
priv->chat_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(priv->chat_view));
priv->tag_table = gtk_text_buffer_get_tag_table(priv->chat_buffer);
priv->twitch_emotes = g_hash_table_new(g_direct_hash, g_direct_equal);
gtk_text_buffer_get_end_iter(priv->chat_buffer, &priv->bottom_iter);
priv->bottom_mark = gtk_text_buffer_create_mark(priv->chat_buffer, "end", &priv->bottom_iter, TRUE);
priv->chat = gt_twitch_chat_client_new();
priv->cur_chan = NULL;
priv->joined_channel = FALSE;
g_signal_connect(priv->chat_entry, "key-press-event", G_CALLBACK(key_press_cb), self);
g_signal_connect(self, "hierarchy-changed", G_CALLBACK(anchored_cb), self);
g_source_set_callback((GSource*) priv->chat->source, (GSourceFunc) twitch_chat_source_cb, self, NULL);
ADD_STYLE_CLASS(self, "gt-twitch-chat-view");
}
/**
* gpm_applet_cb:
* @_applet: GpmInhibitApplet instance created by the applet factory
* @iid: Applet id
*
* the function called by libpanel-applet factory after creation
**/
static gboolean
gpm_applet_cb (PanelApplet *_applet, const gchar *iid, gpointer data)
{
GpmInhibitApplet *applet = GPM_INHIBIT_APPLET(_applet);
GSimpleActionGroup *action_group;
gchar *ui_path;
static const GActionEntry menu_actions [] = {
{ "about", gpm_applet_dialog_about_cb, NULL, NULL, NULL },
};
if (strcmp (iid, GPM_INHIBIT_APPLET_ID) != 0) {
return FALSE;
}
action_group = g_simple_action_group_new ();
g_action_map_add_action_entries (G_ACTION_MAP (action_group),
menu_actions,
G_N_ELEMENTS (menu_actions),
applet);
ui_path = g_build_filename (INHIBIT_MENU_UI_DIR, "inhibit-applet-menu.xml", NULL);
panel_applet_setup_menu_from_file (PANEL_APPLET (applet), ui_path, action_group, GETTEXT_PACKAGE);
g_free (ui_path);
gtk_widget_insert_action_group (GTK_WIDGET (applet), "inhibit",
G_ACTION_GROUP (action_group));
g_object_unref (action_group);
return TRUE;
}
/**
* irc_context_get_action_group:
*
* Returns: (transfer full): Valid actions for this context
*/
GActionGroup *
irc_context_get_action_group (void)
{
GSimpleActionGroup *group = g_simple_action_group_new ();
GAction *close_action = irc_context_action_new ("close", irc_context_close);
GAction *focus_action = irc_context_action_new ("focus", irc_context_focus);
g_action_map_add_action (G_ACTION_MAP (group), close_action);
g_action_map_add_action (G_ACTION_MAP (group), focus_action);
return G_ACTION_GROUP (group);
}
void
_ide_layout_stack_actions_init (IdeLayoutStack *self)
{
g_assert (IDE_IS_LAYOUT_STACK (self));
self->actions = g_simple_action_group_new ();
g_action_map_add_action_entries (G_ACTION_MAP (self->actions), gbViewStackActions,
G_N_ELEMENTS (gbViewStackActions), self);
gtk_widget_insert_action_group (GTK_WIDGET (self), "view-stack", G_ACTION_GROUP (self->actions));
}
void
gstyle_color_widget_actions_init (GstyleColorWidget *self)
{
g_autoptr (GSimpleActionGroup) action_group = NULL;
action_group = g_simple_action_group_new ();
g_action_map_add_action_entries (G_ACTION_MAP (action_group), actions,
G_N_ELEMENTS (actions), self);
gtk_widget_insert_action_group (GTK_WIDGET (self), "gstyle-color-widget-menu", G_ACTION_GROUP (action_group));
}
static void
activate (GApplication *app,
gpointer user_data)
{
GtkWidget *win;
GtkWidget *button;
GSimpleActionGroup *doc_actions;
GtkBuilder *builder;
GMenuModel *doc_menu;
GMenuModel *win_menu;
GMenu *button_menu;
GMenuItem *section;
if (gtk_application_get_windows (GTK_APPLICATION (app)) != NULL)
return;
win = gtk_application_window_new (GTK_APPLICATION (app));
doc_actions = g_simple_action_group_new ();
g_action_map_add_action_entries (G_ACTION_MAP (doc_actions), doc_entries, G_N_ELEMENTS (doc_entries), win);
g_action_map_add_action_entries (G_ACTION_MAP (win), win_entries,
G_N_ELEMENTS (win_entries), win);
builder = gtk_builder_new ();
gtk_builder_add_from_string (builder, menu_ui, -1, NULL);
doc_menu = G_MENU_MODEL (gtk_builder_get_object (builder, "doc-menu"));
win_menu = G_MENU_MODEL (gtk_builder_get_object (builder, "win-menu"));
button_menu = g_menu_new ();
section = g_menu_item_new_section (NULL, doc_menu);
g_menu_item_set_attribute (section, "action-namespace", "s", "doc");
g_menu_append_item (button_menu, section);
g_object_unref (section);
section = g_menu_item_new_section (NULL, win_menu);
g_menu_item_set_attribute (section, "action-namespace", "s", "win");
g_menu_append_item (button_menu, section);
g_object_unref (section);
button = gtk_menu_button_new ();
gtk_button_set_label (GTK_BUTTON (button), "Menu");
gtk_widget_insert_action_group (button, "doc", G_ACTION_GROUP (doc_actions));
gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (button), G_MENU_MODEL (button_menu));
gtk_container_add (GTK_CONTAINER (win), button);
gtk_container_set_border_width (GTK_CONTAINER (win), 12);
gtk_widget_show_all (win);
g_object_unref (button_menu);
g_object_unref (doc_actions);
g_object_unref (builder);
}
static GActionGroup *
get_group (void)
{
GSimpleActionGroup *group;
group = g_simple_action_group_new ();
g_action_map_add_action_entries (G_ACTION_MAP (group), actions, G_N_ELEMENTS (actions), NULL);
return G_ACTION_GROUP (group);
}
void
_ide_editor_perspective_init_actions (IdeEditorPerspective *self)
{
g_autoptr(GSimpleActionGroup) group = NULL;
group = g_simple_action_group_new ();
g_action_map_add_action_entries (G_ACTION_MAP (group),
editor_actions,
G_N_ELEMENTS (editor_actions),
self);
gtk_widget_insert_action_group (GTK_WIDGET (self), "editor", G_ACTION_GROUP (group));
}
static void
drawing_area_hierarchy_changed (GtkWidget *widget,
GtkWidget *previous_toplevel)
{
DrawingArea *area = (DrawingArea *) widget;
GSimpleActionGroup *action_group;
GSimpleAction *action;
GtkWidget *toplevel;
gint i;
if (previous_toplevel && area->pad_controller)
{
gtk_widget_remove_controller (previous_toplevel,
GTK_EVENT_CONTROLLER (area->pad_controller));
area->pad_controller = NULL;
}
toplevel = gtk_widget_get_toplevel (GTK_WIDGET (area));
if (!GTK_IS_WINDOW (toplevel))
return;
action_group = g_simple_action_group_new ();
area->pad_controller = gtk_pad_controller_new (G_ACTION_GROUP (action_group),
NULL);
for (i = 0; i < G_N_ELEMENTS (pad_actions); i++)
{
if (pad_actions[i].type == GTK_PAD_ACTION_BUTTON)
{
action = g_simple_action_new (pad_actions[i].action_name, NULL);
g_object_set_data (G_OBJECT (action), "color",
(gpointer) pad_colors[i]);
g_signal_connect (action, "activate",
G_CALLBACK (on_pad_button_activate), area);
}
else
{
action = g_simple_action_new_stateful (pad_actions[i].action_name,
G_VARIANT_TYPE_DOUBLE, NULL);
g_signal_connect (action, "activate",
G_CALLBACK (on_pad_knob_change), area);
}
g_action_map_add_action (G_ACTION_MAP (action_group), G_ACTION (action));
g_object_unref (action);
}
gtk_pad_controller_set_action_entries (area->pad_controller, pad_actions,
G_N_ELEMENTS (pad_actions));
gtk_widget_add_controller (toplevel,
GTK_EVENT_CONTROLLER (area->pad_controller));
}
static void
photos_import_dialog_init (PhotosImportDialog *self)
{
GApplication *app;
GVariant *initial_state;
PhotosSearchContextState *state;
gtk_widget_init_template (GTK_WIDGET (self));
app = g_application_get_default ();
state = photos_search_context_get_state (PHOTOS_SEARCH_CONTEXT (app));
self->cancellable = g_cancellable_new ();
self->collections = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, g_object_unref);
self->action_group = g_simple_action_group_new ();
gtk_widget_insert_action_group (GTK_WIDGET (self), "dialog", G_ACTION_GROUP (self->action_group));
initial_state = g_variant_new_string ("");
self->add_existing_action = g_simple_action_new_stateful ("add-existing", G_VARIANT_TYPE_STRING, initial_state);
g_signal_connect_swapped (self->add_existing_action,
"notify::state",
G_CALLBACK (photos_import_dialog_add_existing_notify_state),
self);
g_action_map_add_action (G_ACTION_MAP (self->action_group), G_ACTION (self->add_existing_action));
self->item_mngr = g_object_ref (state->item_mngr);
{
g_autoptr (GError) error = NULL;
self->queue = photos_tracker_queue_dup_singleton (NULL, &error);
if (G_UNLIKELY (error != NULL))
g_warning ("Unable to create PhotosTrackerQueue: %s", error->message);
}
if (G_LIKELY (self->queue != NULL))
{
g_autoptr (PhotosQuery) query = NULL;
query = photos_query_builder_fetch_collections_local (state);
photos_tracker_queue_select (self->queue,
query,
self->cancellable,
photos_import_dialog_fetch_collections_local_query_executed,
self,
NULL);
}
photos_import_dialog_show_add_existing (self, FALSE);
gtk_dialog_set_response_sensitive (GTK_DIALOG (self), GTK_RESPONSE_OK, FALSE);
}
int
main (int argc, char **argv)
{
IndicatorTestService indicator = { 0 };
GMenuItem *item;
GMenu *submenu;
GActionEntry entries[] = {
{ "_header", NULL, NULL, "{'label': <'Test'>,"
" 'icon': <'indicator-test'>,"
" 'accessible-desc': <'Test indicator'> }", NULL },
{ "show", activate_show, NULL, NULL, NULL }
};
GMainLoop *loop;
indicator.actions = g_simple_action_group_new ();
g_simple_action_group_add_entries (indicator.actions, entries, G_N_ELEMENTS (entries), NULL);
submenu = g_menu_new ();
g_menu_append (submenu, "Show", "indicator.show");
item = g_menu_item_new (NULL, "indicator._header");
g_menu_item_set_attribute (item, "x-canonical-type", "s", "com.canonical.indicator.root");
g_menu_item_set_submenu (item, G_MENU_MODEL (submenu));
indicator.menu = g_menu_new ();
g_menu_append_item (indicator.menu, item);
g_bus_own_name (G_BUS_TYPE_SESSION,
"com.canonical.indicator.test",
G_BUS_NAME_OWNER_FLAGS_NONE,
bus_acquired,
NULL,
name_lost,
&indicator,
NULL);
loop = g_main_loop_new (NULL, FALSE);
g_main_loop_run (loop);
g_object_unref (submenu);
g_object_unref (item);
g_object_unref (indicator.actions);
g_object_unref (indicator.menu);
g_object_unref (loop);
return 0;
}
GtkWidget *
do_modelbutton (GtkWidget *do_widget)
{
static GtkWidget *window = NULL;
static GActionEntry win_entries[] = {
{ "color", NULL, "s", "'red'", NULL },
{ "chocolate", NULL, NULL, "true", NULL },
{ "vanilla", NULL, NULL, "false", NULL },
{ "sprinkles", NULL, NULL, NULL, NULL }
};
if (!window)
{
GtkBuilder *builder;
GActionGroup *actions;
builder = gtk_builder_new_from_resource ("/modelbutton/modelbutton.ui");
gtk_builder_add_callback_symbol (builder, "tool_clicked", G_CALLBACK (tool_clicked));
gtk_builder_connect_signals (builder, NULL);
window = GTK_WIDGET (gtk_builder_get_object (builder, "window1"));
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (do_widget));
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
actions = (GActionGroup*)g_simple_action_group_new ();
g_action_map_add_action_entries (G_ACTION_MAP (actions),
win_entries, G_N_ELEMENTS (win_entries),
window);
gtk_widget_insert_action_group (window, "win", actions);
g_object_unref (builder);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
return window;
}
static void
pnl_tab_strip_init (PnlTabStrip *self)
{
PnlTabStripPrivate *priv = pnl_tab_strip_get_instance_private (self);
GSimpleActionGroup *group;
static const GActionEntry entries[] = {
{ "tab", NULL, "i", "0", set_tab_state },
};
gtk_orientable_set_orientation (GTK_ORIENTABLE (self), GTK_ORIENTATION_HORIZONTAL);
group = g_simple_action_group_new ();
g_action_map_add_action_entries (G_ACTION_MAP (group), entries, G_N_ELEMENTS (entries), self);
priv->action = g_object_ref (g_action_map_lookup_action (G_ACTION_MAP (group), "tab"));
gtk_widget_insert_action_group (GTK_WIDGET (self), "tab-strip", G_ACTION_GROUP (group));
g_object_unref (group);
pnl_tab_strip_set_edge (self, GTK_POS_TOP);
}
void
gstyle_color_panel_actions_init (GstyleColorPanel *self)
{
g_autoptr (GSimpleActionGroup) pages_group = NULL;
GActionGroup *palette_widget_actions_group;
pages_group = g_simple_action_group_new ();
g_action_map_add_action_entries (G_ACTION_MAP (pages_group), ColorPanelPagesPrefsActions,
G_N_ELEMENTS (ColorPanelPagesPrefsActions), self);
gtk_widget_insert_action_group (GTK_WIDGET (self), "gstyle-pages-prefs", G_ACTION_GROUP (pages_group));
if (self->palette_widget != NULL)
{
palette_widget_actions_group = gtk_widget_get_action_group (GTK_WIDGET (self->palette_widget), "gstyle-palettes-prefs");
if (palette_widget_actions_group != NULL)
gtk_widget_insert_action_group (GTK_WIDGET (self),
"gstyle-palettes-prefs",
palette_widget_actions_group);
}
}
static void
panel_applet_init (PanelApplet *applet)
{
GtkStyleContext *context;
applet->priv = PANEL_APPLET_GET_PRIVATE (applet);
applet->priv->flags = PANEL_APPLET_FLAGS_NONE;
applet->priv->orient = PANEL_APPLET_ORIENT_UP;
applet->priv->has_handle = FALSE;
applet->priv->builder = gtk_builder_new ();
gtk_builder_add_from_string (applet->priv->builder, panel_menu_ui, -1, NULL);
applet->priv->action_group = g_simple_action_group_new ();
gtk_widget_set_events (GTK_WIDGET (applet), GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
context = gtk_widget_get_style_context (GTK_WIDGET (applet));
gtk_style_context_add_class (context, GTK_STYLE_CLASS_HORIZONTAL);
}
static void
add_actions (GApplication *app)
{
GSimpleActionGroup *actions;
GSimpleAction *action;
actions = g_simple_action_group_new ();
action = g_simple_action_new ("simple-action", NULL);
g_signal_connect (action, "activate", G_CALLBACK (activate_action), app);
g_simple_action_group_insert (actions, G_ACTION (action));
g_object_unref (action);
action = g_simple_action_new_stateful ("toggle-action", NULL,
g_variant_new_boolean (FALSE));
g_signal_connect (action, "activate", G_CALLBACK (activate_toggle_action), app);
g_simple_action_group_insert (actions, G_ACTION (action));
g_object_unref (action);
g_application_set_action_group (app, G_ACTION_GROUP (actions));
g_object_unref (actions);
}
static void
gbp_grep_tree_addin_load (IdeTreeAddin *addin,
IdeTree *tree,
IdeTreeModel *model)
{
GbpGrepTreeAddin *self = (GbpGrepTreeAddin *)addin;
g_autoptr(GActionMap) group = NULL;
static const GActionEntry actions[] = {
{ "find-in-files", find_in_files_action },
};
g_assert (IDE_IS_MAIN_THREAD ());
g_assert (GBP_IS_GREP_TREE_ADDIN (self));
g_assert (IDE_IS_TREE (tree));
g_assert (IDE_IS_TREE_MODEL (model));
self->tree = tree;
group = G_ACTION_MAP (g_simple_action_group_new ());
g_action_map_add_action_entries (group, actions, G_N_ELEMENTS (actions), self);
gtk_widget_insert_action_group (GTK_WIDGET (tree), "grep", G_ACTION_GROUP (group));
}
int
main (int argc, char *argv[])
{
GtkWidget *win;
GtkWidget *box;
GtkWidget *button;
GtkWidget *button2;
GtkBuilder *builder;
GMenuModel *model;
GSimpleActionGroup *actions;
GtkWidget *overlay;
GtkWidget *grid;
GtkWidget *popover;
GtkWidget *popover2;
GtkWidget *label;
GtkWidget *check;
GtkWidget *combo;
gtk_init (&argc, &argv);
win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW (win), 400, 600);
actions = g_simple_action_group_new ();
g_action_map_add_action_entries (G_ACTION_MAP (actions), entries, G_N_ELEMENTS (entries), NULL);
gtk_widget_insert_action_group (win, "top", G_ACTION_GROUP (actions));
overlay = gtk_overlay_new ();
gtk_container_add (GTK_CONTAINER (win), overlay);
grid = gtk_grid_new ();
gtk_widget_set_halign (grid, GTK_ALIGN_FILL);
gtk_widget_set_valign (grid, GTK_ALIGN_FILL);
gtk_grid_set_row_spacing (GTK_GRID (grid), 10);
gtk_grid_set_column_spacing (GTK_GRID (grid), 10);
gtk_container_add (GTK_CONTAINER (overlay), grid);
label = gtk_label_new ("");
gtk_widget_set_hexpand (label, TRUE);
gtk_widget_set_vexpand (label, TRUE);
gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 1);
label = gtk_label_new ("");
gtk_widget_set_hexpand (label, TRUE);
gtk_widget_set_vexpand (label, TRUE);
gtk_grid_attach (GTK_GRID (grid), label, 3, 6, 1, 1);
builder = gtk_builder_new_from_file ("popover.ui");
model = (GMenuModel *)gtk_builder_get_object (builder, "menu");
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
button = gtk_menu_button_new ();
gtk_container_add (GTK_CONTAINER (box), button);
button2 = gtk_menu_button_new ();
gtk_container_add (GTK_CONTAINER (box), button2);
gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (button), model);
gtk_menu_button_set_use_popover (GTK_MENU_BUTTON (button), TRUE);
popover = GTK_WIDGET (gtk_menu_button_get_popover (GTK_MENU_BUTTON (button)));
builder = gtk_builder_new_from_file ("popover2.ui");
popover2 = (GtkWidget *)gtk_builder_get_object (builder, "popover");
gtk_menu_button_set_popover (GTK_MENU_BUTTON (button2), popover2);
g_object_set (box, "margin", 10, NULL);
gtk_widget_set_halign (box, GTK_ALIGN_END);
gtk_widget_set_valign (box, GTK_ALIGN_START);
gtk_overlay_add_overlay (GTK_OVERLAY (overlay), box);
label = gtk_label_new ("Popover hexpand");
check = gtk_check_button_new ();
g_object_bind_property (check, "active", popover, "hexpand", G_BINDING_DEFAULT);
g_object_bind_property (check, "active", popover2, "hexpand", G_BINDING_DEFAULT);
gtk_grid_attach (GTK_GRID (grid), label , 1, 1, 1, 1);
gtk_grid_attach (GTK_GRID (grid), check, 2, 1, 1, 1);
label = gtk_label_new ("Popover vexpand");
check = gtk_check_button_new ();
g_object_bind_property (check, "active", popover, "vexpand", G_BINDING_DEFAULT);
g_object_bind_property (check, "active", popover2, "vexpand", G_BINDING_DEFAULT);
gtk_grid_attach (GTK_GRID (grid), label , 1, 2, 1, 1);
gtk_grid_attach (GTK_GRID (grid), check, 2, 2, 1, 1);
label = gtk_label_new ("Button direction");
combo = gtk_combo_box_text_new ();
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "up", "Up");
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "down", "Down");
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "left", "Left");
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "right", "Right");
g_object_bind_property (combo, "active", button, "direction", G_BINDING_DEFAULT);
g_object_bind_property (combo, "active", button2, "direction", G_BINDING_DEFAULT);
gtk_grid_attach (GTK_GRID (grid), label , 1, 3, 1, 1);
gtk_grid_attach (GTK_GRID (grid), combo, 2, 3, 1, 1);
label = gtk_label_new ("Button halign");
combo = gtk_combo_box_text_new ();
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "fill", "Fill");
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "start", "Start");
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "end", "End");
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "center", "Center");
g_object_bind_property (combo, "active", box, "halign", G_BINDING_DEFAULT);
gtk_grid_attach (GTK_GRID (grid), label , 1, 4, 1, 1);
gtk_grid_attach (GTK_GRID (grid), combo, 2, 4, 1, 1);
label = gtk_label_new ("Button valign");
combo = gtk_combo_box_text_new ();
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "fill", "Fill");
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "start", "Start");
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "end", "End");
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "center", "Center");
g_object_bind_property (combo, "active", box, "valign", G_BINDING_DEFAULT);
gtk_grid_attach (GTK_GRID (grid), label , 1, 5, 1, 1);
gtk_grid_attach (GTK_GRID (grid), combo, 2, 5, 1, 1);
gtk_widget_show_all (win);
gtk_main ();
return 0;
}
gboolean
workspace_switcher_applet_fill (PanelApplet *applet)
{
PagerData *pager;
GSimpleActionGroup *action_group;
GAction *action;
gboolean display_names;
pager = g_new0 (PagerData, 1);
pager->applet = GTK_WIDGET (applet);
panel_applet_set_flags (PANEL_APPLET (pager->applet), PANEL_APPLET_EXPAND_MINOR);
setup_gsettings (pager);
pager->n_rows = g_settings_get_int (pager->settings, "num-rows");
display_names = g_settings_get_boolean (pager->settings, "display-workspace-names");
if (display_names) {
pager->display_mode = WNCK_PAGER_DISPLAY_NAME;
} else {
pager->display_mode = WNCK_PAGER_DISPLAY_CONTENT;
}
pager->display_all = g_settings_get_boolean (pager->settings, "display-all-workspaces");
switch (panel_applet_get_orient (applet)) {
case PANEL_APPLET_ORIENT_LEFT:
case PANEL_APPLET_ORIENT_RIGHT:
pager->orientation = GTK_ORIENTATION_VERTICAL;
break;
case PANEL_APPLET_ORIENT_UP:
case PANEL_APPLET_ORIENT_DOWN:
default:
pager->orientation = GTK_ORIENTATION_HORIZONTAL;
break;
}
pager->pager = wnck_pager_new ();
pager->screen = NULL;
pager->wm = PAGER_WM_UNKNOWN;
wnck_pager_set_shadow_type (WNCK_PAGER (pager->pager), GTK_SHADOW_IN);
g_signal_connect (G_OBJECT (pager->pager), "destroy",
G_CALLBACK (destroy_pager),
pager);
gtk_container_add (GTK_CONTAINER (pager->applet), pager->pager);
gtk_widget_show (pager->pager);
g_signal_connect (G_OBJECT (pager->applet),
"realize",
G_CALLBACK (applet_realized),
pager);
g_signal_connect (G_OBJECT (pager->applet),
"unrealize",
G_CALLBACK (applet_unrealized),
pager);
g_signal_connect (G_OBJECT (pager->applet),
"change_orient",
G_CALLBACK (applet_change_orient),
pager);
g_signal_connect (G_OBJECT (pager->applet),
"change_background",
G_CALLBACK (applet_change_background),
pager);
gtk_widget_show (pager->applet);
action_group = g_simple_action_group_new ();
g_action_map_add_action_entries (G_ACTION_MAP (action_group),
pager_menu_actions,
G_N_ELEMENTS (pager_menu_actions),
pager);
panel_applet_setup_menu_from_resource (PANEL_APPLET (pager->applet),
WNCKLET_RESOURCE_PATH "workspace-switcher-menu.xml",
action_group,
GETTEXT_PACKAGE);
gtk_widget_insert_action_group (GTK_WIDGET (applet), "ws",
G_ACTION_GROUP (action_group));
action = g_action_map_lookup_action (G_ACTION_MAP (action_group), "preferences");
g_object_bind_property (pager->applet, "locked-down",
action, "enabled",
G_BINDING_DEFAULT|G_BINDING_INVERT_BOOLEAN|G_BINDING_SYNC_CREATE);
g_object_unref (action_group);
return TRUE;
}
void gweather_applet_create (GWeatherApplet *gw_applet)
{
GSimpleActionGroup *action_group;
GAction *action;
gchar *ui_path;
AtkObject *atk_obj;
GWeatherForecastType type;
GNetworkMonitor*monitor;
panel_applet_set_flags (gw_applet->applet, PANEL_APPLET_EXPAND_MINOR);
gw_applet->container = gtk_alignment_new (0.5, 0.5, 0, 0);
gtk_container_add (GTK_CONTAINER (gw_applet->applet), gw_applet->container);
g_signal_connect (G_OBJECT(gw_applet->applet), "change_orient",
G_CALLBACK(change_orient_cb), gw_applet);
g_signal_connect (G_OBJECT(gw_applet->applet), "size_allocate",
G_CALLBACK(size_allocate_cb), gw_applet);
g_signal_connect (G_OBJECT(gw_applet->applet), "destroy",
G_CALLBACK (applet_destroy), gw_applet);
g_signal_connect (G_OBJECT(gw_applet->applet), "button_press_event",
G_CALLBACK(clicked_cb), gw_applet);
g_signal_connect (G_OBJECT(gw_applet->applet), "key_press_event",
G_CALLBACK(key_press_cb), gw_applet);
gtk_widget_set_tooltip_text (GTK_WIDGET(gw_applet->applet), _("GNOME Weather"));
atk_obj = gtk_widget_get_accessible (GTK_WIDGET (gw_applet->applet));
if (GTK_IS_ACCESSIBLE (atk_obj))
atk_object_set_name (atk_obj, _("GNOME Weather"));
gw_applet->orient = panel_applet_get_orient (gw_applet->applet);
action_group = g_simple_action_group_new ();
g_action_map_add_action_entries (G_ACTION_MAP (action_group),
weather_applet_menu_actions,
G_N_ELEMENTS (weather_applet_menu_actions),
gw_applet);
ui_path = g_build_filename (GWEATHER_MENU_UI_DIR, "gweather-applet-menu.xml", NULL);
panel_applet_setup_menu_from_file (gw_applet->applet,
ui_path, action_group,
GETTEXT_PACKAGE);
g_free (ui_path);
gtk_widget_insert_action_group (GTK_WIDGET (gw_applet->applet), "gweather",
G_ACTION_GROUP (action_group));
action = g_action_map_lookup_action (G_ACTION_MAP (action_group), "preferences");
g_object_bind_property (gw_applet->applet, "locked-down", action, "enabled",
G_BINDING_DEFAULT|G_BINDING_INVERT_BOOLEAN|G_BINDING_SYNC_CREATE);
g_object_unref (action_group);
type = g_settings_get_boolean (gw_applet->applet_settings, "detailed") ?
GWEATHER_FORECAST_ZONE : GWEATHER_FORECAST_STATE;
gw_applet->gweather_info = gweather_info_new(NULL, type);
g_signal_connect (gw_applet->gweather_info, "updated",
G_CALLBACK (update_finish), gw_applet);
place_widgets(gw_applet);
monitor = g_network_monitor_get_default();
g_signal_connect (monitor, "network-changed",
G_CALLBACK (network_changed), gw_applet);
}
static void
cpufreq_applet_setup (CPUFreqApplet *applet)
{
GSimpleActionGroup *action_group;
GAction *action;
gchar *ui_path;
AtkObject *atk_obj;
GSettings *settings;
/* Preferences */
if (applet->prefs)
g_object_unref (applet->prefs);
settings = panel_applet_settings_new (PANEL_APPLET (applet), "org.gnome.gnome-applets.cpufreq");
applet->prefs = cpufreq_prefs_new (settings);
g_signal_connect (G_OBJECT (applet->prefs),
"notify::cpu",
G_CALLBACK (cpufreq_applet_prefs_cpu_changed),
(gpointer) applet);
g_signal_connect (G_OBJECT (applet->prefs),
"notify::show-mode",
G_CALLBACK (cpufreq_applet_prefs_show_mode_changed),
(gpointer) applet);
g_signal_connect (G_OBJECT (applet->prefs),
"notify::show-text-mode",
G_CALLBACK (cpufreq_applet_prefs_show_mode_changed),
(gpointer) applet);
/* Monitor */
applet->monitor = cpufreq_monitor_new (cpufreq_prefs_get_cpu (applet->prefs));
cpufreq_monitor_run (applet->monitor);
g_signal_connect_swapped (G_OBJECT (applet->monitor), "changed",
G_CALLBACK (cpufreq_applet_update),
(gpointer) applet);
/* Setup the menus */
action_group = g_simple_action_group_new ();
g_action_map_add_action_entries (G_ACTION_MAP (action_group),
cpufreq_applet_menu_actions,
G_N_ELEMENTS (cpufreq_applet_menu_actions),
applet);
ui_path = g_build_filename (CPUFREQ_MENU_UI_DIR, "cpufreq-applet-menu.xml", NULL);
panel_applet_setup_menu_from_file (PANEL_APPLET (applet),
ui_path, action_group,
GETTEXT_PACKAGE);
g_free (ui_path);
gtk_widget_insert_action_group (GTK_WIDGET (applet), "cpufreq",
G_ACTION_GROUP (action_group));
action = g_action_map_lookup_action (G_ACTION_MAP (action_group), "preferences");
g_object_bind_property (applet, "locked-down", action, "enabled",
G_BINDING_DEFAULT|G_BINDING_INVERT_BOOLEAN|G_BINDING_SYNC_CREATE);
g_object_unref (action_group);
atk_obj = gtk_widget_get_accessible (GTK_WIDGET (applet));
if (GTK_IS_ACCESSIBLE (atk_obj)) {
atk_object_set_name (atk_obj, _("CPU Frequency Scaling Monitor"));
atk_object_set_description (atk_obj, _("This utility shows the current CPU Frequency"));
}
cpufreq_applet_update_visibility (applet);
gtk_widget_show (GTK_WIDGET (applet));
}
static void
do_appwindow (GSimpleAction *action,
GVariant *parameter,
gpointer user_data)
{
GtkWidget *window;
GtkWidget *grid;
GtkWidget *statusbar;
GtkWidget *contents;
GtkWidget *sw;
GtkTextBuffer *buffer;
GSimpleActionGroup *action_group;
GtkBuilder *builder;
GMenuModel *model;
GtkWidget *menubar;
GtkWidget *toolbar;
/* Create the toplevel window
*/
++window_count;
aspect_on = FALSE;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Application Window");
g_signal_connect (G_OBJECT (window), "destroy",
G_CALLBACK (destroy_cb), NULL);
grid = gtk_grid_new ();
gtk_widget_set_vexpand (grid, TRUE);
gtk_widget_set_hexpand (grid, TRUE);
gtk_container_add (GTK_CONTAINER (window), grid);
action_group = g_simple_action_group_new ();
builder = gtk_builder_new_from_string (xml, -1);
g_action_map_add_action_entries (G_ACTION_MAP (action_group),
demo_entries,
G_N_ELEMENTS (demo_entries),
window);
gtk_widget_insert_action_group (window, "demo", G_ACTION_GROUP (action_group));
/* Create the menubar
*/
model = G_MENU_MODEL (gtk_builder_get_object (builder, "menubar"));
menubar = gtk_menu_bar_new_from_model (model);
gtk_grid_attach (GTK_GRID (grid), menubar, 0, 0, 1, 1);
gtk_widget_set_hexpand (menubar, TRUE);
/* Create the toolbar
*/
toolbar = create_toolbar ();
gtk_grid_attach (GTK_GRID (grid), toolbar, 0, 1, 1, 1);
gtk_widget_set_hexpand (toolbar, TRUE);
/* Create document
*/
contents = gtk_text_view_new ();
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
GTK_SHADOW_IN);
gtk_grid_attach (GTK_GRID (grid), sw, 0, 2, 1, 1);
gtk_widget_set_hexpand (sw, TRUE);
gtk_widget_set_vexpand (sw, TRUE);
gtk_window_set_default_size (GTK_WINDOW (window),
200, 200);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (contents),
PANGO_WRAP_WORD);
gtk_container_add (GTK_CONTAINER (sw),
contents);
/* Create statusbar
*/
statusbar = gtk_statusbar_new ();
gtk_grid_attach (GTK_GRID (grid), statusbar, 0, 3, 1, 1);
gtk_widget_set_hexpand (statusbar, TRUE);
/* Show text widget info in the statusbar */
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (contents));
gtk_text_buffer_set_text (buffer,
"This demo demonstrates various kinds of windows that "
"window managers and window manager themes should handle. "
"Be sure to tear off the menu and toolbar, those are also "
"a special kind of window.",
-1);
g_signal_connect_object (buffer,
"changed",
G_CALLBACK (update_statusbar),
statusbar,
0);
g_signal_connect_object (buffer,
"mark_set", /* cursor moved */
G_CALLBACK (mark_set_callback),
statusbar,
0);
update_statusbar (buffer, GTK_STATUSBAR (statusbar));
gtk_widget_show_all (window);
g_object_unref (action_group);
g_object_unref (builder);
}
static void popup_menu (tilda_window *tw, tilda_term *tt)
{
DEBUG_FUNCTION ("popup_menu");
DEBUG_ASSERT (tw != NULL);
DEBUG_ASSERT (tt != NULL);
static const gchar menu_str[] = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
"<interface>\n"
" <menu id=\"menu\">\n"
" <section>\n"
" <item>\n"
" <attribute name=\"label\" translatable=\"yes\">_New Tab</attribute>\n"
" <attribute name=\"action\">window.new-tab</attribute>\n"
" </item>\n"
" <item>\n"
" <attribute name=\"label\" translatable=\"yes\">_Close Tab</attribute>\n"
" <attribute name=\"action\">window.close-tab</attribute>\n"
" </item>\n"
" </section>\n"
" <section>\n"
" <item>\n"
" <attribute name=\"label\" translatable=\"yes\">_Copy</attribute>\n"
" <attribute name=\"action\">window.copy</attribute>\n"
" </item>\n"
" <item>\n"
" <attribute name=\"label\" translatable=\"yes\">_Paste</attribute>\n"
" <attribute name=\"action\">window.paste</attribute>\n"
" </item>\n"
" </section> \n"
" <section>\n"
" <item>\n"
" <attribute name=\"label\" translatable=\"yes\">_Toggle Fullscreen</attribute>\n"
" <attribute name=\"action\">window.fullscreen</attribute>\n"
" </item>\n"
" </section> \n"
" <section>\n"
" <item>\n"
" <attribute name=\"label\" translatable=\"yes\">_Preferences</attribute>\n"
" <attribute name=\"action\">window.preferences</attribute>\n"
" </item>\n"
" </section> \n"
" <section>\n"
" <item>\n"
" <attribute name=\"label\" translatable=\"yes\">_Quit</attribute>\n"
" <attribute name=\"action\">window.quit</attribute>\n"
" </item>\n"
" </section> \n"
" </menu>\n"
"</interface>";
GtkBuilder *builder = gtk_builder_new();
gtk_builder_add_from_string(builder, menu_str, strlen(menu_str), NULL);
/* Create the action group */
GSimpleActionGroup *action_group = g_simple_action_group_new();
/* We need two different lists of entries because the
* because the actions have different scope, some concern the
* tilda_window and others concern the current terminal, so
* when we add them to the action_group we need to pass different
* user_data (tw or tt).
*
* Note: Using designated initializers here, allows us to skip the remaining fields which are NULL anyway and
* also gets rid of missing field initializer warnings.
*/
GActionEntry entries_for_tilda_window[] = {
{ .name="new-tab", menu_add_tab_cb },
{ .name="close-tab", menu_close_tab_cb },
/* create the toolbar-customization dialog
*/
void
customize_dialog_cb(GtkWidget * widget, gpointer data)
{
GtkWidget *notebook;
GtkWidget *child;
GtkWidget *option_frame;
GtkWidget *option_box;
GtkWidget *wrap_button;
GtkWidget *active_window = data;
BalsaToolbarType type;
BalsaToolbarModel *model;
GSimpleActionGroup *group;
GtkWidget *content_area;
/* There can only be one */
if (customize_widget) {
gtk_window_present(GTK_WINDOW(customize_widget));
return;
}
customize_widget =
gtk_dialog_new_with_buttons(_("Customize Toolbars"),
GTK_WINDOW(active_window),
GTK_DIALOG_DESTROY_WITH_PARENT |
libbalsa_dialog_flags(),
_("_Close"), GTK_RESPONSE_CLOSE,
_("_Help"), GTK_RESPONSE_HELP,
NULL);
#if HAVE_MACOSX_DESKTOP
libbalsa_macosx_menu_for_parent(customize_widget, GTK_WINDOW(active_window));
#endif
g_object_add_weak_pointer(G_OBJECT(customize_widget),
(gpointer) & customize_widget);
g_signal_connect(G_OBJECT(customize_widget), "response",
G_CALLBACK(tp_dialog_response_cb), NULL);
notebook = gtk_notebook_new();
content_area =
gtk_dialog_get_content_area(GTK_DIALOG(customize_widget));
gtk_box_pack_start(GTK_BOX(content_area), notebook, TRUE, TRUE, 0);
gtk_window_set_role(GTK_WINDOW(customize_widget), "customize");
gtk_window_set_default_size(GTK_WINDOW(customize_widget), 600, 440);
/* The order of pages must be consistent with the BalsaToolbarType
* enum. */
model = balsa_window_get_toolbar_model();
group = g_simple_action_group_new();
balsa_window_add_action_entries(G_ACTION_MAP(group));
#ifdef BALSA_TOOLBAR_DEBUG_ACTIONS
g_print("main window\n");
#endif /* BALSA_TOOLBAR_DEBUG_ACTIONS */
child = create_toolbar_page(model, G_ACTION_MAP(group));
g_object_unref(group);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), child,
gtk_label_new(_("Main window")));
model = sendmsg_window_get_toolbar_model();
group = g_simple_action_group_new();
sendmsg_window_add_action_entries(G_ACTION_MAP(group));
#ifdef BALSA_TOOLBAR_DEBUG_ACTIONS
g_print("compose window\n");
#endif /* BALSA_TOOLBAR_DEBUG_ACTIONS */
child = create_toolbar_page(model, G_ACTION_MAP(group));
g_object_unref(group);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), child,
gtk_label_new(_("Compose window")));
model = message_window_get_toolbar_model();
group = g_simple_action_group_new();
message_window_add_action_entries(G_ACTION_MAP(group));
#ifdef BALSA_TOOLBAR_DEBUG_ACTIONS
g_print("message window\n");
#endif /* BALSA_TOOLBAR_DEBUG_ACTIONS */
child = create_toolbar_page(model, G_ACTION_MAP(group));
g_object_unref(group);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), child,
gtk_label_new(_("Message window")));
option_frame = gtk_frame_new(_("Toolbar options"));
gtk_container_set_border_width(GTK_CONTAINER(option_frame), 6);
gtk_box_pack_start(GTK_BOX(content_area), option_frame, FALSE, FALSE, 0);
option_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 6);
gtk_container_set_border_width(GTK_CONTAINER(option_box), 6);
gtk_container_add(GTK_CONTAINER(option_frame), option_box);
wrap_button =
gtk_check_button_new_with_mnemonic(_("_Wrap button labels"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(wrap_button),
balsa_app.toolbar_wrap_button_text);
g_signal_connect(G_OBJECT(wrap_button), "toggled",
G_CALLBACK(wrap_toggled_cb), notebook);
gtk_box_pack_start(GTK_BOX(option_box), wrap_button, FALSE, FALSE, 0);
gtk_widget_show_all(customize_widget);
/* Now that the pages are shown, we can switch to the page
* corresponding to the toolbar that the user clicked on. */
type =
GPOINTER_TO_INT(g_object_get_data
(G_OBJECT(widget), BALSA_TOOLBAR_MODEL_TYPE));
gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), type);
}
