gboolean
pause_game_cb (GtkAction * action, gpointer data)
{
if (paused) {
paused = 0;
dummy_id = g_timeout_add (500, (GSourceFunc) new_game_2_cb, NULL);
} else {
if (main_id || restart_id || dummy_id) {
paused = 1;
if (main_id) {
g_source_remove (main_id);
main_id = 0;
}
if (keyboard_id) {
g_signal_handler_disconnect (G_OBJECT (stage), keyboard_id);
keyboard_id = 0;
}
if (add_bonus_id) {
g_source_remove (add_bonus_id);
add_bonus_id = 0;
}
}
}
gtk_action_set_sensitive (pause_action, !paused);
gtk_action_set_sensitive (resume_action, paused);
gtk_action_set_visible (pause_action, !paused);
gtk_action_set_visible (resume_action, paused);
return TRUE;
}
static void
update_discoverability (GtkTreeIter *iter)
{
gboolean discoverable;
GObject *object;
/* Avoid loops from changing the UI */
if (discover_lock != FALSE)
return;
discover_lock = TRUE;
object = gtk_builder_get_object (xml, "discoverable");
if (iter == NULL) {
discover_lock = FALSE;
gtk_action_set_visible (GTK_ACTION (object), FALSE);
return;
}
gtk_tree_model_get (devices_model, iter,
BLUETOOTH_COLUMN_DISCOVERABLE, &discoverable,
-1);
gtk_action_set_visible (GTK_ACTION (object), TRUE);
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (object), discoverable);
discover_lock = FALSE;
}
void update_3270_toggle_action(int toggle, int value)
{
const gchar *name = get_toggle_name(toggle);
GtkAction *action;
gchar *ptr;
ptr = g_strconcat("Toggle",name,NULL);
action = get_action_by_name(ptr);
g_free(ptr);
// Update toggle buttons
if(action)
gtk_toggle_action_set_active((GtkToggleAction *) action,value);
// Update toolbar items
ptr = g_strconcat("ToggleReset",name,NULL);
action = get_action_by_name(ptr);
g_free(ptr);
if(action)
gtk_action_set_visible(action,value ? TRUE : FALSE);
ptr = g_strconcat("ToggleSet",name,NULL);
action = get_action_by_name(ptr);
g_free(ptr);
if(action)
gtk_action_set_visible(action,value ? FALSE : TRUE);
}
void
egg_editable_toolbar_set_selected (EggEditableToolbar *etoolbar,
GtkWidget *widget)
{
GtkWidget *toolbar, *toolitem;
gboolean editable;
etoolbar->priv->selected = widget;
toolbar = (widget != NULL) ? gtk_widget_get_ancestor (widget, GTK_TYPE_TOOLBAR) : NULL;
toolitem = (widget != NULL) ? gtk_widget_get_ancestor (widget, GTK_TYPE_TOOL_ITEM) : NULL;
if(toolbar != NULL)
{
gint tpos = get_toolbar_position (etoolbar, toolbar);
editable = ((egg_toolbars_model_get_flags (etoolbar->priv->model, tpos) & EGG_TB_MODEL_NOT_EDITABLE) == 0);
}
else
{
editable = FALSE;
}
gtk_action_set_visible (find_action (etoolbar, "RemoveToolbar"), (toolbar != NULL) && (etoolbar->priv->edit_mode > 0));
gtk_action_set_visible (find_action (etoolbar, "RemoveToolItem"), (toolitem != NULL) && editable);
gtk_action_set_visible (find_action (etoolbar, "MoveToolItem"), (toolitem != NULL) && editable);
}
static void
set_fullscreen_actions (gboolean is_fullscreen)
{
gtk_action_set_sensitive (leave_fullscreen_action, is_fullscreen);
gtk_action_set_visible (leave_fullscreen_action, is_fullscreen);
gtk_action_set_sensitive (fullscreen_action, !is_fullscreen);
gtk_action_set_visible (fullscreen_action, !is_fullscreen);
}
static gboolean
gimp_color_panel_button_press (GtkWidget *widget,
GdkEventButton *bevent)
{
if (gdk_event_triggers_context_menu ((GdkEvent *) bevent))
{
GimpColorButton *color_button;
GimpColorPanel *color_panel;
GtkUIManager *ui_manager;
GtkActionGroup *group;
GtkAction *action;
GimpRGB color;
color_button = GIMP_COLOR_BUTTON (widget);
color_panel = GIMP_COLOR_PANEL (widget);
ui_manager = GTK_UI_MANAGER (color_button->popup_menu);
group = gtk_ui_manager_get_action_groups (ui_manager)->data;
action = gtk_action_group_get_action (group,
"color-button-use-foreground");
gtk_action_set_visible (action, color_panel->context != NULL);
action = gtk_action_group_get_action (group,
"color-button-use-background");
gtk_action_set_visible (action, color_panel->context != NULL);
if (color_panel->context)
{
action = gtk_action_group_get_action (group,
"color-button-use-foreground");
gimp_context_get_foreground (color_panel->context, &color);
g_object_set (action, "color", &color, NULL);
action = gtk_action_group_get_action (group,
"color-button-use-background");
gimp_context_get_background (color_panel->context, &color);
g_object_set (action, "color", &color, NULL);
}
action = gtk_action_group_get_action (group, "color-button-use-black");
gimp_rgba_set (&color, 0.0, 0.0, 0.0, GIMP_OPACITY_OPAQUE);
g_object_set (action, "color", &color, NULL);
action = gtk_action_group_get_action (group, "color-button-use-white");
gimp_rgba_set (&color, 1.0, 1.0, 1.0, GIMP_OPACITY_OPAQUE);
g_object_set (action, "color", &color, NULL);
}
if (GTK_WIDGET_CLASS (parent_class)->button_press_event)
return GTK_WIDGET_CLASS (parent_class)->button_press_event (widget, bevent);
return FALSE;
}
/**
* gva_main_init:
*
* Initializes the main window.
*
* This function should be called once when the application starts.
**/
void
gva_main_init (void)
{
GSettings *settings;
gchar *text;
settings = gva_get_settings ();
gva_tree_view_init ();
gtk_box_pack_start (
GTK_BOX (GVA_WIDGET_MAIN_VBOX),
gva_ui_get_managed_widget ("/main-menu"),
FALSE, FALSE, 0);
gtk_box_reorder_child (
GTK_BOX (GVA_WIDGET_MAIN_VBOX),
gva_ui_get_managed_widget ("/main-menu"), 0);
gtk_widget_set_sensitive (
GVA_WIDGET_MAIN_MUTE_BUTTON,
gva_mame_supports_sound ());
g_settings_bind (
settings, GVA_SETTING_SOUND_MUTED,
GVA_WIDGET_MAIN_MUTE_BUTTON, "muted",
G_SETTINGS_BIND_DEFAULT);
gtk_window_move (
GTK_WINDOW (GVA_WIDGET_MAIN_WINDOW),
g_settings_get_int (settings, "window-x"),
g_settings_get_int (settings, "window-y"));
gtk_window_resize (
GTK_WINDOW (GVA_WIDGET_MAIN_WINDOW),
g_settings_get_int (settings, "window-width"),
g_settings_get_int (settings, "window-height"));
if (g_settings_get_boolean (settings, "window-maximized"))
gtk_window_maximize (GTK_WINDOW (GVA_WIDGET_MAIN_WINDOW));
/* Initialize the search entry. */
text = gva_main_get_last_search_text ();
gtk_entry_set_text (GTK_ENTRY (GVA_WIDGET_MAIN_SEARCH_ENTRY), text);
g_free (text);
gva_ui_lock ();
gtk_action_set_visible (GVA_ACTION_INSERT_FAVORITE, FALSE);
gtk_action_set_visible (GVA_ACTION_REMOVE_FAVORITE, FALSE);
gtk_window_present (GTK_WINDOW (GVA_WIDGET_MAIN_WINDOW));
}
static void
killswitch_state_changed (GObject *gobject,
GParamSpec *pspec,
gpointer user_data)
{
GObject *object;
BluetoothApplet *applet = BLUETOOTH_APPLET (gobject);
BluetoothKillswitchState state = bluetooth_applet_get_killswitch_state (applet);
gboolean sensitive = TRUE;
gboolean bstate = FALSE;
const char *label, *status_label;
if (state == BLUETOOTH_KILLSWITCH_STATE_NO_ADAPTER) {
object = gtk_builder_get_object (xml, "bluetooth-applet-popup");
gtk_menu_popdown (GTK_MENU (object));
update_icon_visibility ();
return;
}
if (state == BLUETOOTH_KILLSWITCH_STATE_SOFT_BLOCKED) {
label = N_("Turn on Bluetooth");
status_label = N_("Bluetooth: Off");
bstate = FALSE;
} else if (state == BLUETOOTH_KILLSWITCH_STATE_UNBLOCKED) {
label = N_("Turn off Bluetooth");
status_label = N_("Bluetooth: On");
bstate = TRUE;
} else if (state == BLUETOOTH_KILLSWITCH_STATE_HARD_BLOCKED) {
sensitive = FALSE;
label = NULL;
status_label = N_("Bluetooth: Disabled");
} else {
g_assert_not_reached ();
}
object = gtk_builder_get_object (xml, "killswitch-label");
gtk_action_set_label (GTK_ACTION (object), _(status_label));
gtk_action_set_visible (GTK_ACTION (object), TRUE);
object = gtk_builder_get_object (xml, "killswitch");
gtk_action_set_visible (GTK_ACTION (object), sensitive);
gtk_action_set_label (GTK_ACTION (object), _(label));
if (sensitive != FALSE) {
gtk_action_set_label (GTK_ACTION (object), _(label));
g_object_set_data (object, "bt-active", GINT_TO_POINTER (bstate));
}
object = gtk_builder_get_object (xml, "bluetooth-applet-ui-manager");
gtk_ui_manager_ensure_update (GTK_UI_MANAGER (object));
update_icon_visibility ();
}
static void
update_mmp_entries_cb (EShellView *shell_view,
gpointer user_data)
{
EShellWindow *shell_window;
GtkActionGroup *action_group;
gboolean visible;
gchar *full_name = NULL, *uri = NULL;
guint n_selected = 0;
g_return_if_fail (E_IS_SHELL_VIEW (shell_view));
shell_window = e_shell_view_get_shell_window (shell_view);
action_group = e_shell_window_get_action_group (shell_window, "mail");
visible = is_in_gw_account (shell_view, NULL, &full_name);
if (visible) {
EShellContent *shell_content;
EMailReader *reader;
GPtrArray *uids;
shell_content = e_shell_view_get_shell_content (shell_view);
reader = E_MAIL_READER (shell_content);
uids = e_mail_reader_get_selected_uids (reader);
if (uids)
n_selected = uids->len;
em_utils_uids_free (uids);
visible = n_selected > 0;
}
visible_actions (action_group, visible, mmp_entries, G_N_ELEMENTS (mmp_entries));
if (visible) {
GtkAction *action;
gboolean is_sent_items_folder = full_name && g_ascii_strncasecmp (full_name, "Sent Items", 10) == 0;
action = gtk_action_group_get_action (action_group, "gw-track-message-status");
g_return_if_fail (action != NULL);
gtk_action_set_visible (action, is_sent_items_folder && n_selected == 1);
action = gtk_action_group_get_action (action_group, "gw-retract-mail");
g_return_if_fail (action != NULL);
gtk_action_set_visible (action, is_sent_items_folder && n_selected == 1);
}
g_free (full_name);
g_free (uri);
}
int
Tetris::gameNew(GtkAction *action, void *d)
{
Tetris *t = (Tetris*) d;
if (t->timeoutId)
{
g_source_remove(t->timeoutId);
t->timeoutId = 0;
/* Catch the case where we started a new game without
* finishing the old one. */
if ((t->scoreFrame->getScore() > 0) && t->inPlay)
t->high_scores->add (t->scoreFrame->getScore());
}
t->inPlay = true;
int level = t->cmdlineLevel ? t->cmdlineLevel : t->startingLevel;
t->fastFall = false;
t->scoreFrame->setLevel(level);
t->scoreFrame->setStartingLevel(level);
t->field->setUseTarget (t->useTarget);
t->generateTimer (level);
t->field->emptyField(t->line_fill_height,t->line_fill_prob);
t->scoreFrame->resetScore();
t->paused = false;
t->field->generateFallingBlock();
t->field->redraw();
t->preview->previewBlock(blocknr_next, rot_next, color_next);
gtk_widget_queue_draw(t->preview->getWidget());
gtk_action_set_visible(t->pause_action, TRUE);
gtk_action_set_visible(t->resume_action, FALSE);
gtk_action_set_sensitive(t->pause_action, TRUE);
gtk_action_set_sensitive(t->end_game_action, TRUE);
gtk_action_set_sensitive(t->preferences_action, FALSE);
t->field->hidePauseMessage();
t->field->hideGameOverMessage();
games_sound_play ("gnometris");
return TRUE;
}
static void
idol_disc_recorder_file_closed (IdolObject *idol,
IdolDiscRecorderPlugin *pi)
{
GtkAction *action;
action = gtk_action_group_get_action (pi->action_group, "VideoBurnToDisc");
gtk_action_set_visible (action, FALSE);
action = gtk_action_group_get_action (pi->action_group, "VideoDVDCopy");
gtk_action_set_visible (action, FALSE);
action = gtk_action_group_get_action (pi->action_group, "VideoVCDCopy");
gtk_action_set_visible (action, FALSE);
}
static void
xplayer_disc_recorder_file_closed (XplayerObject *xplayer,
XplayerDiscRecorderPlugin *pi)
{
GtkAction *action;
action = gtk_action_group_get_action (pi->priv->action_group, "VideoBurnToDisc");
gtk_action_set_visible (action, FALSE);
action = gtk_action_group_get_action (pi->priv->action_group, "VideoDVDCopy");
gtk_action_set_visible (action, FALSE);
action = gtk_action_group_get_action (pi->priv->action_group, "VideoVCDCopy");
gtk_action_set_visible (action, FALSE);
}
void
Tetris::togglePause()
{
paused = !paused;
if (paused)
field->showPauseMessage();
else
field->hidePauseMessage();
gtk_action_set_sensitive (pause_action, !paused);
gtk_action_set_sensitive (resume_action, paused);
gtk_action_set_visible (pause_action, !paused);
gtk_action_set_visible (resume_action, paused);
}
static GtkWidget *create_popupmenu(void)
{
GObject *object;
GError *error = NULL;
xml = gtk_builder_new ();
if (gtk_builder_add_from_file (xml, "popup-menu.ui", &error) == 0) {
if (error->domain == GTK_BUILDER_ERROR) {
g_warning ("Failed to load popup-menu.ui: %s", error->message);
g_error_free (error);
return NULL;
}
g_error_free (error);
error = NULL;
if (gtk_builder_add_from_file (xml, PKGDATADIR "/popup-menu.ui", &error) == 0) {
g_warning ("Failed to load popup-menu.ui: %s", error->message);
g_error_free (error);
return NULL;
}
}
gtk_builder_connect_signals (xml, NULL);
if (bluetooth_applet_get_killswitch_state (applet) != BLUETOOTH_KILLSWITCH_STATE_NO_ADAPTER) {
GObject *object;
object = gtk_builder_get_object (xml, "killswitch-label");
gtk_action_set_visible (GTK_ACTION (object), TRUE);
}
if (option_debug != FALSE) {
GObject *object;
object = gtk_builder_get_object (xml, "quit");
gtk_action_set_visible (GTK_ACTION (object), TRUE);
}
object = gtk_builder_get_object (xml, "bluetooth-applet-ui-manager");
devices_action_group = gtk_action_group_new ("devices-action-group");
gtk_ui_manager_insert_action_group (GTK_UI_MANAGER (object),
devices_action_group, -1);
action_set_bold (GTK_UI_MANAGER (object),
GTK_ACTION (gtk_builder_get_object (xml, "devices-label")),
"/bluetooth-applet-popup/devices-label");
return GTK_WIDGET (gtk_builder_get_object (xml, "bluetooth-applet-popup"));
}
static void
update_discoverability (GObject *gobject,
GParamSpec *pspec,
gpointer user_data)
{
BluetoothApplet *applet = BLUETOOTH_APPLET (gobject);
gboolean discoverable;
GObject *object;
/* Avoid loops from changing the UI */
if (discover_lock != FALSE)
return;
discover_lock = TRUE;
object = gtk_builder_get_object (xml, "discoverable");
discoverable = bluetooth_applet_get_discoverable (applet);
#ifndef HAVE_APP_INDICATOR
gtk_action_set_visible (GTK_ACTION (object), TRUE);
#else
gtk_action_set_sensitive (GTK_TOGGLE_ACTION (object), TRUE);
#endif
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (object), discoverable);
discover_lock = FALSE;
}
static gboolean accessx_status_applet_fill(MatePanelApplet* applet)
{
AccessxStatusApplet* sapplet;
AtkObject* atk_object;
GtkActionGroup* action_group;
gchar* ui_path;
gboolean was_realized = FALSE;
sapplet = create_applet(applet);
if (!gtk_widget_get_realized(sapplet->box))
{
g_signal_connect_after(G_OBJECT(sapplet->box), "realize", G_CALLBACK(accessx_status_applet_realize), sapplet);
}
else
{
accessx_status_applet_initialize(sapplet);
was_realized = TRUE;
}
g_object_connect(sapplet->applet,
"signal::destroy", accessx_status_applet_destroy, sapplet,
"signal::change_orient", accessx_status_applet_reorient, sapplet,
"signal::change_size", accessx_status_applet_resize, sapplet,
NULL);
g_signal_connect(sapplet->applet, "button_press_event", G_CALLBACK(button_press_cb), sapplet);
g_signal_connect(sapplet->applet, "key_press_event", G_CALLBACK(key_press_cb), sapplet);
action_group = gtk_action_group_new("Accessx Applet Actions");
gtk_action_group_set_translation_domain(action_group, GETTEXT_PACKAGE);
gtk_action_group_add_actions(action_group, accessx_status_applet_menu_actions, G_N_ELEMENTS(accessx_status_applet_menu_actions), sapplet);
ui_path = g_build_filename(ACCESSX_MENU_UI_DIR, "accessx-status-applet-menu.xml", NULL);
mate_panel_applet_setup_menu_from_file(sapplet->applet, ui_path, action_group);
g_free(ui_path);
if (mate_panel_applet_get_locked_down(sapplet->applet))
{
GtkAction* action = gtk_action_group_get_action(action_group, "Dialog");
gtk_action_set_visible(action, FALSE);
}
g_object_unref(action_group);
gtk_widget_set_tooltip_text(GTK_WIDGET(sapplet->applet), _("Keyboard Accessibility Status"));
atk_object = gtk_widget_get_accessible(GTK_WIDGET(sapplet->applet));
atk_object_set_name(atk_object, _("AccessX Status"));
atk_object_set_description(atk_object, _("Displays current state of keyboard accessibility features"));
gtk_widget_show_all(GTK_WIDGET(sapplet->applet));
if (was_realized)
{
accessx_status_applet_reset(sapplet);
}
mate_panel_applet_set_background_widget (sapplet->applet, GTK_WIDGET (sapplet->applet));
return TRUE;
}
static void
network_gui_update (void)
{
#ifdef GGZ_CLIENT
if (ggz_network_mode) {
gtk_widget_show (chat);
} else {
gtk_widget_hide (chat);
}
gtk_action_set_visible (new_game_action, !ggz_network_mode);
gtk_action_set_visible (player_list_action, ggz_network_mode);
gtk_container_check_resize (GTK_CONTAINER (window));
#endif
}
static gboolean
geyes_applet_fill (MatePanelApplet *applet)
{
EyesApplet *eyes_applet;
GtkActionGroup *action_group;
gchar *ui_path;
g_set_application_name (_("Eyes"));
gtk_window_set_default_icon_name ("mate-eyes-applet");
mate_panel_applet_set_flags (applet, MATE_PANEL_APPLET_EXPAND_MINOR);
mate_panel_applet_set_background_widget (applet, GTK_WIDGET (applet));
eyes_applet = create_eyes (applet);
eyes_applet->timeout_id = g_timeout_add (
UPDATE_TIMEOUT, (GSourceFunc) timer_cb, eyes_applet);
action_group = gtk_action_group_new ("Geyes Applet Actions");
gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
gtk_action_group_add_actions (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);
mate_panel_applet_setup_menu_from_file (eyes_applet->applet,
ui_path, action_group);
g_free (ui_path);
if (mate_panel_applet_get_locked_down (eyes_applet->applet)) {
GtkAction *action;
action = gtk_action_group_get_action (action_group, "Props");
gtk_action_set_visible (action, FALSE);
}
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,
"dispose",
G_CALLBACK (dispose_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;
}
void
gnac_ui_utils_set_action_visible(GtkBuilder *builder,
const gchar *action_name,
gboolean visible)
{
GtkAction *action = gnac_ui_utils_get_action(builder, action_name);
if (GTK_IS_ACTION(action)) gtk_action_set_visible(action, visible);
}
static void
view_terminal_tab_remove_cb (GtkNotebook *notebook,
GtkWidget *child,
GiggleView *view)
{
if (0 == gtk_notebook_get_n_pages (notebook))
gtk_action_set_visible (giggle_view_get_action (view), FALSE);
}
LOCAL_EXTERN void gui_toogle_set_visible(enum GUI_TOGGLE id, gboolean visible)
{
gchar *name = g_strconcat("Toggle",gui_toggle_info[id].name,NULL);
GtkAction *action = get_action_by_name(name);
if(action)
gtk_action_set_visible(action,visible);
g_free(name);
}
static void
mail_attachment_bar_update_status (EMailAttachmentBar *bar)
{
EAttachmentView *view;
EAttachmentStore *store;
GtkActivatable *activatable;
GtkAction *action;
GtkLabel *label;
gint num_attachments;
guint64 total_size;
gchar *display_size;
gchar *markup;
view = E_ATTACHMENT_VIEW (bar);
store = e_attachment_view_get_store (view);
label = GTK_LABEL (bar->priv->status_label);
num_attachments = e_attachment_store_get_num_attachments (store);
total_size = e_attachment_store_get_total_size (store);
display_size = g_format_size_for_display (total_size);
if (total_size > 0)
markup = g_strdup_printf (
"<b>%d</b> %s (%s)", num_attachments, ngettext (
"Attachment", "Attachments", num_attachments),
display_size);
else
markup = g_strdup_printf (
"<b>%d</b> %s", num_attachments, ngettext (
"Attachment", "Attachments", num_attachments));
gtk_label_set_markup (label, markup);
g_free (markup);
activatable = GTK_ACTIVATABLE (bar->priv->save_all_button);
action = gtk_activatable_get_related_action (activatable);
gtk_action_set_visible (action, (num_attachments > 1));
activatable = GTK_ACTIVATABLE (bar->priv->save_one_button);
action = gtk_activatable_get_related_action (activatable);
gtk_action_set_visible (action, (num_attachments == 1));
g_free (display_size);
}
static gboolean
button_press_event_cb (WebKitWebView *view,
GdkEventButton *event,
EphyGreasemonkeyExtension *extension)
{
/*
* Set whether or not the action is visible before we display the
* context popup menu
*/
WindowData *window_data;
EphyWindow *window;
GtkAction *action;
WebKitHitTestResult *hit_test;
char *uri;
guint context;
gboolean show_install;
if (event->button != 3 || event->type != GDK_BUTTON_PRESS)
return FALSE;
hit_test = webkit_web_view_get_hit_test_result (view, event);
g_object_get (hit_test, "context", &context, NULL);
if (!(context & WEBKIT_HIT_TEST_RESULT_CONTEXT_LINK))
return FALSE;
g_object_get (hit_test, "link-uri", &uri, NULL);
show_install = g_str_has_suffix (uri, ".user.js");
window = EPHY_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (view)));
g_return_val_if_fail (window != NULL, FALSE);
window_data = (WindowData *) g_object_get_data (G_OBJECT (window),
WINDOW_DATA_KEY);
g_return_val_if_fail (window_data != NULL, FALSE);
action = gtk_action_group_get_action (window_data->action_group,
ACTION_NAME);
g_return_val_if_fail (action != NULL, FALSE);
if (show_install == TRUE)
{
g_free (window_data->last_clicked_url);
window_data->last_clicked_url = g_strdup (uri);
}
gtk_action_set_visible (action, show_install);
g_free (uri);
g_object_unref (hit_test);
return FALSE;
}
GtkAction* PopupMenuGtk::createGtkActionForMenuItem(int itemIndex)
{
GOwnPtr<char> actionName(g_strdup_printf("popup-menu-action-%d", itemIndex));
GtkAction* action = gtk_action_new(actionName.get(), client()->itemText(itemIndex).utf8().data(), client()->itemToolTip(itemIndex).utf8().data(), 0);
g_object_set_data(G_OBJECT(action), "popup-menu-action-index", GINT_TO_POINTER(itemIndex));
g_signal_connect(action, "activate", G_CALLBACK(menuItemActivated), this);
// FIXME: Apply the PopupMenuStyle from client()->itemStyle(i)
gtk_action_set_visible(action, !client()->itemStyle(itemIndex).isDisplayNone());
gtk_action_set_sensitive(action, client()->itemIsEnabled(itemIndex));
return action;
}
void
nautilus_navigation_window_update_spatial_menu_item (NautilusNavigationWindow *window)
{
GtkAction *action;
g_assert (NAUTILUS_IS_NAVIGATION_WINDOW (window));
action = gtk_action_group_get_action (window->details->navigation_action_group,
NAUTILUS_ACTION_FOLDER_WINDOW);
gtk_action_set_visible (action,
!eel_preferences_get_boolean (NAUTILUS_PREFERENCES_ALWAYS_USE_BROWSER));
}
void on_menu_changed(gpointer instance, GVariant *parameters, gpointer user_data)
{
WorkraveApplet *applet = (WorkraveApplet *)user_data;
applet->inhibit++;
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;
}
GtkAction *action = gtk_action_group_get_action(applet->action_group, menu_data[index].action);
if (flags & MENU_ITEM_FLAG_SUBMENU_END ||
flags & MENU_ITEM_FLAG_SUBMENU_BEGIN)
{
continue;
}
visible[index] = TRUE;
if (GTK_IS_TOGGLE_ACTION(action))
{
GtkToggleAction *toggle = GTK_TOGGLE_ACTION(action);
gtk_toggle_action_set_active(toggle, flags & MENU_ITEM_FLAG_ACTIVE);
}
}
g_variant_iter_free (iter);
for (int i = 0; i < sizeof(menu_data)/sizeof(struct Menuitems); i++)
{
GtkAction *action = gtk_action_group_get_action(applet->action_group, menu_data[i].action);
gtk_action_set_visible(action, visible[i]);
}
applet->inhibit--;
}
static void
composer_actions_toolbar_option_toggled_cb (GtkToggleAction *toggle_action,
EMsgComposer *composer)
{
GtkAction *action;
action = GTK_ACTION (toggle_action);
/* Show the action only after the first time the option is used */
if (!gtk_action_get_visible (action) &&
gtk_toggle_action_get_active (toggle_action))
gtk_action_set_visible (action, TRUE);
}
void on_alive_changed(gpointer instance, gboolean alive, gpointer user_data)
{
WorkraveApplet *applet = (WorkraveApplet *)(user_data);
applet->alive = alive;
if (!alive)
{
for (int i = 0; i < sizeof(menu_data)/sizeof(struct Menuitems); i++)
{
GtkAction *action = gtk_action_group_get_action(applet->action_group, menu_data[i].action);
gtk_action_set_visible(action, menu_data[i].visible_when_not_running);
}
}
}
static void
gdm_smartcard_extension_ask_secret (GdmLoginExtension *login_extension,
const char *message)
{
GdmSmartcardExtension *extension = GDM_SMARTCARD_EXTENSION (login_extension);
gtk_widget_show (extension->priv->prompt_label);
gtk_label_set_text (GTK_LABEL (extension->priv->prompt_label), message);
gtk_entry_set_visibility (GTK_ENTRY (extension->priv->prompt_entry), FALSE);
gtk_entry_set_text (GTK_ENTRY (extension->priv->prompt_entry), "");
gtk_widget_show (extension->priv->prompt_entry);
gtk_widget_grab_focus (extension->priv->prompt_entry);
gtk_action_set_visible (extension->priv->login_action, TRUE);
gtk_action_set_sensitive (extension->priv->login_action, TRUE);
extension->priv->answer_pending = TRUE;
}
void
nautilus_window_initialize_menus_constructed (NautilusWindow *window)
{
GtkAction *action;
/* Don't call have_burn_uri() for the desktop window, as this is a very
* expensive operation during login (around 1 second) ---
* have_burn_uri() has to create a "burn:///" URI, which causes
* gnome-vfs to link in libmapping.so from nautilus-cd-burner.
*/
if (nautilus_window_has_menubar_and_statusbar (window) && !have_burn_uri ()) {
action = gtk_action_group_get_action (window->details->main_action_group, NAUTILUS_ACTION_GO_TO_BURN_CD);
gtk_action_set_visible (action, FALSE);
}
}
