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); }