static bool_t init (void)
{
search_tool = aud_plugin_lookup_basename ("search-tool");
aud_config_set_defaults ("gtkui", gtkui_defaults);
pw_col_init ();
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_has_resize_grip ((GtkWindow *) window, FALSE);
g_signal_connect(G_OBJECT(window), "delete-event", G_CALLBACK(window_delete), NULL);
accel = gtk_accel_group_new ();
gtk_window_add_accel_group ((GtkWindow *) window, accel);
vbox_outer = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add ((GtkContainer *) window, vbox_outer);
menu_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start ((GtkBox *) vbox_outer, menu_box, FALSE, FALSE, 0);
toolbar = gtk_toolbar_new ();
gtk_toolbar_set_style ((GtkToolbar *) toolbar, GTK_TOOLBAR_ICONS);
GtkStyleContext * context = gtk_widget_get_style_context (toolbar);
gtk_style_context_add_class (context, GTK_STYLE_CLASS_PRIMARY_TOOLBAR);
gtk_box_pack_start ((GtkBox *) vbox_outer, toolbar, FALSE, FALSE, 0);
/* search button */
if (search_tool)
{
search_button = toggle_button_new ("edit-find", toggle_search_tool);
gtk_toolbar_insert ((GtkToolbar *) toolbar, search_button, -1);
gtk_toggle_tool_button_set_active ((GtkToggleToolButton *) search_button,
aud_plugin_get_enabled (search_tool));
aud_plugin_add_watch (search_tool, search_tool_toggled, NULL);
}
/* playback buttons */
toolbar_button_add (toolbar, button_open_pressed, "document-open");
toolbar_button_add (toolbar, button_add_pressed, "list-add");
button_play = toolbar_button_add (toolbar, aud_drct_play_pause, "media-playback-start");
button_stop = toolbar_button_add (toolbar, aud_drct_stop, "media-playback-stop");
toolbar_button_add (toolbar, aud_drct_pl_prev, "media-skip-backward");
toolbar_button_add (toolbar, aud_drct_pl_next, "media-skip-forward");
/* time slider and label */
GtkToolItem * boxitem1 = gtk_tool_item_new ();
gtk_tool_item_set_expand (boxitem1, TRUE);
gtk_toolbar_insert ((GtkToolbar *) toolbar, boxitem1, -1);
GtkWidget * box1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_add ((GtkContainer *) boxitem1, box1);
slider = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, NULL);
gtk_range_set_increments ((GtkRange *) slider, 5000, 5000);
gtk_scale_set_draw_value(GTK_SCALE(slider), FALSE);
gtk_widget_set_size_request(slider, 120, -1);
gtk_widget_set_valign (slider, GTK_ALIGN_CENTER);
gtk_widget_set_can_focus(slider, FALSE);
gtk_box_pack_start ((GtkBox *) box1, slider, TRUE, TRUE, 6);
label_time = markup_label_new(NULL);
gtk_box_pack_end ((GtkBox *) box1, label_time, FALSE, FALSE, 6);
gtk_widget_set_no_show_all (slider, TRUE);
gtk_widget_set_no_show_all (label_time, TRUE);
/* repeat and shuffle buttons */
button_repeat = toggle_button_new ("media-playlist-repeat", toggle_repeat);
gtk_toolbar_insert ((GtkToolbar *) toolbar, button_repeat, -1);
button_shuffle = toggle_button_new ("media-playlist-shuffle", toggle_shuffle);
gtk_toolbar_insert ((GtkToolbar *) toolbar, button_shuffle, -1);
/* volume button */
GtkToolItem * boxitem2 = gtk_tool_item_new ();
gtk_toolbar_insert ((GtkToolbar *) toolbar, boxitem2, -1);
GtkWidget * box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_add ((GtkContainer *) boxitem2, box2);
volume = gtk_volume_button_new();
gtk_button_set_relief(GTK_BUTTON(volume), GTK_RELIEF_NONE);
gtk_scale_button_set_adjustment(GTK_SCALE_BUTTON(volume), GTK_ADJUSTMENT(gtk_adjustment_new(0, 0, 100, 1, 5, 0)));
gtk_widget_set_can_focus(volume, FALSE);
int lvol = 0, rvol = 0;
aud_drct_get_volume(&lvol, &rvol);
gtk_scale_button_set_value(GTK_SCALE_BUTTON(volume), (lvol + rvol) / 2);
gtk_box_pack_start ((GtkBox *) box2, volume, FALSE, FALSE, 0);
/* main UI layout */
layout_load ();
GtkWidget * layout = layout_new ();
gtk_box_pack_start ((GtkBox *) vbox_outer, layout, TRUE, TRUE, 0);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
layout_add_center (vbox);
ui_playlist_notebook_new ();
gtk_box_pack_start ((GtkBox *) vbox, (GtkWidget *) UI_PLAYLIST_NOTEBOOK, TRUE, TRUE, 0);
/* optional UI elements */
show_menu (aud_get_bool ("gtkui", "menu_visible"));
show_infoarea (aud_get_bool ("gtkui", "infoarea_visible"));
if (aud_get_bool ("gtkui", "statusbar_visible"))
{
statusbar = ui_statusbar_new ();
gtk_box_pack_end ((GtkBox *) vbox_outer, statusbar, FALSE, FALSE, 0);
}
AUDDBG("hooks associate\n");
ui_hooks_associate();
AUDDBG("playlist associate\n");
ui_playlist_notebook_populate();
g_signal_connect(slider, "change-value", G_CALLBACK(ui_slider_change_value_cb), NULL);
g_signal_connect(slider, "button-press-event", G_CALLBACK(ui_slider_button_press_cb), NULL);
g_signal_connect(slider, "button-release-event", G_CALLBACK(ui_slider_button_release_cb), NULL);
volume_change_handler_id = g_signal_connect(volume, "value-changed", G_CALLBACK(ui_volume_value_changed_cb), NULL);
g_signal_connect(volume, "pressed", G_CALLBACK(ui_volume_pressed_cb), NULL);
g_signal_connect(volume, "released", G_CALLBACK(ui_volume_released_cb), NULL);
update_volume_timeout_source = g_timeout_add(250, (GSourceFunc) ui_volume_slider_update, volume);
g_signal_connect (window, "map-event", (GCallback) window_mapped_cb, NULL);
g_signal_connect (window, "key-press-event", (GCallback) window_keypress_cb, NULL);
g_signal_connect (UI_PLAYLIST_NOTEBOOK, "key-press-event", (GCallback) playlist_keypress_cb, NULL);
if (aud_drct_get_playing ())
{
ui_playback_begin ();
if (aud_drct_get_ready ())
ui_playback_ready ();
}
else
ui_playback_stop ();
title_change_cb ();
gtk_widget_show_all (vbox_outer);
update_toggles (NULL, NULL);
menu_rclick = make_menu_rclick (accel);
menu_tab = make_menu_tab (accel);
return TRUE;
}
/* Create a new TilemKeypadDialog. */
TilemKeypadDialog *tilem_keypad_dialog_new(TilemDebugger *dbg)
{
TilemKeypadDialog *kpdlg;
GtkWidget *tbl1, *tbl2, *hbox, *vbox, *btn, *lbl;
int i, j;
char buf[20];
g_return_val_if_fail(dbg != NULL, NULL);
kpdlg = g_slice_new0(TilemKeypadDialog);
kpdlg->dbg = dbg;
kpdlg->window = gtk_dialog_new_with_buttons
(_("Keypad"), NULL, 0,
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
NULL);
g_signal_connect(kpdlg->window, "delete-event",
G_CALLBACK(gtk_widget_hide_on_delete), NULL);
tbl1 = gtk_table_new(NGROUPS, NKEYS, TRUE);
hbox = gtk_hbox_new(TRUE, 0);
vbox = gtk_vbox_new(TRUE, 0);
/* Keypad buttons (labels will be filled in, and buttons
shown/hidden, by tilem_keypad_dialog_calc_changed())
Buttons are displayed right to left, top to bottom; this
way, the layout of groups 1-5 roughly corresponds to the
physical layout of the keys, and the "input" value can be
read across the bottom as a binary number. */
for (i = 0; i < NGROUPS; i++) {
for (j = 0; j < NKEYS; j++) {
btn = gtk_toggle_button_new_with_label("");
kpdlg->keys[i][j] = btn;
gtk_table_attach(GTK_TABLE(tbl1), btn,
NKEYS - j - 1, NKEYS - j,
i, i + 1,
GTK_FILL, GTK_FILL, 2, 2);
g_signal_connect(btn, "toggled",
G_CALLBACK(key_toggled), kpdlg);
gtk_widget_set_no_show_all(btn, TRUE);
}
}
/* Check buttons for key groups (output bits) */
for (i = 0; i < NGROUPS; i++) {
g_snprintf(buf, sizeof(buf), _("Group %d"), i);
btn = gtk_check_button_new_with_label(buf);
kpdlg->output[i] = btn;
gtk_box_pack_start(GTK_BOX(vbox), btn, FALSE, TRUE, 2);
g_signal_connect(btn, "toggled",
G_CALLBACK(group_toggled), kpdlg);
}
/* Labels for input bits */
for (j = NKEYS - 1; j >= 0; j--) {
kpdlg->input[j] = lbl = gtk_label_new("");
gtk_box_pack_start(GTK_BOX(hbox), lbl, FALSE, TRUE, 2);
}
tbl2 = gtk_table_new(3, 2, FALSE);
gtk_container_set_border_width(GTK_CONTAINER(tbl2), 6);
gtk_table_set_row_spacings(GTK_TABLE(tbl2), 12);
gtk_table_set_col_spacings(GTK_TABLE(tbl2), 12);
lbl = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(lbl), _("<b>Scan Groups</b>"));
gtk_table_attach(GTK_TABLE(tbl2), lbl, 0, 1, 0, 1,
GTK_FILL, GTK_FILL, 0, 0);
lbl = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(lbl), _("<b>Keys</b>"));
gtk_table_attach(GTK_TABLE(tbl2), lbl, 1, 2, 0, 1,
GTK_FILL, GTK_FILL, 0, 0);
lbl = gtk_label_new(_("Input Value:"));
gtk_table_attach(GTK_TABLE(tbl2), lbl, 0, 1, 2, 3,
GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(tbl2), vbox, 0, 1, 1, 2,
GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(tbl2), tbl1, 1, 2, 1, 2,
GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(tbl2), hbox, 1, 2, 2, 3,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show_all(tbl2);
vbox = gtk_dialog_get_content_area(GTK_DIALOG(kpdlg->window));
gtk_box_pack_start(GTK_BOX(vbox), tbl2, FALSE, FALSE, 0);
tilem_keypad_dialog_calc_changed(kpdlg);
return kpdlg;
}
GtkWidget *
gimp_thumb_box_new (GimpContext *context)
{
GimpThumbBox *box;
GtkWidget *vbox;
GtkWidget *vbox2;
GtkWidget *ebox;
GtkWidget *hbox;
GtkWidget *button;
GtkWidget *label;
gchar *str;
gint h, v;
GtkRequisition info_requisition;
GtkRequisition progress_requisition;
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
box = g_object_new (GIMP_TYPE_THUMB_BOX, NULL);
box->context = context;
ebox = gtk_event_box_new ();
gtk_container_add (GTK_CONTAINER (box), ebox);
gtk_widget_show (ebox);
g_signal_connect (ebox, "button-press-event",
G_CALLBACK (gimp_thumb_box_ebox_button_press),
box);
str = g_strdup_printf (_("Click to update preview\n"
"%s%sClick to force update even "
"if preview is up-to-date"),
gimp_get_mod_string (GDK_CONTROL_MASK),
gimp_get_mod_separator ());
gimp_help_set_help_data (ebox, str, NULL);
g_free (str);
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (ebox), vbox);
gtk_widget_show (vbox);
button = gtk_button_new ();
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
label = gtk_label_new_with_mnemonic (_("Pr_eview"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_container_add (GTK_CONTAINER (button), label);
gtk_widget_show (label);
g_signal_connect (button, "button-press-event",
G_CALLBACK (gtk_true),
NULL);
g_signal_connect (button, "button-release-event",
G_CALLBACK (gtk_true),
NULL);
g_signal_connect (button, "enter-notify-event",
G_CALLBACK (gtk_true),
NULL);
g_signal_connect (button, "leave-notify-event",
G_CALLBACK (gtk_true),
NULL);
vbox2 = gtk_vbox_new (FALSE, 6);
gtk_container_set_border_width (GTK_CONTAINER (vbox2), 2);
gtk_container_add (GTK_CONTAINER (vbox), vbox2);
gtk_widget_show (vbox2);
hbox = gtk_hbox_new (TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
box->imagefile = gimp_imagefile_new (context->gimp, NULL);
g_signal_connect (box->imagefile, "info-changed",
G_CALLBACK (gimp_thumb_box_imagefile_info_changed),
box);
g_signal_connect (box->imagefile->thumbnail, "notify::thumb-state",
G_CALLBACK (gimp_thumb_box_thumb_state_notify),
box);
gimp_view_renderer_get_frame_size (&h, &v);
box->preview = gimp_view_new (context,
GIMP_VIEWABLE (box->imagefile),
/* add padding for the shadow frame */
context->gimp->config->thumbnail_size +
MAX (h, v),
0, FALSE);
gtk_box_pack_start (GTK_BOX (hbox), box->preview, TRUE, FALSE, 2);
gtk_widget_show (box->preview);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), box->preview);
g_signal_connect (box->preview, "clicked",
G_CALLBACK (gimp_thumb_box_thumbnail_clicked),
box);
box->filename = gtk_label_new (_("No selection"));
gtk_label_set_ellipsize (GTK_LABEL (box->filename), PANGO_ELLIPSIZE_MIDDLE);
gtk_label_set_justify (GTK_LABEL (box->filename), GTK_JUSTIFY_CENTER);
gimp_label_set_attributes (GTK_LABEL (box->filename),
PANGO_ATTR_STYLE, PANGO_STYLE_OBLIQUE,
-1);
gtk_box_pack_start (GTK_BOX (vbox2), box->filename, FALSE, FALSE, 0);
gtk_widget_show (box->filename);
box->info = gtk_label_new (" \n \n \n ");
gtk_misc_set_alignment (GTK_MISC (box->info), 0.5, 0.0);
gtk_label_set_justify (GTK_LABEL (box->info), GTK_JUSTIFY_CENTER);
gimp_label_set_attributes (GTK_LABEL (box->info),
PANGO_ATTR_SCALE, PANGO_SCALE_SMALL,
-1);
gtk_box_pack_start (GTK_BOX (vbox2), box->info, FALSE, FALSE, 0);
gtk_widget_show (box->info);
box->progress = gtk_progress_bar_new ();
gtk_progress_bar_set_text (GTK_PROGRESS_BAR (box->progress), "Fog");
gtk_box_pack_end (GTK_BOX (vbox2), box->progress, FALSE, FALSE, 0);
gtk_widget_set_no_show_all (box->progress, TRUE);
/* don't gtk_widget_show (box->progress); */
/* eek */
gtk_widget_size_request (box->info, &info_requisition);
gtk_widget_size_request (box->progress, &progress_requisition);
gtk_widget_set_size_request (box->info,
progress_requisition.width,
info_requisition.height);
gtk_widget_set_size_request (box->filename,
progress_requisition.width, -1);
gtk_widget_set_size_request (box->progress, -1,
progress_requisition.height);
gtk_progress_bar_set_text (GTK_PROGRESS_BAR (box->progress), "");
return GTK_WIDGET (box);
}
Compose * compose_new(Config * config)
{
Compose * compose;
GtkAccelGroup * group;
GtkWidget * vbox;
GtkWidget * toolbar;
GtkToolItem * toolitem;
GtkSizeGroup * sizegroup;
GtkWidget * vpaned;
GtkWidget * vbox2;
GtkWidget * widget;
GtkCellRenderer * renderer;
GtkTreeViewColumn * column;
GtkTreeIter iter;
char const * headers[] = {
"To:", "Cc:", "Bcc:", "Reply-To:", "Newsgroup:",
"Followup-To:" };
size_t i;
gint size;
if((compose = malloc(sizeof(*compose))) == NULL)
{
compose_error(NULL, strerror(errno), 0);
return NULL;
}
compose->mime = mime_new(NULL);
/* check errors */
if(compose->mime == NULL)
{
free(compose);
return NULL;
}
compose->config = config;
compose->standalone = FALSE;
/* window */
group = gtk_accel_group_new();
compose->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_add_accel_group(GTK_WINDOW(compose->window), group);
g_object_unref(group);
#ifndef EMBEDDED
gtk_window_set_default_size(GTK_WINDOW(compose->window), 512, 384);
#else
gtk_window_set_default_size(GTK_WINDOW(compose->window), 200, 300);
#endif
gtk_window_set_title(GTK_WINDOW(compose->window), _("Compose"));
#if GTK_CHECK_VERSION(2, 6, 0)
gtk_window_set_icon_name(GTK_WINDOW(compose->window), "mailer");
#endif
g_signal_connect_swapped(G_OBJECT(compose->window), "delete-event",
G_CALLBACK(_compose_on_closex), compose);
#if GTK_CHECK_VERSION(3, 0, 0)
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
#else
vbox = gtk_vbox_new(FALSE, 0);
#endif
/* menubar */
#ifndef EMBEDDED
widget = desktop_menubar_create(_compose_menubar, compose, group);
gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, FALSE, 0);
#endif
/* toolbar */
toolbar = desktop_toolbar_create(_compose_toolbar, compose, group);
gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, TRUE, 0);
/* from */
sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
toolbar = gtk_toolbar_new();
widget = gtk_label_new(_("From: "));
#if GTK_CHECK_VERSION(3, 14, 0)
g_object_set(widget, "halign", GTK_ALIGN_START, NULL);
#else
gtk_misc_set_alignment(GTK_MISC(widget), 0.1, 0.5);
#endif
gtk_widget_set_size_request(widget, 80, -1);
gtk_size_group_add_widget(sizegroup, widget);
toolitem = gtk_tool_item_new();
gtk_container_add(GTK_CONTAINER(toolitem), widget);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
#if GTK_CHECK_VERSION(2, 24, 0)
compose->from = gtk_combo_box_text_new_with_entry();
#else
compose->from = gtk_combo_box_entry_new_text();
#endif
toolitem = gtk_tool_item_new();
gtk_tool_item_set_expand(toolitem, TRUE);
gtk_container_add(GTK_CONTAINER(toolitem), compose->from);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0);
/* paned */
#if GTK_CHECK_VERSION(3, 0, 0)
vpaned = gtk_paned_new(GTK_ORIENTATION_VERTICAL);
#else
vpaned = gtk_vpaned_new();
#endif
if(gtk_icon_size_lookup(GTK_ICON_SIZE_MENU, &size, &size) != TRUE)
size = 24;
gtk_paned_set_position(GTK_PANED(vpaned), size * 2);
/* headers */
widget = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
compose->h_store = gtk_list_store_new(CHC_COUNT, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_BOOLEAN);
compose->h_store_filter = gtk_tree_model_filter_new(GTK_TREE_MODEL(
compose->h_store), NULL);
gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(
compose->h_store_filter),
_compose_on_headers_filter, compose, NULL);
compose->h_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(
compose->h_store_filter));
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(compose->h_view),
FALSE);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(compose->h_view), TRUE);
compose->h_headers = gtk_list_store_new(2, G_TYPE_STRING,
G_TYPE_STRING);
for(i = 0; i < sizeof(headers) / sizeof(*headers); i++)
{
gtk_list_store_append(compose->h_headers, &iter);
gtk_list_store_set(compose->h_headers, &iter, 0, headers[i], 1,
headers[i], -1);
}
renderer = gtk_cell_renderer_combo_new();
g_object_set(renderer, "editable", TRUE, "model", compose->h_headers,
"text-column", 1, NULL);
g_signal_connect(G_OBJECT(renderer), "edited", G_CALLBACK(
_on_header_field_edited), compose);
column = gtk_tree_view_column_new_with_attributes("", renderer, "text",
CHC_HEADER, NULL);
gtk_tree_view_column_set_min_width(column, 80);
gtk_tree_view_append_column(GTK_TREE_VIEW(compose->h_view), column);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "editable", TRUE, NULL);
g_signal_connect(G_OBJECT(renderer), "edited", G_CALLBACK(
_on_header_edited), compose);
column = gtk_tree_view_column_new_with_attributes("", renderer, "text",
CHC_VALUE, NULL);
#if GTK_CHECK_VERSION(2, 4, 0)
gtk_tree_view_column_set_expand(column, TRUE);
#endif
gtk_tree_view_append_column(GTK_TREE_VIEW(compose->h_view), column);
/* default to 8-bits transfers with UTF-8 encoding */
compose_set_header(compose, "Content-Transfer-Encoding:", "8bit",
FALSE);
compose_set_header(compose, "Content-Type:",
"text/plain; charset=UTF-8", FALSE);
compose_add_field(compose, "To:", NULL);
gtk_container_add(GTK_CONTAINER(widget), compose->h_view);
gtk_paned_add1(GTK_PANED(vpaned), widget);
/* paned */
#if GTK_CHECK_VERSION(3, 0, 0)
vbox2 = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
#else
vbox2 = gtk_vbox_new(FALSE, 0);
#endif
/* subject */
toolbar = gtk_toolbar_new();
widget = gtk_label_new(_("Subject: "));
#if GTK_CHECK_VERSION(3, 14, 0)
g_object_set(widget, "halign", GTK_ALIGN_START, NULL);
#else
gtk_misc_set_alignment(GTK_MISC(widget), 0.1, 0.5);
#endif
gtk_size_group_add_widget(sizegroup, widget);
toolitem = gtk_tool_item_new();
gtk_container_add(GTK_CONTAINER(toolitem), widget);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
compose->subject = gtk_entry_new();
toolitem = gtk_tool_item_new();
gtk_tool_item_set_expand(toolitem, TRUE);
gtk_container_add(GTK_CONTAINER(toolitem), compose->subject);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
gtk_box_pack_start(GTK_BOX(vbox2), toolbar, FALSE, TRUE, 0);
/* view */
widget = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
compose->view = _new_text_view(compose);
compose_set_font(compose, _compose_get_font(compose));
gtk_container_add(GTK_CONTAINER(widget), compose->view);
gtk_box_pack_start(GTK_BOX(vbox2), widget, TRUE, TRUE, 0);
gtk_paned_add2(GTK_PANED(vpaned), vbox2);
gtk_box_pack_start(GTK_BOX(vbox), vpaned, TRUE, TRUE, 0);
/* attachments */
compose->a_window = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(compose->a_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER);
compose->a_store = gtk_list_store_new(CAC_COUNT, G_TYPE_STRING,
G_TYPE_STRING, GDK_TYPE_PIXBUF, G_TYPE_POINTER);
compose->a_view = gtk_icon_view_new_with_model(GTK_TREE_MODEL(
compose->a_store));
gtk_icon_view_set_pixbuf_column(GTK_ICON_VIEW(compose->a_view),
CAC_ICON);
gtk_icon_view_set_selection_mode(GTK_ICON_VIEW(compose->a_view),
GTK_SELECTION_MULTIPLE);
gtk_icon_view_set_text_column(GTK_ICON_VIEW(compose->a_view),
CAC_BASENAME);
gtk_container_add(GTK_CONTAINER(compose->a_window), compose->a_view);
gtk_widget_show_all(compose->a_view);
gtk_widget_set_no_show_all(compose->a_window, TRUE);
gtk_box_pack_start(GTK_BOX(vbox), compose->a_window, FALSE, TRUE, 0);
/* statusbar */
compose->statusbar = gtk_statusbar_new();
compose->statusbar_id = 0;
gtk_box_pack_start(GTK_BOX(vbox), compose->statusbar, FALSE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(compose->window), vbox);
/* about dialog */
compose->ab_window = NULL;
/* signature */
compose_append_signature(compose);
compose_set_modified(compose, FALSE);
compose_scroll_to_offset(compose, 0);
/* display */
gtk_widget_grab_focus(compose->view);
gtk_widget_show_all(vbox);
gtk_widget_show(compose->window);
return compose;
}
static void edit_preset(const char *name_in, dt_iop_module_t *module)
{
gchar *name = NULL;
if(name_in == NULL)
{
name = get_active_preset_name(module);
if(name == NULL) return;
}
else
name = g_strdup(name_in);
GtkWidget *dialog;
/* Create the widgets */
char title[1024];
GtkWidget *window = dt_ui_main_window(darktable.gui->ui);
snprintf(title, sizeof(title), _("edit `%s' for module `%s'"), name, module->name());
dialog = gtk_dialog_new_with_buttons(title, GTK_WINDOW(window), GTK_DIALOG_DESTROY_WITH_PARENT, _("_ok"),
GTK_RESPONSE_ACCEPT, _("_cancel"), GTK_RESPONSE_REJECT, NULL);
GtkContainer *content_area = GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog)));
GtkBox *box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 5));
gtk_widget_set_margin_start(GTK_WIDGET(box), DT_PIXEL_APPLY_DPI(10));
gtk_widget_set_margin_end(GTK_WIDGET(box), DT_PIXEL_APPLY_DPI(10));
gtk_widget_set_margin_top(GTK_WIDGET(box), DT_PIXEL_APPLY_DPI(10));
gtk_widget_set_margin_bottom(GTK_WIDGET(box), DT_PIXEL_APPLY_DPI(10));
gtk_container_add(content_area, GTK_WIDGET(box));
GtkWidget *label;
dt_gui_presets_edit_dialog_t *g
= (dt_gui_presets_edit_dialog_t *)malloc(sizeof(dt_gui_presets_edit_dialog_t));
g->old_id = -1;
g->original_name = name;
g->module = module;
g->name = GTK_ENTRY(gtk_entry_new());
gtk_entry_set_text(g->name, name);
gtk_box_pack_start(box, GTK_WIDGET(g->name), FALSE, FALSE, 0);
gtk_widget_set_tooltip_text(GTK_WIDGET(g->name), _("name of the preset"));
g->description = GTK_ENTRY(gtk_entry_new());
gtk_box_pack_start(box, GTK_WIDGET(g->description), FALSE, FALSE, 0);
gtk_widget_set_tooltip_text(GTK_WIDGET(g->description), _("description or further information"));
g->autoapply
= GTK_CHECK_BUTTON(gtk_check_button_new_with_label(_("auto apply this preset to matching images")));
gtk_box_pack_start(box, GTK_WIDGET(g->autoapply), FALSE, FALSE, 0);
g->filter
= GTK_CHECK_BUTTON(gtk_check_button_new_with_label(_("only show this preset for matching images")));
gtk_widget_set_tooltip_text(GTK_WIDGET(g->filter), _("be very careful with this option. "
"this might be the last time you see your preset."));
gtk_box_pack_start(box, GTK_WIDGET(g->filter), FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(g->autoapply), "toggled", G_CALLBACK(check_buttons_activated), g);
g_signal_connect(G_OBJECT(g->filter), "toggled", G_CALLBACK(check_buttons_activated), g);
int line = 0;
g->details = gtk_grid_new();
gtk_grid_set_row_spacing(GTK_GRID(g->details), DT_PIXEL_APPLY_DPI(5));
gtk_grid_set_column_spacing(GTK_GRID(g->details), DT_PIXEL_APPLY_DPI(10));
gtk_box_pack_start(box, GTK_WIDGET(g->details), TRUE, TRUE, 0);
// model, maker, lens
g->model = gtk_entry_new();
gtk_widget_set_hexpand(GTK_WIDGET(g->model), TRUE);
gtk_widget_set_tooltip_text(g->model, _("string to match model (use % as wildcard)"));
label = gtk_label_new(_("model"));
gtk_widget_set_halign(label, GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(g->details), label, 0, line++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(g->details), g->model, label, GTK_POS_RIGHT, 2, 1);
g->maker = gtk_entry_new();
gtk_widget_set_tooltip_text(g->maker, _("string to match maker (use % as wildcard)"));
label = gtk_label_new(_("maker"));
gtk_widget_set_halign(label, GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(g->details), label, 0, line++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(g->details), g->maker, label, GTK_POS_RIGHT, 2, 1);
g->lens = gtk_entry_new();
gtk_widget_set_tooltip_text(g->lens, _("string to match lens (use % as wildcard)"));
label = gtk_label_new(_("lens"));
gtk_widget_set_halign(label, GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(g->details), label, 0, line++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(g->details), g->lens, label, GTK_POS_RIGHT, 2, 1);
// iso
label = gtk_label_new(_("ISO"));
gtk_widget_set_halign(label, GTK_ALIGN_START);
g->iso_min = gtk_spin_button_new_with_range(0, 51200, 100);
gtk_widget_set_tooltip_text(g->iso_min, _("minimum ISO value"));
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(g->iso_min), 0);
g->iso_max = gtk_spin_button_new_with_range(0, 51200, 100);
gtk_widget_set_tooltip_text(g->iso_max, _("maximum ISO value"));
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(g->iso_max), 0);
gtk_grid_attach(GTK_GRID(g->details), label, 0, line++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(g->details), g->iso_min, label, GTK_POS_RIGHT, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(g->details), g->iso_max, g->iso_min, GTK_POS_RIGHT, 1, 1);
// exposure
label = gtk_label_new(_("exposure"));
gtk_widget_set_halign(label, GTK_ALIGN_START);
g->exposure_min = dt_bauhaus_combobox_new(NULL);
g->exposure_max = dt_bauhaus_combobox_new(NULL);
gtk_widget_set_tooltip_text(g->exposure_min, _("minimum exposure time"));
gtk_widget_set_tooltip_text(g->exposure_max, _("maximum exposure time"));
for(int k = 0; k < dt_gui_presets_exposure_value_cnt; k++)
dt_bauhaus_combobox_add(g->exposure_min, dt_gui_presets_exposure_value_str[k]);
for(int k = 0; k < dt_gui_presets_exposure_value_cnt; k++)
dt_bauhaus_combobox_add(g->exposure_max, dt_gui_presets_exposure_value_str[k]);
gtk_grid_attach(GTK_GRID(g->details), label, 0, line++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(g->details), g->exposure_min, label, GTK_POS_RIGHT, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(g->details), g->exposure_max, g->exposure_min, GTK_POS_RIGHT, 1, 1);
// aperture
label = gtk_label_new(_("aperture"));
gtk_widget_set_halign(label, GTK_ALIGN_START);
g->aperture_min = dt_bauhaus_combobox_new(NULL);
g->aperture_max = dt_bauhaus_combobox_new(NULL);
gtk_widget_set_tooltip_text(g->aperture_min, _("minimum aperture value"));
gtk_widget_set_tooltip_text(g->aperture_max, _("maximum aperture value"));
for(int k = 0; k < dt_gui_presets_aperture_value_cnt; k++)
dt_bauhaus_combobox_add(g->aperture_min, dt_gui_presets_aperture_value_str[k]);
for(int k = 0; k < dt_gui_presets_aperture_value_cnt; k++)
dt_bauhaus_combobox_add(g->aperture_max, dt_gui_presets_aperture_value_str[k]);
gtk_grid_attach(GTK_GRID(g->details), label, 0, line++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(g->details), g->aperture_min, label, GTK_POS_RIGHT, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(g->details), g->aperture_max, g->aperture_min, GTK_POS_RIGHT, 1, 1);
// focal length
label = gtk_label_new(_("focal length"));
gtk_widget_set_halign(label, GTK_ALIGN_START);
g->focal_length_min = gtk_spin_button_new_with_range(0, 1000, 10);
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(g->focal_length_min), 0);
g->focal_length_max = gtk_spin_button_new_with_range(0, 1000, 10);
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(g->focal_length_max), 0);
gtk_widget_set_tooltip_text(g->focal_length_min, _("minimum focal length"));
gtk_widget_set_tooltip_text(g->focal_length_max, _("maximum focal length"));
gtk_grid_attach(GTK_GRID(g->details), label, 0, line++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(g->details), g->focal_length_min, label, GTK_POS_RIGHT, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(g->details), g->focal_length_max, g->focal_length_min, GTK_POS_RIGHT, 1, 1);
// raw/hdr/ldr
label = gtk_label_new(_("format"));
gtk_widget_set_halign(label, GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(g->details), label, 0, line, 1, 1);
for(int i = 0; i < 3; i++)
{
g->format_btn[i] = gtk_check_button_new_with_label(_(dt_gui_presets_format_value_str[i]));
gtk_grid_attach(GTK_GRID(g->details), g->format_btn[i], 1, line + i, 2, 1);
}
gtk_widget_set_no_show_all(GTK_WIDGET(g->details), TRUE);
sqlite3_stmt *stmt;
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db),
"SELECT rowid, description, model, maker, lens, iso_min, iso_max, "
"exposure_min, exposure_max, aperture_min, aperture_max, focal_length_min, "
"focal_length_max, autoapply, filter, format FROM presets WHERE name = ?1 AND "
"operation = ?2 AND op_version = ?3",
-1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, name, -1, SQLITE_TRANSIENT);
DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 2, module->op, -1, SQLITE_TRANSIENT);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 3, module->version());
if(sqlite3_step(stmt) == SQLITE_ROW)
{
g->old_id = sqlite3_column_int(stmt, 0);
gtk_entry_set_text(GTK_ENTRY(g->description), (const char *)sqlite3_column_text(stmt, 1));
gtk_entry_set_text(GTK_ENTRY(g->model), (const char *)sqlite3_column_text(stmt, 2));
gtk_entry_set_text(GTK_ENTRY(g->maker), (const char *)sqlite3_column_text(stmt, 3));
gtk_entry_set_text(GTK_ENTRY(g->lens), (const char *)sqlite3_column_text(stmt, 4));
gtk_spin_button_set_value(GTK_SPIN_BUTTON(g->iso_min), sqlite3_column_double(stmt, 5));
gtk_spin_button_set_value(GTK_SPIN_BUTTON(g->iso_max), sqlite3_column_double(stmt, 6));
float val = sqlite3_column_double(stmt, 7);
int k = 0;
for(; k < dt_gui_presets_exposure_value_cnt && val > dt_gui_presets_exposure_value[k]; k++)
;
dt_bauhaus_combobox_set(g->exposure_min, k);
val = sqlite3_column_double(stmt, 8);
for(k = 0; k < dt_gui_presets_exposure_value_cnt && val > dt_gui_presets_exposure_value[k]; k++)
;
dt_bauhaus_combobox_set(g->exposure_max, k);
val = sqlite3_column_double(stmt, 9);
for(k = 0; k < dt_gui_presets_aperture_value_cnt && val > dt_gui_presets_aperture_value[k]; k++)
;
dt_bauhaus_combobox_set(g->aperture_min, k);
val = sqlite3_column_double(stmt, 10);
for(k = 0; k < dt_gui_presets_aperture_value_cnt && val > dt_gui_presets_aperture_value[k]; k++)
;
dt_bauhaus_combobox_set(g->aperture_max, k);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(g->focal_length_min), sqlite3_column_double(stmt, 11));
gtk_spin_button_set_value(GTK_SPIN_BUTTON(g->focal_length_max), sqlite3_column_double(stmt, 12));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->autoapply), sqlite3_column_int(stmt, 13));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->filter), sqlite3_column_int(stmt, 14));
const int format = sqlite3_column_int(stmt, 15);
for(k = 0; k < 3; k++)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->format_btn[k]), format & (dt_gui_presets_format_flag[k]));
}
else
{
gtk_entry_set_text(GTK_ENTRY(g->description), "");
gtk_entry_set_text(GTK_ENTRY(g->model), "%");
gtk_entry_set_text(GTK_ENTRY(g->maker), "%");
gtk_entry_set_text(GTK_ENTRY(g->lens), "%");
gtk_spin_button_set_value(GTK_SPIN_BUTTON(g->iso_min), 0);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(g->iso_max), 51200);
float val = 0;
int k = 0;
for(; k < dt_gui_presets_exposure_value_cnt && val > dt_gui_presets_exposure_value[k]; k++)
;
dt_bauhaus_combobox_set(g->exposure_min, k);
val = 100000000;
for(k = 0; k < dt_gui_presets_exposure_value_cnt && val > dt_gui_presets_exposure_value[k]; k++)
;
dt_bauhaus_combobox_set(g->exposure_max, k);
val = 0;
for(k = 0; k < dt_gui_presets_aperture_value_cnt && val > dt_gui_presets_aperture_value[k]; k++)
;
dt_bauhaus_combobox_set(g->aperture_min, k);
val = 100000000;
for(k = 0; k < dt_gui_presets_aperture_value_cnt && val > dt_gui_presets_aperture_value[k]; k++)
;
dt_bauhaus_combobox_set(g->aperture_max, k);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(g->focal_length_min), 0);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(g->focal_length_max), 1000);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->autoapply), 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->filter), 0);
for(k = 0; k < 3; k++) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->format_btn[k]), TRUE);
}
sqlite3_finalize(stmt);
g_signal_connect(dialog, "response", G_CALLBACK(edit_preset_response), g);
gtk_widget_show_all(dialog);
}
static void
polkit_mate_authentication_dialog_constructed (GObject *object)
{
PolkitMateAuthenticationDialog *dialog;
GtkWidget *hbox;
GtkWidget *main_vbox;
GtkWidget *vbox;
GtkWidget *table_alignment;
GtkWidget *table;
GtkWidget *details_expander;
GtkWidget *details_vbox;
GtkWidget *label;
GtkWidget *image;
GtkWidget *content_area;
GtkWidget *action_area;
gboolean have_user_combobox;
gchar *s;
guint rows;
dialog = POLKIT_MATE_AUTHENTICATION_DIALOG (object);
if (G_OBJECT_CLASS (polkit_mate_authentication_dialog_parent_class)->constructed != NULL)
G_OBJECT_CLASS (polkit_mate_authentication_dialog_parent_class)->constructed (object);
have_user_combobox = FALSE;
dialog->priv->cancel_button = gtk_dialog_add_button (GTK_DIALOG (dialog),
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL);
dialog->priv->auth_button = gtk_dialog_add_button (GTK_DIALOG (dialog),
_("_Authenticate"),
GTK_RESPONSE_OK);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
action_area = gtk_dialog_get_action_area (GTK_DIALOG (dialog));
gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
gtk_box_set_spacing (GTK_BOX (content_area), 2); /* 2 * 5 + 2 = 12 */
gtk_container_set_border_width (GTK_CONTAINER (action_area), 5);
gtk_box_set_spacing (GTK_BOX (action_area), 6);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
gtk_window_set_icon_name (GTK_WINDOW (dialog), GTK_STOCK_DIALOG_AUTHENTICATION);
hbox = gtk_hbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
gtk_box_pack_start (GTK_BOX (content_area), hbox, TRUE, TRUE, 0);
image = get_image (dialog);
gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.0);
gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0);
main_vbox = gtk_vbox_new (FALSE, 10);
gtk_box_pack_start (GTK_BOX (hbox), main_vbox, TRUE, TRUE, 0);
/* main message */
label = gtk_label_new (NULL);
s = g_strdup_printf ("<big><b>%s</b></big>", dialog->priv->message);
gtk_label_set_markup (GTK_LABEL (label), s);
g_free (s);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_box_pack_start (GTK_BOX (main_vbox), label, FALSE, FALSE, 0);
/* secondary message */
label = gtk_label_new (NULL);
if (g_strv_length (dialog->priv->users) > 1)
{
gtk_label_set_markup (GTK_LABEL (label),
_("An application is attempting to perform an action that requires privileges. "
"Authentication as one of the users below is required to perform this action."));
}
else
{
if (strcmp (g_get_user_name (), dialog->priv->users[0]) == 0)
{
gtk_label_set_markup (GTK_LABEL (label),
_("An application is attempting to perform an action that requires privileges. "
"Authentication is required to perform this action."));
}
else
{
gtk_label_set_markup (GTK_LABEL (label),
_("An application is attempting to perform an action that requires privileges. "
"Authentication as the super user is required to perform this action."));
}
}
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_box_pack_start (GTK_BOX (main_vbox), label, FALSE, FALSE, 0);
/* user combobox */
if (g_strv_length (dialog->priv->users) > 1)
{
dialog->priv->user_combobox = gtk_combo_box_new ();
gtk_box_pack_start (GTK_BOX (main_vbox), GTK_WIDGET (dialog->priv->user_combobox), FALSE, FALSE, 0);
create_user_combobox (dialog);
have_user_combobox = TRUE;
}
else
{
dialog->priv->selected_user = g_strdup (dialog->priv->users[0]);
}
/* password entry */
vbox = gtk_vbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0);
table_alignment = gtk_alignment_new (0.0, 0.0, 1.0, 1.0);
gtk_box_pack_start (GTK_BOX (vbox), table_alignment, FALSE, FALSE, 0);
table = gtk_table_new (1, 2, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 12);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_container_add (GTK_CONTAINER (table_alignment), table);
dialog->priv->password_entry = gtk_entry_new ();
gtk_entry_set_visibility (GTK_ENTRY (dialog->priv->password_entry), FALSE);
dialog->priv->prompt_label = add_row (table, 0, _("_Password:"******"activate",
G_CALLBACK (gtk_window_activate_default),
dialog);
dialog->priv->table_alignment = table_alignment;
/* initially never show the password entry stuff; we'll toggle it on/off so it's
* only shown when prompting for a password */
gtk_widget_set_no_show_all (dialog->priv->table_alignment, TRUE);
/* A label for showing PAM_TEXT_INFO and PAM_TEXT_ERROR messages */
label = gtk_label_new (NULL);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
dialog->priv->info_label = label;
/* Details */
details_expander = gtk_expander_new_with_mnemonic (_("<small><b>_Details</b></small>"));
gtk_expander_set_use_markup (GTK_EXPANDER (details_expander), TRUE);
gtk_box_pack_start (GTK_BOX (content_area), details_expander, FALSE, FALSE, 0);
details_vbox = gtk_vbox_new (FALSE, 10);
gtk_container_add (GTK_CONTAINER (details_expander), details_vbox);
table_alignment = gtk_alignment_new (0.0, 0.0, 1.0, 1.0);
gtk_box_pack_start (GTK_BOX (details_vbox), table_alignment, FALSE, FALSE, 0);
table = gtk_table_new (1, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 12);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_container_add (GTK_CONTAINER (table_alignment), table);
/* TODO: sort keys? */
rows = 0;
if (dialog->priv->details != NULL)
{
guint n;
gchar **keys;
keys = polkit_details_get_keys (dialog->priv->details);
for (n = 0; keys[n] != NULL; n++)
{
const gchar *key = keys[n];
const gchar *value;
value = polkit_details_lookup (dialog->priv->details, key);
label = gtk_label_new (NULL);
s = g_strdup_printf ("<small>%s</small>", value);
gtk_label_set_markup (GTK_LABEL (label), s);
g_free (s);
gtk_misc_set_alignment (GTK_MISC (label), 0, 1.0);
s = g_strdup_printf ("<small><b>%s:</b></small>", key);
add_row (table, rows, s, label);
g_free (s);
rows++;
}
g_strfreev (keys);
}
/* --- */
label = gtk_label_new (NULL);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
s = g_strdup_printf ("<small><a href=\"%s\">%s</a></small>",
dialog->priv->action_id,
dialog->priv->action_id);
gtk_label_set_markup (GTK_LABEL (label), s);
g_free (s);
gtk_misc_set_alignment (GTK_MISC (label), 0, 1.0);
add_row (table, rows++, _("<small><b>Action:</b></small>"), label);
g_signal_connect (label, "activate-link", G_CALLBACK (action_id_activated), NULL);
s = g_strdup_printf (_("Click to edit %s"), dialog->priv->action_id);
gtk_widget_set_tooltip_markup (label, s);
g_free (s);
/* --- */
label = gtk_label_new (NULL);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
s = g_strdup_printf ("<small><a href=\"%s\">%s</a></small>",
dialog->priv->vendor_url,
dialog->priv->vendor);
gtk_label_set_markup (GTK_LABEL (label), s);
g_free (s);
gtk_misc_set_alignment (GTK_MISC (label), 0, 1.0);
add_row (table, rows++, _("<small><b>Vendor:</b></small>"), label);
s = g_strdup_printf (_("Click to open %s"), dialog->priv->vendor_url);
gtk_widget_set_tooltip_markup (label, s);
g_free (s);
if (have_user_combobox)
{
/* ... and make the password entry and "Authenticate" button insensitive */
gtk_widget_set_sensitive (dialog->priv->prompt_label, FALSE);
gtk_widget_set_sensitive (dialog->priv->password_entry, FALSE);
gtk_widget_set_sensitive (dialog->priv->auth_button, FALSE);
}
else
{
}
gtk_widget_realize (GTK_WIDGET (dialog));
}
Download * download_new(DownloadPrefs * prefs, char const * url)
{
Download * download;
char * p;
char buf[256];
GtkWidget * vbox;
GtkWidget * hbox;
GtkSizeGroup * left;
GtkWidget * widget;
PangoFontDescription * bold;
unsigned long id;
/* verify arguments */
if(prefs == NULL || url == NULL)
{
errno = EINVAL;
_download_error(NULL, NULL, 1);
return NULL;
}
if((download = malloc(sizeof(*download))) == NULL)
{
_download_error(NULL, "malloc", 1);
return NULL;
}
/* initialize structure */
download->prefs.output = (prefs->output != NULL) ? strdup(prefs->output)
: NULL;
download->prefs.user_agent = (prefs->user_agent != NULL)
? strdup(prefs->user_agent) : NULL;
if((p = _ghtml_make_url(NULL, url)) != NULL)
url = p;
download->url = strdup(url);
free(p);
if(download->url != NULL && prefs->output == NULL)
download->prefs.output = strdup(basename(download->url));
download->conn = NULL;
download->data_received = 0;
download->content_length = 0;
download->timeout = 0;
download->pulse = 0;
/* verify initialization */
if((prefs->output != NULL && download->prefs.output == NULL)
|| (prefs->user_agent != NULL
&& download->prefs.user_agent == NULL)
|| download->url == NULL
|| gettimeofday(&download->tv, NULL) != 0)
{
_download_error(NULL, "gettimeofday", 1);
download_delete(download);
return NULL;
}
/* window */
if(prefs->embedded == 0)
{
download->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
snprintf(buf, sizeof(buf), "%s %s", _("Download"),
download->url);
#if GTK_CHECK_VERSION(2, 6, 0)
gtk_window_set_icon_name(GTK_WINDOW(download->window),
"stock_download");
#endif
gtk_window_set_resizable(GTK_WINDOW(download->window), FALSE);
gtk_window_set_title(GTK_WINDOW(download->window), buf);
g_signal_connect_swapped(download->window, "delete-event",
G_CALLBACK(_download_on_closex), download);
}
else
{
download->window = gtk_plug_new(0);
g_signal_connect_swapped(download->window, "embedded",
G_CALLBACK(_download_on_embedded), download);
}
#if GTK_CHECK_VERSION(3, 0, 0)
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 2);
#else
vbox = gtk_vbox_new(FALSE, 2);
#endif
bold = pango_font_description_new();
pango_font_description_set_weight(bold, PANGO_WEIGHT_BOLD);
left = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
/* address */
#if GTK_CHECK_VERSION(3, 0, 0)
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);
#else
hbox = gtk_hbox_new(FALSE, 4);
#endif
widget = gtk_label_new(_("Address: "));
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_widget_override_font(widget, bold);
g_object_set(widget, "halign", GTK_ALIGN_START, NULL);
#else
gtk_widget_modify_font(widget, bold);
gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);
#endif
gtk_size_group_add_widget(left, widget);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0);
download->address = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(download->address), download->url);
gtk_editable_set_editable(GTK_EDITABLE(download->address), FALSE);
gtk_box_pack_start(GTK_BOX(hbox), download->address, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
/* labels */
_download_label(vbox, bold, left, _("File: "), &download->filename,
download->prefs.output);
_download_label(vbox, bold, left, _("Status: "), &download->status,
_("Resolving..."));
_download_label(vbox, bold, left, _("Received: "), &download->received,
_("0.0 kB"));
_download_label(vbox, bold, left, _("Remaining: "),
&download->remaining, _("Unknown"));
/* progress bar */
download->progress = gtk_progress_bar_new();
gtk_box_pack_start(GTK_BOX(vbox), download->progress, FALSE, FALSE, 0);
/* checkbox */
download->check = gtk_check_button_new_with_label(
_("Close window when the download is complete"));
gtk_box_pack_start(GTK_BOX(vbox), download->check, FALSE, FALSE, 0);
/* button */
#if GTK_CHECK_VERSION(3, 0, 0)
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);
#else
hbox = gtk_hbox_new(FALSE, 4);
#endif
download->cancel = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
g_signal_connect_swapped(download->cancel, "clicked", G_CALLBACK(
_download_on_cancel), download);
gtk_box_pack_end(GTK_BOX(hbox), download->cancel, FALSE, TRUE, 0);
download->browse = gtk_button_new_with_mnemonic("_Open folder");
gtk_widget_set_no_show_all(download->browse, TRUE);
widget = gtk_image_new_from_stock(GTK_STOCK_OPEN, GTK_ICON_SIZE_BUTTON);
gtk_button_set_image(GTK_BUTTON(download->browse), widget);
g_signal_connect_swapped(download->browse, "clicked", G_CALLBACK(
_download_on_browse), download);
gtk_box_pack_end(GTK_BOX(hbox), download->browse, FALSE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(download->window), 4);
gtk_container_add(GTK_CONTAINER(download->window), vbox);
download->timeout = g_idle_add(_download_on_idle, download);
_download_refresh(download);
gtk_widget_show_all(vbox);
if(prefs->embedded == 0)
gtk_widget_show(download->window);
else
{
id = gtk_plug_get_id(GTK_PLUG(download->window));
printf("%lu\n", id);
fclose(stdout);
}
_download_cnt++;
return download;
}
static void
impl_constructed (GObject *object)
{
RBPodcastAddDialog *dialog;
GtkBuilder *builder;
GtkWidget *widget;
GtkWidget *paned;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
RBEntryView *episodes;
RBShellPlayer *shell_player;
RhythmDBQuery *query;
RhythmDBQueryModel *query_model;
const char *episode_strings[3];
RB_CHAIN_GOBJECT_METHOD (rb_podcast_add_dialog_parent_class, constructed, object);
dialog = RB_PODCAST_ADD_DIALOG (object);
g_object_get (dialog->priv->podcast_mgr, "db", &dialog->priv->db, NULL);
builder = rb_builder_load ("podcast-add-dialog.ui", NULL);
dialog->priv->info_bar_message = gtk_label_new ("");
dialog->priv->info_bar = gtk_info_bar_new ();
g_object_set (dialog->priv->info_bar, "spacing", 0, NULL);
gtk_container_add (GTK_CONTAINER (gtk_info_bar_get_content_area (GTK_INFO_BAR (dialog->priv->info_bar))),
dialog->priv->info_bar_message);
gtk_widget_set_no_show_all (dialog->priv->info_bar, TRUE);
gtk_box_pack_start (GTK_BOX (dialog), dialog->priv->info_bar, FALSE, FALSE, 0);
gtk_widget_show (dialog->priv->info_bar_message);
dialog->priv->subscribe_button = GTK_WIDGET (gtk_builder_get_object (builder, "subscribe-button"));
g_signal_connect_object (dialog->priv->subscribe_button, "clicked", G_CALLBACK (subscribe_clicked_cb), dialog, 0);
gtk_widget_set_sensitive (dialog->priv->subscribe_button, FALSE);
dialog->priv->feed_view = GTK_WIDGET (gtk_builder_get_object (builder, "feed-view"));
g_signal_connect (dialog->priv->feed_view, "row-activated", G_CALLBACK (feed_activated_cb), dialog);
g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->priv->feed_view)),
"changed",
G_CALLBACK (feed_selection_changed_cb),
dialog);
dialog->priv->search_entry = rb_search_entry_new (FALSE);
gtk_widget_set_size_request (GTK_WIDGET (dialog->priv->search_entry), 400, -1);
g_object_set (dialog->priv->search_entry,"explicit-mode", TRUE, NULL);
g_signal_connect (dialog->priv->search_entry, "search", G_CALLBACK (search_cb), dialog);
g_signal_connect (dialog->priv->search_entry, "activate", G_CALLBACK (search_cb), dialog);
gtk_container_add (GTK_CONTAINER (gtk_builder_get_object (builder, "search-entry-box")),
GTK_WIDGET (dialog->priv->search_entry));
g_signal_connect (gtk_builder_get_object (builder, "close-button"),
"clicked",
G_CALLBACK (close_clicked_cb),
dialog);
dialog->priv->feed_model = gtk_list_store_new (7,
G_TYPE_STRING, /* name */
G_TYPE_STRING, /* author */
GDK_TYPE_PIXBUF, /* image */
G_TYPE_FILE, /* image file */
G_TYPE_INT, /* episode count */
G_TYPE_POINTER, /* RBPodcastChannel */
G_TYPE_ULONG); /* date */
gtk_tree_view_set_model (GTK_TREE_VIEW (dialog->priv->feed_view), GTK_TREE_MODEL (dialog->priv->feed_model));
column = gtk_tree_view_column_new_with_attributes (_("Title"), gtk_cell_renderer_pixbuf_new (), "pixbuf", FEED_COLUMN_IMAGE, NULL);
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column, renderer, "text", FEED_COLUMN_TITLE, NULL);
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->priv->feed_view), column);
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
column = gtk_tree_view_column_new_with_attributes (_("Author"), renderer, "text", FEED_COLUMN_AUTHOR, NULL);
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->priv->feed_view), column);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Episodes"), renderer, NULL);
gtk_tree_view_column_set_cell_data_func (column, renderer, episode_count_column_cell_data_func, NULL, NULL);
episode_strings[0] = "0000";
episode_strings[1] = _("Episodes");
episode_strings[2] = NULL;
rb_set_tree_view_column_fixed_width (dialog->priv->feed_view, column, renderer, episode_strings, 6);
gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->priv->feed_view), column);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "podcast-add-dialog"));
gtk_box_pack_start (GTK_BOX (dialog), widget, TRUE, TRUE, 0);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (dialog->priv->feed_view), TRUE);
/* set up episode view */
g_object_get (dialog->priv->shell, "shell-player", &shell_player, NULL);
episodes = rb_entry_view_new (dialog->priv->db, G_OBJECT (shell_player), TRUE, FALSE);
g_object_unref (shell_player);
g_signal_connect (episodes, "entry-activated", G_CALLBACK (episode_entry_activated_cb), dialog);
/* date column */
column = gtk_tree_view_column_new ();
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_clickable (column, TRUE);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
{
const char *sample_strings[3];
sample_strings[0] = _("Date");
sample_strings[1] = rb_entry_view_get_time_date_column_sample ();
sample_strings[2] = NULL;
rb_entry_view_set_fixed_column_width (episodes, column, renderer, sample_strings);
}
gtk_tree_view_column_set_cell_data_func (column, renderer,
(GtkTreeCellDataFunc) podcast_post_date_cell_data_func,
dialog, NULL);
rb_entry_view_append_column_custom (episodes, column,
_("Date"), "Date",
(GCompareDataFunc) podcast_post_date_sort_func,
0, NULL);
rb_entry_view_append_column (episodes, RB_ENTRY_VIEW_COL_TITLE, TRUE);
rb_entry_view_append_column (episodes, RB_ENTRY_VIEW_COL_DURATION, TRUE);
rb_entry_view_set_sorting_order (RB_ENTRY_VIEW (episodes), "Date", GTK_SORT_DESCENDING);
g_signal_connect (episodes,
"notify::sort-order",
G_CALLBACK (episodes_sort_changed_cb),
dialog);
query = rhythmdb_query_parse (dialog->priv->db,
RHYTHMDB_QUERY_PROP_EQUALS,
RHYTHMDB_PROP_TYPE,
RHYTHMDB_ENTRY_TYPE_PODCAST_SEARCH,
RHYTHMDB_QUERY_END);
query_model = rhythmdb_query_model_new_empty (dialog->priv->db);
rb_entry_view_set_model (episodes, query_model);
rhythmdb_do_full_query_async_parsed (dialog->priv->db, RHYTHMDB_QUERY_RESULTS (query_model), query);
rhythmdb_query_free (query);
g_object_unref (query_model);
paned = GTK_WIDGET (gtk_builder_get_object (builder, "paned"));
g_signal_connect (paned, "size-allocate", G_CALLBACK (paned_size_allocate_cb), dialog);
gtk_paned_pack2 (GTK_PANED (paned),
GTK_WIDGET (episodes),
TRUE,
FALSE);
gtk_widget_show_all (GTK_WIDGET (dialog));
g_object_unref (builder);
}
static void
main_window_error_display (EmpathyMainWindow *window,
TpAccount *account,
const gchar *message)
{
GtkWidget *info_bar;
GtkWidget *content_area;
GtkWidget *label;
GtkWidget *image;
GtkWidget *retry_button;
GtkWidget *edit_button;
GtkWidget *close_button;
GtkWidget *action_area;
GtkWidget *action_table;
gchar *str;
const gchar *icon_name;
str = g_markup_printf_escaped ("<b>%s</b>\n%s",
tp_account_get_display_name (account),
message);
info_bar = g_hash_table_lookup (window->errors, account);
if (info_bar) {
label = g_object_get_data (G_OBJECT (info_bar), "label");
/* Just set the latest error and return */
gtk_label_set_markup (GTK_LABEL (label), str);
g_free (str);
return;
}
info_bar = gtk_info_bar_new ();
gtk_info_bar_set_message_type (GTK_INFO_BAR (info_bar), GTK_MESSAGE_ERROR);
gtk_widget_set_no_show_all (info_bar, TRUE);
gtk_box_pack_start (GTK_BOX (window->errors_vbox), info_bar, FALSE, TRUE, 0);
gtk_widget_show (info_bar);
icon_name = tp_account_get_icon_name (account);
image = gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_SMALL_TOOLBAR);
gtk_widget_show (image);
label = gtk_label_new (str);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_widget_show (label);
g_free (str);
content_area = gtk_info_bar_get_content_area (GTK_INFO_BAR (info_bar));
gtk_box_pack_start (GTK_BOX (content_area), image, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (content_area), label, TRUE, TRUE, 0);
image = gtk_image_new_from_stock (GTK_STOCK_REFRESH, GTK_ICON_SIZE_BUTTON);
retry_button = gtk_button_new ();
gtk_button_set_image (GTK_BUTTON (retry_button), image);
gtk_widget_set_tooltip_text (retry_button, _("Reconnect"));
gtk_widget_show (retry_button);
image = gtk_image_new_from_stock (GTK_STOCK_EDIT, GTK_ICON_SIZE_BUTTON);
edit_button = gtk_button_new ();
gtk_button_set_image (GTK_BUTTON (edit_button), image);
gtk_widget_set_tooltip_text (edit_button, _("Edit Account"));
gtk_widget_show (edit_button);
image = gtk_image_new_from_stock (GTK_STOCK_CLOSE, GTK_ICON_SIZE_BUTTON);
close_button = gtk_button_new ();
gtk_button_set_image (GTK_BUTTON (close_button), image);
gtk_widget_set_tooltip_text (close_button, _("Close"));
gtk_widget_show (close_button);
action_table = gtk_table_new (1, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (action_table), 2);
gtk_widget_show (action_table);
action_area = gtk_info_bar_get_action_area (GTK_INFO_BAR (info_bar));
gtk_box_pack_start (GTK_BOX (action_area), action_table, FALSE, FALSE, 0);
gtk_table_attach (GTK_TABLE (action_table), retry_button, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_SHRINK),
(GtkAttachOptions) (GTK_SHRINK), 0, 0);
gtk_table_attach (GTK_TABLE (action_table), edit_button, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_SHRINK),
(GtkAttachOptions) (GTK_SHRINK), 0, 0);
gtk_table_attach (GTK_TABLE (action_table), close_button, 2, 3, 0, 1,
(GtkAttachOptions) (GTK_SHRINK),
(GtkAttachOptions) (GTK_SHRINK), 0, 0);
g_object_set_data (G_OBJECT (info_bar), "label", label);
g_object_set_data_full (G_OBJECT (info_bar),
"account", g_object_ref (account),
g_object_unref);
g_object_set_data_full (G_OBJECT (edit_button),
"account", g_object_ref (account),
g_object_unref);
g_object_set_data_full (G_OBJECT (close_button),
"account", g_object_ref (account),
g_object_unref);
g_object_set_data_full (G_OBJECT (retry_button),
"account", g_object_ref (account),
g_object_unref);
g_signal_connect (edit_button, "clicked",
G_CALLBACK (main_window_error_edit_clicked_cb),
window);
g_signal_connect (close_button, "clicked",
G_CALLBACK (main_window_error_close_clicked_cb),
window);
g_signal_connect (retry_button, "clicked",
G_CALLBACK (main_window_error_retry_clicked_cb),
window);
gtk_widget_show (window->errors_vbox);
g_hash_table_insert (window->errors, g_object_ref (account), info_bar);
}
static void
init_capplet (void)
{
GtkWidget *dialog;
GtkWidget *preview;
GtkWidget *treeview;
GtkWidget *list_scroller;
GtkWidget *activate_delay_hscale;
GtkWidget *activate_delay_hbox;
GtkWidget *label;
GtkWidget *enabled_checkbox;
GtkWidget *lock_checkbox;
GtkWidget *root_warning_label;
GtkWidget *preview_button;
GtkWidget *gpm_button;
GtkWidget *fullscreen_preview_window;
GtkWidget *fullscreen_preview_previous;
GtkWidget *fullscreen_preview_next;
GtkWidget *fullscreen_preview_area;
GtkWidget *fullscreen_preview_close;
char *gtk_builder_file;
gdouble activate_delay;
gboolean enabled;
gboolean is_writable;
GSettings *settings;
GError *error=NULL;
gint mode;
gtk_builder_file = g_build_filename (GTKBUILDERDIR, GTK_BUILDER_FILE, NULL);
builder = gtk_builder_new();
if (!gtk_builder_add_from_file(builder, gtk_builder_file, &error))
{
g_warning("Couldn't load builder file: %s", error->message);
g_error_free(error);
}
g_free (gtk_builder_file);
if (builder == NULL)
{
dialog = gtk_message_dialog_new (NULL,
0, GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK,
_("Could not load the main interface"));
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
_("Please make sure that the screensaver is properly installed"));
gtk_dialog_set_default_response (GTK_DIALOG (dialog),
GTK_RESPONSE_OK);
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
exit (1);
}
preview = GTK_WIDGET (gtk_builder_get_object (builder, "preview_area"));
dialog = GTK_WIDGET (gtk_builder_get_object (builder, "prefs_dialog"));
treeview = GTK_WIDGET (gtk_builder_get_object (builder, "savers_treeview"));
list_scroller = GTK_WIDGET (gtk_builder_get_object (builder, "themes_scrolled_window"));
activate_delay_hscale = GTK_WIDGET (gtk_builder_get_object (builder, "activate_delay_hscale"));
activate_delay_hbox = GTK_WIDGET (gtk_builder_get_object (builder, "activate_delay_hbox"));
enabled_checkbox = GTK_WIDGET (gtk_builder_get_object (builder, "enable_checkbox"));
lock_checkbox = GTK_WIDGET (gtk_builder_get_object (builder, "lock_checkbox"));
root_warning_label = GTK_WIDGET (gtk_builder_get_object (builder, "root_warning_label"));
preview_button = GTK_WIDGET (gtk_builder_get_object (builder, "preview_button"));
gpm_button = GTK_WIDGET (gtk_builder_get_object (builder, "gpm_button"));
fullscreen_preview_window = GTK_WIDGET (gtk_builder_get_object (builder, "fullscreen_preview_window"));
fullscreen_preview_area = GTK_WIDGET (gtk_builder_get_object (builder, "fullscreen_preview_area"));
fullscreen_preview_close = GTK_WIDGET (gtk_builder_get_object (builder, "fullscreen_preview_close"));
fullscreen_preview_previous = GTK_WIDGET (gtk_builder_get_object (builder, "fullscreen_preview_previous_button"));
fullscreen_preview_next = GTK_WIDGET (gtk_builder_get_object (builder, "fullscreen_preview_next_button"));
label = GTK_WIDGET (gtk_builder_get_object (builder, "activate_delay_label"));
gtk_label_set_mnemonic_widget (GTK_LABEL (label), activate_delay_hscale);
label = GTK_WIDGET (gtk_builder_get_object (builder, "savers_label"));
gtk_label_set_mnemonic_widget (GTK_LABEL (label), treeview);
gtk_widget_set_no_show_all (root_warning_label, TRUE);
widget_set_best_colormap (preview);
if (! is_program_in_path (GPM_COMMAND))
{
gtk_widget_set_no_show_all (gpm_button, TRUE);
gtk_widget_hide (gpm_button);
}
activate_delay = config_get_activate_delay (&is_writable);
ui_set_delay (activate_delay);
if (! is_writable)
{
gtk_widget_set_sensitive (activate_delay_hbox, FALSE);
}
g_signal_connect (activate_delay_hscale, "format-value",
G_CALLBACK (format_value_callback_time), NULL);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (lock_checkbox), config_get_lock (&is_writable));
if (! is_writable)
{
gtk_widget_set_sensitive (lock_checkbox, FALSE);
}
g_signal_connect (lock_checkbox, "toggled",
G_CALLBACK (lock_checkbox_toggled), NULL);
enabled = config_get_enabled (&is_writable);
ui_set_enabled (enabled);
if (! is_writable)
{
gtk_widget_set_sensitive (enabled_checkbox, FALSE);
}
g_signal_connect (enabled_checkbox, "toggled",
G_CALLBACK (enabled_checkbox_toggled), NULL);
setup_list_size_constraint (list_scroller, treeview);
gtk_widget_set_size_request (preview, 480, 300);
gtk_window_set_icon_name (GTK_WINDOW (dialog), "preferences-desktop-screensaver");
gtk_window_set_icon_name (GTK_WINDOW (fullscreen_preview_window), "screensaver");
gtk_drag_dest_set (dialog, GTK_DEST_DEFAULT_ALL,
drop_types, G_N_ELEMENTS (drop_types),
GDK_ACTION_COPY | GDK_ACTION_LINK | GDK_ACTION_MOVE);
g_signal_connect (dialog, "drag-motion",
G_CALLBACK (drag_motion_cb), NULL);
g_signal_connect (dialog, "drag-leave",
G_CALLBACK (drag_leave_cb), NULL);
g_signal_connect (dialog, "drag-data-received",
G_CALLBACK (drag_data_received_cb), NULL);
gtk_widget_show_all (dialog);
/* Update list of themes if using random screensaver */
settings = g_settings_new (GSETTINGS_SCHEMA);
mode = g_settings_get_enum (settings, KEY_MODE);
if (mode == GS_MODE_RANDOM) {
gchar **list;
list = get_all_theme_ids (theme_manager);
g_settings_set_strv (settings, KEY_THEMES, (const gchar * const*) list);
g_strfreev (list);
}
g_signal_connect (settings,
"changed",
G_CALLBACK (key_changed_cb),
NULL);
g_object_unref (settings);
preview_clear (preview);
gs_job_set_widget (job, preview);
if (check_is_root_user ())
{
setup_for_root_user ();
}
g_signal_connect (activate_delay_hscale, "value-changed",
G_CALLBACK (activate_delay_value_changed_cb), NULL);
g_signal_connect (dialog, "response",
G_CALLBACK (response_cb), NULL);
g_signal_connect (preview_button, "clicked",
G_CALLBACK (fullscreen_preview_start_cb),
treeview);
g_signal_connect (fullscreen_preview_close, "clicked",
G_CALLBACK (fullscreen_preview_cancelled_cb), NULL);
g_signal_connect (fullscreen_preview_previous, "clicked",
G_CALLBACK (fullscreen_preview_previous_cb), NULL);
g_signal_connect (fullscreen_preview_next, "clicked",
G_CALLBACK (fullscreen_preview_next_cb), NULL);
g_idle_add ((GSourceFunc)setup_treeview_idle, NULL);
}
/**
* vinagre_connect:
* @window: A Window
*
* Return value: (allow-none) (transfer full):
*/
VinagreConnection *
vinagre_connect (VinagreWindow *window)
{
VinagreConnection *conn = NULL;
gint result;
VinagreConnectDialog dialog;
dialog.xml = vinagre_utils_get_builder ();
if (!dialog.xml)
return NULL;
dialog.dialog = GTK_WIDGET (gtk_builder_get_object (dialog.xml, "connect_dialog"));
gtk_window_set_transient_for (GTK_WINDOW (dialog.dialog), GTK_WINDOW (window));
dialog.protocol_combo = GTK_WIDGET (gtk_builder_get_object (dialog.xml, "protocol_combo"));
dialog.protocol_description_label = GTK_WIDGET (gtk_builder_get_object (dialog.xml, "protocol_description_label"));
dialog.host_entry = GTK_WIDGET (gtk_builder_get_object (dialog.xml, "host_entry"));
dialog.find_button = GTK_WIDGET (gtk_builder_get_object (dialog.xml, "find_button"));
dialog.fullscreen_check = GTK_WIDGET (gtk_builder_get_object (dialog.xml, "fullscreen_check"));
dialog.plugin_box = GTK_WIDGET (gtk_builder_get_object (dialog.xml, "plugin_options_connect_vbox"));
dialog.connect_button = GTK_WIDGET (gtk_builder_get_object (dialog.xml, "connect_button"));
setup_protocol (&dialog);
setup_combo (&dialog);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog.fullscreen_check),
vinagre_cache_prefs_get_boolean ("connection", "fullscreen", FALSE));
#ifdef VINAGRE_HAVE_AVAHI
g_signal_connect (dialog.find_button,
"clicked",
G_CALLBACK (vinagre_connect_find_button_cb),
&dialog);
#else
gtk_widget_hide (dialog.find_button);
gtk_widget_set_no_show_all (dialog.find_button, TRUE);
#endif
gtk_widget_show_all (dialog.dialog);
result = gtk_dialog_run (GTK_DIALOG (dialog.dialog));
if (result == GTK_RESPONSE_HELP)
{
vinagre_utils_show_help (GTK_WINDOW (window), "connect");
}
else if (result == GTK_RESPONSE_OK)
{
gchar *host = NULL, *error_msg = NULL, *protocol = NULL, *actual_host;
gint port;
GtkWidget *options;
GtkTreeIter iter;
VinagreProtocol *ext;
host = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT (dialog.host_entry));
gtk_widget_hide (GTK_WIDGET (dialog.dialog));
if (!host || !g_strcmp0 (host, ""))
goto fail;
save_history (dialog.host_entry);
if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (dialog.protocol_combo), &iter))
{
g_warning (_("Could not get the active protocol from the protocol list."));
goto fail;
}
gtk_tree_model_get (GTK_TREE_MODEL (dialog.protocol_store), &iter,
PROTOCOL_NAME, &protocol,
PROTOCOL_OPTIONS, &options,
PROTOCOL_PLUGIN, &ext,
-1);
vinagre_cache_prefs_set_string ("connection", "last-protocol", protocol);
g_free (protocol);
vinagre_cache_prefs_set_boolean ("connection", "fullscreen", gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (dialog.fullscreen_check)));
conn = vinagre_protocol_new_connection (ext);
if (vinagre_connection_split_string (host,
vinagre_connection_get_protocol (conn),
&protocol,
&actual_host,
&port,
&error_msg))
{
g_object_set (conn,
"host", actual_host,
"port", port,
"fullscreen", gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (dialog.fullscreen_check)),
NULL);
if (options)
vinagre_connection_parse_options_widget (conn, options);
g_free (protocol);
g_free (actual_host);
}
else
{
vinagre_utils_show_error_dialog (NULL, error_msg ? error_msg : _("Unknown error"),
GTK_WINDOW (window));
}
g_object_unref (ext);
if (options)
g_object_unref (options);
fail:
g_free (host);
g_free (error_msg);
}
gtk_widget_destroy (dialog.dialog);
g_object_unref (dialog.xml);
return conn;
}
void
gui_init (dt_imageio_module_storage_t *self)
{
self->gui_data = (dt_storage_picasa_gui_data_t *)malloc(sizeof(dt_storage_picasa_gui_data_t));
memset(self->gui_data,0,sizeof(dt_storage_picasa_gui_data_t));
dt_storage_picasa_gui_data_t *ui= self->gui_data;
self->widget = gtk_vbox_new(TRUE, 0);
GtkWidget *hbox1=gtk_hbox_new(FALSE,5);
GtkWidget *vbox1=gtk_vbox_new(FALSE,0);
GtkWidget *vbox2=gtk_vbox_new(FALSE,0);
ui->label1 = GTK_LABEL( gtk_label_new( _("user") ) );
ui->label2 = GTK_LABEL( gtk_label_new( _("password") ) );
ui->label3 = GTK_LABEL( gtk_label_new( _("albums") ) );
ui->label4 = GTK_LABEL( gtk_label_new( NULL ) );
ui->label5 = GTK_LABEL( gtk_label_new( _("title") ) );
ui->label6 = GTK_LABEL( gtk_label_new( _("summary") ) );
ui->label7 = GTK_LABEL( gtk_label_new( _("rights") ) );
gtk_misc_set_alignment(GTK_MISC(ui->label1), 0.0, 0.5);
gtk_misc_set_alignment(GTK_MISC(ui->label2), 0.0, 0.5);
gtk_misc_set_alignment(GTK_MISC(ui->label3), 0.0, 0.5);
gtk_misc_set_alignment(GTK_MISC(ui->label5), 0.0, 0.5);
gtk_misc_set_alignment(GTK_MISC(ui->label6), 0.0, 0.5);
gtk_misc_set_alignment(GTK_MISC(ui->label7), 0.0, 0.5);
ui->entry1 = GTK_ENTRY( gtk_entry_new() );
ui->entry2 = GTK_ENTRY( gtk_entry_new() );
ui->entry3 = GTK_ENTRY( gtk_entry_new() ); // Album title
ui->entry4 = GTK_ENTRY( gtk_entry_new() ); // Album summary
dt_gui_key_accel_block_on_focus (GTK_WIDGET (ui->entry1));
dt_gui_key_accel_block_on_focus (GTK_WIDGET (ui->entry2));
dt_gui_key_accel_block_on_focus (GTK_WIDGET (ui->entry3));
dt_gui_key_accel_block_on_focus (GTK_WIDGET (ui->entry4));
/*
gtk_widget_add_events(GTK_WIDGET(ui->entry1), GDK_FOCUS_CHANGE_MASK);
g_signal_connect (G_OBJECT (ui->entry1), "focus-in-event", G_CALLBACK(focus_in), NULL);
g_signal_connect (G_OBJECT (ui->entry1), "focus-out-event", G_CALLBACK(focus_out), NULL);
gtk_widget_add_events(GTK_WIDGET(ui->entry2), GDK_FOCUS_CHANGE_MASK);
g_signal_connect (G_OBJECT (ui->entry2), "focus-in-event", G_CALLBACK(focus_in), NULL);
g_signal_connect (G_OBJECT (ui->entry2), "focus-out-event", G_CALLBACK(focus_out), NULL);
gtk_widget_add_events(GTK_WIDGET(ui->entry3), GDK_FOCUS_CHANGE_MASK);
g_signal_connect (G_OBJECT (ui->entry3), "focus-in-event", G_CALLBACK(focus_in), NULL);
g_signal_connect (G_OBJECT (ui->entry3), "focus-out-event", G_CALLBACK(focus_out), NULL);
gtk_widget_add_events(GTK_WIDGET(ui->entry4), GDK_FOCUS_CHANGE_MASK);
g_signal_connect (G_OBJECT (ui->entry4), "focus-in-event", G_CALLBACK(focus_in), NULL);
g_signal_connect (G_OBJECT (ui->entry4), "focus-out-event", G_CALLBACK(focus_out), NULL);
*/
GHashTable* table = dt_pwstorage_get("picasa");
gchar* _username = g_strdup( g_hash_table_lookup(table, "username"));
gchar* _password = g_strdup( g_hash_table_lookup(table, "password"));
g_hash_table_destroy(table);
gtk_entry_set_text( ui->entry1, _username == NULL?"":_username );
gtk_entry_set_text( ui->entry2, _password == NULL?"":_password );
gtk_entry_set_text( ui->entry3, _("my new album") );
gtk_entry_set_text( ui->entry4, _("exported from darktable") );
gtk_entry_set_visibility(ui->entry2, FALSE);
GtkWidget *albumlist=gtk_hbox_new(FALSE,0);
ui->comboBox1=GTK_COMBO_BOX( gtk_combo_box_new_text()); // Available albums
dt_ellipsize_combo(ui->comboBox1);
ui->dtbutton1 = DTGTK_BUTTON( dtgtk_button_new(dtgtk_cairo_paint_refresh,0) );
g_object_set(G_OBJECT(ui->dtbutton1), "tooltip-text", _("refresh album list"), (char *)NULL);
gtk_widget_set_sensitive( GTK_WIDGET(ui->comboBox1), FALSE);
gtk_combo_box_set_row_separator_func(ui->comboBox1,combobox_separator,ui->comboBox1,NULL);
gtk_box_pack_start(GTK_BOX(albumlist), GTK_WIDGET(ui->comboBox1), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(albumlist), GTK_WIDGET(ui->dtbutton1), FALSE, FALSE, 0);
ui->checkButton1 = GTK_CHECK_BUTTON( gtk_check_button_new_with_label(_("public album")) );
ui->checkButton2 = GTK_CHECK_BUTTON( gtk_check_button_new_with_label(_("export tags")) );
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON( ui->checkButton2 ),TRUE);
// Auth
gtk_box_pack_start(GTK_BOX(hbox1), vbox1, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox1), vbox2, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), hbox1, TRUE, FALSE, 5);
gtk_box_pack_start(GTK_BOX( vbox1 ), GTK_WIDGET( ui->label1 ), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX( vbox1 ), GTK_WIDGET( ui->label2 ), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX( vbox1 ), GTK_WIDGET( gtk_label_new("")), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX( vbox1 ), GTK_WIDGET( gtk_label_new("")), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX( vbox1 ), GTK_WIDGET( ui->label3 ), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( ui->entry1 ), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( ui->entry2 ), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( ui->label4 ), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( ui->checkButton2 ), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( albumlist ), TRUE, FALSE, 0);
// Create Album
ui->hbox1=GTK_BOX(gtk_hbox_new(FALSE,5));
gtk_widget_set_no_show_all(GTK_WIDGET(ui->hbox1), TRUE);
vbox1=gtk_vbox_new(FALSE,0);
vbox2=gtk_vbox_new(FALSE,0);
gtk_box_pack_start(GTK_BOX(ui->hbox1), vbox1, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(ui->hbox1), vbox2, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(ui->hbox1), TRUE, FALSE, 5);
gtk_box_pack_start(GTK_BOX( vbox1 ), GTK_WIDGET( ui->label5 ), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX( vbox1 ), GTK_WIDGET( ui->label6 ), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX( vbox1 ), GTK_WIDGET( ui->label7 ), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( ui->entry3 ), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( ui->entry4 ), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX( vbox2 ), GTK_WIDGET( ui->checkButton1 ), TRUE, FALSE, 0);
// Setup signals
// add signal on realize and hide gtk_widget_hide(GTK_WIDGET(ui->hbox1));
g_signal_connect(G_OBJECT(ui->dtbutton1), "clicked", G_CALLBACK(button1_clicked), (gpointer)ui);
g_signal_connect(G_OBJECT(ui->entry1), "changed", G_CALLBACK(entry_changed), (gpointer)ui);
g_signal_connect(G_OBJECT(ui->entry2), "changed", G_CALLBACK(entry_changed), (gpointer)ui);
g_signal_connect(G_OBJECT(ui->comboBox1), "changed", G_CALLBACK(album_changed), (gpointer)ui);
// If username and password is stored, let's populate the combo
// if( _username && _password )
// refresh_albums(ui);
if( _username )
g_free( _username );
if( _password )
g_free( _password );
gtk_combo_box_set_active( ui->comboBox1, 0);
}
static void _lib_recentcollection_updated(gpointer instance, gpointer user_data)
{
dt_lib_module_t *self = (dt_lib_module_t *)user_data;
dt_lib_recentcollect_t *d = (dt_lib_recentcollect_t *)self->data;
// serialize, check for recently used
char confname[200];
const int bufsize = 4096;
char buf[bufsize];
if(dt_collection_serialize(buf, bufsize)) return;
// is the current position, i.e. the one to be stored with the old collection (pos0, pos1-to-be)
uint32_t curr_pos = dt_view_lighttable_get_position(darktable.view_manager);
uint32_t new_pos = -1;
if(!d->inited)
{
new_pos = dt_conf_get_int("plugins/lighttable/recentcollect/pos0");
d->inited = 1;
dt_view_lighttable_set_position(darktable.view_manager, new_pos);
}
else if(curr_pos != -1)
{
dt_conf_set_int("plugins/lighttable/recentcollect/pos0", curr_pos);
}
int n = -1;
for(int k = 0; k < CLAMPS(dt_conf_get_int("plugins/lighttable/recentcollect/num_items"), 0, NUM_LINES); k++)
{
// is it already in the current list?
snprintf(confname, sizeof(confname), "plugins/lighttable/recentcollect/line%1d", k);
gchar *line = dt_conf_get_string(confname);
if(!line) continue;
if(!strcmp(line, buf))
{
snprintf(confname, sizeof(confname), "plugins/lighttable/recentcollect/pos%1d", k);
new_pos = dt_conf_get_int(confname);
n = k;
break;
}
g_free(line);
}
if(n < 0)
{
const int num_items = CLAMPS(dt_conf_get_int("plugins/lighttable/recentcollect/num_items"), 0, NUM_LINES);
if(num_items < NUM_LINES)
{
// new, unused entry
n = num_items;
dt_conf_set_int("plugins/lighttable/recentcollect/num_items", num_items + 1);
}
else
{
// kill least recently used entry:
n = num_items - 1;
}
}
if(n >= 0 && n < NUM_LINES)
{
// sort n to the top
for(int k = n; k > 0; k--)
{
snprintf(confname, sizeof(confname), "plugins/lighttable/recentcollect/line%1d", k - 1);
gchar *line1 = dt_conf_get_string(confname);
snprintf(confname, sizeof(confname), "plugins/lighttable/recentcollect/pos%1d", k - 1);
uint32_t pos1 = dt_conf_get_int(confname);
if(line1 && line1[0] != '\0')
{
snprintf(confname, sizeof(confname), "plugins/lighttable/recentcollect/line%1d", k);
dt_conf_set_string(confname, line1);
snprintf(confname, sizeof(confname), "plugins/lighttable/recentcollect/pos%1d", k);
dt_conf_set_int(confname, pos1);
}
g_free(line1);
}
dt_conf_set_string("plugins/lighttable/recentcollect/line0", buf);
dt_conf_set_int("plugins/lighttable/recentcollect/pos0",
(new_pos != -1 ? new_pos : (curr_pos != -1 ? curr_pos : 0)));
}
// update button descriptions:
for(int k = 0; k < NUM_LINES; k++)
{
char str[2048] = { 0 };
char str_cut[200] = { 0 };
char str_pretty[200] = { 0 };
snprintf(confname, sizeof(confname), "plugins/lighttable/recentcollect/line%1d", k);
gchar *line2 = dt_conf_get_string(confname);
if(line2 && line2[0] != '\0') pretty_print(line2, str, sizeof(str));
g_free(line2);
g_object_set(G_OBJECT(d->item[k].button), "tooltip-text", str, (char *)NULL);
const int cut = 45;
if(g_utf8_validate(str, -1, NULL))
{
if(g_utf8_strlen(str, -1) > cut)
{
g_utf8_strncpy(str_cut, str, cut);
snprintf(str_pretty, sizeof(str_pretty), "%s...", str_cut);
gtk_button_set_label(GTK_BUTTON(d->item[k].button), str_pretty);
}
else
{
gtk_button_set_label(GTK_BUTTON(d->item[k].button), str);
}
}
else if(strlen(str) > cut)
{
g_strlcpy(str_cut, str, cut);
snprintf(str_pretty, sizeof(str_pretty), "%s...", str_cut);
gtk_button_set_label(GTK_BUTTON(d->item[k].button), str_pretty);
}
else
{
gtk_button_set_label(GTK_BUTTON(d->item[k].button), str);
}
GtkWidget *child = gtk_bin_get_child(GTK_BIN(d->item[k].button));
if(child)
gtk_widget_set_halign(child, GTK_ALIGN_START);
gtk_widget_set_no_show_all(d->item[k].button, TRUE);
gtk_widget_set_visible(d->item[k].button, FALSE);
}
for(int k = 0; k < CLAMPS(dt_conf_get_int("plugins/lighttable/recentcollect/num_items"), 0, NUM_LINES); k++)
{
gtk_widget_set_no_show_all(d->item[k].button, FALSE);
gtk_widget_set_visible(d->item[k].button, TRUE);
}
if((new_pos != -1) && (new_pos != curr_pos))
dt_view_lighttable_set_position(darktable.view_manager, new_pos);
}
static void
activate (GApplication *gapp)
{
GtkApplication *app = GTK_APPLICATION (gapp);
GtkWidget *window;
GtkWidget *box;
GtkWidget *grid;
GtkWidget *label;
GtkWidget *spin;
GtkWidget *check;
GtkWidget *bar;
window = gtk_application_window_new (app);
gtk_application_add_window (app, GTK_WINDOW (window));
bar = gtk_action_bar_new ();
gtk_widget_set_no_show_all (bar, TRUE);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
grid = gtk_grid_new ();
g_object_set (grid,
"halign", GTK_ALIGN_CENTER,
"margin", 20,
"row-spacing", 12,
"column-spacing", 12,
NULL);
gtk_box_pack_start (GTK_BOX (box), grid, FALSE, FALSE);
label = gtk_label_new ("Start");
gtk_widget_set_halign (label, GTK_ALIGN_END);
spin = gtk_spin_button_new_with_range (0, 10, 1);
g_signal_connect (spin, "notify::value",
G_CALLBACK (change_start), bar);
gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 1);
gtk_grid_attach (GTK_GRID (grid), spin, 1, 0, 1, 1);
label = gtk_label_new ("Center");
gtk_widget_set_halign (label, GTK_ALIGN_END);
check = gtk_check_button_new ();
g_signal_connect (check, "notify::active",
G_CALLBACK (toggle_center), bar);
gtk_grid_attach (GTK_GRID (grid), label, 0, 1, 1, 1);
gtk_grid_attach (GTK_GRID (grid), check, 1, 1, 1, 1);
label = gtk_label_new ("End");
gtk_widget_set_halign (label, GTK_ALIGN_END);
spin = gtk_spin_button_new_with_range (0, 10, 1);
g_signal_connect (spin, "notify::value",
G_CALLBACK (change_end), bar);
gtk_grid_attach (GTK_GRID (grid), label, 0, 2, 1, 1);
gtk_grid_attach (GTK_GRID (grid), spin, 1, 2, 1, 1);
label = gtk_label_new ("Visible");
gtk_widget_set_halign (label, GTK_ALIGN_END);
check = gtk_check_button_new ();
g_signal_connect (check, "notify::active",
G_CALLBACK (toggle_visibility), bar);
gtk_grid_attach (GTK_GRID (grid), label, 0, 3, 1, 1);
gtk_grid_attach (GTK_GRID (grid), check, 1, 3, 1, 1);
gtk_box_pack_end (GTK_BOX (box), bar, FALSE, FALSE);
gtk_container_add (GTK_CONTAINER (window), box);
gtk_widget_show_all (window);
}
static void
bluetooth_chooser_init(BluetoothChooser *self)
{
BluetoothChooserPrivate *priv = BLUETOOTH_CHOOSER_GET_PRIVATE(self);
GtkWidget *vbox;
GtkWidget *hbox;
gtk_widget_push_composite_child ();
g_object_set (G_OBJECT (self), "orientation", GTK_ORIENTATION_VERTICAL, NULL);
priv->client = bluetooth_client_new ();
/* Setup the widget itself */
gtk_box_set_spacing (GTK_BOX(self), 18);
gtk_container_set_border_width (GTK_CONTAINER(self), 0);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_widget_show (vbox);
gtk_box_pack_start (GTK_BOX (self), vbox, TRUE, TRUE, 0);
/* The treeview label */
priv->search_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 24);
gtk_widget_set_name (priv->search_hbox, "search_hbox");
if (priv->show_searching)
gtk_widget_show (priv->search_hbox);
gtk_box_pack_end (GTK_BOX (vbox), priv->search_hbox, FALSE, TRUE, 0);
gtk_widget_set_no_show_all (priv->search_hbox, TRUE);
/* Setup the adapter disco mode callback for the search button */
priv->adapter_model = bluetooth_client_get_adapter_model (priv->client);
g_signal_connect (priv->adapter_model, "row-changed",
G_CALLBACK (adapter_model_row_changed), self);
/* The searching label */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_widget_set_name (hbox, "searching label hbox");
priv->spinner = gtk_spinner_new ();
gtk_container_add (GTK_CONTAINER (hbox), priv->spinner);
gtk_widget_show (priv->spinner);
priv->search_label = gtk_label_new (_("Searching for devices…"));
gtk_container_add (GTK_CONTAINER (hbox), priv->search_label);
gtk_widget_show (priv->search_label);
gtk_widget_show (hbox);
if (priv->show_searching) {
gboolean discovering;
g_object_get (G_OBJECT (priv->client), "default-adapter-discovering", &discovering, NULL);
set_search_label (self, discovering);
}
gtk_box_pack_start (GTK_BOX (priv->search_hbox), hbox, FALSE, TRUE, 0);
/* The treeview */
priv->scrolled_window = create_treeview (self);
gtk_widget_show_all (priv->scrolled_window);
gtk_box_pack_start (GTK_BOX (vbox), priv->scrolled_window, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (priv->scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (priv->scrolled_window), GTK_SHADOW_IN);
/* The filters */
priv->device_type_filter_model = GTK_TREE_MODEL (gtk_list_store_new (DEVICE_TYPE_FILTER_NUM_COLS,
G_TYPE_STRING, G_TYPE_INT));
priv->filters_vbox = bluetooth_filter_widget_new ();
gtk_widget_show (priv->filters_vbox);
gtk_box_pack_start (GTK_BOX (self), priv->filters_vbox, FALSE, TRUE, 0);
gtk_widget_set_no_show_all (priv->filters_vbox, TRUE);
/* if filters are not visible hide the vbox */
if (!priv->show_device_type && !priv->show_device_category)
gtk_widget_hide (priv->filters_vbox);
priv->default_adapter_changed_id = g_signal_connect (priv->client, "notify::default-adapter",
G_CALLBACK (default_adapter_changed), self);
g_signal_connect(self, "notify::device-type-filter",
G_CALLBACK(filter_type_changed_cb), NULL);
g_signal_connect(self, "notify::device-category-filter",
G_CALLBACK(filter_category_changed_cb), NULL);
gtk_widget_pop_composite_child ();
}
static void
create_account_details_ui (GoaProvider *provider,
GtkDialog *dialog,
GtkBox *vbox,
gboolean new_account,
AddAccountData *data)
{
GtkWidget *grid0;
GtkWidget *grid1;
GtkWidget *grid2;
GtkWidget *hbox;
gint width;
goa_utils_set_dialog_title (provider, dialog, new_account);
grid0 = gtk_grid_new ();
gtk_container_set_border_width (GTK_CONTAINER (grid0), 5);
gtk_widget_set_margin_bottom (grid0, 6);
gtk_orientable_set_orientation (GTK_ORIENTABLE (grid0), GTK_ORIENTATION_VERTICAL);
gtk_grid_set_row_spacing (GTK_GRID (grid0), 12);
gtk_container_add (GTK_CONTAINER (vbox), grid0);
data->cluebar = gtk_info_bar_new ();
gtk_info_bar_set_message_type (GTK_INFO_BAR (data->cluebar), GTK_MESSAGE_ERROR);
gtk_widget_set_hexpand (data->cluebar, TRUE);
gtk_widget_set_no_show_all (data->cluebar, TRUE);
gtk_container_add (GTK_CONTAINER (grid0), data->cluebar);
data->cluebar_label = gtk_label_new ("");
gtk_label_set_line_wrap (GTK_LABEL (data->cluebar_label), TRUE);
gtk_container_add (GTK_CONTAINER (gtk_info_bar_get_content_area (GTK_INFO_BAR (data->cluebar))),
data->cluebar_label);
grid1 = gtk_grid_new ();
gtk_orientable_set_orientation (GTK_ORIENTABLE (grid1), GTK_ORIENTATION_VERTICAL);
gtk_grid_set_row_spacing (GTK_GRID (grid1), 12);
grid2 = gtk_grid_new ();
gtk_orientable_set_orientation (GTK_ORIENTABLE (grid2), GTK_ORIENTATION_VERTICAL);
gtk_grid_set_row_spacing (GTK_GRID (grid2), 12);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_box_set_homogeneous (GTK_BOX (hbox), FALSE);
gtk_box_pack_start (GTK_BOX (hbox), grid1, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), grid2, TRUE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (grid0), hbox);
add_entry (grid1, grid2, _("_E-mail"), &data->email_address);
add_entry (grid1, grid2, _("_Password"), &data->password);
if (new_account)
{
data->expander = gtk_expander_new_with_mnemonic (_("_Custom"));
gtk_expander_set_expanded (GTK_EXPANDER (data->expander), FALSE);
gtk_expander_set_resize_toplevel (GTK_EXPANDER (data->expander), TRUE);
gtk_container_add (GTK_CONTAINER (grid0), data->expander);
grid1 = gtk_grid_new ();
gtk_orientable_set_orientation (GTK_ORIENTABLE (grid1), GTK_ORIENTATION_VERTICAL);
gtk_grid_set_row_spacing (GTK_GRID (grid1), 12);
grid2 = gtk_grid_new ();
gtk_orientable_set_orientation (GTK_ORIENTABLE (grid2), GTK_ORIENTATION_VERTICAL);
gtk_grid_set_row_spacing (GTK_GRID (grid2), 12);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_box_set_homogeneous (GTK_BOX (hbox), FALSE);
gtk_box_pack_start (GTK_BOX (hbox), grid1, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), grid2, TRUE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (data->expander), hbox);
add_entry (grid1, grid2, _("User_name"), &data->username);
add_entry (grid1, grid2, _("_Server"), &data->server);
}
gtk_entry_set_visibility (GTK_ENTRY (data->password), FALSE);
gtk_widget_grab_focus ((new_account) ? data->email_address : data->password);
g_signal_connect (data->email_address, "changed", G_CALLBACK (on_email_address_or_password_changed), data);
g_signal_connect (data->password, "changed", G_CALLBACK (on_email_address_or_password_changed), data);
data->spinner_button = goa_spinner_button_new_from_stock (GTK_STOCK_CONNECT);
gtk_dialog_add_action_widget (data->dialog, data->spinner_button, GTK_RESPONSE_OK);
gtk_dialog_set_default_response (data->dialog, GTK_RESPONSE_OK);
gtk_dialog_set_response_sensitive (data->dialog, GTK_RESPONSE_OK, FALSE);
gtk_window_get_size (GTK_WINDOW (data->dialog), &width, NULL);
gtk_widget_set_size_request (GTK_WIDGET (data->dialog), width, -1);
}
/* construct widget above */
void gui_init(struct dt_imageio_module_storage_t *self)
{
self->gui_data = g_malloc0(sizeof(dt_storage_gphoto_gui_data_t));
dt_storage_gphoto_gui_data_t *ui = self->gui_data;
ui->gphoto_api = gphoto_api_init();
self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
// create labels
ui->label_album_title = GTK_LABEL(gtk_label_new(_("title")));
ui->label_status = GTK_LABEL(gtk_label_new(NULL));
gtk_widget_set_halign(GTK_WIDGET(ui->label_album_title), GTK_ALIGN_START);
// create entries
GtkListStore *model_username
= gtk_list_store_new(COMBO_USER_MODEL_NB_COL, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING); // text, token, refresh_token, id
ui->combo_username = GTK_COMBO_BOX(gtk_combo_box_new_with_model(GTK_TREE_MODEL(model_username)));
GtkCellRenderer *p_cell = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(p_cell), "ellipsize", PANGO_ELLIPSIZE_MIDDLE, "ellipsize-set", TRUE, "width-chars", 35,
(gchar *)0);
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(ui->combo_username), p_cell, FALSE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(ui->combo_username), p_cell, "text", 0, NULL);
ui->entry_album_title = GTK_ENTRY(gtk_entry_new());
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->combo_username));
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->entry_album_title));
// retrieve saved accounts
ui_refresh_users(ui);
//////// album list /////////
GtkWidget *albumlist = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
GtkListStore *model_album
= gtk_list_store_new(COMBO_ALBUM_MODEL_NB_COL, G_TYPE_STRING, G_TYPE_STRING); // name, id
ui->combo_album = GTK_COMBO_BOX(gtk_combo_box_new_with_model(GTK_TREE_MODEL(model_album)));
p_cell = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(p_cell), "ellipsize", PANGO_ELLIPSIZE_MIDDLE, "ellipsize-set", TRUE, "width-chars", 35,
(gchar *)0);
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(ui->combo_album), p_cell, FALSE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(ui->combo_album), p_cell, "text", 0, NULL);
gtk_widget_set_sensitive(GTK_WIDGET(ui->combo_album), FALSE);
gtk_combo_box_set_row_separator_func(ui->combo_album, combobox_separator, ui->combo_album, NULL);
gtk_box_pack_start(GTK_BOX(albumlist), GTK_WIDGET(ui->combo_album), TRUE, TRUE, 0);
ui->button_login = GTK_BUTTON(gtk_button_new_with_label(_("login")));
ui->connected = FALSE;
// pack the ui
////the auth box
GtkWidget *hbox_auth = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
GtkWidget *vbox_auth_labels = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
GtkWidget *vbox_auth_fields = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start(GTK_BOX(hbox_auth), vbox_auth_labels, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_auth), vbox_auth_fields, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox_auth), TRUE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(vbox_auth_fields), GTK_WIDGET(ui->combo_username), TRUE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(vbox_auth_labels), GTK_WIDGET(gtk_label_new("")), TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(vbox_auth_fields), GTK_WIDGET(ui->button_login), TRUE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(vbox_auth_fields), GTK_WIDGET(albumlist), TRUE, FALSE, 2);
////the album creation box
ui->hbox_album = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5));
gtk_widget_set_no_show_all(GTK_WIDGET(ui->hbox_album), TRUE); // hide it by default
GtkWidget *vbox_album_labels = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
GtkWidget *vbox_album_fields = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(ui->hbox_album), TRUE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(ui->hbox_album), vbox_album_labels, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(ui->hbox_album), vbox_album_fields, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox_album_labels), GTK_WIDGET(ui->label_album_title), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox_album_fields), GTK_WIDGET(ui->entry_album_title), TRUE, FALSE, 0);
// connect buttons to signals
g_signal_connect(G_OBJECT(ui->button_login), "clicked", G_CALLBACK(ui_login_clicked), (gpointer)ui);
g_signal_connect(G_OBJECT(ui->combo_username), "changed", G_CALLBACK(ui_combo_username_changed),
(gpointer)ui);
g_signal_connect(G_OBJECT(ui->combo_album), "changed", G_CALLBACK(ui_combo_album_changed), (gpointer)ui);
g_object_unref(model_username);
g_object_unref(model_album);
}
static GoaObject *
add_account (GoaProvider *provider,
GoaClient *client,
GtkDialog *dialog,
GtkBox *vbox,
GError **error)
{
AddAccountData data;
GVariantBuilder credentials;
GVariantBuilder details;
GoaEwsClient *ews_client;
GoaObject *ret;
gboolean accept_ssl_errors;
const gchar *email_address;
const gchar *server;
const gchar *password;
const gchar *username;
const gchar *provider_type;
gint response;
ews_client = NULL;
accept_ssl_errors = FALSE;
ret = NULL;
memset (&data, 0, sizeof (AddAccountData));
data.loop = g_main_loop_new (NULL, FALSE);
data.dialog = dialog;
data.error = NULL;
create_account_details_ui (provider, dialog, vbox, TRUE, &data);
gtk_widget_show_all (GTK_WIDGET (vbox));
ews_client = goa_ews_client_new ();
ews_again:
response = gtk_dialog_run (dialog);
if (response != GTK_RESPONSE_OK)
{
g_set_error (&data.error,
GOA_ERROR,
GOA_ERROR_DIALOG_DISMISSED,
_("Dialog was dismissed"));
goto out;
}
email_address = gtk_entry_get_text (GTK_ENTRY (data.email_address));
password = gtk_entry_get_text (GTK_ENTRY (data.password));
username = gtk_entry_get_text (GTK_ENTRY (data.username));
server = gtk_entry_get_text (GTK_ENTRY (data.server));
/* See if there's already an account of this type with the
* given identity
*/
provider_type = goa_provider_get_provider_type (provider);
if (!goa_utils_check_duplicate (client,
username,
provider_type,
(GoaPeekInterfaceFunc) goa_object_peek_password_based,
&data.error))
goto out;
goa_ews_client_autodiscover (ews_client,
email_address,
password,
username,
server,
accept_ssl_errors,
NULL,
autodiscover_cb,
&data);
goa_spinner_button_start (GOA_SPINNER_BUTTON (data.spinner_button));
g_main_loop_run (data.loop);
if (data.error != NULL)
{
gchar *markup;
if (data.error->code == GOA_ERROR_SSL)
{
goa_spinner_button_set_label (GOA_SPINNER_BUTTON (data.spinner_button), _("_Ignore"));
accept_ssl_errors = TRUE;
}
else
{
goa_spinner_button_set_label (GOA_SPINNER_BUTTON (data.spinner_button), _("_Try Again"));
accept_ssl_errors = FALSE;
}
markup = g_strdup_printf ("<b>%s:</b> %s",
_("Error connecting to Microsoft Exchange server"),
data.error->message);
g_clear_error (&data.error);
gtk_label_set_markup (GTK_LABEL (data.cluebar_label), markup);
g_free (markup);
gtk_expander_set_expanded (GTK_EXPANDER (data.expander), TRUE);
gtk_widget_set_no_show_all (data.cluebar, FALSE);
gtk_widget_show_all (data.cluebar);
goto ews_again;
}
gtk_widget_hide (GTK_WIDGET (dialog));
g_variant_builder_init (&credentials, G_VARIANT_TYPE_VARDICT);
g_variant_builder_add (&credentials, "{sv}", "password", g_variant_new_string (password));
g_variant_builder_init (&details, G_VARIANT_TYPE ("a{ss}"));
g_variant_builder_add (&details, "{ss}", "MailEnabled", "true");
g_variant_builder_add (&details, "{ss}", "CalendarEnabled", "true");
g_variant_builder_add (&details, "{ss}", "ContactsEnabled", "true");
g_variant_builder_add (&details, "{ss}", "Host", server);
g_variant_builder_add (&details, "{ss}", "AcceptSslErrors", (accept_ssl_errors) ? "true" : "false");
/* OK, everything is dandy, add the account */
/* we want the GoaClient to update before this method returns (so it
* can create a proxy for the new object) so run the mainloop while
* waiting for this to complete
*/
goa_manager_call_add_account (goa_client_get_manager (client),
goa_provider_get_provider_type (provider),
username,
email_address,
g_variant_builder_end (&credentials),
g_variant_builder_end (&details),
NULL, /* GCancellable* */
(GAsyncReadyCallback) add_account_cb,
&data);
g_main_loop_run (data.loop);
if (data.error != NULL)
goto out;
ret = GOA_OBJECT (g_dbus_object_manager_get_object (goa_client_get_object_manager (client),
data.account_object_path));
out:
/* We might have an object even when data.error is set.
* eg., if we failed to store the credentials in the keyring.
*/
if (data.error != NULL)
g_propagate_error (error, data.error);
else
g_assert (ret != NULL);
g_free (data.account_object_path);
if (data.loop != NULL)
g_main_loop_unref (data.loop);
if (ews_client != NULL)
g_object_unref (ews_client);
return ret;
}
/* construct widget above */
void gui_init(struct dt_imageio_module_storage_t *self)
{
self->gui_data = g_malloc0(sizeof(dt_storage_facebook_gui_data_t));
dt_storage_facebook_gui_data_t *ui = self->gui_data;
ui->facebook_api = fb_api_init();
self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
// create labels
ui->label_album_title = GTK_LABEL(gtk_label_new(_("title")));
ui->label_album_summary = GTK_LABEL(gtk_label_new(_("summary")));
ui->label_album_privacy = GTK_LABEL(gtk_label_new(_("privacy")));
ui->label_status = GTK_LABEL(gtk_label_new(NULL));
gtk_widget_set_halign(GTK_WIDGET(ui->label_album_title), GTK_ALIGN_START);
gtk_widget_set_halign(GTK_WIDGET(ui->label_album_summary), GTK_ALIGN_START);
gtk_widget_set_halign(GTK_WIDGET(ui->label_album_privacy), GTK_ALIGN_START);
// create entries
GtkListStore *model_username = gtk_list_store_new(COMBO_USER_MODEL_NB_COL, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING); // text, token, id
ui->comboBox_username = GTK_COMBO_BOX(gtk_combo_box_new_with_model(GTK_TREE_MODEL(model_username)));
GtkCellRenderer *p_cell = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(ui->comboBox_username), p_cell, FALSE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(ui->comboBox_username), p_cell, "text", 0, NULL);
ui->entry_album_title = GTK_ENTRY(gtk_entry_new());
ui->entry_album_summary = GTK_ENTRY(gtk_entry_new());
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->comboBox_username));
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->entry_album_title));
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->entry_album_summary));
gtk_entry_set_width_chars(GTK_ENTRY(ui->entry_album_title), 0);
gtk_entry_set_width_chars(GTK_ENTRY(ui->entry_album_summary), 0);
// retrieve saved accounts
ui_refresh_users(ui);
//////// album list /////////
GtkWidget *albumlist = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
GtkListStore *model_album
= gtk_list_store_new(COMBO_ALBUM_MODEL_NB_COL, G_TYPE_STRING, G_TYPE_STRING); // name, id
ui->comboBox_album = GTK_COMBO_BOX(gtk_combo_box_new_with_model(GTK_TREE_MODEL(model_album)));
p_cell = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(ui->comboBox_album), p_cell, FALSE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(ui->comboBox_album), p_cell, "text", 0, NULL);
gtk_widget_set_sensitive(GTK_WIDGET(ui->comboBox_album), FALSE);
gtk_combo_box_set_row_separator_func(ui->comboBox_album, combobox_separator, ui->comboBox_album, NULL);
gtk_box_pack_start(GTK_BOX(albumlist), GTK_WIDGET(ui->comboBox_album), TRUE, TRUE, 0);
ui->comboBox_privacy = GTK_COMBO_BOX(gtk_combo_box_text_new());
GtkListStore *list_store = gtk_list_store_new(COMBO_ALBUM_MODEL_NB_COL, G_TYPE_STRING, G_TYPE_INT);
GtkTreeIter iter;
gtk_list_store_append(list_store, &iter);
gtk_list_store_set(list_store, &iter, COMBO_PRIVACY_MODEL_NAME_COL, _("only me"),
COMBO_PRIVACY_MODEL_VAL_COL, FBALBUM_PRIVACY_SELF, -1);
gtk_list_store_append(list_store, &iter);
gtk_list_store_set(list_store, &iter, COMBO_PRIVACY_MODEL_NAME_COL, _("friends"),
COMBO_PRIVACY_MODEL_VAL_COL, FBALBUM_PRIVACY_ALL_FRIENDS, -1);
gtk_list_store_append(list_store, &iter);
gtk_list_store_set(list_store, &iter, COMBO_PRIVACY_MODEL_NAME_COL, _("public"),
COMBO_PRIVACY_MODEL_VAL_COL, FBALBUM_PRIVACY_EVERYONE, -1);
gtk_list_store_append(list_store, &iter);
gtk_list_store_set(list_store, &iter, COMBO_PRIVACY_MODEL_NAME_COL, _("friends of friends"),
COMBO_PRIVACY_MODEL_VAL_COL, FBALBUM_PRIVACY_FRIENDS_OF_FRIENDS, -1);
gtk_combo_box_set_model(ui->comboBox_privacy, GTK_TREE_MODEL(list_store));
gtk_combo_box_set_active(GTK_COMBO_BOX(ui->comboBox_privacy), 1); // Set default permission to private
ui->button_login = GTK_BUTTON(gtk_button_new_with_label(_("login")));
ui->connected = FALSE;
// pack the ui
////the auth box
GtkWidget *hbox_auth = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
GtkWidget *vbox_auth_labels = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
GtkWidget *vbox_auth_fields = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start(GTK_BOX(hbox_auth), vbox_auth_labels, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_auth), vbox_auth_fields, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox_auth), TRUE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(vbox_auth_fields), GTK_WIDGET(ui->comboBox_username), TRUE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(vbox_auth_labels), GTK_WIDGET(gtk_label_new("")), TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(vbox_auth_fields), GTK_WIDGET(ui->button_login), TRUE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(vbox_auth_fields), GTK_WIDGET(albumlist), TRUE, FALSE, 2);
////the album creation box
ui->hbox_album = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5));
gtk_widget_set_no_show_all(GTK_WIDGET(ui->hbox_album), TRUE); // hide it by default
GtkWidget *vbox_album_labels = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
GtkWidget *vbox_album_fields = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(ui->hbox_album), TRUE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(ui->hbox_album), vbox_album_labels, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(ui->hbox_album), vbox_album_fields, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox_album_labels), GTK_WIDGET(ui->label_album_title), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox_album_fields), GTK_WIDGET(ui->entry_album_title), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_album_labels), GTK_WIDGET(ui->label_album_summary), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox_album_fields), GTK_WIDGET(ui->entry_album_summary), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_album_labels), GTK_WIDGET(ui->label_album_privacy), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox_album_fields), GTK_WIDGET(ui->comboBox_privacy), TRUE, FALSE, 0);
// connect buttons to signals
g_signal_connect(G_OBJECT(ui->button_login), "clicked", G_CALLBACK(ui_login_clicked), (gpointer)ui);
g_signal_connect(G_OBJECT(ui->comboBox_username), "changed", G_CALLBACK(ui_combo_username_changed),
(gpointer)ui);
g_signal_connect(G_OBJECT(ui->comboBox_album), "changed", G_CALLBACK(ui_combo_album_changed), (gpointer)ui);
g_object_unref(model_username);
g_object_unref(model_album);
g_object_unref(list_store);
}
static gboolean
refresh_account (GoaProvider *provider,
GoaClient *client,
GoaObject *object,
GtkWindow *parent,
GError **error)
{
AddAccountData data;
GVariantBuilder builder;
GoaAccount *account;
GoaEwsClient *ews_client;
GoaExchange *exchange;
GtkWidget *dialog;
GtkWidget *vbox;
gboolean accept_ssl_errors;
gboolean ret;
const gchar *email_address;
const gchar *server;
const gchar *password;
const gchar *username;
gint response;
g_return_val_if_fail (GOA_IS_EXCHANGE_PROVIDER (provider), FALSE);
g_return_val_if_fail (GOA_IS_CLIENT (client), FALSE);
g_return_val_if_fail (GOA_IS_OBJECT (object), FALSE);
g_return_val_if_fail (parent == NULL || GTK_IS_WINDOW (parent), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
ews_client = NULL;
ret = FALSE;
dialog = gtk_dialog_new_with_buttons (NULL,
parent,
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
NULL);
gtk_container_set_border_width (GTK_CONTAINER (dialog), 12);
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
vbox = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
gtk_box_set_spacing (GTK_BOX (vbox), 12);
memset (&data, 0, sizeof (AddAccountData));
data.loop = g_main_loop_new (NULL, FALSE);
data.dialog = GTK_DIALOG (dialog);
data.error = NULL;
create_account_details_ui (provider, GTK_DIALOG (dialog), GTK_BOX (vbox), FALSE, &data);
account = goa_object_peek_account (object);
email_address = goa_account_get_presentation_identity (account);
gtk_entry_set_text (GTK_ENTRY (data.email_address), email_address);
gtk_editable_set_editable (GTK_EDITABLE (data.email_address), FALSE);
gtk_widget_show_all (dialog);
ews_client = goa_ews_client_new ();
ews_again:
response = gtk_dialog_run (GTK_DIALOG (dialog));
if (response != GTK_RESPONSE_OK)
{
g_set_error (error,
GOA_ERROR,
GOA_ERROR_DIALOG_DISMISSED,
_("Dialog was dismissed"));
goto out;
}
password = gtk_entry_get_text (GTK_ENTRY (data.password));
username = goa_account_get_identity (account);
exchange = goa_object_peek_exchange (object);
accept_ssl_errors = goa_util_lookup_keyfile_boolean (object, "AcceptSslErrors");
server = goa_exchange_get_host (exchange);
goa_ews_client_autodiscover (ews_client,
email_address,
password,
username,
server,
accept_ssl_errors,
NULL,
autodiscover_cb,
&data);
goa_spinner_button_start (GOA_SPINNER_BUTTON (data.spinner_button));
g_main_loop_run (data.loop);
if (data.error != NULL)
{
GtkWidget *button;
gchar *markup;
markup = g_strdup_printf ("<b>%s:</b> %s",
_("Error connecting to Microsoft Exchange server"),
data.error->message);
g_clear_error (&data.error);
gtk_label_set_markup (GTK_LABEL (data.cluebar_label), markup);
g_free (markup);
button = gtk_dialog_get_widget_for_response (data.dialog, GTK_RESPONSE_OK);
gtk_button_set_label (GTK_BUTTON (button), _("_Try Again"));
gtk_widget_set_no_show_all (data.cluebar, FALSE);
gtk_widget_show_all (data.cluebar);
goto ews_again;
}
/* TODO: run in worker thread */
g_variant_builder_init (&builder, G_VARIANT_TYPE_VARDICT);
g_variant_builder_add (&builder, "{sv}", "password", g_variant_new_string (password));
if (!goa_utils_store_credentials_for_object_sync (provider,
object,
g_variant_builder_end (&builder),
NULL, /* GCancellable */
error))
goto out;
goa_account_call_ensure_credentials (account,
NULL, /* GCancellable */
NULL, NULL); /* callback, user_data */
ret = TRUE;
out:
gtk_widget_destroy (dialog);
if (data.loop != NULL)
g_main_loop_unref (data.loop);
if (ews_client != NULL)
g_object_unref (ews_client);
return ret;
}
void gui_init(struct dt_iop_module_t *self)
{
const int high_quality_processing = dt_conf_get_bool("plugins/lighttable/export/force_lcms2");
self->gui_data = malloc(sizeof(dt_iop_colorout_gui_data_t));
memset(self->gui_data,0,sizeof(dt_iop_colorout_gui_data_t));
dt_iop_colorout_gui_data_t *g = (dt_iop_colorout_gui_data_t *)self->gui_data;
g->profiles = NULL;
dt_iop_color_profile_t *prof = (dt_iop_color_profile_t *)g_malloc0(sizeof(dt_iop_color_profile_t));
g_strlcpy(prof->filename, "sRGB", sizeof(prof->filename));
g_strlcpy(prof->name, "sRGB", sizeof(prof->name));
int pos;
int display_pos;
prof->pos = 0;
prof->display_pos = 0;
g->profiles = g_list_append(g->profiles, prof);
prof = (dt_iop_color_profile_t *)g_malloc0(sizeof(dt_iop_color_profile_t));
g_strlcpy(prof->filename, "adobergb", sizeof(prof->filename));
g_strlcpy(prof->name, "adobergb", sizeof(prof->name));
prof->pos = 1;
prof->display_pos = 1;
g->profiles = g_list_append(g->profiles, prof);
prof = (dt_iop_color_profile_t *)g_malloc0(sizeof(dt_iop_color_profile_t));
g_strlcpy(prof->filename, "X profile", sizeof(prof->filename));
g_strlcpy(prof->name, "X profile", sizeof(prof->name));
prof->pos = -1;
prof->display_pos = 2;
g->profiles = g_list_append(g->profiles, prof);
prof = (dt_iop_color_profile_t *)g_malloc0(sizeof(dt_iop_color_profile_t));
g_strlcpy(prof->filename, "linear_rgb", sizeof(prof->filename));
g_strlcpy(prof->name, "linear_rgb", sizeof(prof->name));
pos = prof->pos = 2;
display_pos = prof->display_pos = 3;
g->profiles = g_list_append(g->profiles, prof);
// read {conf,data}dir/color/out/*.icc
char datadir[DT_MAX_PATH_LEN];
char confdir[DT_MAX_PATH_LEN];
char dirname[DT_MAX_PATH_LEN];
char filename[DT_MAX_PATH_LEN];
dt_loc_get_user_config_dir(confdir, DT_MAX_PATH_LEN);
dt_loc_get_datadir(datadir, DT_MAX_PATH_LEN);
snprintf(dirname, DT_MAX_PATH_LEN, "%s/color/out", confdir);
if(!g_file_test(dirname, G_FILE_TEST_IS_DIR))
snprintf(dirname, DT_MAX_PATH_LEN, "%s/color/out", datadir);
cmsHPROFILE tmpprof;
const gchar *d_name;
GDir *dir = g_dir_open(dirname, 0, NULL);
if(dir)
{
while((d_name = g_dir_read_name(dir)))
{
snprintf(filename, DT_MAX_PATH_LEN, "%s/%s", dirname, d_name);
tmpprof = cmsOpenProfileFromFile(filename, "r");
if(tmpprof)
{
char *lang = getenv("LANG");
if (!lang) lang = "en_US";
dt_iop_color_profile_t *prof = (dt_iop_color_profile_t *)g_malloc0(sizeof(dt_iop_color_profile_t));
dt_colorspaces_get_profile_name(tmpprof, lang, lang+3, prof->name, sizeof(prof->name));
g_strlcpy(prof->filename, d_name, sizeof(prof->filename));
prof->pos = ++pos;
prof->display_pos = ++display_pos;
cmsCloseProfile(tmpprof);
g->profiles = g_list_append(g->profiles, prof);
}
}
g_dir_close(dir);
}
self->widget = gtk_vbox_new(TRUE, DT_BAUHAUS_SPACE);
// TODO:
g->cbox1 = dt_bauhaus_combobox_new(self);
gtk_box_pack_start(GTK_BOX(self->widget), g->cbox1, TRUE, TRUE, 0);
dt_bauhaus_widget_set_label(g->cbox1, NULL, _("output intent"));
dt_bauhaus_combobox_add(g->cbox1, _("perceptual"));
dt_bauhaus_combobox_add(g->cbox1, _("relative colorimetric"));
dt_bauhaus_combobox_add(g->cbox1, C_("rendering intent", "saturation"));
dt_bauhaus_combobox_add(g->cbox1, _("absolute colorimetric"));
g->cbox4 = dt_bauhaus_combobox_new(self);
dt_bauhaus_widget_set_label(g->cbox4, NULL, _("display intent"));
gtk_box_pack_start(GTK_BOX(self->widget), g->cbox4, TRUE, TRUE, 0);
dt_bauhaus_combobox_add(g->cbox4, _("perceptual"));
dt_bauhaus_combobox_add(g->cbox4, _("relative colorimetric"));
dt_bauhaus_combobox_add(g->cbox4, C_("rendering intent", "saturation"));
dt_bauhaus_combobox_add(g->cbox4, _("absolute colorimetric"));
if (!high_quality_processing)
{
gtk_widget_set_no_show_all(g->cbox1, TRUE);
gtk_widget_set_visible(g->cbox1, FALSE);
gtk_widget_set_no_show_all(g->cbox4, TRUE);
gtk_widget_set_visible(g->cbox4, FALSE);
}
g->cbox2 = dt_bauhaus_combobox_new(self);
g->cbox3 = dt_bauhaus_combobox_new(self);
g->cbox5 = dt_bauhaus_combobox_new(self);
dt_bauhaus_widget_set_label(g->cbox2, NULL, _("output profile"));
dt_bauhaus_widget_set_label(g->cbox5, NULL, _("softproof profile"));
dt_bauhaus_widget_set_label(g->cbox3, NULL, _("display profile"));
gtk_box_pack_start(GTK_BOX(self->widget), g->cbox2, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), g->cbox5, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), g->cbox3, TRUE, TRUE, 0);
GList *l = g->profiles;
while(l)
{
dt_iop_color_profile_t *prof = (dt_iop_color_profile_t *)l->data;
if(!strcmp(prof->name, "X profile"))
{
// the system display profile is only suitable for display purposes
dt_bauhaus_combobox_add(g->cbox3, _("system display profile"));
}
else if(!strcmp(prof->name, "linear_rgb"))
{
dt_bauhaus_combobox_add(g->cbox2, _("linear Rec709 RGB"));
dt_bauhaus_combobox_add(g->cbox3, _("linear Rec709 RGB"));
dt_bauhaus_combobox_add(g->cbox5, _("linear Rec709 RGB"));
}
else if(!strcmp(prof->name, "sRGB"))
{
dt_bauhaus_combobox_add(g->cbox2, _("sRGB (web-safe)"));
dt_bauhaus_combobox_add(g->cbox3, _("sRGB (web-safe)"));
dt_bauhaus_combobox_add(g->cbox5, _("sRGB (web-safe)"));
}
else if(!strcmp(prof->name, "adobergb"))
{
dt_bauhaus_combobox_add(g->cbox2, _("Adobe RGB (compatible)"));
dt_bauhaus_combobox_add(g->cbox3, _("Adobe RGB (compatible)"));
dt_bauhaus_combobox_add(g->cbox5, _("Adobe RGB (compatible)"));
}
else
{
dt_bauhaus_combobox_add(g->cbox2, prof->name);
dt_bauhaus_combobox_add(g->cbox3, prof->name);
dt_bauhaus_combobox_add(g->cbox5, prof->name);
}
l = g_list_next(l);
}
char tooltip[1024];
g_object_set(G_OBJECT(g->cbox1), "tooltip-text", _("rendering intent"), (char *)NULL);
snprintf(tooltip, sizeof(tooltip), _("ICC profiles in %s/color/out or %s/color/out"), confdir, datadir);
g_object_set(G_OBJECT(g->cbox2), "tooltip-text", tooltip, (char *)NULL);
snprintf(tooltip, sizeof(tooltip), _("display ICC profiles in %s/color/out or %s/color/out"), confdir, datadir);
g_object_set(G_OBJECT(g->cbox3), "tooltip-text", tooltip, (char *)NULL);
snprintf(tooltip, sizeof(tooltip), _("softproof ICC profiles in %s/color/out or %s/color/out"), confdir, datadir);
g_object_set(G_OBJECT(g->cbox5), "tooltip-text", tooltip, (char *)NULL);
g_signal_connect (G_OBJECT (g->cbox1), "value-changed",
G_CALLBACK (intent_changed),
(gpointer)self);
g_signal_connect (G_OBJECT (g->cbox4), "value-changed",
G_CALLBACK (display_intent_changed),
(gpointer)self);
g_signal_connect (G_OBJECT (g->cbox2), "value-changed",
G_CALLBACK (output_profile_changed),
(gpointer)self);
g_signal_connect (G_OBJECT (g->cbox3), "value-changed",
G_CALLBACK (display_profile_changed),
(gpointer)self);
g_signal_connect (G_OBJECT (g->cbox5), "value-changed",
G_CALLBACK (softproof_profile_changed),
(gpointer)self);
// reload the profiles when the display profile changed!
dt_control_signal_connect(darktable.signals, DT_SIGNAL_CONTROL_PROFILE_CHANGED,
G_CALLBACK(_signal_profile_changed), self->dev);
}
static void
pin_dialog (DBusGProxy *adapter,
DBusGProxy *device,
const char *name,
const char *long_name,
gboolean numeric,
DBusGMethodInvocation *context)
{
GtkWidget *dialog;
GtkWidget *button;
GtkWidget *entry;
GtkBuilder *xml;
char *str;
input_data *input;
xml = gtk_builder_new ();
if (gtk_builder_add_from_file (xml, "passkey-dialogue.ui", NULL) == 0)
gtk_builder_add_from_file (xml, PKGDATADIR "/passkey-dialogue.ui", NULL);
input = g_new0 (input_data, 1);
input->path = g_strdup (dbus_g_proxy_get_path(adapter));
input->numeric = numeric;
input->context = context;
input->device = g_object_ref (device);
dialog = GTK_WIDGET (gtk_builder_get_object (xml, "dialog"));
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER);
if (notification_supports_actions () != FALSE)
gtk_window_set_keep_above (GTK_WINDOW (dialog), TRUE);
else
gtk_window_set_focus_on_map (GTK_WINDOW (dialog), FALSE);
gtk_window_set_urgency_hint (GTK_WINDOW (dialog), TRUE);
input->dialog = dialog;
gtk_dialog_set_default_response (GTK_DIALOG (dialog),
GTK_RESPONSE_OK);
gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
FALSE);
str = g_strdup_printf (_("Device '%s' wants to pair with this computer"),
name);
g_object_set (G_OBJECT (dialog), "text", str, NULL);
g_free (str);
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
_("Please enter the PIN mentioned on device %s."),
long_name);
entry = GTK_WIDGET (gtk_builder_get_object (xml, "entry"));
if (numeric == TRUE) {
gtk_entry_set_max_length (GTK_ENTRY (entry), 6);
gtk_entry_set_width_chars (GTK_ENTRY (entry), 6);
g_signal_connect (G_OBJECT (entry), "insert-text",
G_CALLBACK (insert_callback), input);
} else {
gtk_entry_set_max_length (GTK_ENTRY (entry), 16);
gtk_entry_set_width_chars (GTK_ENTRY (entry), 16);
gtk_entry_set_visibility (GTK_ENTRY (entry), FALSE);
}
gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE);
input->entry = entry;
g_signal_connect (G_OBJECT (entry), "changed",
G_CALLBACK (changed_callback), input);
button = GTK_WIDGET (gtk_builder_get_object (xml, "showinput_button"));
if (numeric == FALSE) {
g_signal_connect (G_OBJECT (button), "toggled",
G_CALLBACK (toggled_callback), input);
} else {
gtk_widget_set_no_show_all (button, TRUE);
gtk_widget_hide (button);
}
input_list = g_list_append(input_list, input);
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (pin_callback), input);
enable_blinking();
}
static void
awn_html_dialog_new(WebApplet *webapplet)
{
/* create viewer */
webapplet->mainwindow = awn_dialog_new_for_widget (GTK_WIDGET(webapplet->applet));
webapplet->box = gtk_vbox_new (FALSE, 1);
webapplet->viewer = html_web_view_new ();
/* Load the .ini file for websites */
GError *err = NULL;
webapplet->sites_file = g_key_file_new();
g_key_file_load_from_file(webapplet->sites_file,
APPLETSDIR"/webapplet/webapplet-websites.ini",
0, &err);
if (err)
{
printf("Error loading websites: %s\n", err->message);
g_error_free(err);
g_key_file_free(webapplet->sites_file);
webapplet->sites_file = NULL;
}
/* If first time using this, hide WebView, show location entry/website buttons */
if (config_get_first_start(webapplet))
{
gtk_widget_set_no_show_all(webapplet->viewer, TRUE);
gtk_box_pack_start(GTK_BOX(webapplet->box), first_start(webapplet),
FALSE, FALSE, 0);
awn_applet_simple_set_tooltip_text(AWN_APPLET_SIMPLE(webapplet->applet),
_("Web Applet"));
}
else
{
go_to_url(webapplet, (gchar*)config_get_uri(webapplet));
if (webapplet->sites_file)
{
const gchar *name = config_get_site(webapplet);
if (name && strcmp(name, "") != 0)
{
gint size = awn_applet_get_size(webapplet->applet);
WebSite *site = get_site(webapplet, (gchar*)name);
gchar *path = g_strdup_printf(APPLETSDIR"/webapplet/icons/%s", site->icon);
GdkPixbuf *pixbuf = gdk_pixbuf_new_from_file_at_size(path, size, size, NULL);
awn_applet_simple_set_icon_pixbuf(AWN_APPLET_SIMPLE(site->webapplet->applet), pixbuf);
if (site->width && site->height)
{
gtk_widget_set_size_request(GTK_WIDGET(site->webapplet->box),
site->width, site->height);
}
}
}
}
gtk_box_pack_start(GTK_BOX(webapplet->box), webapplet->viewer, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(webapplet->mainwindow), webapplet->box);
}
void init_widgets()
{
GtkWidget* container;
GtkWidget* widget;
// Creating the main window
widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
darktable.gui->ui->main_window = widget;
gtk_window_set_default_size(GTK_WINDOW(widget), 900, 500);
gtk_window_set_icon_name(GTK_WINDOW(widget), "darktable");
gtk_window_set_title(GTK_WINDOW(widget), "Darktable");
g_signal_connect (G_OBJECT (widget), "delete_event",
G_CALLBACK (dt_control_quit), NULL);
g_signal_connect (G_OBJECT (widget), "key-press-event",
G_CALLBACK (key_pressed_override), NULL);
g_signal_connect (G_OBJECT (widget), "key-release-event",
G_CALLBACK (key_released), NULL);
container = widget;
// Adding the outermost vbox
widget = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(container), widget);
gtk_widget_show(widget);
/* connect to signal redraw all */
dt_control_signal_connect(darktable.signals,
DT_SIGNAL_CONTROL_REDRAW_ALL,
G_CALLBACK(_ui_widget_redraw_callback),
darktable.gui->ui->main_window);
container = widget;
// Initializing the top border
widget = gtk_drawing_area_new();
darktable.gui->widgets.top_border = widget;
gtk_box_pack_start(GTK_BOX(container), widget, FALSE, TRUE, 0);
gtk_widget_set_size_request(widget, -1, 10);
gtk_widget_set_app_paintable(widget, TRUE);
gtk_widget_set_events(widget,
GDK_EXPOSURE_MASK
| GDK_BUTTON_PRESS_MASK
| GDK_BUTTON_RELEASE_MASK
| GDK_ENTER_NOTIFY_MASK
| GDK_LEAVE_NOTIFY_MASK
| GDK_STRUCTURE_MASK
| GDK_SCROLL_MASK);
gtk_widget_show(widget);
// Initializing the main table
init_main_table(container);
// Initializing the bottom border
widget = gtk_drawing_area_new();
darktable.gui->widgets.bottom_border = widget;
gtk_box_pack_start(GTK_BOX(container), widget, FALSE, TRUE, 0);
gtk_widget_set_size_request(widget, -1, 10);
gtk_widget_set_app_paintable(widget, TRUE);
gtk_widget_set_events(widget,
GDK_EXPOSURE_MASK
| GDK_BUTTON_PRESS_MASK
| GDK_BUTTON_RELEASE_MASK
| GDK_ENTER_NOTIFY_MASK
| GDK_LEAVE_NOTIFY_MASK
| GDK_STRUCTURE_MASK
| GDK_SCROLL_MASK);
gtk_widget_show(widget);
// Showing everything
gtk_widget_show_all(dt_ui_main_window(darktable.gui->ui));
/* hide panels depending on last ui state */
for(int k=0;k<DT_UI_PANEL_SIZE;k++)
{
/* prevent show all */
gtk_widget_set_no_show_all(GTK_WIDGET(darktable.gui->ui->containers[k]), TRUE);
/* check last visible state of panel */
char key[512];
g_snprintf(key, 512, "ui_last/%s/visible", _ui_panel_config_names[k]);
/* if no key, lets default to TRUE*/
if(!dt_conf_key_exists(key))
dt_conf_set_bool(key,TRUE);
if (!dt_conf_get_bool(key))
gtk_widget_set_visible(darktable.gui->ui->panels[k],FALSE);
}
}
static CVS * _cvs_init(BrowserPluginHelper * helper)
{
CVS * cvs;
PangoFontDescription * font;
GtkSizeGroup * group;
GtkSizeGroup * bgroup;
GtkWidget * widget;
if((cvs = object_new(sizeof(*cvs))) == NULL)
return NULL;
cvs->helper = helper;
cvs->filename = NULL;
cvs->source = 0;
/* widgets */
cvs->widget = gtk_vbox_new(FALSE, 4);
font = pango_font_description_new();
pango_font_description_set_weight(font, PANGO_WEIGHT_BOLD);
group = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
bgroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
/* label */
cvs->name = gtk_label_new("");
gtk_label_set_ellipsize(GTK_LABEL(cvs->name), PANGO_ELLIPSIZE_MIDDLE);
gtk_misc_set_alignment(GTK_MISC(cvs->name), 0.0, 0.0);
gtk_widget_modify_font(cvs->name, font);
gtk_box_pack_start(GTK_BOX(cvs->widget), cvs->name, FALSE, TRUE, 0);
cvs->status = gtk_label_new("");
gtk_label_set_ellipsize(GTK_LABEL(cvs->status), PANGO_ELLIPSIZE_END);
gtk_misc_set_alignment(GTK_MISC(cvs->status), 0.0, 0.0);
gtk_box_pack_start(GTK_BOX(cvs->widget), cvs->status, FALSE, TRUE, 0);
/* directory */
cvs->directory = gtk_vbox_new(FALSE, 4);
widget = _init_label(group, _("Root:"), &cvs->d_root);
gtk_box_pack_start(GTK_BOX(cvs->directory), widget, FALSE, TRUE, 0);
widget = _init_label(group, _("Repository:"), &cvs->d_repository);
gtk_box_pack_start(GTK_BOX(cvs->directory), widget, FALSE, TRUE, 0);
widget = _init_label(group, _("Tag:"), &cvs->d_tag);
gtk_box_pack_start(GTK_BOX(cvs->directory), widget, FALSE, TRUE, 0);
widget = _init_button(bgroup, GTK_STOCK_INDEX, _("Request diff"),
G_CALLBACK(_cvs_on_diff), cvs);
gtk_box_pack_start(GTK_BOX(cvs->directory), widget, FALSE, TRUE, 0);
widget = _init_button(bgroup, GTK_STOCK_INDEX, _("Annotate"),
G_CALLBACK(_cvs_on_annotate), cvs);
gtk_box_pack_start(GTK_BOX(cvs->directory), widget, FALSE, TRUE, 0);
widget = _init_button(bgroup, GTK_STOCK_INDEX, _("View log"),
G_CALLBACK(_cvs_on_log), cvs);
gtk_box_pack_start(GTK_BOX(cvs->directory), widget, FALSE, TRUE, 0);
widget = _init_button(bgroup, GTK_STOCK_REFRESH, _("Update"),
G_CALLBACK(_cvs_on_update), cvs);
gtk_box_pack_start(GTK_BOX(cvs->directory), widget, FALSE, TRUE, 0);
widget = _init_button(bgroup, GTK_STOCK_JUMP_TO, _("Commit"),
G_CALLBACK(_cvs_on_commit), cvs);
gtk_box_pack_start(GTK_BOX(cvs->directory), widget, FALSE, TRUE, 0);
gtk_widget_show_all(cvs->directory);
gtk_widget_set_no_show_all(cvs->directory, TRUE);
gtk_box_pack_start(GTK_BOX(cvs->widget), cvs->directory, FALSE, TRUE,
0);
/* file */
cvs->file = gtk_vbox_new(FALSE, 4);
widget = _init_label(group, _("Revision:"), &cvs->f_revision);
gtk_box_pack_start(GTK_BOX(cvs->file), widget, FALSE, TRUE, 0);
widget = _init_button(bgroup, GTK_STOCK_INDEX, _("Request diff"),
G_CALLBACK(_cvs_on_diff), cvs);
gtk_box_pack_start(GTK_BOX(cvs->file), widget, FALSE, TRUE, 0);
widget = _init_button(bgroup, GTK_STOCK_INDEX, _("Annotate"),
G_CALLBACK(_cvs_on_annotate), cvs);
gtk_box_pack_start(GTK_BOX(cvs->file), widget, FALSE, TRUE, 0);
widget = _init_button(bgroup, GTK_STOCK_INDEX, _("View log"),
G_CALLBACK(_cvs_on_log), cvs);
gtk_box_pack_start(GTK_BOX(cvs->file), widget, FALSE, TRUE, 0);
widget = _init_button(bgroup, GTK_STOCK_REFRESH, _("Update"),
G_CALLBACK(_cvs_on_update), cvs);
gtk_box_pack_start(GTK_BOX(cvs->file), widget, FALSE, TRUE, 0);
widget = _init_button(bgroup, GTK_STOCK_JUMP_TO, _("Commit"),
G_CALLBACK(_cvs_on_commit), cvs);
gtk_box_pack_start(GTK_BOX(cvs->file), widget, FALSE, TRUE, 0);
gtk_widget_show_all(cvs->file);
gtk_widget_set_no_show_all(cvs->file, TRUE);
gtk_box_pack_start(GTK_BOX(cvs->widget), cvs->file, FALSE, TRUE, 0);
/* additional actions */
cvs->add = _init_button(bgroup, GTK_STOCK_ADD, _("Add to repository"),
G_CALLBACK(_cvs_on_add), cvs);
gtk_box_pack_start(GTK_BOX(cvs->widget), cvs->add, FALSE, TRUE, 0);
cvs->make = _init_button(bgroup, GTK_STOCK_EXECUTE, _("Run make"),
G_CALLBACK(_cvs_on_make), cvs);
gtk_box_pack_start(GTK_BOX(cvs->widget), cvs->make, FALSE, TRUE, 0);
gtk_widget_show_all(cvs->widget);
pango_font_description_free(font);
/* tasks */
cvs->tasks = NULL;
cvs->tasks_cnt = 0;
return cvs;
}
static void
gd_main_toolbar_constructed (GObject *obj)
{
GdMainToolbar *self = GD_MAIN_TOOLBAR (obj);
GtkToolbar *tb = GTK_TOOLBAR (obj);
GtkWidget *grid;
G_OBJECT_CLASS (gd_main_toolbar_parent_class)->constructed (obj);
self->priv->vertical_size_group = get_vertical_size_group ();
/* left section */
self->priv->left_group = gtk_tool_item_new ();
gtk_widget_set_margin_right (GTK_WIDGET (self->priv->left_group), 12);
gtk_toolbar_insert (tb, self->priv->left_group, -1);
gtk_size_group_add_widget (self->priv->vertical_size_group,
GTK_WIDGET (self->priv->left_group));
/* left button group */
self->priv->left_grid = gtk_grid_new ();
gtk_grid_set_column_spacing (GTK_GRID (self->priv->left_grid), 12);
gtk_container_add (GTK_CONTAINER (self->priv->left_group), self->priv->left_grid);
self->priv->back = get_symbolic_button ("go-previous-symbolic");
gtk_widget_set_no_show_all (self->priv->back, TRUE);
gtk_container_add (GTK_CONTAINER (self->priv->left_grid), self->priv->back);
g_signal_connect (self->priv->back, "clicked",
G_CALLBACK (on_back_button_clicked), self);
/* center section */
self->priv->center_group = gtk_tool_item_new ();
gtk_tool_item_set_expand (self->priv->center_group, TRUE);
gtk_toolbar_insert (tb, self->priv->center_group, -1);
gtk_size_group_add_widget (self->priv->vertical_size_group,
GTK_WIDGET (self->priv->center_group));
/* centered label group */
grid = gtk_grid_new ();
gtk_widget_set_halign (grid, GTK_ALIGN_CENTER);
gtk_widget_set_valign (grid, GTK_ALIGN_CENTER);
gtk_container_add (GTK_CONTAINER (self->priv->center_group), grid);
self->priv->title_label = gtk_label_new (NULL);
gtk_label_set_ellipsize (GTK_LABEL (self->priv->title_label), PANGO_ELLIPSIZE_END);
gtk_container_add (GTK_CONTAINER (grid), self->priv->title_label);
self->priv->detail_label = gtk_label_new (NULL);
gtk_widget_set_no_show_all (self->priv->detail_label, TRUE);
gtk_widget_set_margin_left (self->priv->detail_label, 12);
gtk_style_context_add_class (gtk_widget_get_style_context (self->priv->detail_label), "dim-label");
gtk_container_add (GTK_CONTAINER (grid), self->priv->detail_label);
/* right section */
self->priv->right_group = gtk_tool_item_new ();
gtk_widget_set_margin_left (GTK_WIDGET (self->priv->right_group), 12);
gtk_toolbar_insert (tb, self->priv->right_group, -1);
gtk_size_group_add_widget (self->priv->vertical_size_group,
GTK_WIDGET (self->priv->right_group));
self->priv->right_grid = gtk_grid_new ();
gtk_grid_set_column_spacing (GTK_GRID (self->priv->right_grid), 12);
gtk_container_add (GTK_CONTAINER (self->priv->right_group), self->priv->right_grid);
self->priv->size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
gtk_size_group_add_widget (self->priv->size_group, GTK_WIDGET (self->priv->left_group));
gtk_size_group_add_widget (self->priv->size_group, GTK_WIDGET (self->priv->right_group));
}
void gui_init(dt_lib_module_t *self)
{
self->data = calloc(1, sizeof(dt_lib_live_view_t));
// Setup lib data
dt_lib_live_view_t *lib = self->data;
lib->splitline_x = lib->splitline_y = 0.5;
// Setup gui
self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
dt_gui_add_help_link(self->widget, "live_view.html#live_view");
GtkWidget *box;
box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start(GTK_BOX(self->widget), box, TRUE, TRUE, 0);
lib->live_view = dtgtk_togglebutton_new(dtgtk_cairo_paint_eye, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER, NULL);
lib->live_view_zoom = dtgtk_button_new(
dtgtk_cairo_paint_zoom, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER, NULL); // TODO: see _zoom_live_view_clicked
lib->rotate_ccw = dtgtk_button_new(dtgtk_cairo_paint_refresh, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER, NULL);
lib->rotate_cw = dtgtk_button_new(dtgtk_cairo_paint_refresh,
CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER | CPF_DIRECTION_UP, NULL);
lib->flip = dtgtk_togglebutton_new(dtgtk_cairo_paint_flip,
CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER | CPF_DIRECTION_UP, NULL);
gtk_box_pack_start(GTK_BOX(box), lib->live_view, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), lib->live_view_zoom, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), lib->rotate_ccw, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), lib->rotate_cw, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), lib->flip, TRUE, TRUE, 0);
gtk_widget_set_tooltip_text(lib->live_view, _("toggle live view"));
gtk_widget_set_tooltip_text(lib->live_view_zoom, _("zoom live view"));
gtk_widget_set_tooltip_text(lib->rotate_ccw, _("rotate 90 degrees ccw"));
gtk_widget_set_tooltip_text(lib->rotate_cw, _("rotate 90 degrees cw"));
gtk_widget_set_tooltip_text(lib->flip, _("flip live view horizontally"));
g_signal_connect(G_OBJECT(lib->live_view), "clicked", G_CALLBACK(_toggle_live_view_clicked), lib);
g_signal_connect(G_OBJECT(lib->live_view_zoom), "clicked", G_CALLBACK(_zoom_live_view_clicked), lib);
g_signal_connect(G_OBJECT(lib->rotate_ccw), "clicked", G_CALLBACK(_rotate_ccw), lib);
g_signal_connect(G_OBJECT(lib->rotate_cw), "clicked", G_CALLBACK(_rotate_cw), lib);
g_signal_connect(G_OBJECT(lib->flip), "clicked", G_CALLBACK(_toggle_flip_clicked), lib);
// focus buttons
box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start(GTK_BOX(self->widget), box, TRUE, TRUE, 0);
lib->focus_in_big = dtgtk_button_new(dtgtk_cairo_paint_solid_triangle,
CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER | CPF_DIRECTION_LEFT, NULL);
lib->focus_in_small
= dtgtk_button_new(dtgtk_cairo_paint_arrow, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER
| CPF_DIRECTION_LEFT, NULL); // TODO icon not centered
lib->focus_out_small = dtgtk_button_new(dtgtk_cairo_paint_arrow, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER
| CPF_DIRECTION_RIGHT, NULL); // TODO same here
lib->focus_out_big = dtgtk_button_new(dtgtk_cairo_paint_solid_triangle,
CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER | CPF_DIRECTION_RIGHT, NULL);
gtk_box_pack_start(GTK_BOX(box), lib->focus_in_big, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), lib->focus_in_small, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), lib->focus_out_small, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), lib->focus_out_big, TRUE, TRUE, 0);
gtk_widget_set_tooltip_text(lib->focus_in_big, _("move focus point in (big steps)"));
gtk_widget_set_tooltip_text(lib->focus_in_small, _("move focus point in (small steps)"));
gtk_widget_set_tooltip_text(lib->focus_out_small, _("move focus point out (small steps)"));
gtk_widget_set_tooltip_text(lib->focus_out_big, _("move focus point out (big steps)"));
// Near 3
g_signal_connect(G_OBJECT(lib->focus_in_big), "clicked", G_CALLBACK(_focus_button_clicked),
GINT_TO_POINTER(2));
// Near 1
g_signal_connect(G_OBJECT(lib->focus_in_small), "clicked", G_CALLBACK(_focus_button_clicked),
GINT_TO_POINTER(0));
// Far 1
g_signal_connect(G_OBJECT(lib->focus_out_small), "clicked", G_CALLBACK(_focus_button_clicked),
GINT_TO_POINTER(4));
// Far 3
g_signal_connect(G_OBJECT(lib->focus_out_big), "clicked", G_CALLBACK(_focus_button_clicked),
GINT_TO_POINTER(6));
// Guides
lib->guide_selector = dt_bauhaus_combobox_new(NULL);
dt_bauhaus_widget_set_label(lib->guide_selector, NULL, _("guides"));
gtk_box_pack_start(GTK_BOX(self->widget), lib->guide_selector, TRUE, TRUE, 0);
lib->guides_widgets = gtk_stack_new();
gtk_stack_set_homogeneous(GTK_STACK(lib->guides_widgets), FALSE);
gtk_box_pack_start(GTK_BOX(self->widget), lib->guides_widgets, TRUE, TRUE, 0);
dt_bauhaus_combobox_add(lib->guide_selector, _("none"));
int i = 0;
for(GList *iter = darktable.guides; iter; iter = g_list_next(iter), i++)
{
GtkWidget *widget = NULL;
dt_guides_t *guide = (dt_guides_t *)iter->data;
dt_bauhaus_combobox_add(lib->guide_selector, _(guide->name));
if(guide->widget)
{
// generate some unique name so that we can have the same name several times
char name[5];
snprintf(name, sizeof(name), "%d", i);
widget = guide->widget(NULL, guide->user_data);
gtk_widget_show_all(widget);
gtk_stack_add_named(GTK_STACK(lib->guides_widgets), widget, name);
}
lib->guides_widgets_list = g_list_append(lib->guides_widgets_list, widget);
}
gtk_widget_set_no_show_all(lib->guides_widgets, TRUE);
gtk_widget_set_tooltip_text(lib->guide_selector, _("display guide lines to help compose your photograph"));
g_signal_connect(G_OBJECT(lib->guide_selector), "value-changed", G_CALLBACK(guides_presets_changed), lib);
lib->flip_guides = dt_bauhaus_combobox_new(NULL);
dt_bauhaus_widget_set_label(lib->flip_guides, NULL, _("flip"));
dt_bauhaus_combobox_add(lib->flip_guides, _("none"));
dt_bauhaus_combobox_add(lib->flip_guides, _("horizontally"));
dt_bauhaus_combobox_add(lib->flip_guides, _("vertically"));
dt_bauhaus_combobox_add(lib->flip_guides, _("both"));
gtk_widget_set_tooltip_text(lib->flip_guides, _("flip guides"));
gtk_box_pack_start(GTK_BOX(self->widget), lib->flip_guides, TRUE, TRUE, 0);
lib->overlay = dt_bauhaus_combobox_new(NULL);
dt_bauhaus_widget_set_label(lib->overlay, NULL, _("overlay"));
dt_bauhaus_combobox_add(lib->overlay, _("none"));
dt_bauhaus_combobox_add(lib->overlay, _("selected image"));
dt_bauhaus_combobox_add(lib->overlay, _("id"));
gtk_widget_set_tooltip_text(lib->overlay, _("overlay another image over the live view"));
g_signal_connect(G_OBJECT(lib->overlay), "value-changed", G_CALLBACK(overlay_changed), lib);
gtk_box_pack_start(GTK_BOX(self->widget), lib->overlay, TRUE, TRUE, 0);
lib->overlay_id_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
GtkWidget *label = gtk_label_new(_("image id"));
gtk_widget_set_halign(label, GTK_ALIGN_START);
lib->overlay_id = gtk_spin_button_new_with_range(0, 1000000000, 1);
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(lib->overlay_id), 0);
gtk_widget_set_tooltip_text(lib->overlay_id, _("enter image id of the overlay manually"));
g_signal_connect(G_OBJECT(lib->overlay_id), "value-changed", G_CALLBACK(_overlay_id_changed), lib);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(lib->overlay_id),
dt_conf_get_int("plugins/lighttable/live_view/overlay_imgid"));
gtk_box_pack_start(GTK_BOX(lib->overlay_id_box), label, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(lib->overlay_id_box), lib->overlay_id, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), lib->overlay_id_box, TRUE, TRUE, 0);
gtk_widget_show(lib->overlay_id);
gtk_widget_show(label);
lib->overlay_mode = dt_bauhaus_combobox_new(NULL);
dt_bauhaus_widget_set_label(lib->overlay_mode, NULL, _("overlay mode"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "normal"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "xor"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "add"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "saturate"));
#if(CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1, 10, 0))
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "multiply"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "screen"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "overlay"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "darken"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "lighten"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "color dodge"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "color burn"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "hard light"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "soft light"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "difference"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "exclusion"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "HSL hue"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "HSL saturation"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "HSL color"));
dt_bauhaus_combobox_add(lib->overlay_mode, C_("blendmode", "HSL luminosity"));
#endif
gtk_widget_set_tooltip_text(lib->overlay_mode, _("mode of the overlay"));
dt_bauhaus_combobox_set(lib->overlay_mode, dt_conf_get_int("plugins/lighttable/live_view/overlay_mode"));
g_signal_connect(G_OBJECT(lib->overlay_mode), "value-changed", G_CALLBACK(_overlay_mode_changed), lib);
gtk_box_pack_start(GTK_BOX(self->widget), lib->overlay_mode, TRUE, TRUE, 0);
lib->overlay_splitline = dt_bauhaus_combobox_new(NULL);
dt_bauhaus_widget_set_label(lib->overlay_splitline, NULL, _("split line"));
dt_bauhaus_combobox_add(lib->overlay_splitline, _("off"));
dt_bauhaus_combobox_add(lib->overlay_splitline, _("on"));
gtk_widget_set_tooltip_text(lib->overlay_splitline, _("only draw part of the overlay"));
dt_bauhaus_combobox_set(lib->overlay_splitline, dt_conf_get_int("plugins/lighttable/live_view/splitline"));
g_signal_connect(G_OBJECT(lib->overlay_splitline), "value-changed", G_CALLBACK(_overlay_splitline_changed),
lib);
gtk_box_pack_start(GTK_BOX(self->widget), lib->overlay_splitline, TRUE, TRUE, 0);
gtk_widget_set_visible(GTK_WIDGET(lib->overlay_mode), FALSE);
gtk_widget_set_visible(GTK_WIDGET(lib->overlay_id_box), FALSE);
gtk_widget_set_visible(GTK_WIDGET(lib->overlay_splitline), FALSE);
gtk_widget_set_no_show_all(GTK_WIDGET(lib->overlay_mode), TRUE);
gtk_widget_set_no_show_all(GTK_WIDGET(lib->overlay_id_box), TRUE);
gtk_widget_set_no_show_all(GTK_WIDGET(lib->overlay_splitline), TRUE);
guides_presets_set_visibility(lib, 0);
}
static void
theme_message_area_update (AppearanceData *data)
{
const MateThemeMetaInfo *theme;
gboolean show_apply_background = FALSE;
gboolean show_apply_font = FALSE;
gboolean show_revert_font = FALSE;
gboolean show_error;
const gchar *message;
gchar *font;
GError *error = NULL;
theme = theme_get_selected (GTK_ICON_VIEW (appearance_capplet_get_widget (data, "theme_list")), data);
if (!theme) {
if (data->theme_message_area != NULL)
gtk_widget_hide (data->theme_message_area);
return;
}
show_error = !mate_theme_meta_info_validate (theme, &error);
if (!show_error) {
if (theme->background_image != NULL) {
gchar *background;
background = mateconf_client_get_string (data->client, BACKGROUND_KEY, NULL);
show_apply_background =
(!background || strcmp (theme->background_image, background) != 0);
g_free (background);
}
if (theme->application_font) {
font = mateconf_client_get_string (data->client, APPLICATION_FONT_KEY, NULL);
show_apply_font =
(!font || strcmp (theme->application_font, font) != 0);
g_free (font);
}
if (!show_apply_font && theme->documents_font) {
font = mateconf_client_get_string (data->client, DOCUMENTS_FONT_KEY, NULL);
show_apply_font =
(!font || strcmp (theme->application_font, font) != 0);
g_free (font);
}
if (!show_apply_font && theme->desktop_font) {
font = mateconf_client_get_string (data->client, DESKTOP_FONT_KEY, NULL);
show_apply_font =
(!font || strcmp (theme->application_font, font) != 0);
g_free (font);
}
if (!show_apply_font && theme->windowtitle_font) {
font = mateconf_client_get_string (data->client, WINDOWTITLE_FONT_KEY, NULL);
show_apply_font =
(!font || strcmp (theme->application_font, font) != 0);
g_free (font);
}
if (!show_apply_font && theme->monospace_font) {
font = mateconf_client_get_string (data->client, MONOSPACE_FONT_KEY, NULL);
show_apply_font =
(!font || strcmp (theme->application_font, font) != 0);
g_free (font);
}
show_revert_font = (data->revert_application_font != NULL ||
data->revert_documents_font != NULL || data->revert_desktop_font != NULL ||
data->revert_windowtitle_font != NULL || data->revert_monospace_font != NULL);
}
if (data->theme_message_area == NULL) {
GtkWidget *hbox;
GtkWidget *parent;
GtkWidget *content;
if (!show_apply_background && !show_revert_font && !show_apply_font && !show_error)
return;
data->theme_message_area = gtk_info_bar_new ();
gtk_widget_set_no_show_all (data->theme_message_area, TRUE);
g_signal_connect (data->theme_message_area, "response",
(GCallback) theme_message_area_response_cb, data);
data->apply_background_button = gtk_info_bar_add_button (
GTK_INFO_BAR (data->theme_message_area),
_("Apply Background"),
RESPONSE_APPLY_BG);
data->apply_font_button = gtk_info_bar_add_button (
GTK_INFO_BAR (data->theme_message_area),
_("Apply Font"),
RESPONSE_APPLY_FONT);
data->revert_font_button = gtk_info_bar_add_button (
GTK_INFO_BAR (data->theme_message_area),
_("Revert Font"),
RESPONSE_REVERT_FONT);
data->install_button = gtk_info_bar_add_button (
GTK_INFO_BAR (data->theme_message_area),
_("Install"),
RESPONSE_INSTALL_ENGINE);
data->theme_message_label = gtk_label_new (NULL);
gtk_widget_show (data->theme_message_label);
gtk_label_set_line_wrap (GTK_LABEL (data->theme_message_label), TRUE);
gtk_misc_set_alignment (GTK_MISC (data->theme_message_label), 0.0, 0.5);
hbox = gtk_hbox_new (FALSE, 9);
gtk_widget_show (hbox);
data->theme_info_icon = gtk_image_new_from_stock (GTK_STOCK_DIALOG_INFO, GTK_ICON_SIZE_DIALOG);
data->theme_error_icon = gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_DIALOG);
gtk_misc_set_alignment (GTK_MISC (data->theme_info_icon), 0.5, 0);
gtk_misc_set_alignment (GTK_MISC (data->theme_error_icon), 0.5, 0);
gtk_box_pack_start (GTK_BOX (hbox), data->theme_info_icon, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), data->theme_error_icon, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), data->theme_message_label, TRUE, TRUE, 0);
content = gtk_info_bar_get_content_area (GTK_INFO_BAR (data->theme_message_area));
gtk_container_add (GTK_CONTAINER (content), hbox);
parent = appearance_capplet_get_widget (data, "theme_list_vbox");
gtk_box_pack_start (GTK_BOX (parent), data->theme_message_area, FALSE, FALSE, 0);
}
if (show_error)
message = error->message;
else if (show_apply_background && show_apply_font && show_revert_font)
message = _("The current theme suggests a background and a font. Also, the last applied font suggestion can be reverted.");
else if (show_apply_background && show_revert_font)
message = _("The current theme suggests a background. Also, the last applied font suggestion can be reverted.");
else if (show_apply_background && show_apply_font)
message = _("The current theme suggests a background and a font.");
else if (show_apply_font && show_revert_font)
message = _("The current theme suggests a font. Also, the last applied font suggestion can be reverted.");
else if (show_apply_background)
message = _("The current theme suggests a background.");
else if (show_revert_font)
message = _("The last applied font suggestion can be reverted.");
else if (show_apply_font)
message = _("The current theme suggests a font.");
else
message = NULL;
if (show_apply_background)
gtk_widget_show (data->apply_background_button);
else
gtk_widget_hide (data->apply_background_button);
if (show_apply_font)
gtk_widget_show (data->apply_font_button);
else
gtk_widget_hide (data->apply_font_button);
if (show_revert_font)
gtk_widget_show (data->revert_font_button);
else
gtk_widget_hide (data->revert_font_button);
if (show_error
&& g_error_matches (error, MATE_THEME_ERROR, MATE_THEME_ERROR_GTK_ENGINE_NOT_AVAILABLE)
&& packagekit_available ())
gtk_widget_show (data->install_button);
else
gtk_widget_hide (data->install_button);
if (show_error || show_apply_background || show_apply_font || show_revert_font) {
gtk_widget_show (data->theme_message_area);
gtk_widget_queue_draw (data->theme_message_area);
if (show_error) {
gtk_widget_show (data->theme_error_icon);
gtk_widget_hide (data->theme_info_icon);
} else {
gtk_widget_show (data->theme_info_icon);
gtk_widget_hide (data->theme_error_icon);
}
} else {
gtk_widget_hide (data->theme_message_area);
}
gtk_label_set_text (GTK_LABEL (data->theme_message_label), message);
g_clear_error (&error);
}
static void
gvc_combo_box_init (GvcComboBox *combobox)
{
GtkWidget *frame;
GtkCellRenderer *renderer;
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
combobox->priv = GVC_COMBO_BOX_GET_PRIVATE (combobox);
combobox->priv->model = GTK_TREE_MODEL (gtk_list_store_new (NUM_COLS,
G_TYPE_STRING,
G_TYPE_STRING));
combobox->priv->combobox = gtk_combo_box_new_with_model (combobox->priv->model);
combobox->priv->label = gtk_label_new (NULL);
gtk_label_set_xalign (GTK_LABEL (combobox->priv->label), 0.0);
gtk_label_set_yalign (GTK_LABEL (combobox->priv->label), 0.5);
gtk_label_set_mnemonic_widget (GTK_LABEL (combobox->priv->label),
combobox->priv->combobox);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox->priv->combobox),
renderer,
FALSE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combobox->priv->combobox),
renderer,
"text",
COL_HUMAN_NAME);
combobox->priv->drop_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
combobox->priv->start_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
combobox->priv->end_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
/* Make sure the combo box does not get too long on long profile names */
g_object_set (G_OBJECT (renderer),
"ellipsize",
PANGO_ELLIPSIZE_END,
NULL);
gtk_combo_box_set_popup_fixed_width (GTK_COMBO_BOX (combobox->priv->combobox), FALSE);
gtk_box_pack_start (GTK_BOX (combobox),
frame,
TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (combobox->priv->drop_box),
combobox->priv->start_box,
FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (combobox->priv->start_box),
combobox->priv->label,
FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (combobox->priv->drop_box),
combobox->priv->combobox,
TRUE, TRUE, 0);
combobox->priv->button = gtk_button_new_with_label ("");
gtk_box_pack_start (GTK_BOX (combobox->priv->drop_box),
combobox->priv->button,
FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (combobox->priv->drop_box),
combobox->priv->end_box,
FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (frame), combobox->priv->drop_box);
g_signal_connect (G_OBJECT (combobox->priv->combobox),
"changed",
G_CALLBACK (on_combo_box_changed),
combobox);
g_signal_connect (G_OBJECT (combobox->priv->button),
"clicked",
G_CALLBACK (on_combo_box_button_clicked),
combobox);
gtk_widget_set_no_show_all (combobox->priv->button, TRUE);
gtk_widget_show_all (frame);
}
void
rb_media_player_source_show_properties (RBMediaPlayerSource *source)
{
RBMediaPlayerSourcePrivate *priv = MEDIA_PLAYER_SOURCE_GET_PRIVATE (source);
RBMediaPlayerSourceClass *klass = RB_MEDIA_PLAYER_SOURCE_GET_CLASS (source);
GtkBuilder *builder;
GtkContainer *container;
const char *ui_file;
char *name;
char *text;
if (priv->properties_dialog != NULL) {
gtk_window_present (GTK_WINDOW (priv->properties_dialog));
return;
}
/* load dialog UI */
ui_file = rb_file ("media-player-properties.ui");
if (ui_file == NULL) {
g_warning ("Couldn't find media-player-properties.ui");
return;
}
builder = rb_builder_load (ui_file, NULL);
if (builder == NULL) {
g_warning ("Couldn't load media-player-properties.ui");
return;
}
priv->properties_dialog = GTK_DIALOG (gtk_builder_get_object (builder, "media-player-properties"));
g_object_ref (priv->properties_dialog);
g_signal_connect_object (priv->properties_dialog,
"response",
G_CALLBACK (properties_dialog_response_cb),
source, 0);
g_object_get (source, "name", &name, NULL);
text = g_strdup_printf (_("%s Properties"), name);
gtk_window_set_title (GTK_WINDOW (priv->properties_dialog), text);
g_free (text);
g_free (name);
/* ensure device usage information is available and up to date */
update_sync (source);
/*
* fill in some common details:
* - volume usage (need to hook up signals etc. to update this live)
*/
rb_sync_state_ui_create_bar (&priv->volume_usage, rb_media_player_source_get_capacity (source), NULL);
rb_sync_state_ui_update_volume_usage (&priv->volume_usage, priv->sync_state);
gtk_widget_show_all (priv->volume_usage.widget);
container = GTK_CONTAINER (gtk_builder_get_object (builder, "device-usage-container"));
gtk_container_add (container, priv->volume_usage.widget);
/* let the subclass fill in device type specific details (model names, device names,
* .. battery levels?) and add more tabs to the notebook to display 'advanced' stuff.
*/
if (klass->show_properties) {
klass->show_properties (source,
GTK_WIDGET (gtk_builder_get_object (builder, "device-info-box")),
GTK_WIDGET (gtk_builder_get_object (builder, "media-player-notebook")));
}
/* create sync UI */
container = GTK_CONTAINER (gtk_builder_get_object (builder, "sync-settings-ui-container"));
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (container), rb_sync_settings_ui_new (source, priv->sync_settings));
container = GTK_CONTAINER (gtk_builder_get_object (builder, "sync-state-ui-container"));
gtk_box_pack_start (GTK_BOX (container), rb_sync_state_ui_new (priv->sync_state), TRUE, TRUE, 0);
gtk_widget_show_all (GTK_WIDGET (container));
/* create encoding settings UI */
if (priv->encoding_settings) {
container = GTK_CONTAINER (gtk_builder_get_object (builder, "encoding-settings-container"));
gtk_container_add (container, rb_encoding_settings_new (priv->encoding_settings, priv->encoding_target, TRUE));
gtk_widget_show_all (GTK_WIDGET (container));
} else {
container = GTK_CONTAINER (gtk_builder_get_object (builder, "encoding-settings-frame"));
gtk_widget_hide (GTK_WIDGET (container));
gtk_widget_set_no_show_all (GTK_WIDGET (container), TRUE);
}
gtk_widget_show (GTK_WIDGET (priv->properties_dialog));
g_object_unref (builder);
}
