GtkWidget *
hitori_create_interface (Hitori *hitori)
{
GtkBuilder *builder;
GtkStyleContext *style_context;
GtkCssProvider *css_provider;
const PangoFontDescription *font;
GAction *action;
builder = gtk_builder_new_from_resource ("/org/gnome/Hitori/ui/hitori.ui");
gtk_builder_set_translation_domain (builder, PACKAGE);
gtk_builder_connect_signals (builder, hitori);
/* Setup the main window */
hitori->window = GTK_WIDGET (gtk_builder_get_object (builder, "hitori_main_window"));
hitori->drawing_area = GTK_WIDGET (gtk_builder_get_object (builder, "hitori_drawing_area"));
hitori->timer_label = GTK_LABEL (gtk_builder_get_object (builder, "hitori_timer"));
g_object_unref (builder);
/* Set up actions */
g_action_map_add_action_entries (G_ACTION_MAP (hitori), app_entries, G_N_ELEMENTS (app_entries), hitori);
g_action_map_add_action_entries (G_ACTION_MAP (hitori->window), win_entries, G_N_ELEMENTS (win_entries), hitori);
action = g_settings_create_action (hitori->settings, "board-size");
g_action_map_add_action (G_ACTION_MAP (hitori), action);
g_signal_connect (G_OBJECT (action), "notify::state", (GCallback) board_size_change_cb, hitori);
g_object_unref (action);
hitori->undo_action = G_SIMPLE_ACTION (g_action_map_lookup_action (G_ACTION_MAP (hitori->window), "undo"));
hitori->redo_action = G_SIMPLE_ACTION (g_action_map_lookup_action (G_ACTION_MAP (hitori->window), "redo"));
hitori->hint_action = G_SIMPLE_ACTION (g_action_map_lookup_action (G_ACTION_MAP (hitori->window), "hint"));
/* Set up font descriptions for the drawing area */
style_context = gtk_widget_get_style_context (hitori->drawing_area);
gtk_style_context_get (style_context,
gtk_style_context_get_state (style_context),
GTK_STYLE_PROPERTY_FONT, &font, NULL);
hitori->normal_font_desc = pango_font_description_copy (font);
hitori->painted_font_desc = pango_font_description_copy (font);
/* Load CSS for the drawing area */
css_provider = gtk_css_provider_new ();
gtk_css_provider_load_from_resource (css_provider, "/org/gnome/Hitori/ui/hitori.css");
gtk_style_context_add_provider (style_context, GTK_STYLE_PROVIDER (css_provider),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
g_object_unref (css_provider);
/* Reset the timer */
hitori_reset_timer (hitori);
/* Disable undo/redo until a cell has been clicked. */
g_simple_action_set_enabled (hitori->undo_action, FALSE);
g_simple_action_set_enabled (hitori->redo_action, FALSE);
return hitori->window;
}
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);
}
static void
photos_preview_nav_buttons_update_visibility (PhotosPreviewNavButtons *self)
{
PhotosBaseItem *item;
PhotosBaseItem *next_item;
PhotosBaseItem *previous_item;
item = PHOTOS_BASE_ITEM (photos_base_manager_get_active_object (self->item_mngr));
if (self->old_mode == PHOTOS_WINDOW_MODE_NONE || item == NULL || !self->visible)
{
self->enable_prev = FALSE;
self->enable_next = FALSE;
goto out;
}
previous_item = photos_preview_nav_buttons_get_previous_item (self);
self->enable_prev = previous_item != NULL;
next_item = photos_preview_nav_buttons_get_next_item (self);
self->enable_next = next_item != NULL;
out:
if (self->visible_internal && self->enable_next)
photos_preview_nav_buttons_fade_in_button (self, self->next_widget);
else
photos_preview_nav_buttons_fade_out_button (self, self->next_widget);
if (self->visible_internal && self->enable_prev)
photos_preview_nav_buttons_fade_in_button (self, self->prev_widget);
else
photos_preview_nav_buttons_fade_out_button (self, self->prev_widget);
g_simple_action_set_enabled (G_SIMPLE_ACTION (self->load_next), self->enable_next);
g_simple_action_set_enabled (G_SIMPLE_ACTION (self->load_previous), self->enable_prev);
}
static void
update_ui (GeditSpellPlugin *plugin)
{
GeditSpellPluginPrivate *priv;
GeditView *view;
GAction *check_spell_action;
GAction *config_spell_action;
GAction *auto_spell_action;
gedit_debug (DEBUG_PLUGINS);
priv = plugin->priv;
view = gedit_window_get_active_view (priv->window);
check_spell_action = g_action_map_lookup_action (G_ACTION_MAP (priv->window),
"check-spell");
g_simple_action_set_enabled (G_SIMPLE_ACTION (check_spell_action),
(view != NULL) &&
gtk_text_view_get_editable (GTK_TEXT_VIEW (view)));
config_spell_action = g_action_map_lookup_action (G_ACTION_MAP (priv->window),
"config-spell");
g_simple_action_set_enabled (G_SIMPLE_ACTION (config_spell_action),
(view != NULL) &&
gtk_text_view_get_editable (GTK_TEXT_VIEW (view)));
auto_spell_action = g_action_map_lookup_action (G_ACTION_MAP (priv->window),
"auto-spell");
g_simple_action_set_enabled (G_SIMPLE_ACTION (auto_spell_action),
(view != NULL) &&
gtk_text_view_get_editable (GTK_TEXT_VIEW (view)));
if (view != NULL)
{
GeditDocument *doc;
GeditTab *tab;
GeditTabState state;
gboolean autospell;
doc = GEDIT_DOCUMENT (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)));
tab = gedit_window_get_active_tab (priv->window);
state = gedit_tab_get_state (tab);
autospell = (doc != NULL &&
gedit_automatic_spell_checker_get_from_document (doc) != NULL);
/* If the document is loading we can't get the metadata so we
endup with an useless speller */
if (state == GEDIT_TAB_STATE_NORMAL)
{
g_action_change_state (auto_spell_action, g_variant_new_boolean (autospell));
}
g_simple_action_set_enabled (G_SIMPLE_ACTION (check_spell_action),
gtk_text_buffer_get_char_count (GTK_TEXT_BUFFER (doc)) > 0);
}
}
static void
set_menu_items_state (TotemDiscRecorderPlugin *pi,
gboolean dvd,
gboolean dvd_copy,
gboolean vcd_copy)
{
g_simple_action_set_enabled (G_SIMPLE_ACTION (pi->priv->dvd_action), dvd);
g_simple_action_set_enabled (G_SIMPLE_ACTION (pi->priv->copy_action), dvd_copy);
g_simple_action_set_enabled (G_SIMPLE_ACTION (pi->priv->copy_vcd_action), vcd_copy);
}
static void
update_replace_actions_sensitivity (IdeEditorFrame *self)
{
GtkSourceSearchContext *search_context;
GtkSourceSearchSettings *search_settings;
GtkTextBuffer *buffer;
GtkTextIter start;
GtkTextIter end;
const gchar *search_text;
const gchar *replace_text;
gint pos;
gint count;
gboolean enable_replace;
gboolean enable_replace_all;
gboolean replace_regex_valid;
g_autoptr(GError) regex_error = NULL;
g_autoptr(GError) replace_regex_error = NULL;
GActionGroup *group;
GAction *replace_action;
GAction *replace_all_action;
g_assert (IDE_IS_EDITOR_FRAME (self));
search_context = ide_source_view_get_search_context (self->source_view);
search_settings = gtk_source_search_context_get_settings (search_context);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (self->source_view));
gtk_text_buffer_get_selection_bounds (GTK_TEXT_BUFFER (buffer), &start, &end);
replace_text = gtk_entry_get_text (GTK_ENTRY (self->replace_entry));
/* Gather enough info to determine if Replace or Replace All would make sense */
search_text = gtk_entry_get_text (GTK_ENTRY (self->search_entry));
pos = gtk_source_search_context_get_occurrence_position (search_context, &start, &end);
count = gtk_source_search_context_get_occurrences_count (search_context);
regex_error = gtk_source_search_context_get_regex_error (search_context);
replace_regex_valid = gtk_source_search_settings_get_regex_enabled (search_settings) ?
g_regex_check_replacement (replace_text, NULL, &replace_regex_error) :
TRUE;
enable_replace = (!ide_str_empty0 (search_text) &&
regex_error == NULL &&
replace_regex_valid &&
pos > 0);
enable_replace_all = (!ide_str_empty0 (search_text) &&
regex_error == NULL &&
replace_regex_valid &&
count > 0);
group = gtk_widget_get_action_group (GTK_WIDGET (self->search_frame), "search-entry");
replace_action = g_action_map_lookup_action (G_ACTION_MAP (group), "replace");
replace_all_action = g_action_map_lookup_action (G_ACTION_MAP (group), "replace-all");
g_simple_action_set_enabled (G_SIMPLE_ACTION (replace_action), enable_replace);
g_simple_action_set_enabled (G_SIMPLE_ACTION (replace_all_action), enable_replace_all);
}
static void rotation_plugin_cb_file_closed (RotationPlugin* self) {
BaconVideoWidget* _tmp0_ = NULL;
GSimpleAction* _tmp1_ = NULL;
GSimpleAction* _tmp2_ = NULL;
g_return_if_fail (self != NULL);
_tmp0_ = self->priv->bvw;
bacon_video_widget_set_rotation (_tmp0_, BVW_ROTATION_R_ZERO);
_tmp1_ = self->priv->rotate_right_action;
g_simple_action_set_enabled (_tmp1_, FALSE);
_tmp2_ = self->priv->rotate_left_action;
g_simple_action_set_enabled (_tmp2_, FALSE);
}
static void
enable_win_actions (PtWindow *win,
gboolean state)
{
GAction *action;
action = g_action_map_lookup_action (G_ACTION_MAP (win), "copy");
g_simple_action_set_enabled (G_SIMPLE_ACTION (action), state);
action = g_action_map_lookup_action (G_ACTION_MAP (win), "goto");
g_simple_action_set_enabled (G_SIMPLE_ACTION (action), state);
}
static void rotation_plugin_cb_file_opened (RotationPlugin* self, const gchar* mrl) {
GSimpleAction* _tmp0_ = NULL;
GSimpleAction* _tmp1_ = NULL;
const gchar* _tmp2_ = NULL;
g_return_if_fail (self != NULL);
g_return_if_fail (mrl != NULL);
_tmp0_ = self->priv->rotate_right_action;
g_simple_action_set_enabled (_tmp0_, TRUE);
_tmp1_ = self->priv->rotate_left_action;
g_simple_action_set_enabled (_tmp1_, TRUE);
_tmp2_ = mrl;
rotation_plugin_try_restore_state (self, _tmp2_, ___lambda7__gasync_ready_callback, g_object_ref (self));
}
static void
enabled_cell_toggled (GtkCellRendererToggle *cell,
const gchar *path_str,
GtkTreeModel *model)
{
GActionGroup *group;
GAction *action;
gchar *name;
GtkTreePath *path;
GtkTreeIter iter;
gboolean enabled;
group = g_object_get_data (G_OBJECT (model), "group");
path = gtk_tree_path_new_from_string (path_str);
gtk_tree_model_get_iter (model, &iter, path);
gtk_tree_model_get (model, &iter, 0, &name, -1);
enabled = g_action_group_get_action_enabled (group, name);
action = g_action_map_lookup_action (G_ACTION_MAP (group), name);
g_simple_action_set_enabled (G_SIMPLE_ACTION (action), !enabled);
gtk_tree_model_row_changed (model, path, &iter);
g_free (name);
gtk_tree_path_free (path);
}
void
ide_application_actions_update (IdeApplication *self)
{
GList *windows;
GAction *action;
gboolean enabled;
g_assert (IDE_IS_APPLICATION (self));
/*
* We only enable the preferences action if we have a workbench open
* that is past the greeter.
*/
action = g_action_map_lookup_action (G_ACTION_MAP (self), "preferences");
enabled = FALSE;
for (windows = gtk_application_get_windows (GTK_APPLICATION (self));
windows != NULL;
windows = windows->next)
{
GtkWindow *window = windows->data;
if (IDE_IS_WORKBENCH (window) &&
!ide_str_equal0 ("greeter",
ide_workbench_get_visible_perspective_name (IDE_WORKBENCH (window))))
{
enabled = TRUE;
break;
}
}
g_simple_action_set_enabled (G_SIMPLE_ACTION (action), enabled);
}
void on_menu_changed(gpointer instance, GVariant *parameters, gpointer user_data)
{
WorkraveApplet *applet = WORKRAVE_APPLET(user_data);
GVariantIter *iter;
g_variant_get (parameters, "(a(sii))", &iter);
char *text;
int id;
int flags;
gboolean visible[sizeof(menu_data)/sizeof(struct Menuitems)];
for (int i = 0; i < sizeof(menu_data)/sizeof(struct Menuitems); i++)
{
visible[i] = menu_data[i].visible_when_not_running;
}
while (g_variant_iter_loop(iter, "(sii)", &text, &id, &flags))
{
int index = lookup_menu_index_by_id((enum MenuCommand)id);
if (index == -1)
{
continue;
}
GAction *action = g_action_map_lookup_action(G_ACTION_MAP(applet->priv->action_group), menu_data[index].action);
if (flags & MENU_ITEM_FLAG_SUBMENU_END ||
flags & MENU_ITEM_FLAG_SUBMENU_BEGIN)
{
continue;
}
visible[index] = TRUE;
if (g_action_get_state_type(G_ACTION(action)) != NULL)
{
if (menu_data[index].state == NULL)
{
g_simple_action_set_state(G_SIMPLE_ACTION(action), g_variant_new_boolean(flags & MENU_ITEM_FLAG_ACTIVE));
}
else
{
if (flags & MENU_ITEM_FLAG_ACTIVE)
{
g_simple_action_set_state(G_SIMPLE_ACTION(action), g_variant_new_string(menu_data[index].state));
}
}
}
}
g_variant_iter_free (iter);
for (int i = 0; i < sizeof(menu_data)/sizeof(struct Menuitems); i++)
{
GAction *action = g_action_map_lookup_action(G_ACTION_MAP(applet->priv->action_group), menu_data[i].action);
g_simple_action_set_enabled(G_SIMPLE_ACTION(action), visible[i]);
}
}
static void
ide_editor_frame__search_populate_popup (IdeEditorFrame *self,
GtkWidget *popup,
GdTaggedEntry *entry)
{
g_assert (IDE_IS_EDITOR_FRAME (self));
g_assert (GTK_IS_WIDGET (popup));
g_assert (GD_IS_TAGGED_ENTRY (entry));
if (GTK_IS_MENU_SHELL (popup))
{
GMenu *menu;
GActionGroup *group;
GAction *action;
GtkEntryBuffer *buffer;
GtkClipboard *clipboard;
gboolean clipboard_contains_text;
gboolean entry_has_selection;
group = gtk_widget_get_action_group (GTK_WIDGET (self->search_frame), "search-entry");
menu = ide_application_get_menu_by_id (IDE_APPLICATION_DEFAULT, "ide-editor-frame-search-menu");
gtk_menu_shell_bind_model (GTK_MENU_SHELL (popup), G_MENU_MODEL (menu), NULL, TRUE);
clipboard = gtk_widget_get_clipboard (GTK_WIDGET (entry), GDK_SELECTION_CLIPBOARD);
clipboard_contains_text = gtk_clipboard_wait_is_text_available (clipboard);
action = g_action_map_lookup_action (G_ACTION_MAP (group), "paste-clipboard");
g_simple_action_set_enabled (G_SIMPLE_ACTION (action), clipboard_contains_text);
entry_has_selection = gtk_editable_get_selection_bounds (GTK_EDITABLE (entry), NULL, NULL);
action = g_action_map_lookup_action (G_ACTION_MAP (group), "cut-clipboard");
g_simple_action_set_enabled (G_SIMPLE_ACTION (action), entry_has_selection);
action = g_action_map_lookup_action (G_ACTION_MAP (group), "copy-clipboard");
g_simple_action_set_enabled (G_SIMPLE_ACTION (action), entry_has_selection);
action = g_action_map_lookup_action (G_ACTION_MAP (group), "delete-selection");
g_simple_action_set_enabled (G_SIMPLE_ACTION (action), entry_has_selection);
action = g_action_map_lookup_action (G_ACTION_MAP (group), "select-all");
buffer = gtk_entry_get_buffer (GTK_ENTRY (self->search_entry));
g_simple_action_set_enabled (G_SIMPLE_ACTION (action), gtk_entry_buffer_get_length (buffer) > 0);
}
}
/*
* To stop the recursive search within directories or saving files
*/
void Action_Main_Stop_Button_Pressed (void)
{
GAction *action;
action = g_action_map_lookup_action (G_ACTION_MAP (MainWindow), "stop");
g_simple_action_set_enabled (G_SIMPLE_ACTION (action), FALSE);
Main_Stop_Button_Pressed = TRUE;
}
static void
photos_application_can_fullscreen_changed (PhotosApplication *self)
{
PhotosApplicationPrivate *priv = self->priv;
gboolean can_fullscreen;
can_fullscreen = photos_mode_controller_get_can_fullscreen (priv->mode_cntrlr);
g_simple_action_set_enabled (priv->fs_action, can_fullscreen);
}
static void
update_actions (RBMediaPlayerSource *source)
{
RBMediaPlayerSourcePrivate *priv = MEDIA_PLAYER_SOURCE_GET_PRIVATE (source);
RBSourceLoadStatus status;
gboolean selected;
g_object_get (source,
"load-status", &status,
"selected", &selected,
NULL);
if (selected) {
g_simple_action_set_enabled (G_SIMPLE_ACTION (priv->sync_action),
(status == RB_SOURCE_LOAD_STATUS_LOADED) && (priv->syncing == FALSE));
g_simple_action_set_enabled (G_SIMPLE_ACTION (priv->properties_action),
(status == RB_SOURCE_LOAD_STATUS_LOADED));
}
}
static void
g_simple_action_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GSimpleAction *simple = G_SIMPLE_ACTION (object);
switch (prop_id)
{
case PROP_NAME:
g_assert (simple->priv->name == NULL);
simple->priv->name = g_value_dup_string (value);
break;
case PROP_PARAMETER_TYPE:
g_assert (simple->priv->parameter_type == NULL);
simple->priv->parameter_type = g_value_dup_boxed (value);
break;
case PROP_ENABLED:
g_simple_action_set_enabled (simple, g_value_get_boolean (value));
break;
case PROP_STATE:
/* PROP_STATE is marked as G_PARAM_CONSTRUCT so we always get a
* call during object construction, even if it is NULL. We treat
* that first call differently, for a number of reasons.
*
* First, we don't want the value to be rejected by the
* possibly-overridden .set_state() function. Second, we don't
* want to be tripped by the assertions in g_simple_action_set_state()
* that would enforce the catch22 that we only provide a value of
* the same type as the existing value (when there is not yet an
* existing value).
*/
if (simple->priv->state_set)
g_simple_action_set_state (G_ACTION (simple),
g_value_get_variant (value));
else /* this is the special case */
{
/* only do it the first time. */
simple->priv->state_set = TRUE;
/* blindly set it. */
simple->priv->state = g_value_dup_variant (value);
}
break;
default:
g_assert_not_reached ();
}
}
/*
* GdauiDsnEditor class implementation
*/
static void
_changed_cb (GdauiDsnEditor *config)
{
gboolean can_save = FALSE;
can_save = gdaui_dsn_editor_has_been_changed (config);
GtkWindow *win;
win = gtk_application_get_active_window (GTK_APPLICATION (g_application_get_default ()));
GAction *action;
action = g_action_map_lookup_action (G_ACTION_MAP (win), "DSNReset");
g_simple_action_set_enabled (G_SIMPLE_ACTION (action), can_save);
}
void
update_sensitivity(GsmApplication *app)
{
const char * const selected_actions[] = { "send-signal-stop",
"send-signal-cont",
"send-signal-end",
"send-signal-kill",
"priority",
"memory-maps",
"open-files",
"process-properties" };
const char * const processes_actions[] = { "refresh",
"search",
"show-whose-processes",
"show-dependencies" };
size_t i;
gboolean processes_sensitivity, selected_sensitivity;
GAction *action;
processes_sensitivity = (strcmp (gtk_stack_get_visible_child_name (GTK_STACK (app->stack)), "processes") == 0);
selected_sensitivity = gtk_tree_selection_count_selected_rows (app->selection) > 0;
for (i = 0; i != G_N_ELEMENTS (processes_actions); ++i) {
action = g_action_map_lookup_action (G_ACTION_MAP (app->main_window),
processes_actions[i]);
g_simple_action_set_enabled (G_SIMPLE_ACTION (action),
processes_sensitivity);
}
for (i = 0; i != G_N_ELEMENTS (selected_actions); ++i) {
action = g_action_map_lookup_action (G_ACTION_MAP (app->main_window),
selected_actions[i]);
g_simple_action_set_enabled (G_SIMPLE_ACTION (action),
processes_sensitivity & selected_sensitivity);
}
gtk_revealer_set_reveal_child (GTK_REVEALER (app->proc_actionbar_revealer),
selected_sensitivity);
}
static void
redo_cb (GSimpleAction *action, GVariant *parameter, gpointer user_data)
{
HitoriApplication *self = HITORI_APPLICATION (user_data);
if (self->undo_stack->redo == NULL)
return;
self->undo_stack = self->undo_stack->redo;
switch (self->undo_stack->type) {
case UNDO_PAINT:
self->board[self->undo_stack->cell.x][self->undo_stack->cell.y].status ^= CELL_PAINTED;
break;
case UNDO_TAG1:
self->board[self->undo_stack->cell.x][self->undo_stack->cell.y].status ^= CELL_TAG1;
break;
case UNDO_TAG2:
self->board[self->undo_stack->cell.x][self->undo_stack->cell.y].status ^= CELL_TAG2;
break;
case UNDO_TAGS:
self->board[self->undo_stack->cell.x][self->undo_stack->cell.y].status ^= CELL_TAG1;
self->board[self->undo_stack->cell.x][self->undo_stack->cell.y].status ^= CELL_TAG2;
break;
case UNDO_NEW_GAME:
default:
/* This is just here to stop the compiler warning */
g_assert_not_reached ();
break;
}
g_simple_action_set_enabled (self->undo_action, TRUE);
if (self->undo_stack->redo == NULL)
g_simple_action_set_enabled (self->redo_action, FALSE);
/* The player can't possibly have won, but we need to update the error highlighting */
hitori_check_win (self);
/* Redraw */
gtk_widget_queue_draw (self->drawing_area);
}
static void
photos_preview_nav_buttons_update_visibility (PhotosPreviewNavButtons *self)
{
GtkTreeIter iter;
GtkTreeIter tmp;
GtkTreePath *current_path = NULL;
if (self->model == NULL
|| !gtk_tree_row_reference_valid (self->current_row)
|| !self->visible)
{
self->enable_prev = FALSE;
self->enable_next = FALSE;
goto out;
}
current_path = gtk_tree_row_reference_get_path (self->current_row);
gtk_tree_model_get_iter (self->model, &iter, current_path);
tmp = iter;
self->enable_prev = gtk_tree_model_iter_previous (self->model, &tmp);
tmp = iter;
self->enable_next = gtk_tree_model_iter_next (self->model, &tmp);
out:
if (self->visible_internal && self->enable_next)
photos_preview_nav_buttons_fade_in_button (self, self->next_widget);
else
photos_preview_nav_buttons_fade_out_button (self, self->next_widget);
if (self->visible_internal && self->enable_prev)
photos_preview_nav_buttons_fade_in_button (self, self->prev_widget);
else
photos_preview_nav_buttons_fade_out_button (self, self->prev_widget);
g_simple_action_set_enabled (G_SIMPLE_ACTION (self->load_next), self->enable_next);
g_simple_action_set_enabled (G_SIMPLE_ACTION (self->load_previous), self->enable_prev);
g_clear_pointer (¤t_path, (GDestroyNotify) gtk_tree_path_free);
}
static void
action_set_enabled (GActionGroup *group, const gchar *action_name, bool value)
{
g_assert (G_IS_ACTION_GROUP (group));
g_assert (G_IS_ACTION_MAP (group));
GAction *action = g_action_map_lookup_action (G_ACTION_MAP (group), action_name);
if (action) {
g_simple_action_set_enabled (G_SIMPLE_ACTION (action), value);
}
}
static void
update_app_menu_sensitivity (GApplication *application)
{
GVariant *state;
FrWindowListMode list_mode;
state = g_action_get_state (G_ACTION (GET_ACTION (PREF_LISTING_LIST_MODE)));
list_mode = _g_enum_type_get_value_by_nick (FR_TYPE_WINDOW_LIST_MODE, g_variant_get_string (state, NULL))->value;
g_variant_unref (state);
g_simple_action_set_enabled (GET_ACTION (PREF_UI_VIEW_SIDEBAR), list_mode == FR_WINDOW_LIST_MODE_AS_DIR);
}
static void
ide_editor_frame_actions_exit_search (GSimpleAction *action,
GVariant *state,
gpointer user_data)
{
IdeEditorFrame *self = user_data;
GtkTextBuffer *buffer;
GActionGroup *group;
GAction *replace_action;
GAction *replace_all_action;
g_assert (IDE_IS_EDITOR_FRAME (self));
/* stash the search string for later */
g_free (self->previous_search_string);
g_object_get (self->search_entry, "text", &self->previous_search_string, NULL);
/* disable the replace and replace all actions */
group = gtk_widget_get_action_group (GTK_WIDGET (self->search_frame), "search-entry");
replace_action = g_action_map_lookup_action (G_ACTION_MAP (group), "replace");
replace_all_action = g_action_map_lookup_action (G_ACTION_MAP (group), "replace-all");
g_simple_action_set_enabled (G_SIMPLE_ACTION (replace_action), FALSE);
g_simple_action_set_enabled (G_SIMPLE_ACTION (replace_all_action), FALSE);
/* clear the highlights in the source view */
ide_source_view_clear_search (self->source_view);
/* disable rubberbanding and ensure insert mark is on screen */
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (self->source_view));
ide_source_view_set_rubberband_search (self->source_view, FALSE);
ide_source_view_scroll_mark_onscreen (self->source_view,
gtk_text_buffer_get_insert (buffer),
TRUE,
0.5,
0.5);
/* finally we can focus the source view */
gtk_widget_grab_focus (GTK_WIDGET (self->source_view));
}
void on_alive_changed(gpointer instance, gboolean alive, gpointer user_data)
{
WorkraveApplet *applet = WORKRAVE_APPLET(user_data);
applet->priv->alive = alive;
if (!alive)
{
for (int i = 0; i < sizeof(menu_data)/sizeof(struct Menuitems); i++)
{
GAction *action = g_action_map_lookup_action(G_ACTION_MAP(applet->priv->action_group), menu_data[i].action);
g_simple_action_set_enabled(G_SIMPLE_ACTION(action), menu_data[i].visible_when_not_running);
}
}
}
static void
connection_status_changed_cb (G_GNUC_UNUSED TConnection *tcnc, GdaConnectionStatus status, QueryConsolePage *tconsole)
{
gboolean is_busy;
is_busy = (status == GDA_CONNECTION_STATUS_IDLE) ? FALSE : TRUE;
gtk_widget_set_sensitive (tconsole->priv->exec_button, !is_busy);
gtk_widget_set_sensitive (tconsole->priv->indent_button, !is_busy);
GAction *action;
action = customization_data_get_action (G_OBJECT (tconsole), "ExecuteQuery");
if (action)
g_simple_action_set_enabled (G_SIMPLE_ACTION (action), !is_busy);
}
static void
eog_reload_plugin_update_action_state (EogReloadPlugin *plugin)
{
GAction *action;
EogThumbView *thumbview;
gboolean enable = FALSE;
thumbview = EOG_THUMB_VIEW (eog_window_get_thumb_view (plugin->window));
if (G_LIKELY (thumbview))
{
enable = (eog_thumb_view_get_n_selected (thumbview) != 0);
}
action = g_action_map_lookup_action (G_ACTION_MAP (plugin->window),
EOG_RELOAD_PLUGIN_ACTION);
g_simple_action_set_enabled (G_SIMPLE_ACTION (action), enable);
}
static void
photos_application_window_mode_changed (PhotosApplication *self, PhotosWindowMode mode, PhotosWindowMode old_mode)
{
PhotosApplicationPrivate *priv = self->priv;
gboolean enable;
enable = (mode == PHOTOS_WINDOW_MODE_OVERVIEW
|| mode == PHOTOS_WINDOW_MODE_COLLECTIONS
|| mode == PHOTOS_WINDOW_MODE_FAVORITES);
g_simple_action_set_enabled (priv->sel_all_action, enable);
g_simple_action_set_enabled (priv->sel_none_action, enable);
enable = (mode == PHOTOS_WINDOW_MODE_PREVIEW);
g_simple_action_set_enabled (priv->gear_action, enable);
g_simple_action_set_enabled (priv->open_action, enable);
g_simple_action_set_enabled (priv->print_action, enable);
g_simple_action_set_enabled (priv->properties_action, enable);
g_simple_action_set_enabled (priv->set_bg_action, enable);
}
static void
totem_skipto_update_from_state (TotemObject *totem,
TotemSkiptoPlugin *plugin)
{
gint64 _time;
gboolean seekable;
TotemSkiptoPluginPrivate *priv = plugin->priv;
g_object_get (G_OBJECT (totem),
"stream-length", &_time,
"seekable", &seekable,
NULL);
if (priv->st != NULL) {
totem_skipto_update_range (priv->st, _time);
totem_skipto_set_seekable (priv->st, seekable);
}
/* Update the action's sensitivity */
g_simple_action_set_enabled (G_SIMPLE_ACTION (priv->action), seekable);
}
void
gb_editor_view_actions_update (GbEditorView *self)
{
GtkSourceLanguage *language;
const gchar *lang_id = NULL;
GActionGroup *group;
GAction *action;
gboolean enabled;
g_assert (GB_IS_EDITOR_VIEW (self));
group = gtk_widget_get_action_group (GTK_WIDGET (self), "view");
if (!G_IS_SIMPLE_ACTION_GROUP (group))
return;
/* update preview sensitivity */
language = gtk_source_buffer_get_language (GTK_SOURCE_BUFFER (self->document));
if (language)
lang_id = gtk_source_language_get_id (language);
enabled = ((g_strcmp0 (lang_id, "html") == 0) ||
(g_strcmp0 (lang_id, "markdown") == 0));
action = g_action_map_lookup_action (G_ACTION_MAP (group), "preview");
g_simple_action_set_enabled (G_SIMPLE_ACTION (action), enabled);
}
