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?
}
