static void
ide_workbench_notify_visible_child (IdeWorkbench *self,
GParamSpec *pspec,
GtkStack *stack)
{
IdePerspective *perspective;
g_assert (IDE_IS_WORKBENCH (self));
g_assert (GTK_IS_STACK (stack));
perspective = IDE_PERSPECTIVE (gtk_stack_get_visible_child (stack));
if (perspective != NULL)
{
GActionGroup *actions;
gchar *id;
id = ide_perspective_get_id (perspective);
gtk_stack_set_visible_child_name (self->titlebar_stack, id);
actions = ide_perspective_get_actions (perspective);
gtk_widget_insert_action_group (GTK_WIDGET (self), "perspective", actions);
g_clear_object (&actions);
g_free (id);
}
}
static void
gstyle_color_panel_actions_toggle_page (GSimpleAction *action,
GVariant *variant,
gpointer user_data)
{
GstyleColorPanel *self = (GstyleColorPanel *)user_data;
g_autoptr (GVariant) value = NULL;
g_autofree gchar *page_name = NULL;
const gchar *name;
gboolean state;
g_assert (GSTYLE_IS_COLOR_PANEL (self));
value = g_action_get_state (G_ACTION (action));
state = g_variant_get_boolean (value);
name = g_action_get_name(G_ACTION (action));
if (!g_str_has_prefix (name, "toggle-"))
return;
page_name = g_strdup (&name [7]);
g_simple_action_set_state (action, g_variant_new_boolean (!state));
if (!state)
{
_gstyle_color_panel_update_prefs_page (self, page_name);
gtk_stack_set_visible_child_name (self->prefs_stack, page_name);
}
gstyle_slidein_reveal_slide (GSTYLE_SLIDEIN (self->prefs_slidein),
!gstyle_slidein_get_revealed (GSTYLE_SLIDEIN (self->prefs_slidein)));
}
static void
progress_ui_handler_add_to_window (NemoProgressUIHandler *self,
NemoProgressInfo *info)
{
GtkWidget *progress;
progress = nemo_progress_info_widget_new (info);
NemoProgressInfoWidgetPriv *priv = NEMO_PROGRESS_INFO_WIDGET (progress)->priv;
progress_ui_handler_ensure_window (self);
if (!gtk_widget_get_visible (self->priv->progress_window))
gtk_window_present (GTK_WINDOW (self->priv->progress_window));
gboolean started = nemo_progress_info_get_is_started (info);
gtk_stack_set_visible_child_name (GTK_STACK (priv->stack), started ? "running" : "pending");
gtk_box_pack_start (GTK_BOX (self->priv->list), progress, FALSE, FALSE, 0);
gtk_widget_show (progress);
if (self->priv->active_infos == 1)
gtk_widget_hide (priv->separator);
nemo_progress_info_widget_reveal (NEMO_PROGRESS_INFO_WIDGET (progress));
InfoChangedData *payload = g_slice_new0 (InfoChangedData);
payload->handler = self;
payload->widget = NEMO_PROGRESS_INFO_WIDGET (progress);
g_signal_connect (info, "started", G_CALLBACK (on_info_started), payload);
g_signal_connect (info, "finished", G_CALLBACK (on_info_finished), payload);
ensure_first_separator_hidden (self);
}
void
gs_popular_tile_set_app (GsPopularTile *tile, GsApp *app)
{
g_return_if_fail (GS_IS_POPULAR_TILE (tile));
g_return_if_fail (GS_IS_APP (app) || app == NULL);
if (tile->app)
g_signal_handlers_disconnect_by_func (tile->app, app_state_changed, tile);
g_set_object (&tile->app, app);
if (!app)
return;
if (gs_app_get_rating (tile->app) >= 0) {
gtk_widget_set_visible (tile->stars, TRUE);
gs_star_widget_set_rating (GS_STAR_WIDGET (tile->stars),
gs_app_get_rating (tile->app));
} else {
gtk_widget_set_visible (tile->stars, FALSE);
}
gtk_stack_set_visible_child_name (GTK_STACK (tile->stack), "content");
g_signal_connect (tile->app, "notify::state",
G_CALLBACK (app_state_changed), tile);
app_state_changed (tile->app, NULL, tile);
/* perhaps set custom css */
gs_utils_widget_set_custom_css (app, GTK_WIDGET (tile),
"GnomeSoftware::PopularTile-css");
gs_image_set_from_pixbuf (GTK_IMAGE (tile->image), gs_app_get_pixbuf (tile->app));
gtk_label_set_label (GTK_LABEL (tile->label), gs_app_get_name (app));
}
static void
photos_view_container_set_error (PhotosViewContainer *self, const gchar *primary, const gchar *secondary)
{
PhotosViewContainerPrivate *priv = self->priv;
photos_error_box_update (PHOTOS_ERROR_BOX (priv->error_box), primary, secondary);
gtk_stack_set_visible_child_name (GTK_STACK (self), "error");
}
static void
switch_to_label (void)
{
g_free (text);
text = NULL;
gtk_stack_set_visible_child_name (GTK_STACK (stack), "label");
update ();
}
/**
* gdaui_dsn_editor_show_pane:
*/
void
gdaui_dsn_editor_show_pane (GdauiDsnEditor *config, GdauiDsnEditorPaneType type)
{
switch (type) {
case GDAUI_DSN_EDITOR_PANE_DEFINITION:
gtk_stack_set_visible_child_name (GTK_STACK (config->priv->stack), PANE_DEFINITION);
break;
case GDAUI_DSN_EDITOR_PANE_PARAMS:
gtk_stack_set_visible_child_name (GTK_STACK (config->priv->stack), PANE_PARAMS);
break;
case GDAUI_DSN_EDITOR_PANE_AUTH:
gtk_stack_set_visible_child_name (GTK_STACK (config->priv->stack), PANE_AUTH);
break;
default:
g_assert_not_reached ();
}
}
static void
dialog_adjustments_set_frac_hours (CcNightLightDialog *self,
gdouble value,
GtkAdjustment *adj_hours,
GtkAdjustment *adj_mins,
GtkStack *stack)
{
gdouble hours;
gdouble mins = 0.f;
gboolean is_pm = FALSE;
gboolean is_24h;
/* display the right thing for AM/PM */
is_24h = self->clock_format == G_DESKTOP_CLOCK_FORMAT_24H;
mins = modf (value, &hours) * 60.f;
if (!is_24h)
{
if (hours > 12)
{
hours -= 12;
is_pm = TRUE;
}
else if (hours < 1.0)
{
hours += 12;
is_pm = FALSE;
}
else if (hours == 12.f)
{
is_pm = TRUE;
}
}
g_debug ("setting adjustment %.3f to %.0f:%02.0f", value, hours, mins);
self->ignore_value_changed = TRUE;
gtk_adjustment_set_value (GTK_ADJUSTMENT (adj_hours), hours);
gtk_adjustment_set_value (GTK_ADJUSTMENT (adj_mins), mins);
self->ignore_value_changed = FALSE;
if (is_24h)
gtk_stack_set_visible_child_name (stack, "blank");
else
gtk_stack_set_visible_child_name (stack, is_pm ? "pm" : "am");
}
static void
update_selected_format (NautilusCompressDialogController *self,
NautilusCompressionFormat format)
{
const char *extension;
const char *description_label_name;
GtkWidget *active_button;
switch (format)
{
case NAUTILUS_COMPRESSION_ZIP:
{
extension = ".zip";
description_label_name = "zip-description-label";
active_button = self->zip_radio_button;
}
break;
case NAUTILUS_COMPRESSION_TAR_XZ:
{
extension = ".tar.xz";
description_label_name = "tar-xz-description-label";
active_button = self->tar_xz_radio_button;
}
break;
case NAUTILUS_COMPRESSION_7ZIP:
{
extension = ".7z";
description_label_name = "seven-zip-description-label";
active_button = self->seven_zip_radio_button;
}
break;
default:
{
g_assert_not_reached ();
}
break;
}
self->extension = extension;
gtk_stack_set_visible_child_name (GTK_STACK (self->description_stack),
description_label_name);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (active_button),
TRUE);
g_settings_set_enum (nautilus_compression_preferences,
NAUTILUS_PREFERENCES_DEFAULT_COMPRESSION_FORMAT,
format);
/* Since the extension changes when the button is toggled, force a
* verification of the new file name by simulating an entry change
*/
g_signal_emit_by_name (self->name_entry, "changed");
}
static void
on_object_activated (GtkInspectorObjectTree *wt,
GObject *selected,
const gchar *name,
GtkInspectorWindow *iw)
{
const gchar *tab;
if (!set_selected_object (iw, selected))
return;
tab = g_object_get_data (G_OBJECT (wt), "next-tab");
if (tab)
gtk_stack_set_visible_child_name (GTK_STACK (iw->object_details), tab);
gtk_stack_set_visible_child_name (GTK_STACK (iw->object_stack), "object-details");
gtk_stack_set_visible_child_name (GTK_STACK (iw->object_buttons), "details");
}
static void
credentials_set_cb(GObject* source,
GParamSpec* pspec,
gpointer udata)
{
GtTwitchChatView* self = GT_TWITCH_CHAT_VIEW(udata);
GtTwitchChatViewPrivate* priv = gt_twitch_chat_view_get_instance_private(self);
gchar* user_name;
gchar* oauth_token;
g_object_get(main_app,
"user-name", &user_name,
"oauth-token", &oauth_token,
NULL);
if (!user_name || !oauth_token ||
strlen(user_name) < 1 || strlen(oauth_token) < 1)
{
gt_twitch_chat_client_disconnect(priv->chat);
gtk_text_buffer_set_text(priv->chat_buffer, "", -1);
gtk_stack_set_visible_child_name(GTK_STACK(priv->main_stack), "loginview");
priv->joined_channel = FALSE;
}
else
{
GtChannel* open_chan = NULL;
g_object_get(GT_WIN_TOPLEVEL(self)->player, "open-channel", &open_chan, NULL);
gt_twitch_chat_client_connect(priv->chat, oauth_token, user_name);
gtk_stack_set_visible_child_name(GTK_STACK(priv->main_stack), "chatview");
if (open_chan && !priv->joined_channel)
{
gt_twitch_chat_client_join(priv->chat, gt_channel_get_name(open_chan));
g_object_unref(open_chan);
}
}
g_free(user_name);
g_free(oauth_token);
}
void
gt_win_browse_games_view(GtWin* self)
{
GtWinPrivate* priv = gt_win_get_instance_private(self);
gt_win_browse_view(self);
gtk_stack_set_visible_child_name(GTK_STACK(priv->browse_stack),
"games");
}
static void
on_info_started (NemoProgressInfo *info, InfoChangedData *payload) {
NemoProgressUIHandler *handler = payload->handler;
NemoProgressInfoWidget *widget = payload->widget;
NemoProgressInfoWidgetPriv *priv = widget->priv;
gtk_stack_set_visible_child_name (GTK_STACK (priv->stack), "running");
reorder_before_pending_jobs (handler, widget);
}
static void
settings_clicked(G_GNUC_UNUSED GtkButton *button, RingMainWindow *win)
{
g_return_if_fail(IS_RING_MAIN_WINDOW(win));
RingMainWindowPrivate *priv = RING_MAIN_WINDOW_GET_PRIVATE(win);
/* check which view to show */
if (!priv->show_settings) {
/* show the settings */
/* make sure we are not showing a call view so we don't have more than one clutter stage at a time */
selection_changed(QModelIndex(), win);
/* show settings */
gtk_image_set_from_icon_name(GTK_IMAGE(priv->image_settings), "emblem-ok-symbolic", GTK_ICON_SIZE_LARGE_TOOLBAR);
gtk_widget_show(priv->hbox_settings);
/* make sure to start preview if we're showing the video settings */
if (priv->last_settings_view == priv->media_settings_view)
media_settings_view_show_preview(MEDIA_SETTINGS_VIEW(priv->media_settings_view), TRUE);
gtk_stack_set_transition_type(GTK_STACK(priv->stack_main_view), GTK_STACK_TRANSITION_TYPE_SLIDE_UP);
gtk_stack_set_visible_child(GTK_STACK(priv->stack_main_view), priv->last_settings_view);
priv->show_settings = TRUE;
} else {
/* hide the settings */
priv->show_settings = FALSE;
/* show working dialog in case save operation takes time */
GtkWidget *working = ring_dialog_working(GTK_WIDGET(win), NULL);
gtk_window_present(GTK_WINDOW(working));
/* now save after the time it takes to transition back to the call view (400ms)
* the save doesn't happen before the "working" dialog is presented
* the timeout function should destroy the "working" dialog when done saving
*/
g_timeout_add_full(G_PRIORITY_DEFAULT, 400, (GSourceFunc)save_accounts, working, NULL);
/* show calls */
gtk_image_set_from_icon_name(GTK_IMAGE(priv->image_settings), "emblem-system-symbolic", GTK_ICON_SIZE_LARGE_TOOLBAR);
gtk_widget_hide(priv->hbox_settings);
/* make sure video preview is stopped, in case it was started */
media_settings_view_show_preview(MEDIA_SETTINGS_VIEW(priv->media_settings_view), FALSE);
gtk_stack_set_transition_type(GTK_STACK(priv->stack_main_view), GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN);
gtk_stack_set_visible_child_name(GTK_STACK(priv->stack_main_view), CALL_VIEW_NAME);
/* show the view which was selected previously */
selection_changed(RecentModel::instance().selectionModel()->currentIndex(), win);
}
}
static void
update_toggle_state (NemoContextMenuMenuItem *item,
gboolean from_event,
gboolean on_item)
{
gboolean complex_mode = g_settings_get_boolean (nemo_preferences, NEMO_PREFERENCES_CONTEXT_MENUS_SHOW_ALL_ACTIONS);
/* const */ gchar *tip_text = complex_mode ? _("Show less actions") :
_("Show more actions");
gchar *markup = g_strdup_printf ("<small><i>%s</i></small>", tip_text);
gtk_label_set_markup (GTK_LABEL (item->toggle_label_widget), markup);
g_free (markup);
if (item->on_toggle) {
set_action_image_temporary_visibility (item, FALSE);
gtk_stack_set_visible_child_name (GTK_STACK (item->stack), "toggle");
} else {
set_action_image_temporary_visibility (item, TRUE);
gtk_stack_set_visible_child_name (GTK_STACK (item->stack), "action");
}
GtkStyleContext *context = gtk_widget_get_style_context (GTK_WIDGET (item));
if (on_item) {
gtk_image_set_from_icon_name (GTK_IMAGE (item->toggle_widget),
complex_mode ? "collapse-menu-hover-symbolic" : "expand-menu-hover-symbolic",
GTK_ICON_SIZE_MENU);
} else {
gtk_image_set_from_icon_name (GTK_IMAGE (item->toggle_widget),
complex_mode ? "collapse-menu-symbolic" : "expand-menu-symbolic",
GTK_ICON_SIZE_MENU);
}
GtkStateFlags default_item_state = from_event ? GTK_STATE_FLAG_PRELIGHT : gtk_style_context_get_state (context);
gtk_style_context_set_state (context, item->on_toggle ? GTK_STATE_FLAG_NORMAL : default_item_state);
gtk_widget_queue_draw (GTK_WIDGET (item));
}
static void
gtk_shortcuts_window_constructed (GObject *object)
{
GtkShortcutsWindow *self = (GtkShortcutsWindow *)object;
GtkShortcutsWindowPrivate *priv = gtk_shortcuts_window_get_instance_private (self);
G_OBJECT_CLASS (gtk_shortcuts_window_parent_class)->constructed (object);
if (priv->initial_section != NULL)
gtk_stack_set_visible_child_name (priv->stack, priv->initial_section);
}
static void
gtk_shortcuts_window__search_mode__changed (GtkShortcutsWindow *self)
{
GtkShortcutsWindowPrivate *priv = gtk_shortcuts_window_get_instance_private (self);
if (!gtk_search_bar_get_search_mode (priv->search_bar))
{
if (priv->last_section_name != NULL)
gtk_stack_set_visible_child_name (priv->stack, priv->last_section_name);
}
}
static void
gb_shortcuts_dialog_constructed (GObject *object)
{
GbShortcutsDialog *self = (GbShortcutsDialog *)object;
GbShortcutsDialogPrivate *priv = gb_shortcuts_dialog_get_instance_private (self);
G_OBJECT_CLASS (gb_shortcuts_dialog_parent_class)->constructed (object);
if (priv->initial_view != NULL)
gtk_stack_set_visible_child_name (priv->stack, priv->initial_view);
}
static void
show_general_settings(GtkToggleButton *navbutton, RingMainWindow *win)
{
g_return_if_fail(IS_RING_MAIN_WINDOW(win));
RingMainWindowPrivate *priv = RING_MAIN_WINDOW_GET_PRIVATE(win);
if (gtk_toggle_button_get_active(navbutton)) {
gtk_stack_set_transition_type(GTK_STACK(priv->stack_main_view), GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT);
gtk_stack_set_visible_child_name(GTK_STACK(priv->stack_main_view), GENERAL_SETTINGS_VIEW_NAME);
priv->last_settings_view = priv->general_settings_view;
}
}
static void
update_jobs_list_cb (cups_job_t *jobs,
gint num_of_jobs,
gpointer user_data)
{
PpJobsDialog *dialog = user_data;
GtkWidget *clear_all_button;
GtkStack *stack;
guint i;
g_list_store_remove_all (dialog->store);
stack = GTK_STACK (gtk_builder_get_object (GTK_BUILDER (dialog->builder), "stack"));
clear_all_button = GTK_WIDGET (gtk_builder_get_object (GTK_BUILDER (dialog->builder), "jobs-clear-all-button"));
if (num_of_jobs > 0)
{
gtk_widget_set_sensitive (clear_all_button, TRUE);
gtk_stack_set_visible_child_name (stack, "list-jobs-page");
}
else
{
gtk_widget_set_sensitive (clear_all_button, FALSE);
gtk_stack_set_visible_child_name (stack, "no-jobs-page");
}
for (i = 0; i < num_of_jobs; i++)
{
PpJob *job;
job = g_object_new (pp_job_get_type (),
"id", jobs[i].id,
"title", jobs[i].title,
"state", jobs[i].state,
NULL);
g_list_store_append (dialog->store, job);
}
dialog->ref_count--;
}
static void mode_callback(GtkWidget *combo, gpointer user_data)
{
dt_iop_module_t *self = (dt_iop_module_t *)user_data;
if(darktable.gui->reset) return;
dt_iop_exposure_gui_data_t *g = (dt_iop_exposure_gui_data_t *)self->gui_data;
dt_iop_exposure_params_t *p = (dt_iop_exposure_params_t *)self->params;
const dt_iop_exposure_mode_t new_mode
= GPOINTER_TO_UINT(g_list_nth_data(g->modes, dt_bauhaus_combobox_get(combo)));
free(g->deflicker_histogram);
g->deflicker_histogram = NULL;
switch(new_mode)
{
case EXPOSURE_MODE_DEFLICKER:
autoexp_disable(self);
if(!dt_image_is_raw(&self->dev->image_storage))
{
dt_bauhaus_combobox_set(g->mode, g_list_index(g->modes, GUINT_TO_POINTER(EXPOSURE_MODE_MANUAL)));
gtk_widget_hide(GTK_WIDGET(g->mode));
break;
}
p->mode = EXPOSURE_MODE_DEFLICKER;
gtk_stack_set_visible_child_name(GTK_STACK(g->mode_stack), "deflicker");
if(p->deflicker_histogram_source == DEFLICKER_HISTOGRAM_SOURCE_SOURCEFILE)
deflicker_prepare_histogram(self, &g->deflicker_histogram, &g->deflicker_histogram_stats);
break;
case EXPOSURE_MODE_MANUAL:
default:
p->mode = EXPOSURE_MODE_MANUAL;
gtk_stack_set_visible_child_name(GTK_STACK(g->mode_stack), "manual");
break;
}
dt_dev_add_history_item(darktable.develop, self, TRUE);
}
static void
cc_bluetooth_panel_update_power (CcBluetoothPanel *self)
{
GObject *toggle;
gboolean sensitive, powered, change_powered;
const char *page;
g_debug ("Updating airplane mode: has_airplane_mode %d, hardware_airplane_mode %d, BT airplane_mode %d, airplane_mode %d",
self->priv->has_airplane_mode, self->priv->hardware_airplane_mode, self->priv->bt_airplane_mode, self->priv->airplane_mode);
change_powered = TRUE;
if (self->priv->has_airplane_mode == FALSE) {
g_debug ("No Bluetooth available");
sensitive = FALSE;
powered = FALSE;
page = BLUETOOTH_NO_DEVICES_PAGE;
} else if (self->priv->hardware_airplane_mode) {
g_debug ("Bluetooth is Hard blocked");
sensitive = FALSE;
powered = FALSE;
page = BLUETOOTH_HW_AIRPLANE_PAGE;
} else if (self->priv->airplane_mode) {
g_debug ("Airplane mode is on, Wi-Fi and Bluetooth are disabled");
sensitive = FALSE;
powered = FALSE;
page = BLUETOOTH_AIRPLANE_PAGE;
} else if (self->priv->bt_airplane_mode ||
!bluetooth_settings_widget_get_default_adapter_powered (BLUETOOTH_SETTINGS_WIDGET (self->priv->widget))) {
g_debug ("Default adapter is unpowered, but should be available");
sensitive = TRUE;
change_powered = FALSE;
page = BLUETOOTH_DISABLED_PAGE;
} else {
g_debug ("Bluetooth is available and powered");
sensitive = TRUE;
powered = TRUE;
page = BLUETOOTH_WORKING_PAGE;
}
gtk_widget_set_sensitive (WID ("box_power") , sensitive);
toggle = G_OBJECT (WID ("switch_bluetooth"));
if (change_powered) {
g_signal_handlers_block_by_func (toggle, power_callback, self);
gtk_switch_set_active (GTK_SWITCH (toggle), powered);
g_signal_handlers_unblock_by_func (toggle, power_callback, self);
}
gtk_stack_set_visible_child_name (GTK_STACK (self->priv->stack), page);
}
static void
gs_editor_set_page (GsEditor *self, const gchar *name)
{
GtkWidget *widget;
widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "stack_main"));
gtk_stack_set_visible_child_name (GTK_STACK (widget), name);
if (g_strcmp0 (name, "none") == 0) {
widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "button_back"));
gtk_widget_set_visible (widget, FALSE);
widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "button_new"));
gtk_widget_set_visible (widget, TRUE);
widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "button_import"));
gtk_widget_set_visible (widget, TRUE);
widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "button_save"));
gtk_widget_set_visible (widget, TRUE);
widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "button_search"));
gtk_widget_set_visible (widget, FALSE);
widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "button_remove"));
gtk_widget_set_visible (widget, FALSE);
} else if (g_strcmp0 (name, "choice") == 0) {
widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "button_back"));
gtk_widget_set_visible (widget, FALSE);
widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "button_new"));
gtk_widget_set_visible (widget, TRUE);
widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "button_import"));
gtk_widget_set_visible (widget, TRUE);
widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "button_save"));
gtk_widget_set_visible (widget, TRUE);
widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "button_search"));
gtk_widget_set_visible (widget, TRUE);
widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "button_remove"));
gtk_widget_set_visible (widget, FALSE);
} else if (g_strcmp0 (name, "details") == 0) {
widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "button_back"));
gtk_widget_set_visible (widget, TRUE);
widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "button_new"));
gtk_widget_set_visible (widget, FALSE);
widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "button_import"));
gtk_widget_set_visible (widget, FALSE);
widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "button_save"));
gtk_widget_set_visible (widget, FALSE);
widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "button_search"));
gtk_widget_set_visible (widget, FALSE);
widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "button_remove"));
gtk_widget_set_visible (widget, TRUE);
}
}
static void
gs_screenshot_image_set_error (GsScreenshotImage *ssimg, const gchar *message)
{
gint width, height;
gtk_stack_set_visible_child_name (GTK_STACK (ssimg->stack), "error");
gtk_label_set_label (GTK_LABEL (ssimg->label_error), message);
gtk_widget_get_size_request (ssimg->stack, &width, &height);
if (width < 200)
gtk_widget_hide (ssimg->label_error);
else
gtk_widget_show (ssimg->label_error);
ssimg->showing_image = FALSE;
}
static void
on_item_selection_changed (GtkTreeSelection *selection,
ReaderItemsView *view)
{
int read;
gchar *url;
gchar *title;
gchar *contents;
gchar *str_date;
GtkTreeIter iter;
GtkTreePath *path;
GtkTreeModel *model;
GDateTime *date;
ReaderItemsViewPrivate *priv;
priv = reader_items_view_get_instance_private (view);
if (gtk_tree_selection_get_selected (selection, &model, &iter)) {
path = gtk_tree_model_get_path (model, &iter);
if (gtk_tree_path_get_depth (path) != 1) {
gtk_tree_model_get (model, &iter,
ITEM_COLUMN_CONTENTS, &contents,
ITEM_COLUMN_TITLE, &title,
ITEM_COLUMN_TIME, &date,
ITEM_COLUMN_URL, &url,
ITEM_COLUMN_READ, &read, -1);
gtk_stack_set_visible_child_name (GTK_STACK (priv->webstack), "webcontents");
gtk_button_set_label (GTK_BUTTON (priv->title), title);
gtk_link_button_set_uri (priv->title, url);
str_date = g_date_time_format (date, "%c");
gtk_label_set_text (priv->date, str_date);
g_free (str_date);
webkit_web_view_load_html (priv->webview, contents, NULL);
g_free (title);
g_free (url);
g_free (contents);
if (read == UNREAD_FONT_WEIGHT)
gtk_tree_store_set (GTK_TREE_STORE (model), &iter, ITEM_COLUMN_READ, READ_FONT_WEIGHT, -1);
}
gtk_tree_path_free (path);
}
}
static void
ide_omni_bar_next_message (IdeOmniBar *self)
{
IdeBuildManager *build_manager;
const gchar *name;
IdeContext *context;
g_assert (IDE_IS_OMNI_BAR (self));
if (NULL == (context = ide_widget_get_context (GTK_WIDGET (self))))
return;
build_manager = ide_context_get_build_manager (context);
name = gtk_stack_get_visible_child_name (self->message_stack);
/*
* TODO: This isn't the cleanest way to do this.
* We need to come up with a strategy for moving between these
* in a way that has a "check" function to determine if we can
* toggle to the next child.
*/
if (g_strcmp0 (name, "config") == 0)
{
/* Only rotate to build result if we have one and we haven't
* flapped too many times.
*/
if (self->did_build && self->seen_count < 2)
gtk_stack_set_visible_child_name (self->message_stack, "build");
}
else if (!ide_build_manager_get_busy (build_manager))
{
self->seen_count++;
gtk_stack_set_visible_child_name (self->message_stack, "config");
}
}
static void
account_creation_done_clicked(G_GNUC_UNUSED GtkButton *button, RingMainWindow *win)
{
RingMainWindowPrivate *priv = RING_MAIN_WINDOW_GET_PRIVATE(win);
QObject::disconnect(priv->hash_updated);
/* show the call view */
gtk_stack_set_transition_type(GTK_STACK(priv->stack_main_view), GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT);
gtk_stack_set_visible_child_name(GTK_STACK(priv->stack_main_view), CALL_VIEW_NAME);
/* show the settings button*/
gtk_widget_show(priv->ring_settings);
}
static void
as_screenshot_show_image (GsScreenshotImage *ssimg)
{
g_autoptr(GdkPixbuf) pixbuf = NULL;
/* no need to composite */
if (ssimg->width == G_MAXUINT || ssimg->height == G_MAXUINT) {
pixbuf = gdk_pixbuf_new_from_file (ssimg->filename, NULL);
} else {
/* this is always going to have alpha */
pixbuf = gdk_pixbuf_new_from_file_at_scale (ssimg->filename,
(gint) (ssimg->width * ssimg->scale),
(gint) (ssimg->height * ssimg->scale),
FALSE, NULL);
}
/* show icon */
if (g_strcmp0 (ssimg->current_image, "image1") == 0) {
if (pixbuf != NULL) {
gs_image_set_from_pixbuf_with_scale (GTK_IMAGE (ssimg->image2),
pixbuf, (gint) ssimg->scale);
}
gtk_stack_set_visible_child_name (GTK_STACK (ssimg->stack), "image2");
ssimg->current_image = "image2";
} else {
if (pixbuf != NULL) {
gs_image_set_from_pixbuf_with_scale (GTK_IMAGE (ssimg->image1),
pixbuf, (gint) ssimg->scale);
}
gtk_stack_set_visible_child_name (GTK_STACK (ssimg->stack), "image1");
ssimg->current_image = "image1";
}
gtk_widget_show (GTK_WIDGET (ssimg));
ssimg->showing_image = TRUE;
}
static void
gb_shortcuts_dialog__list_box__row_activated (GbShortcutsDialog *self,
GtkListBoxRow *row,
GtkListBox *list_box)
{
GbShortcutsDialogPrivate *priv = gb_shortcuts_dialog_get_instance_private (self);
const gchar *name;
g_assert (GB_IS_SHORTCUTS_DIALOG (self));
g_assert (GTK_IS_LIST_BOX_ROW (row));
g_assert (GTK_IS_LIST_BOX (list_box));
name = g_object_get_data (G_OBJECT (row), "GB_SHORTCUTS_VIEW_NAME");
gtk_stack_set_visible_child_name (priv->stack, name);
gtk_widget_hide (GTK_WIDGET (priv->popover));
}
/**
* gs_screenshot_image_set_error:
**/
static void
gs_screenshot_image_set_error (GsScreenshotImage *ssimg, const gchar *message)
{
GsScreenshotImagePrivate *priv;
gint width, height;
priv = gs_screenshot_image_get_instance_private (ssimg);
gtk_stack_set_visible_child_name (GTK_STACK (priv->stack), "error");
gtk_label_set_label (GTK_LABEL (priv->label_error), message);
gtk_widget_get_size_request (priv->stack, &width, &height);
if (width < 200)
gtk_widget_hide (priv->label_error);
else
gtk_widget_show (priv->label_error);
}
