自学教程：C++ GTK_STACK函数代码示例

void gui_update(dt_iop_module_t *self){  dt_iop_levels_gui_data_t *g = (dt_iop_levels_gui_data_t *)self->gui_data;  dt_iop_levels_params_t *p = (dt_iop_levels_params_t *)self->params;  dt_bauhaus_combobox_set(g->mode, g_list_index(g->modes, GUINT_TO_POINTER(p->mode)));  dt_bauhaus_slider_set(g->percentile_black, p->percentiles[0]);  dt_bauhaus_slider_set(g->percentile_grey, p->percentiles[1]);  dt_bauhaus_slider_set(g->percentile_white, p->percentiles[2]);  switch(p->mode)  {    case LEVELS_MODE_AUTOMATIC:      gtk_stack_set_visible_child_name(GTK_STACK(g->mode_stack), "automatic");      break;    case LEVELS_MODE_MANUAL:    default:      gtk_stack_set_visible_child_name(GTK_STACK(g->mode_stack), "manual");      break;  }  dt_pthread_mutex_lock(&g->lock);  g->auto_levels[0] = NAN;  g->auto_levels[1] = NAN;  g->auto_levels[2] = NAN;  dt_pthread_mutex_unlock(&g->lock);  gtk_widget_queue_draw(self->widget);}

static void dt_iop_levels_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_levels_gui_data_t *g = (dt_iop_levels_gui_data_t *)self->gui_data;  dt_iop_levels_params_t *p = (dt_iop_levels_params_t *)self->params;  const dt_iop_levels_mode_t new_mode      = GPOINTER_TO_UINT(g_list_nth_data(g->modes, dt_bauhaus_combobox_get(combo)));  switch(new_mode)  {    case LEVELS_MODE_AUTOMATIC:      p->mode = LEVELS_MODE_AUTOMATIC;      gtk_stack_set_visible_child_name(GTK_STACK(g->mode_stack), "automatic");      break;    case LEVELS_MODE_MANUAL:    default:      p->mode = LEVELS_MODE_MANUAL;      gtk_stack_set_visible_child_name(GTK_STACK(g->mode_stack), "manual");      break;  }  dt_dev_add_history_item(darktable.develop, self, TRUE);}

voidgt_games_view_show_type(GtGamesView* self, gint type){    GtGamesViewPrivate* priv = gt_games_view_get_instance_private(self);    switch (type)    {        case GT_GAMES_CONTAINER_TYPE_TOP:            gtk_stack_set_visible_child(GTK_STACK(priv->games_stack), priv->top_container);            priv->was_showing_game = FALSE;            break;        case GT_GAMES_CONTAINER_TYPE_SEARCH:            gtk_stack_set_visible_child(GTK_STACK(priv->games_stack), priv->search_container);            break;        case GT_CHANNELS_CONTAINER_TYPE_GAME:            gtk_stack_set_visible_child(GTK_STACK(priv->games_stack), priv->game_container);            priv->was_showing_game = TRUE;            break;        default:            break;    }    g_object_notify_by_pspec(G_OBJECT(self), props[PROP_SHOWING_TOP_GAMES]);    g_object_notify_by_pspec(G_OBJECT(self), props[PROP_SHOWING_GAME_CHANNELS]);}

static GtkWidget* main_window() {  GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL);  gtk_window_set_title(GTK_WINDOW(window), "Switcher");  gtk_container_set_border_width(GTK_CONTAINER(window), 10);  GtkWidget* box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10);  gtk_container_add(GTK_CONTAINER(window), box);  // Stack  GtkWidget* main_area = gtk_stack_new();  gtk_stack_set_transition_type(GTK_STACK(main_area),                                GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT);  gtk_stack_set_transition_duration(GTK_STACK(main_area), 2000);  // Checkbox  GtkWidget* check_button =      gtk_check_button_new_with_label("Do not fn check me");  gtk_stack_add_titled(GTK_STACK(main_area), check_button, "check_name",                       "Check Box");  // Label  GtkWidget* label = gtk_label_new(NULL);  gtk_label_set_markup(GTK_LABEL(label), "<big>OMG this text is huge!</big>");  gtk_stack_add_titled(GTK_STACK(main_area), label, "label_name", "Big Label");  // StackSwitcher  GtkWidget* stack_switcher = gtk_stack_switcher_new();  gtk_stack_switcher_set_stack(GTK_STACK_SWITCHER(stack_switcher),                               GTK_STACK(main_area));  gtk_box_pack_start(GTK_BOX(box), stack_switcher, TRUE, TRUE, 0);  gtk_box_pack_start(GTK_BOX(box), main_area, TRUE, TRUE, 0);  return window;}

static voidephy_title_box_constructed (GObject *object){  EphyTitleBox        *title_box = EPHY_TITLE_BOX (object);  EphyWindowChrome chrome;  LOG ("EphyTitleBox constructed");  G_OBJECT_CLASS (ephy_title_box_parent_class)->constructed (object);  gtk_widget_add_events (GTK_WIDGET (title_box),                         GDK_BUTTON_PRESS_MASK |                         GDK_POINTER_MOTION_MASK |                         GDK_BUTTON_RELEASE_MASK);  ephy_title_box_add_address_bar (title_box);  ephy_title_box_add_title_bar (title_box);  chrome = ephy_window_get_chrome (title_box->window);  title_box->location_disabled = !(chrome & EPHY_WINDOW_CHROME_LOCATION);  if (title_box->location_disabled) {    title_box->mode = EPHY_TITLE_BOX_MODE_TITLE;    gtk_stack_set_visible_child_name (GTK_STACK (title_box), "title-bar");  } else {    title_box->mode = EPHY_TITLE_BOX_MODE_LOCATION_ENTRY;    gtk_stack_set_visible_child_name (GTK_STACK (title_box), "address-bar");  }  g_signal_connect_swapped (title_box->window, "notify::chrome",                            G_CALLBACK (sync_chromes_visibility),                            title_box);}

static voidgtk_inspector_window_init (GtkInspectorWindow *iw){  GIOExtensionPoint *extension_point;  GList *l, *extensions;  gtk_widget_init_template (GTK_WIDGET (iw));  gtk_window_group_add_window (gtk_window_group_new (), GTK_WINDOW (iw));  extension_point = g_io_extension_point_lookup ("gtk-inspector-page");  extensions = g_io_extension_point_get_extensions (extension_point);  for (l = extensions; l != NULL; l = l->next)    {      GIOExtension *extension = l->data;      GType type;      GtkWidget *widget;      const char *name;      char *title;      GtkWidget *button;      gboolean use_picker;      type = g_io_extension_get_type (extension);      widget = g_object_new (type, NULL);      iw->extra_pages = g_list_prepend (iw->extra_pages, widget);      name = g_io_extension_get_name (extension);      g_object_get (widget, "title", &title, NULL);      if (g_object_class_find_property (G_OBJECT_GET_CLASS (widget), "use-picker"))        g_object_get (widget, "use-picker", &use_picker, NULL);      else        use_picker = FALSE;      if (use_picker)        {          button = gtk_button_new_from_icon_name ("find-location-symbolic",                                                  GTK_ICON_SIZE_MENU);          gtk_button_set_focus_on_click (GTK_BUTTON (button), FALSE);          gtk_widget_set_halign (button, GTK_ALIGN_START);          gtk_widget_set_valign (button, GTK_ALIGN_CENTER);          g_signal_connect (button, "clicked",                            G_CALLBACK (gtk_inspector_on_inspect), iw);        }      else        button = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);      gtk_stack_add_titled (GTK_STACK (iw->top_stack), widget, name, title);      gtk_stack_add_named (GTK_STACK (iw->button_stack), button, name);      gtk_widget_show (widget);      gtk_widget_show (button);      g_free (title);    }}

static voidphotos_view_container_count_changed (PhotosViewContainer *self, gint count){  if (count == 0)    gtk_stack_set_visible_child_name (GTK_STACK (self), "no-results");  else    gtk_stack_set_visible_child_name (GTK_STACK (self), "view");}

//TODO: Make these actionsvoidgt_win_browse_view(GtWin* self){    GtWinPrivate* priv = gt_win_get_instance_private(self);    gtk_stack_set_visible_child_name(GTK_STACK(priv->header_stack),                                     "browse");    gtk_stack_set_visible_child_name(GTK_STACK(priv->main_stack),                                     "browse");}

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

void gui_update(struct dt_iop_module_t *self){  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;  if(!dt_image_is_raw(&self->dev->image_storage))  {    gtk_widget_hide(GTK_WIDGET(g->mode));    p->mode = EXPOSURE_MODE_MANUAL;    dt_dev_add_history_item(darktable.develop, self, TRUE);  }  else  {    gtk_widget_show(GTK_WIDGET(g->mode));  }  dt_bauhaus_combobox_set(g->mode, g_list_index(g->modes, GUINT_TO_POINTER(p->mode)));  dt_bauhaus_slider_set_soft(g->black, p->black);  dt_bauhaus_slider_set_soft(g->exposure, p->exposure);  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->autoexp), FALSE);  dt_bauhaus_slider_set(g->autoexpp, 0.01);  gtk_widget_set_sensitive(GTK_WIDGET(g->autoexpp), FALSE);  dt_bauhaus_slider_set(g->deflicker_percentile, p->deflicker_percentile);  dt_bauhaus_slider_set(g->deflicker_target_level, p->deflicker_target_level);  dt_bauhaus_combobox_set(      g->deflicker_histogram_source,      g_list_index(g->deflicker_histogram_sources, GUINT_TO_POINTER(p->deflicker_histogram_source)));  self->request_color_pick = DT_REQUEST_COLORPICK_OFF;  free(g->deflicker_histogram);  g->deflicker_histogram = NULL;  gtk_label_set_text(g->deflicker_used_EC, "");  dt_pthread_mutex_lock(&g->lock);  g->deflicker_computed_exposure = NAN;  dt_pthread_mutex_unlock(&g->lock);  switch(p->mode)  {    case EXPOSURE_MODE_DEFLICKER:      autoexp_disable(self);      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:      gtk_stack_set_visible_child_name(GTK_STACK(g->mode_stack), "manual");      break;  }}

/** * as_screenshot_show_image: **/static voidas_screenshot_show_image (GsScreenshotImage *ssimg){	GsScreenshotImagePrivate *priv;	_cleanup_object_unref_ GdkPixbuf *pixbuf_bg = NULL;	_cleanup_object_unref_ GdkPixbuf *pixbuf = NULL;	priv = gs_screenshot_image_get_instance_private (ssimg);	/* no need to composite */	if (priv->width == G_MAXUINT || priv->height == G_MAXUINT) {		pixbuf_bg = gdk_pixbuf_new_from_file (priv->filename, NULL);	} else {		/* this is always going to have alpha */		pixbuf = gdk_pixbuf_new_from_file_at_scale (priv->filename,							    priv->width * priv->scale,							    priv->height * priv->scale,							    FALSE, NULL);		if (pixbuf != NULL) {			if (gs_screenshot_image_use_desktop_background (ssimg, pixbuf)) {				pixbuf_bg = gs_screenshot_image_get_desktop_pixbuf (ssimg);				if (pixbuf_bg == NULL) {					pixbuf_bg = g_object_ref (pixbuf);				} else {					gdk_pixbuf_composite (pixbuf, pixbuf_bg,							      0, 0,							      priv->width, priv->height,							      0, 0, 1.0f, 1.0f,							      GDK_INTERP_NEAREST, 255);				}			} else {				pixbuf_bg = g_object_ref (pixbuf);			}		}	}	/* show icon */	if (g_strcmp0 (priv->current_image, "image1") == 0) {		if (pixbuf_bg != NULL) {			gs_image_set_from_pixbuf_with_scale (GTK_IMAGE (priv->image2),							     pixbuf_bg, priv->scale);		}		gtk_stack_set_visible_child_name (GTK_STACK (priv->stack), "image2");		priv->current_image = "image2";	} else {		if (pixbuf_bg != NULL) {			gs_image_set_from_pixbuf_with_scale (GTK_IMAGE (priv->image1),							     pixbuf_bg, priv->scale);		}		gtk_stack_set_visible_child_name (GTK_STACK (priv->stack), "image1");		priv->current_image = "image1";	}	gtk_widget_show (GTK_WIDGET (ssimg));}

static voidgs_shell_overview_refreshed (GsShellOverview *self){	GsShellOverviewPrivate *priv = gs_shell_overview_get_instance_private (self);	if (priv->empty) {		gtk_stack_set_visible_child_name (GTK_STACK (priv->stack_overview), "no-results");	} else {		gtk_stack_set_visible_child_name (GTK_STACK (priv->stack_overview), "overview");	}}

static voidclickity (GtkButton *button,          gpointer   stack){  if (g_strcmp0 (gtk_stack_get_visible_child_name (GTK_STACK (stack)), "label") == 0)    gtk_stack_set_visible_child_name (GTK_STACK (stack), "clutter");  else    gtk_stack_set_visible_child_name (GTK_STACK (stack), "label");  fade = !fade;}

static voidshow_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;    }}

//TODO: Make this actionvoidgt_win_open_channel(GtWin* self, GtChannel* chan){    GtWinPrivate* priv = gt_win_get_instance_private(self);    gt_player_open_channel(GT_PLAYER(self->player), chan);    gtk_stack_set_visible_child_name(GTK_STACK(priv->main_stack),                                     "player");    gtk_stack_set_visible_child_name(GTK_STACK(priv->header_stack),                                     "player");}

static voidsearch_active_cb(GObject* source,                 GParamSpec* pspec,                 gpointer udata){    GtGamesView* self = GT_GAMES_VIEW(udata);    GtGamesViewPrivate* priv = gt_games_view_get_instance_private(self);    if (priv->search_active)        gtk_stack_set_visible_child(GTK_STACK(priv->games_stack), priv->search_container);    else        gtk_stack_set_visible_child(GTK_STACK(priv->games_stack), priv->top_container);}

static voidopen_object_details (GtkWidget *button, GtkInspectorWindow *iw){  GObject *selected;  selected = gtk_inspector_object_tree_get_selected (GTK_INSPECTOR_OBJECT_TREE (iw->object_tree));   if (!set_selected_object (iw, selected))    return;  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 voidshow_view_default_cb(GSimpleAction* action,                     GVariant* arg,                     gpointer udata){    GtWin* self = GT_WIN(udata);    GtWinPrivate* priv = gt_win_get_instance_private(self);    if (gtk_stack_get_visible_child(GTK_STACK(priv->browse_stack)) == priv->channels_view)        gt_channels_view_show_type(GT_CHANNELS_VIEW(priv->channels_view), GT_CHANNELS_CONTAINER_TYPE_TOP);    else if (gtk_stack_get_visible_child(GTK_STACK(priv->browse_stack)) == priv->games_view)        gt_games_view_show_type(GT_GAMES_VIEW(priv->games_view), GT_GAMES_CONTAINER_TYPE_TOP);}

static voidupdate_sidebar (GcalYearView *year_view){  GcalYearViewPrivate *priv = year_view->priv;  GtkWidget *child_widget;  GList *events, *l;  GList **days_widgets_array;  gint i, days_span;  update_selected_dates_from_button_data (year_view);  gtk_container_foreach (GTK_CONTAINER (priv->events_sidebar), (GtkCallback) gtk_widget_destroy, NULL);  days_span = icaltime_day_of_year(*(priv->end_selected_date)) - icaltime_day_of_year(*(priv->start_selected_date)) + 1;  days_widgets_array = g_new0 (GList*, days_span);  events = gcal_manager_get_events (priv->manager, priv->start_selected_date, priv->end_selected_date);  if (events == NULL)    {      days_span = 0;      update_no_events_page (year_view);      gtk_stack_set_visible_child_name (GTK_STACK (priv->navigator_stack), "no-events");    }  else    {      gtk_stack_set_visible_child_name (GTK_STACK (priv->navigator_stack), "events-list");    }  for (l = events; l != NULL; l = g_list_next (l))    add_event_to_day_array (year_view, l->data, days_widgets_array, days_span);  for (i = 0; i < days_span; i++)    {      GList *current_day = days_widgets_array[i];      for (l = current_day; l != NULL; l = g_list_next (l))        {          child_widget = l->data;          gtk_widget_show (child_widget);          g_signal_connect (child_widget, "activate", G_CALLBACK (event_activated), year_view);          g_object_set_data (G_OBJECT (child_widget), "shift", GINT_TO_POINTER (i));          gtk_container_add (GTK_CONTAINER (priv->events_sidebar), child_widget);        }      g_list_free (current_day);    }  g_free (days_widgets_array);  g_list_free_full (events, g_free);}

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

voidgt_settings_dlg_set_view(GtSettingsDlg* self, GtSettingsDlgView view){    GtSettingsDlgPrivate* priv = gt_settings_dlg_get_instance_private(self);    switch (view)    {        case GT_SETTINGS_DLG_VIEW_GENERAL:            gtk_stack_set_visible_child_name(GTK_STACK(priv->settings_stack), "general");            break;        case GT_SETTINGS_DLG_VIEW_PLAYERS:            gtk_stack_set_visible_child_name(GTK_STACK(priv->settings_stack), "players");            break;    }}

static voidclose_player_cb(GSimpleAction* action,                GVariant* arg,                gpointer udata){    GtWin* self = GT_WIN(udata);    GtWinPrivate* priv = gt_win_get_instance_private(self);    gt_player_close_channel(GT_PLAYER(self->player));    gtk_stack_set_visible_child_name(GTK_STACK(priv->header_stack),                                     "browse");    gtk_stack_set_visible_child_name(GTK_STACK(priv->main_stack),                                     "browse");}

static voidpage_changed_cb (GtkWidget *stack, GParamSpec *pspec, gpointer data){  const gchar *name;  GtkWidget *page;  if (gtk_widget_in_destruction (stack))    return;  name = gtk_stack_get_visible_child_name (GTK_STACK (stack));  if (g_str_equal (name, "page3"))    {      page = gtk_stack_get_visible_child (GTK_STACK (stack));      set_needs_attention (GTK_WIDGET (page), FALSE);    }}

static voidget_property (GObject*    obj,              guint       prop,              GValue*     val,              GParamSpec* pspec){    GtWin* self = GT_WIN(obj);    GtWinPrivate* priv = gt_win_get_instance_private(self);    switch (prop)    {        case PROP_CHANNELS_VIEW:            g_value_set_object(val, priv->channels_view);            break;        case PROP_GAMES_VIEW:            g_value_set_object(val, priv->games_view);            break;        case PROP_FULLSCREEN:            g_value_set_boolean(val, priv->fullscreen);            break;        case PROP_VISIBLE_VIEW:            g_value_set_object(val, gtk_stack_get_visible_child(GTK_STACK(priv->browse_stack)));            break;        default:            G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, prop, pspec);    }}

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

static voidupdated_database_cb (gpointer data, gpointer user_data){    FsearchApplicationWindow *win = (FsearchApplicationWindow *) user_data;    g_assert (FSEARCH_WINDOW_IS_WINDOW (win));    hide_overlays (win);    update_statusbar (win, "");    fsearch_application_window_update_search (win);    gtk_spinner_stop (GTK_SPINNER (win->database_spinner));    gtk_stack_set_visible_child (GTK_STACK (win->database_stack), win->database_box2);    Database *db = fsearch_application_get_db (FSEARCH_APPLICATION_DEFAULT);    uint32_t num_items = db_get_num_entries (db);    gchar db_text[100] = "";    snprintf (db_text, sizeof (db_text), _("%'d Items"), num_items);    gtk_label_set_text (GTK_LABEL (win->database_label), db_text);    time_t timestamp = db_get_timestamp (db);    strftime (db_text, sizeof(db_text),             "Last Updated: %Y-%m-%d %H:%M", //"%Y-%m-%d %H:%M",             localtime (&timestamp));    gtk_widget_set_tooltip_text (win->database_toggle_button, db_text);}

intmain (int argc, char **argv){  GtkWidget *window;  GtkWidget *vbox, *hbox, *button, *stack, *switcher;  gtk_init (&argc, &argv);  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);  vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);  gtk_container_add (GTK_CONTAINER (window), vbox);  switcher = gtk_stack_switcher_new ();  gtk_box_pack_start (GTK_BOX (vbox), switcher, FALSE, FALSE, 0);  stack = gtk_stack_new ();  gtk_box_pack_start (GTK_BOX (vbox), stack, TRUE, TRUE, 0);  gtk_stack_switcher_set_stack (GTK_STACK_SWITCHER (switcher), GTK_STACK (stack));  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8);  gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);  button = gtk_button_new_with_label ("Embedd");  gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);  g_signal_connect (button, "clicked", G_CALLBACK (button_clicked), stack);  gtk_widget_show_all (window);  gtk_main ();  return 0;}

static voidekiga_window_init_dialpad (EkigaWindow *mw){  GtkWidget *dialpad = NULL;  GtkWidget *grid = NULL;  grid = gtk_grid_new ();  gtk_grid_set_row_spacing (GTK_GRID (grid), 18);  gtk_container_set_border_width (GTK_CONTAINER (grid), 18);  dialpad = ekiga_dialpad_new (mw->priv->accel);  gtk_widget_set_hexpand (dialpad, FALSE);  gtk_widget_set_vexpand (dialpad, FALSE);  gtk_widget_set_halign (dialpad, GTK_ALIGN_CENTER);  gtk_widget_set_valign (dialpad, GTK_ALIGN_CENTER);  gtk_grid_attach (GTK_GRID (grid), dialpad, 0, 0, 1, 1);  g_signal_connect (dialpad, "button-clicked",                    G_CALLBACK (dialpad_button_clicked_cb), mw);  mw->priv->entry = ekiga_window_uri_entry_new (mw);  gtk_widget_set_hexpand (dialpad, TRUE);  gtk_widget_set_vexpand (dialpad, TRUE);  gtk_widget_set_halign (mw->priv->entry, GTK_ALIGN_FILL);  gtk_widget_set_valign (mw->priv->entry, GTK_ALIGN_END);  gtk_grid_attach_next_to (GTK_GRID (grid), mw->priv->entry, dialpad,                           GTK_POS_BOTTOM, 1, 1);  gtk_stack_add_named (GTK_STACK (mw->priv->main_stack), grid, "dialpad");  gtk_container_child_set (GTK_CONTAINER (mw->priv->main_stack),                           grid,                           "icon-name", "input-dialpad-symbolic", NULL);  g_signal_connect (mw, "key-press-event",                    G_CALLBACK (key_press_event_cb), mw);}

static void guides_presets_set_visibility(dt_lib_live_view_t *lib, int which){  if(which == 0)  {    gtk_widget_set_no_show_all(lib->guides_widgets, TRUE);    gtk_widget_hide(lib->guides_widgets);    gtk_widget_set_no_show_all(lib->flip_guides, TRUE);    gtk_widget_hide(lib->flip_guides);  }  else  {    GtkWidget *widget = g_list_nth_data(lib->guides_widgets_list, which - 1);    if(widget)    {      gtk_widget_set_no_show_all(lib->guides_widgets, FALSE);      gtk_widget_show_all(lib->guides_widgets);      gtk_stack_set_visible_child(GTK_STACK(lib->guides_widgets), widget);    }    else    {      gtk_widget_set_no_show_all(lib->guides_widgets, TRUE);      gtk_widget_hide(lib->guides_widgets);    }    gtk_widget_set_no_show_all(lib->flip_guides, FALSE);    gtk_widget_show_all(lib->flip_guides);  }  // TODO: add a support_flip flag to guides to hide the flip gui?}