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); }
static void set_mode (GisAccountPage *page, UmAccountMode mode) { GisAccountPagePrivate *priv = gis_account_page_get_instance_private (page); if (priv->mode == mode) return; priv->mode = mode; gis_driver_set_account_mode (GIS_PAGE (page)->driver, mode); switch (mode) { case UM_LOCAL: gtk_stack_set_visible_child (GTK_STACK (priv->stack), priv->page_local); gis_account_page_local_shown (GIS_ACCOUNT_PAGE_LOCAL (priv->page_local)); break; case UM_ENTERPRISE: gtk_stack_set_visible_child (GTK_STACK (priv->stack), priv->page_enterprise); gis_account_page_enterprise_shown (GIS_ACCOUNT_PAGE_ENTERPRISE (priv->page_enterprise)); break; default: g_assert_not_reached (); } update_page_validation (page); }
void gt_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 void ephy_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 void gtk_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 void photos_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 actions void gt_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 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); } }
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 void as_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 void gs_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 void clickity (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 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; } }
//TODO: Make this action void gt_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 void search_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 void open_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 void show_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 void update_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 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); }
void gt_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 void close_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 void page_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 void get_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 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); }
static void updated_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 (×tamp)); gtk_widget_set_tooltip_text (win->database_toggle_button, db_text); }
int main (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 void ekiga_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? }