void equalizerwin_show (gboolean show)
{
GtkAction * a = gtk_action_group_get_action (toggleaction_group_others,
"show equalizer");
if (a && gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (a)) != show)
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (a), show);
else
{
config.equalizer_visible = show;
button_set_active (mainwin_eq, show);
equalizerwin_real_show (show && gtk_widget_get_visible (mainwin));
}
}
/* show integrated UI main toolbar and set pulldown menu action. */
void
integrated_ui_toolbar_show (gboolean show)
{
if (ui.toolbar) {
GtkAction *action = NULL;
if (show)
gtk_widget_show (GTK_WIDGET (ui.toolbar));
else
gtk_widget_hide (GTK_WIDGET (ui.toolbar));
action = menus_get_action (VIEW_MAIN_TOOLBAR_ACTION);
if (action)
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), show);
}
}
static void
query_editor_cancel_callback (NautilusQueryEditor *editor,
NautilusWindowSlot *slot)
{
GtkAction *search;
NautilusWindow *window;
GtkActionGroup *action_group;
window = slot->details->pane->window;
action_group = nautilus_window_get_main_action_group (window);
search = gtk_action_group_get_action (action_group, NAUTILUS_ACTION_SEARCH);
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (search), FALSE);
}
void
integrated_ui_layer_view_show (gboolean show)
{
if (ui.layer_view) {
GtkAction *action;
if (show)
gtk_widget_show (ui.layer_view);
else
gtk_widget_hide (ui.layer_view);
action = menus_get_action (VIEW_LAYERS_ACTION);
if (action)
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), show);
}
}
static void
update_ui (PlumaSpellPlugin *plugin)
{
PlumaSpellPluginPrivate *data;
PlumaWindow *window;
PlumaDocument *doc;
PlumaView *view;
gboolean autospell;
GtkAction *action;
pluma_debug (DEBUG_PLUGINS);
data = plugin->priv;
window = PLUMA_WINDOW (data->window);
doc = pluma_window_get_active_document (window);
view = pluma_window_get_active_view (window);
autospell = (doc != NULL &&
pluma_automatic_spell_checker_get_from_document (doc) != NULL);
if (doc != NULL)
{
PlumaTab *tab;
PlumaTabState state;
tab = pluma_window_get_active_tab (window);
state = pluma_tab_get_state (tab);
/* If the document is loading we can't get the metadata so we
endup with an useless speller */
if (state == PLUMA_TAB_STATE_NORMAL)
{
action = gtk_action_group_get_action (data->action_group,
"AutoSpell");
g_signal_handlers_block_by_func (action, auto_spell_cb,
plugin);
set_auto_spell (window, doc, autospell);
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
autospell);
g_signal_handlers_unblock_by_func (action, auto_spell_cb,
plugin);
}
}
gtk_action_group_set_sensitive (data->action_group,
(view != NULL) &&
gtk_text_view_get_editable (GTK_TEXT_VIEW (view)));
}
static GtkAction*
create_action_for_view_menu (PgpugPane *pane)
{
g_return_if_fail (PGPUG_IS_PANE (pane));
const gchar *name = pgpug_pane_get_menu_text (pane);
GtkToggleAction *action = gtk_toggle_action_new (name, name, NULL, NULL);
gboolean is_pane_installed = gtk_widget_get_parent (pgpug_pane_get_view (pane)) != NULL;
gtk_toggle_action_set_active (action, is_pane_installed);
g_signal_connect (action, "toggled", G_CALLBACK (menu_view_item_toggled), pane);
return GTK_ACTION (action);
}
static void
toggle_toolbar_search_button (NemoWindowPane *pane)
{
GtkActionGroup *group;
GtkAction *action;
group = pane->action_group;
action = gtk_action_group_get_action (group, NEMO_ACTION_SEARCH);
g_signal_handlers_block_by_func (action,
action_show_hide_search_callback, pane);
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), TRUE);
g_signal_handlers_unblock_by_func (action,
action_show_hide_search_callback, pane);
}
/* This updates the UI state of the search button, but does not
in itself trigger a search action */
void
caja_navigation_window_set_search_button (CajaNavigationWindow *window,
gboolean state)
{
GtkAction *action;
action = gtk_action_group_get_action (window->details->navigation_action_group,
"Search");
/* Block callback so we don't activate the action and thus focus the
search entry */
g_object_set_data (G_OBJECT (action), "blocked", GINT_TO_POINTER (1));
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), state);
g_object_set_data (G_OBJECT (action), "blocked", NULL);
}
/* TODO: use g_settings_bind instead of manual visibility switching
* see also cmd_show_hide_bar()
*/
static void
update_ui_visibility (EmerillonWindow *self)
{
gboolean visible;
GtkAction *action;
/* Toolbar. */
visible = g_settings_get_boolean (self->priv->settings_ui,
EMERILLON_CONF_UI_TOOLBAR);
action = gtk_ui_manager_get_action (self->priv->ui_manager,
"/MainMenu/View/ToolbarToggle");
g_assert (action != NULL);
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), visible);
g_object_set (G_OBJECT (self->priv->toolbar), "visible", visible, NULL);
/* Statusbar. */
visible = g_settings_get_boolean (self->priv->settings_ui,
EMERILLON_CONF_UI_STATUSBAR);
action = gtk_ui_manager_get_action (self->priv->ui_manager,
"/MainMenu/View/StatusbarToggle");
g_assert (action != NULL);
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), visible);
g_object_set (G_OBJECT (self->priv->statusbar), "visible", visible, NULL);
/* Sidebar. */
visible = g_settings_get_boolean (self->priv->settings_ui,
EMERILLON_CONF_UI_SIDEBAR);
action = gtk_ui_manager_get_action (self->priv->ui_manager,
"/MainMenu/View/SidebarToggle");
g_assert (action != NULL);
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), visible);
if (visible)
gtk_widget_show (self->priv->sidebar);
else
gtk_widget_hide (self->priv->sidebar);
}
static void
init_toolbar( BaseWindow *window, GtkActionGroup *group, int toolbar_id )
{
ToolbarProps *props;
gboolean is_active;
GtkToggleAction *action;
props = get_toolbar_properties( toolbar_id );
if( props ){
is_active = na_settings_get_boolean( props->prefs_key, NULL, NULL );
if( is_active ){
action = GTK_TOGGLE_ACTION( gtk_action_group_get_action( group, props->ui_item ));
gtk_toggle_action_set_active( action, TRUE );
}
}
}
int
clip_GTK_TOGGLEACTIONSETACTIVE(ClipMachine * cm)
{
C_object *caction = _fetch_co_arg(cm);
gboolean is_active = _clip_parl(cm, 2);
CHECKARG2(1,MAP_t, NUMERIC_t);
CHECKCOBJ(caction, GTK_IS_TOGGLE_ACTION(caction->object));
CHECKARG(2, LOGICAL_t);
gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(caction->object), is_active);
return 0;
err:
return 1;
}
static void
on_layout_locked_notify (GdlDockMaster *master, GParamSpec *pspec,
AnjutaWindow *win)
{
AnjutaUI *ui;
GtkAction *action;
gint locked;
ui = win->ui;
action = anjuta_ui_get_action (ui, "ActionGroupToggleView",
"ActionViewLockLayout");
g_object_get (master, "locked", &locked, NULL);
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
(locked == 1));
}
static void
sidebar_visibility_changed_cb (GtkWidget *widget,
EmerillonWindow *self)
{
GtkAction *action;
gboolean visible;
visible = gtk_widget_get_visible (self->priv->sidebar);
g_settings_set_boolean (self->priv->settings_ui, EMERILLON_CONF_UI_SIDEBAR,
visible);
action = gtk_action_group_get_action (self->priv->main_actions,
"ViewSidebar");
if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)) != visible)
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), visible);
}
static void
update_ui_real (GeditWindow *window,
WindowData *data)
{
GeditDocument *doc;
GeditView *view;
gboolean autospell;
GtkAction *action;
gedit_debug (DEBUG_PLUGINS);
doc = gedit_window_get_active_document (window);
view = gedit_window_get_active_view (window);
autospell = (doc != NULL &&
gedit_automatic_spell_checker_get_from_document (doc) != NULL);
if (doc != NULL)
{
GeditTab *tab;
GeditTabState state;
tab = gedit_window_get_active_tab (window);
state = gedit_tab_get_state (tab);
/* If the document is loading we can't get the metadata so we
endup with an useless speller */
if (state == GEDIT_TAB_STATE_NORMAL)
{
action = gtk_action_group_get_action (data->action_group,
"AutoSpell");
g_signal_handlers_block_by_func (action, auto_spell_cb,
window);
set_auto_spell (window, doc, autospell);
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
autospell);
g_signal_handlers_unblock_by_func (action, auto_spell_cb,
window);
}
}
gtk_action_group_set_sensitive (data->action_group,
(view != NULL) &&
gtk_text_view_get_editable (GTK_TEXT_VIEW (view)));
}
void
_gedit_cmd_view_leave_fullscreen_mode (GtkAction *action,
GeditWindow *window)
{
GtkAction *view_action;
view_action = gtk_action_group_get_action (window->priv->always_sensitive_action_group,
"ViewFullscreen");
g_signal_handlers_block_by_func
(view_action, G_CALLBACK (_gedit_cmd_view_toggle_fullscreen_mode),
window);
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (view_action),
FALSE);
_gedit_window_unfullscreen (window);
g_signal_handlers_unblock_by_func
(view_action, G_CALLBACK (_gedit_cmd_view_toggle_fullscreen_mode),
window);
}
int main(int argc, char *argv[])
{
gtk_init(&argc, &argv);
GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(window), 200, 200);
g_signal_connect(window, "destroy", G_CALLBACK(destroy), NULL);
GtkWidget *menubar = gtk_menu_bar_new();
gtk_container_add(GTK_CONTAINER(window), menubar);
GtkActionGroup *actiongroup = gtk_action_group_new("ActionGroup");
GtkAction *action = gtk_action_new("actionFile", "_File", NULL, NULL);
gtk_action_group_add_action(GTK_ACTION_GROUP(actiongroup), action);
GtkWidget *menuitemFile = gtk_action_create_menu_item(GTK_ACTION(action));
gtk_menu_bar_append(GTK_MENU_BAR(menubar), menuitemFile);
GtkWidget *menu = gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitemFile), menu);
GtkToggleAction *toggleaction;
toggleaction = gtk_toggle_action_new("actionNew", "_New", "Create a new document", GTK_STOCK_NEW);
gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(toggleaction), TRUE);
gtk_action_group_add_action(GTK_ACTION_GROUP(actiongroup), GTK_ACTION(toggleaction));
GtkWidget *menuitemNew = gtk_action_create_menu_item(GTK_ACTION(toggleaction));
gtk_menu_append(GTK_MENU(menu), menuitemNew);
toggleaction = gtk_toggle_action_new("actionOpen", "_Open", "Open a file", GTK_STOCK_OPEN);
gtk_action_group_add_action(GTK_ACTION_GROUP(actiongroup), GTK_ACTION(toggleaction));
GtkWidget *menuitemOpen = gtk_action_create_menu_item(GTK_ACTION(toggleaction));
gtk_menu_append(GTK_MENU(menu), menuitemOpen);
toggleaction = gtk_toggle_action_new("actionSave", "_Save", "Save a file", GTK_STOCK_SAVE);
gtk_action_group_add_action(GTK_ACTION_GROUP(actiongroup), GTK_ACTION(toggleaction));
GtkWidget *menuitemSave = gtk_action_create_menu_item(GTK_ACTION(toggleaction));
gtk_menu_append(GTK_MENU(menu), menuitemSave);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
void
nemo_window_update_show_hide_menu_items (NemoWindow *window)
{
GtkActionGroup *action_group;
GtkAction *action;
guint current_value;
action_group = nemo_window_get_main_action_group (window);
action = gtk_action_group_get_action (action_group,
NEMO_ACTION_SHOW_HIDE_EXTRA_PANE);
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
nemo_window_split_view_showing (window));
nemo_window_update_split_view_actions_sensitivity (window);
action = gtk_action_group_get_action (action_group,
"Sidebar Places");
current_value = sidebar_id_to_value (window->details->sidebar_id);
gtk_radio_action_set_current_value (GTK_RADIO_ACTION (action), current_value);
}
void
search_box_toggle_highlight (SearchBox * search_box, gboolean status)
{
if (!search_box->priv->current_editor)
return;
search_box->priv->highlight_all = status;
gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(search_box->priv->highlight_action),
status);
if (!status)
{
ianjuta_indicable_clear(IANJUTA_INDICABLE(search_box->priv->current_editor), NULL);
g_clear_object (&search_box->priv->start_highlight);
g_clear_object (&search_box->priv->end_highlight);
}
else
{
search_box_highlight_all (search_box);
}
}
static void
action_toggle_face_cb (GtkToggleAction *action,
EMsgComposer *composer)
{
if (gtk_toggle_action_get_active (action)) {
gchar *face = get_face_base64 ();
if (!face) {
GdkPixbuf *pixbuf = choose_new_face ();
if (pixbuf) {
g_object_unref (pixbuf);
} else {
/* cannot load a face image, uncheck the option */
gtk_toggle_action_set_active (action, FALSE);
}
} else {
g_free (face);
}
}
}
static void
set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GtkToggleAction *action = GTK_TOGGLE_ACTION (object);
switch (prop_id)
{
case PROP_DRAW_AS_RADIO:
gtk_toggle_action_set_draw_as_radio (action, g_value_get_boolean (value));
break;
case PROP_ACTIVE:
gtk_toggle_action_set_active (action, g_value_get_boolean (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
/* gtk_radio_action_set_current_value() replacement for GTK+ < 2.10 */
void radio_action_set_current_value(GtkRadioAction *action, gint current_value)
{
#if GTK_CHECK_VERSION(2, 10, 0)
gtk_radio_action_set_current_value(action, current_value);
#else
GSList *group;
gint value;
group = gtk_radio_action_get_group(action);
while (group)
{
action = GTK_RADIO_ACTION(group->data);
g_object_get(G_OBJECT(action), "value", &value, NULL);
if (value == current_value)
{
gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), TRUE);
return;
}
group = g_slist_next(group);
}
#endif
}
static void
on_session_load (AnjutaShell *shell, AnjutaSessionPhase phase,
AnjutaSession *session, AnjutaApp *app)
{
/* We load layout at last so that all plugins would have loaded by now */
if (phase == ANJUTA_SESSION_PHASE_LAST)
{
gchar *geometry;
gchar *layout_file;
/* Restore geometry */
geometry = anjuta_session_get_string (session, "Anjuta", "Geometry");
anjuta_app_set_geometry (app, geometry);
/* Restore window state */
if (anjuta_session_get_int (session, "Anjuta", "Fullscreen"))
{
/* bug #304495 */
AnjutaUI* ui = anjuta_shell_get_ui(shell, NULL);
GtkAction* action = anjuta_ui_get_action (ui, "ActionGroupToggleView",
"ActionViewFullscreen");
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
TRUE);
gtk_window_fullscreen (GTK_WINDOW (shell));
}
else if (anjuta_session_get_int (session, "Anjuta", "Maximized"))
{
gtk_window_maximize (GTK_WINDOW (shell));
}
/* Restore layout */
layout_file = g_build_filename (anjuta_session_get_session_directory (session),
"dock-layout.xml", NULL);
anjuta_app_layout_load (app, layout_file, NULL);
g_free (layout_file);
}
}
static void
set_auto_spell_from_metadata (GeditWindow *window,
GeditDocument *doc,
GtkActionGroup *action_group)
{
gboolean active = FALSE;
gchar *active_str;
GeditDocument *active_doc;
active_str = gedit_document_get_metadata (doc,
GEDIT_METADATA_ATTRIBUTE_SPELL_ENABLED);
if (active_str)
{
active = *active_str == '1';
g_free (active_str);
}
set_auto_spell (window, doc, active);
/* In case that the doc is the active one we mark the spell action */
active_doc = gedit_window_get_active_document (window);
if (active_doc == doc && action_group != NULL)
{
GtkAction *action;
action = gtk_action_group_get_action (action_group,
"AutoSpell");
g_signal_handlers_block_by_func (action, auto_spell_cb,
window);
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
active);
g_signal_handlers_unblock_by_func (action, auto_spell_cb,
window);
}
}
static void
anjuta_docman_update_documents_menu_status (AnjutaDocman* docman)
{
AnjutaDocmanPriv *priv = docman->priv;
GtkUIManager* ui = GTK_UI_MANAGER (anjuta_shell_get_ui (ANJUTA_PLUGIN (priv->plugin)->shell,
NULL));
GtkAction* action;
gint n_pages = gtk_notebook_get_n_pages (GTK_NOTEBOOK (docman));
gint current_page = gtk_notebook_get_current_page (GTK_NOTEBOOK (docman));
gchar *action_name;
action = gtk_ui_manager_get_action (ui,
"/MenuMain/PlaceHolderDocumentsMenus/Documents/PreviousDocument");
g_object_set (action, "sensitive", current_page > 0, NULL);
action = gtk_ui_manager_get_action (ui,
"/MenuMain/PlaceHolderDocumentsMenus/Documents/NextDocument");
g_object_set (action, "sensitive", (current_page + 1) < n_pages, NULL);
action_name = g_strdup_printf ("Tab_%d", current_page);
action = gtk_action_group_get_action (docman->priv->documents_action_group, action_name);
g_free (action_name);
if (action)
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), TRUE);
}
static void
show_hidden_files_preference_callback (gpointer callback_data)
{
NemoWindow *window;
GtkAction *action;
window = NEMO_WINDOW (callback_data);
if (window->details->show_hidden_files_mode == NEMO_WINDOW_SHOW_HIDDEN_FILES_DEFAULT) {
action = gtk_action_group_get_action (nemo_window_get_main_action_group (window),
NEMO_ACTION_SHOW_HIDDEN_FILES);
/* update button */
g_signal_handlers_block_by_func (action, action_show_hidden_files_callback, window);
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
g_settings_get_boolean (nemo_preferences, NEMO_PREFERENCES_SHOW_HIDDEN_FILES));
g_signal_handlers_unblock_by_func (action, action_show_hidden_files_callback, window);
/* inform views */
nemo_window_set_hidden_files_mode (window, NEMO_WINDOW_SHOW_HIDDEN_FILES_DEFAULT);
}
}
static void
show_hidden_files_preference_callback (gpointer callback_data)
{
NautilusWindow *window;
GtkAction *action;
window = NAUTILUS_WINDOW (callback_data);
if (window->details->show_hidden_files_mode == NAUTILUS_WINDOW_SHOW_HIDDEN_FILES_DEFAULT) {
action = gtk_action_group_get_action (window->details->main_action_group, NAUTILUS_ACTION_SHOW_HIDDEN_FILES);
g_assert (GTK_IS_ACTION (action));
/* update button */
g_signal_handlers_block_by_func (action, action_show_hidden_files_callback, window);
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
eel_preferences_get_boolean (NAUTILUS_PREFERENCES_SHOW_HIDDEN_FILES));
g_signal_handlers_unblock_by_func (action, action_show_hidden_files_callback, window);
/* inform views */
nautilus_window_info_set_hidden_files_mode (window, NAUTILUS_WINDOW_SHOW_HIDDEN_FILES_DEFAULT);
}
}
static void
ui_states_init (SourceviewPlugin* plugin, AnjutaUI *ui)
{
static const gchar *prefs[] = {
VIEW_LINENUMBERS,
VIEW_MARKS,
VIEW_WHITE_SPACES,
VIEW_EOL,
VIEW_LINE_WRAP
};
gint i;
for (i = 0; i < sizeof (prefs)/sizeof(const gchar *); i++)
{
GtkAction *action;
gboolean state;
state = g_settings_get_boolean (plugin->settings, prefs[i]);
action = anjuta_ui_get_action (ui, "ActionGroupEditorView",
actions_view[i].name);
g_object_set (G_OBJECT (action), "sensitive", TRUE, "visible", TRUE, NULL);
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), state);
}
}
void
display_update_menu_state(DDisplay *ddisp)
{
GtkToggleAction *rulers;
GtkToggleAction *visible_grid;
GtkToggleAction *snap_to_grid;
GtkToggleAction *show_cx_pts;
GtkToggleAction *antialiased;
gboolean scrollbars_shown;
rulers = GTK_TOGGLE_ACTION (menus_get_action ("ViewShowrulers"));
visible_grid = GTK_TOGGLE_ACTION (menus_get_action ("ViewShowgrid"));
snap_to_grid = GTK_TOGGLE_ACTION (menus_get_action ("ViewSnaptogrid"));
show_cx_pts = GTK_TOGGLE_ACTION (menus_get_action ("ViewShowconnectionpoints"));
antialiased = GTK_TOGGLE_ACTION (menus_get_action ("ViewAntialiased"));
gtk_action_set_sensitive (menus_get_action ("ViewAntialiased"),
g_type_from_name ("DiaCairoInteractiveRenderer") != 0 || g_type_from_name ("DiaLibartRenderer") != 0);
ddisplay_do_update_menu_sensitivity (ddisp);
gtk_toggle_action_set_active (rulers, display_get_rulers_showing(ddisp));
#if GTK_CHECK_VERSION(2,20,0)
scrollbars_shown = gtk_widget_get_visible (ddisp->hsb);
#else
scrollbars_shown = GTK_WIDGET_VISIBLE (ddisp->hsb);
#endif
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (menus_get_action ("ViewShowscrollbars")),
scrollbars_shown);
gtk_toggle_action_set_active (visible_grid,
ddisp->grid.visible);
gtk_toggle_action_set_active (snap_to_grid,
ddisp->grid.snap);
gtk_toggle_action_set_active (show_cx_pts,
ddisp->show_cx_pts);
gtk_toggle_action_set_active (antialiased,
ddisp->aa_renderer);
}
static gboolean
create_window(void)
{
GError *error = NULL;
builder = gtk_builder_new();
if( !gtk_builder_add_from_file(builder, PACKAGE_DATA_DIR "/chimara.ui", &error) ) {
#ifdef DEBUG
g_error_free(error);
error = NULL;
if( !gtk_builder_add_from_file(builder, PACKAGE_SRC_DIR "/chimara.ui", &error) ) {
#endif /* DEBUG */
return FALSE;
#ifdef DEBUG
}
#endif /* DEBUG */
}
window = GTK_WIDGET(load_object("chimara"));
aboutwindow = GTK_WIDGET(load_object("aboutwindow"));
prefswindow = GTK_WIDGET(load_object("prefswindow"));
GtkActionGroup *actiongroup = GTK_ACTION_GROUP(load_object("actiongroup"));
/* Set the default value of the "View/Toolbar" menu item upon creation of a
new window to the "show-toolbar-default" setting, but bind the setting
one-way only - we don't want toolbars to disappear suddenly */
GtkToggleAction *toolbar_action = GTK_TOGGLE_ACTION(load_object("toolbar"));
gtk_toggle_action_set_active(toolbar_action, g_settings_get_boolean(state_settings, "show-toolbar-default"));
g_settings_bind(state_settings, "show-toolbar-default", toolbar_action, "active", G_SETTINGS_BIND_SET);
const gchar **ptr;
GtkRecentFilter *filter = gtk_recent_filter_new();
/* TODO: Use mimetypes and construct the filter dynamically depending on
what plugins are installed */
const gchar *patterns[] = {
"*.z[1-8]", "*.[zg]lb", "*.[zg]blorb", "*.ulx", "*.blb", "*.blorb", NULL
};
for(ptr = patterns; *ptr; ptr++)
gtk_recent_filter_add_pattern(filter, *ptr);
GtkRecentChooser *recent = GTK_RECENT_CHOOSER(load_object("recent"));
gtk_recent_chooser_add_filter(recent, filter);
uimanager = gtk_ui_manager_new();
if( !gtk_ui_manager_add_ui_from_file(uimanager, PACKAGE_DATA_DIR "/chimara.menus", &error) ) {
#ifdef DEBUG
g_error_free(error);
error = NULL;
if( !gtk_ui_manager_add_ui_from_file(uimanager, PACKAGE_SRC_DIR "/chimara.menus", &error) )
#endif /* DEBUG */
return FALSE;
}
glk = chimara_if_new();
g_object_set(glk,
"ignore-errors", TRUE,
/*"interpreter-number", CHIMARA_IF_ZMACHINE_TANDY_COLOR,*/
NULL);
if( !chimara_glk_set_css_from_file(CHIMARA_GLK(glk), PACKAGE_DATA_DIR "/style.css", &error) ) {
#ifdef DEBUG
g_error_free(error);
error = NULL;
if( !chimara_glk_set_css_from_file(CHIMARA_GLK(glk), PACKAGE_SRC_DIR "/style.css", &error) )
#endif /* DEBUG */
return FALSE;
}
/* DON'T UNCOMMENT THIS your eyes will burn
but it is a good test of programmatically altering just one style
chimara_glk_set_css_from_string(CHIMARA_GLK(glk),
"buffer { font-family: 'Comic Sans MS'; }");*/
GtkBox *vbox = GTK_BOX( gtk_builder_get_object(builder, "vbox") );
if(vbox == NULL)
return FALSE;
gtk_ui_manager_insert_action_group(uimanager, actiongroup, 0);
GtkWidget *menubar = gtk_ui_manager_get_widget(uimanager, "/menubar");
toolbar = gtk_ui_manager_get_widget(uimanager, "/toolbar");
gtk_widget_set_no_show_all(toolbar, TRUE);
if(gtk_toggle_action_get_active(toolbar_action))
gtk_widget_show(toolbar);
else
gtk_widget_hide(toolbar);
/* Connect the accelerators */
GtkAccelGroup *accels = gtk_ui_manager_get_accel_group(uimanager);
gtk_window_add_accel_group(GTK_WINDOW(window), accels);
gtk_box_pack_end(vbox, glk, TRUE, TRUE, 0);
gtk_box_pack_start(vbox, menubar, FALSE, FALSE, 0);
gtk_box_pack_start(vbox, toolbar, FALSE, FALSE, 0);
gtk_builder_connect_signals(builder, glk);
g_signal_connect(glk, "notify::program-name", G_CALLBACK(change_window_title), window);
g_signal_connect(glk, "notify::story-name", G_CALLBACK(change_window_title), window);
/* Create preferences window */
preferences_create(CHIMARA_GLK(glk));
return TRUE;
}
static gpointer
periodical_thread (gpointer data)
{
GSQLPRunnerExecOptions *eopt = data;
guint period;
gchar mess[GSQL_MESSAGE_LEN];
guint c, i, p;
if (eopt->suspended)
{
GSQL_DEBUG ("Suspended period: %d", eopt->suspended_period);
period = eopt->suspended_period;
while (period)
{
if (!eopt->run_state)
{
GSQL_DEBUG ("stop from suspend");
g_snprintf (mess, GSQL_MESSAGE_LEN, "Periodical execution stopped on suspend state [thread %d]",
eopt->thread_id);
gsql_message_add (eopt->workspace, GSQL_MESSAGE_NOTICE, mess);
g_thread_exit (NULL);
}
period--;
sleep(1);
}
}
c = eopt->cycles;
i = 0;
while (c)
{
gsql_editor_run_sql (eopt->editor);
GSQL_DEBUG ("c = %d",c);
i++;
p = eopt->period;
while (p)
{
if (!eopt->run_state)
{
GSQL_DEBUG ("stop from run");
g_snprintf (mess, GSQL_MESSAGE_LEN, "Periodical execution stopped [thread %d]"
"\n\truns total: %d",
eopt->thread_id, i);
gsql_message_add (eopt->workspace, GSQL_MESSAGE_NOTICE, mess);
g_thread_exit (NULL);
}
sleep(1);
p--;
}
if (eopt->cycles_limit)
c--;
}
g_snprintf (mess, GSQL_MESSAGE_LEN, "Periodical execution completed [thread %d]"
"\n\truns total: %d",
eopt->thread_id, i);
gsql_message_add (eopt->workspace, GSQL_MESSAGE_NOTICE, mess);
eopt->run_state = FALSE;
gtk_toggle_action_set_active (eopt->action, FALSE);
g_thread_exit (NULL);
}
