static GtkWidget *create_custom_widget(GtkPrintOperation *operation, gpointer user_data)
{ /* copied from interface.c */
GtkWidget *page;
GtkWidget *frame33;
GtkWidget *alignment36;
GtkWidget *vbox30;
GtkWidget *hbox10;
GtkWidget *label203;
PrintWidgets *w = user_data;
gtk_print_operation_set_custom_tab_label(operation, _("Document Setup"));
page = gtk_vbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(page), 5);
w->check_print_linenumbers = gtk_check_button_new_with_mnemonic(_("Print line numbers"));
gtk_box_pack_start(GTK_BOX(page), w->check_print_linenumbers, FALSE, FALSE, 0);
gtk_widget_set_tooltip_text(w->check_print_linenumbers, _("Add line numbers to the printed page"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w->check_print_linenumbers), printing_prefs.print_line_numbers);
w->check_print_pagenumbers = gtk_check_button_new_with_mnemonic(_("Print page numbers"));
gtk_box_pack_start(GTK_BOX(page), w->check_print_pagenumbers, FALSE, FALSE, 0);
gtk_widget_set_tooltip_text(w->check_print_pagenumbers, _("Add page numbers at the bottom of each page. It takes 2 lines of the page."));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w->check_print_pagenumbers), printing_prefs.print_page_numbers);
w->check_print_pageheader = gtk_check_button_new_with_mnemonic(_("Print page header"));
gtk_box_pack_start(GTK_BOX(page), w->check_print_pageheader, FALSE, FALSE, 0);
gtk_widget_set_tooltip_text(w->check_print_pageheader, _("Add a little header to every page containing the page number, the filename and the current date (see below). It takes 3 lines of the page."));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w->check_print_pageheader), printing_prefs.print_page_header);
g_signal_connect(w->check_print_pageheader, "toggled", G_CALLBACK(on_page_header_toggled), w);
frame33 = gtk_frame_new(NULL);
gtk_box_pack_start(GTK_BOX(page), frame33, FALSE, FALSE, 0);
gtk_frame_set_label_align(GTK_FRAME(frame33), 0, 0);
gtk_frame_set_shadow_type(GTK_FRAME(frame33), GTK_SHADOW_NONE);
alignment36 = gtk_alignment_new(0, 0.5, 1, 1);
gtk_container_add(GTK_CONTAINER(frame33), alignment36);
gtk_alignment_set_padding(GTK_ALIGNMENT(alignment36), 0, 0, 12, 0);
vbox30 = gtk_vbox_new(FALSE, 1);
gtk_container_add(GTK_CONTAINER(alignment36), vbox30);
w->check_print_basename = gtk_check_button_new_with_mnemonic(_("Use the basename of the printed file"));
gtk_box_pack_start(GTK_BOX(vbox30), w->check_print_basename, FALSE, FALSE, 0);
gtk_widget_set_tooltip_text(w->check_print_basename, _("Print only the basename(without the path) of the printed file"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w->check_print_basename), printing_prefs.page_header_basename);
hbox10 = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(vbox30), hbox10, TRUE, TRUE, 0);
label203 = gtk_label_new(_("Date format:"));
gtk_box_pack_start(GTK_BOX(hbox10), label203, FALSE, FALSE, 0);
w->entry_print_dateformat = gtk_entry_new();
ui_entry_add_clear_icon(GTK_ENTRY(w->entry_print_dateformat));
gtk_box_pack_start(GTK_BOX(hbox10), w->entry_print_dateformat, TRUE, TRUE, 0);
gtk_widget_set_tooltip_text(w->entry_print_dateformat, _("Specify a format for the date and time stamp which is added to the page header on each page. You can use any conversion specifiers which can be used with the ANSI C strftime function."));
gtk_entry_set_text(GTK_ENTRY(w->entry_print_dateformat), printing_prefs.page_header_datefmt);
on_page_header_toggled(GTK_TOGGLE_BUTTON(w->check_print_pageheader), w);
gtk_widget_show_all(page);
return page;
}
GtkWidget *build_drive_status_widget(app_shell_type *as, GdkWindow *window)
{
GtkWidget *drive_box, *frame;
int i;
char *empty = util_concat("<", _("empty"), ">", NULL);
drive_box = gtk_hbox_new(FALSE, 0);
for (i = 0; i < NUM_DRIVES; i++) {
char label[256];
as->drive_status[i].event_box = gtk_event_box_new();
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
sprintf(label, _("Drive %d "), i + 8);
as->drive_status[i].box = gtk_hbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(frame), as->drive_status[i].box);
gtk_widget_show(as->drive_status[i].box);
gtk_container_add(GTK_CONTAINER(as->drive_status[i].event_box), frame);
gtk_widget_show(frame);
gtk_widget_set_tooltip_text(GTK_WIDGET(gtk_widget_get_parent(gtk_widget_get_parent(as->drive_status[i].box))), empty);
/* Label */
as->drive_status[i].label = (void *)gtk_label_new(g_strdup(label));
gtk_box_pack_start(GTK_BOX(as->drive_status[i].box), (GtkWidget *)as->drive_status[i].label, TRUE, TRUE, 0);
gtk_widget_show((GtkWidget *)as->drive_status[i].label);
/* Track Label */
as->drive_status[i].track_label = gtk_label_new("");
gtk_box_pack_start(GTK_BOX(as->drive_status[i].box), as->drive_status[i].track_label, FALSE, FALSE, 0);
gtk_widget_show(as->drive_status[i].track_label);
/* Single Led */
#if !defined(HAVE_CAIRO)
as->drive_status[i].led_pixmap = gdk_pixmap_new(window, LED_WIDTH, LED_HEIGHT, -1);
as->drive_status[i].led = gtk_image_new_from_pixmap(as->drive_status[i].led_pixmap, NULL);
#else
as->drive_status[i].led = gtk_drawing_area_new();
#endif
gtk_widget_set_size_request(as->drive_status[i].led, LED_WIDTH, LED_HEIGHT);
gtk_box_pack_start(GTK_BOX(as->drive_status[i].box), (GtkWidget *)as->drive_status[i].led, FALSE, FALSE, 4);
gtk_widget_show(as->drive_status[i].led);
/* Led1 for double Led drive */
#if !defined(HAVE_CAIRO)
as->drive_status[i].led1_pixmap = gdk_pixmap_new(window, LED_WIDTH / 2, LED_HEIGHT, -1);
as->drive_status[i].led1 = gtk_image_new_from_pixmap(as->drive_status[i].led1_pixmap, NULL);
gtk_widget_set_size_request(as->drive_status[i].led1, LED_WIDTH / 2, LED_HEIGHT);
gtk_box_pack_start(GTK_BOX(as->drive_status[i].box), (GtkWidget *)as->drive_status[i].led1, FALSE, FALSE, 1);
gtk_widget_show(as->drive_status[i].led1);
#endif
/* Led2 for double Led drive */
#if !defined(HAVE_CAIRO)
as->drive_status[i].led2_pixmap = gdk_pixmap_new(window, LED_WIDTH / 2, LED_HEIGHT, -1);
as->drive_status[i].led2 = gtk_image_new_from_pixmap(as->drive_status[i].led2_pixmap, NULL);
gtk_widget_set_size_request(as->drive_status[i].led2, LED_WIDTH / 2, LED_HEIGHT);
gtk_box_pack_start(GTK_BOX(as->drive_status[i].box), (GtkWidget *)as->drive_status[i].led2, FALSE, FALSE, 1);
gtk_widget_show(as->drive_status[i].led2);
#endif
/* Pack everything together */
gtk_box_pack_start(GTK_BOX(drive_box), as->drive_status[i].event_box, FALSE, FALSE, 0);
gtk_widget_set_events(as->drive_status[i].event_box, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_ENTER_NOTIFY_MASK);
g_signal_connect(G_OBJECT(as->drive_status[i].event_box), "button-press-event", G_CALLBACK(fliplist_popup_cb), (gpointer)(int_to_void_ptr(i)));
gtk_widget_show(as->drive_status[i].event_box);
#if defined(HAVE_CAIRO)
#if GTK_CHECK_VERSION(3, 0, 0)
g_signal_connect(G_OBJECT(as->drive_status[i].led), "draw", G_CALLBACK(leds_draw), int_to_void_ptr(i));
#else
g_signal_connect(G_OBJECT(as->drive_status[i].led), "expose-event", G_CALLBACK(leds_draw), int_to_void_ptr(i));
#endif
#endif
}
lib_free(empty);
return drive_box;
}
/** \brief Create layout selector. */
static void create_layout_selector (GKeyFile *cfg, GtkTable *table)
{
GtkWidget *label;
gchar *buffer;
gchar *thumbfile;
guint i,sel=PREDEF_NUM-1;
/* get the current settings */
if (cfg != NULL) {
buffer = mod_cfg_get_str (cfg,
MOD_CFG_GLOBAL_SECTION,
MOD_CFG_GRID,
SAT_CFG_STR_MODULE_GRID);
}
else {
buffer = sat_cfg_get_str (SAT_CFG_STR_MODULE_GRID);
}
/* create header */
label = gtk_label_new (_("Select layout:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
GTK_SHRINK | GTK_FILL, GTK_EXPAND | GTK_FILL, 5, 0);
/* layout selector */
selector = gtk_combo_box_new_text ();
gtk_table_attach (GTK_TABLE (table), selector, 1, 3, 0, 1,
GTK_FILL, GTK_SHRINK, 0, 0);
for (i = 0; i < PREDEF_NUM; i++) {
/* append default layout string to combo box */
gtk_combo_box_append_text (GTK_COMBO_BOX (selector), predef_layout[i][1]);
/* check if this layout corresponds to the settings */
if (!g_ascii_strcasecmp (buffer, predef_layout[i][0])) {
sel = i;
}
}
/* select settings */
gtk_combo_box_set_active (GTK_COMBO_BOX (selector), sel);
/* connect signal handler */
g_signal_connect (selector, "changed", G_CALLBACK (layout_selected_cb), NULL);
/* layout preview thumbnail */
thumbfile = thumb_file_from_sel (sel);
thumb = gtk_image_new_from_file (thumbfile);
g_free (thumbfile);
gtk_table_attach (GTK_TABLE (table), thumb, 1, 3, 1, 2,
GTK_EXPAND, GTK_EXPAND, 0, 5);
/* layout string */
label = gtk_label_new (_("Layout code:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3,
GTK_SHRINK | GTK_FILL, GTK_EXPAND | GTK_FILL, 5, 0);
gridstr = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (gridstr), buffer);
g_free (buffer);
gtk_widget_set_tooltip_text (gridstr,
_("This entry holds the layout code for the module.\n"\
"Consult the user manual for how to create custom layouts "\
"using layout codes."));
/* disable if it is a predefined layout */
if (sel < PREDEF_NUM-1) {
gtk_widget_set_sensitive (gridstr, FALSE);
}
/* connect changed signal handler */
gridstr_sigid = g_signal_connect (gridstr, "changed", G_CALLBACK (layout_code_changed), NULL);
gtk_table_attach_defaults (GTK_TABLE (table), gridstr, 1, 4, 2, 3);
}
static void
add_settings_info (GtkInspectorPropEditor *editor)
{
gchar *key;
GSettingsBinding *binding;
GObject *object;
const gchar *name;
const gchar *direction;
const gchar *tip;
GtkWidget *row;
GtkWidget *label;
gchar *str;
object = editor->priv->object;
name = editor->priv->name;
key = g_strconcat ("gsettingsbinding-", name, NULL);
binding = (GSettingsBinding *)g_object_get_data (object, key);
g_free (key);
if (!binding)
return;
if (binding->key_handler_id && binding->property_handler_id)
{
direction = "↔";
tip = _("bidirectional");
}
else if (binding->key_handler_id)
{
direction = "←";
tip = NULL;
}
else if (binding->property_handler_id)
{
direction = "→";
tip = NULL;
}
else
{
direction = "?";
tip = NULL;
}
row = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
gtk_container_add (GTK_CONTAINER (row), gtk_label_new (_("Setting:")));
label = gtk_label_new (direction);
if (tip)
gtk_widget_set_tooltip_text (label, tip);
gtk_container_add (GTK_CONTAINER (row), label);
str = g_strdup_printf ("%s %s",
g_settings_schema_get_id (binding->key.schema),
binding->key.name);
label = gtk_label_new (str);
gtk_container_add (GTK_CONTAINER (row), label);
g_free (str);
gtk_widget_show_all (row);
gtk_container_add (GTK_CONTAINER (editor), row);
}
void nsgtk_options_load(void)
{
GtkBox *box;
char languagefile[strlen(res_dir_location) + SLEN("languages") + 1];
const char *default_accept_language =
option_accept_language ? option_accept_language : "en";
int combo_row_count = 0;
int active_language = 0;
int proxytype = 0;
FILE *fp;
char buf[50];
/* Create combobox */
box = GTK_BOX(glade_xml_get_widget(gladeFile, "combolanguagevbox"));
comboLanguage = gtk_combo_box_new_text();
sprintf(languagefile, "%slanguages", res_dir_location);
/* Populate combobox from languages file */
fp = fopen((const char *) languagefile, "r");
if (fp == NULL) {
LOG(("Failed opening languages file"));
warn_user("FileError", (const char *) languagefile);
return;
}
while (fgets(buf, sizeof(buf), fp)) {
/* Ignore blank lines */
if (buf[0] == '\0')
continue;
/* Remove trailing \n */
buf[strlen(buf) - 1] = '\0';
gtk_combo_box_append_text(GTK_COMBO_BOX(comboLanguage), buf);
if (strcmp(buf, default_accept_language) == 0)
active_language = combo_row_count;
combo_row_count++;
}
fclose(fp);
gtk_combo_box_set_active(GTK_COMBO_BOX(comboLanguage), active_language);
/** \todo localisation */
gtk_widget_set_tooltip_text(GTK_WIDGET(comboLanguage),
"set preferred language for web pages");
gtk_box_pack_start(box, comboLanguage, FALSE, FALSE, 0);
gtk_widget_show(comboLanguage);
nsgtk_options_theme_combo();
SET_ENTRY(entryHomePageURL,
option_homepage_url ? option_homepage_url : "");
SET_BUTTON(setCurrentPage);
SET_BUTTON(setDefaultPage);
SET_CHECK(checkHideAdverts, option_block_ads);
SET_CHECK(checkDisablePopups, option_disable_popups);
SET_CHECK(checkDisablePlugins, option_disable_plugins);
SET_SPIN(spinHistoryAge, option_history_age);
SET_CHECK(checkHoverURLs, option_hover_urls);
SET_CHECK(checkDisplayRecentURLs, option_url_suggestion);
SET_CHECK(checkSendReferer, option_send_referer);
SET_CHECK(checkShowSingleTab, option_show_single_tab);
if (option_http_proxy == false)
proxytype = 0;
else
proxytype = option_http_proxy_auth + 1;
SET_COMBO(comboProxyType, proxytype);
SET_ENTRY(entryProxyHost,
option_http_proxy_host ? option_http_proxy_host : "");
gtk_widget_set_sensitive(entryProxyHost, proxytype != 0);
snprintf(buf, sizeof(buf), "%d", option_http_proxy_port);
SET_ENTRY(entryProxyPort, buf);
gtk_widget_set_sensitive(entryProxyPort, proxytype != 0);
SET_ENTRY(entryProxyUser, option_http_proxy_auth_user ?
option_http_proxy_auth_user : "");
gtk_widget_set_sensitive(entryProxyUser, proxytype != 0);
SET_ENTRY(entryProxyPassword, option_http_proxy_auth_pass ?
option_http_proxy_auth_pass : "");
gtk_widget_set_sensitive(entryProxyPassword, proxytype != 0);
SET_SPIN(spinMaxFetchers, option_max_fetchers);
SET_SPIN(spinFetchesPerHost, option_max_fetchers_per_host);
SET_SPIN(spinCachedConnections, option_max_cached_fetch_handles);
SET_CHECK(checkResampleImages, option_render_resample);
SET_SPIN(spinAnimationSpeed, option_minimum_gif_delay / 100.0);
SET_CHECK(checkDisableAnimations, !option_animate_images);
SET_FONT(fontSansSerif, option_font_sans);
SET_FONT(fontSerif, option_font_serif);
SET_FONT(fontMonospace, option_font_mono);
SET_FONT(fontCursive, option_font_cursive);
SET_FONT(fontFantasy, option_font_fantasy);
SET_COMBO(comboDefault, option_font_default);
SET_SPIN(spinDefaultSize, option_font_size / 10);
SET_SPIN(spinMinimumSize, option_font_min_size / 10);
SET_BUTTON(fontPreview);
SET_COMBO(comboButtonType, option_button_type -1);
SET_SPIN(spinMemoryCacheSize, option_memory_cache_size >> 20);
SET_SPIN(spinDiscCacheAge, option_disc_cache_age);
SET_CHECK(checkClearDownloads, option_downloads_clear);
SET_CHECK(checkRequestOverwrite, option_request_overwrite);
SET_FILE_CHOOSER(fileChooserDownloads, option_downloads_directory);
SET_CHECK(checkFocusNew, option_focus_new);
SET_CHECK(checkNewBlank, option_new_blank);
SET_CHECK(checkUrlSearch, option_search_url_bar);
SET_COMBO(comboSearch, option_search_provider);
SET_BUTTON(buttonaddtheme);
SET_CHECK(sourceButtonTab, option_source_tab);
SET_SPIN(spinMarginTop, option_margin_top);
SET_SPIN(spinMarginBottom, option_margin_bottom);
SET_SPIN(spinMarginLeft, option_margin_left);
SET_SPIN(spinMarginRight, option_margin_right);
SET_SPIN(spinExportScale, option_export_scale);
SET_CHECK(checkSuppressImages, option_suppress_images);
SET_CHECK(checkRemoveBackgrounds, option_remove_backgrounds);
SET_CHECK(checkFitPage, option_enable_loosening);
SET_CHECK(checkCompressPDF, option_enable_PDF_compression);
SET_CHECK(checkPasswordPDF, option_enable_PDF_password);
SET_BUTTON(setDefaultExportOptions);
}
static void
cpufreq_applet_update (CPUFreqApplet *applet, CPUFreqMonitor *monitor)
{
gchar *text_mode = NULL;
gchar *freq_label, *unit_label;
gint freq;
gint perc;
guint cpu;
const gchar *governor;
cpu = cpufreq_monitor_get_cpu (monitor);
freq = cpufreq_monitor_get_frequency (monitor);
perc = cpufreq_monitor_get_percentage (monitor);
governor = cpufreq_monitor_get_governor (monitor);
freq_label = cpufreq_utils_get_frequency_label (freq);
unit_label = cpufreq_utils_get_frequency_unit (freq);
if (applet->show_freq) {
gtk_label_set_text (GTK_LABEL (applet->label), freq_label);
}
if (applet->show_perc) {
gchar *text_perc;
text_perc = g_strdup_printf ("%d%%", perc);
gtk_label_set_text (GTK_LABEL (applet->label), text_perc);
g_free (text_perc);
}
if (applet->show_unit) {
gtk_label_set_text (GTK_LABEL (applet->unit_label), unit_label);
}
if (applet->show_icon) {
cpufreq_applet_pixmap_set_image (applet, perc);
}
if (governor) {
gchar *gov_text;
gov_text = g_strdup (governor);
gov_text[0] = g_ascii_toupper (gov_text[0]);
text_mode = g_strdup_printf ("%s\n%s %s (%d%%)",
gov_text, freq_label,
unit_label, perc);
g_free (gov_text);
}
g_free (freq_label);
g_free (unit_label);
if (text_mode) {
gchar *text_tip;
text_tip = cpufreq_utils_get_n_cpus () == 1 ?
g_strdup_printf ("%s", text_mode) :
g_strdup_printf ("CPU %u - %s", cpu, text_mode);
g_free (text_mode);
gtk_widget_set_tooltip_text (GTK_WIDGET (applet), text_tip);
g_free (text_tip);
}
/* Call refresh only the first time */
if (applet->need_refresh) {
cpufreq_applet_refresh (applet);
applet->need_refresh = FALSE;
}
}
static void create_win0_gui()
{
if (top_bin)
return;
GtkWidget *vbox_top = gtk_vbox_new (FALSE, 0);
gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox_top), GTK_ORIENTATION_VERTICAL);
gtk_container_set_border_width (GTK_CONTAINER (gwin0), 0);
if (hime_inner_frame) {
GtkWidget *frame;
top_bin = frame = gtk_frame_new(NULL);
gtk_container_set_border_width (GTK_CONTAINER (frame), 0);
gtk_container_add (GTK_CONTAINER(gwin0), frame);
gtk_container_add (GTK_CONTAINER (frame), vbox_top);
} else {
top_bin = vbox_top;
gtk_container_add (GTK_CONTAINER (gwin0), vbox_top);
}
bzero(chars, sizeof(chars));
GtkWidget *hbox_row1 = gtk_hbox_new (FALSE, 0);
/* This packs the button into the gwin0 (a gtk container). */
gtk_box_pack_start (GTK_BOX (vbox_top), hbox_row1, FALSE, FALSE, 0);
hbox_edit = gtk_hbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox_edit), 0);
/* This packs the button into the gwin0 (a gtk container). */
gtk_box_pack_start (GTK_BOX (hbox_row1), hbox_edit, FALSE, FALSE, 0);
create_cursor_attr();
button_pho = gtk_button_new();
gtk_container_set_border_width (GTK_CONTAINER (button_pho), 0);
gtk_box_pack_start (GTK_BOX (hbox_row1), button_pho, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(button_pho),"button-press-event",
G_CALLBACK(mouse_button_callback), NULL);
#if GTK_CHECK_VERSION(2,18,0)
gtk_widget_set_can_focus(button_pho, FALSE);
gtk_widget_set_can_default(button_pho, FALSE);
#else
GTK_WIDGET_UNSET_FLAGS(button_pho, GTK_CAN_FOCUS|GTK_CAN_DEFAULT);
#endif
#if 0
if (left_right_button_tips) {
#if GTK_CHECK_VERSION(2,12,0)
gtk_widget_set_tooltip_text (button_pho, _("左鍵符號，右鍵設定"));
#else
GtkTooltips *button_pho_tips = gtk_tooltips_new ();
gtk_tooltips_set_tip (GTK_TOOLTIPS (button_pho_tips), button_pho, _("左鍵符號，右鍵設定"),NULL);
#endif
}
#endif
label_pho = gtk_label_new("");
set_label_font_size(label_pho, hime_font_size_tsin_pho_in);
gtk_container_add (GTK_CONTAINER (button_pho), label_pho);
clr_in_area_pho_tsin();
gtk_widget_show_all (gwin0);
// gdk_flush();
gtk_widget_hide(gwin0);
init_tsin_selection_win();
set_win0_bg();
// change_win1_font();
}
// Updates the images according to preferences and the window situation
// Warning! This function is called very often, so it should only do the most necessary things!
void updateTitle(WTApplet *wtapplet) {
WnckWindow *controlledwindow;
gchar *title_text, *title_color, *title_font;
GdkPixbuf *icon_pixbuf;
if (wtapplet->prefs->only_maximized) {
controlledwindow = wtapplet->umaxedwindow;
} else {
controlledwindow = wtapplet->activewindow;
}
if (controlledwindow == NULL)
return;
if (controlledwindow == wtapplet->rootwindow) {
// we're on desktop
if (wtapplet->prefs->hide_on_unmaximized) {
// hide everything
icon_pixbuf = NULL;
title_text = "";
} else {
// display "custom" icon/title (TODO: customization via preferences?)
icon_pixbuf = gtk_widget_render_icon(GTK_WIDGET(wtapplet),GTK_STOCK_HOME,GTK_ICON_SIZE_MENU,NULL); // This has to be unrefed!
title_text = ("Desktop");
}
} else {
icon_pixbuf = wnck_window_get_icon(controlledwindow); // This only returns a pointer - it SHOULDN'T be unrefed!
title_text = (gchar*)wnck_window_get_name(controlledwindow);
}
// TODO: we need the default font to somehow be the same in both modes
if (wtapplet->prefs->custom_style) {
// custom style
if (controlledwindow == wtapplet->activewindow) {
// window focused
title_color = wtapplet->prefs->title_active_color;
title_font = wtapplet->prefs->title_active_font;
} else {
// window unfocused
title_color = wtapplet->prefs->title_inactive_color;
title_font = wtapplet->prefs->title_inactive_font;
}
} else {
// automatic (non-custom) style
if (controlledwindow == wtapplet->activewindow) {
// window focused
title_color = wtapplet->panel_color_fg;
title_font = "";
} else {
// window unfocused
title_color = "#808080"; // inactive title color. best fits for any panel regardless of color
title_font = "";
}
}
// Set tooltips
if (wtapplet->prefs->show_tooltips) {
gtk_widget_set_tooltip_text (GTK_WIDGET(wtapplet->icon), title_text);
gtk_widget_set_tooltip_text (GTK_WIDGET(wtapplet->title), title_text);
}
title_text = g_markup_printf_escaped("<span font=\"%s\" color=\"%s\">%s</span>", title_font, title_color, title_text);
// Apply markup to label widget
gtk_label_set_markup(GTK_LABEL(wtapplet->title), title_text);
g_free(title_text);
if (icon_pixbuf == NULL) {
gtk_image_clear(wtapplet->icon);
} else {
// We're updating window info (Careful! We've had pixbuf memory leaks here)
GdkPixbuf *ipb1 = gdk_pixbuf_scale_simple(icon_pixbuf, ICON_WIDTH, ICON_HEIGHT, GDK_INTERP_BILINEAR);
if (controlledwindow == wtapplet->rootwindow) g_object_unref(icon_pixbuf); //this is stupid beyond belief, thanks to the retarded GTK framework
GdkPixbuf *ipb2 = gdk_pixbuf_rotate_simple(ipb1, wtapplet->angle);
g_object_unref(ipb1); // Unref ipb1 to get it cleared from memory (we still need ipb2)
// Saturate icon when window is not focused
if (controlledwindow != wtapplet->activewindow)
gdk_pixbuf_saturate_and_pixelate(ipb2, ipb2, 0, FALSE);
// Apply pixbuf to icon widget
gtk_image_set_from_pixbuf(wtapplet->icon, ipb2);
g_object_unref(ipb2); // Unref ipb2 to get it cleared from memory
}
}
/**
* @param ddisp The diagram display object that a window is created for
* @param width Diagram widgth
* @param height Diagram Height
* @param title Window title
* @param use_mbar Flag to indicate whether to add a menubar to the window
*/
void
create_display_shell(DDisplay *ddisp,
int width, int height,
char *title, int use_mbar)
{
GtkWidget *table, *widget;
GtkWidget *status_hbox;
GtkWidget *root_vbox = NULL;
GtkWidget *zoom_hbox, *zoom_label;
int s_width, s_height;
if (app_is_interactive() && is_integrated_ui())
{
use_integrated_ui_for_display_shell(ddisp, title);
return;
}
ddisp->is_standalone_window = TRUE;
ddisp->container = NULL;
s_width = gdk_screen_width ();
s_height = gdk_screen_height ();
if (width > s_width)
width = s_width;
if (height > s_height)
height = s_height;
/* The toplevel shell */
ddisp->shell = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (ddisp->shell), title);
gtk_window_set_role (GTK_WINDOW (ddisp->shell), "diagram_window");
gtk_window_set_icon_name (GTK_WINDOW (ddisp->shell), "dia");
gtk_window_set_default_size(GTK_WINDOW (ddisp->shell), width, height);
/* set_icon_name needs registered theme icons, not always available: provide fallback */
if (!gtk_window_get_icon (GTK_WINDOW (ddisp->shell))) {
static GdkPixbuf *pixbuf = NULL;
if (!pixbuf)
pixbuf = gdk_pixbuf_new_from_inline(-1, dia_diagram_icon, FALSE, NULL);
if (pixbuf)
gtk_window_set_icon (GTK_WINDOW (ddisp->shell), pixbuf);
}
g_object_set_data (G_OBJECT (ddisp->shell), "user_data", (gpointer) ddisp);
_ddisplay_setup_events (ddisp, ddisp->shell);
/* following two not shared with integrated UI */
g_signal_connect (G_OBJECT (ddisp->shell), "delete_event",
G_CALLBACK (ddisplay_delete), ddisp);
g_signal_connect (G_OBJECT (ddisp->shell), "destroy",
G_CALLBACK (ddisplay_destroy), ddisp);
/* the table containing all widgets */
table = gtk_table_new (4, 3, FALSE);
gtk_table_set_col_spacing (GTK_TABLE (table), 0, 1);
gtk_table_set_col_spacing (GTK_TABLE (table), 1, 2);
gtk_table_set_row_spacing (GTK_TABLE (table), 0, 1);
gtk_table_set_row_spacing (GTK_TABLE (table), 1, 2);
gtk_container_set_border_width (GTK_CONTAINER (table), 2);
if (use_mbar)
{
root_vbox = gtk_vbox_new (FALSE, 1);
gtk_container_add (GTK_CONTAINER (ddisp->shell), root_vbox);
gtk_box_pack_end (GTK_BOX (root_vbox), table, TRUE, TRUE, 0);
}
else
{
gtk_container_add (GTK_CONTAINER (ddisp->shell), table);
}
/* scrollbars, rulers, canvas, menu popup button */
if (!use_mbar) {
ddisp->origin = gtk_button_new();
#if GTK_CHECK_VERSION(2,18,0)
gtk_widget_set_can_focus (ddisp->origin, FALSE);
#else
GTK_WIDGET_UNSET_FLAGS(ddisp->origin, GTK_CAN_FOCUS);
#endif
widget = gtk_arrow_new(GTK_ARROW_RIGHT, GTK_SHADOW_OUT);
gtk_container_add(GTK_CONTAINER(ddisp->origin), widget);
gtk_widget_set_tooltip_text(widget, _("Diagram menu."));
gtk_widget_show(widget);
g_signal_connect(G_OBJECT(ddisp->origin), "button_press_event",
G_CALLBACK(origin_button_press), ddisp);
}
else {
ddisp->origin = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (ddisp->origin), GTK_SHADOW_OUT);
}
_ddisplay_setup_rulers (ddisp, ddisp->shell, table);
_ddisplay_setup_scrollbars (ddisp, table, width, height);
_ddisplay_setup_navigation (ddisp, table);
ddisp->canvas = create_canvas (ddisp);
/* pack all remaining widgets */
gtk_table_attach (GTK_TABLE (table), ddisp->origin, 0, 1, 0, 1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach (GTK_TABLE (table), ddisp->canvas, 1, 2, 1, 2,
GTK_EXPAND | GTK_SHRINK | GTK_FILL,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
/* TODO rob use per window accel */
ddisp->accel_group = menus_get_display_accels ();
gtk_window_add_accel_group(GTK_WINDOW(ddisp->shell), ddisp->accel_group);
if (use_mbar)
{
ddisp->menu_bar = menus_create_display_menubar (&ddisp->ui_manager, &ddisp->actions);
g_assert (ddisp->menu_bar);
gtk_box_pack_start (GTK_BOX (root_vbox), ddisp->menu_bar, FALSE, TRUE, 0);
}
/* the statusbars */
status_hbox = gtk_hbox_new (FALSE, 2);
/* Zoom status pseudo-optionmenu */
ddisp->zoom_status = create_zoom_widget(ddisp);
zoom_hbox = gtk_hbox_new(FALSE, 0);
zoom_label = gtk_label_new(_("Zoom"));
gtk_box_pack_start (GTK_BOX(zoom_hbox), zoom_label,
FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(zoom_hbox), ddisp->zoom_status,
FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (status_hbox), zoom_hbox, FALSE, FALSE, 0);
/* Grid on/off button */
ddisp->grid_status = dia_toggle_button_new_with_icons(dia_on_grid_icon,
dia_off_grid_icon);
g_signal_connect(G_OBJECT(ddisp->grid_status), "toggled",
G_CALLBACK (grid_toggle_snap), ddisp);
gtk_widget_set_tooltip_text(ddisp->grid_status,
_("Toggles snap-to-grid for this window."));
gtk_box_pack_start (GTK_BOX (status_hbox), ddisp->grid_status,
FALSE, FALSE, 0);
ddisp->mainpoint_status = dia_toggle_button_new_with_icons(dia_mainpoints_on_icon,
dia_mainpoints_off_icon);
g_signal_connect(G_OBJECT(ddisp->mainpoint_status), "toggled",
G_CALLBACK (interface_toggle_mainpoint_magnetism), ddisp);
gtk_widget_set_tooltip_text(ddisp->mainpoint_status,
_("Toggles object snapping for this window."));
gtk_box_pack_start (GTK_BOX (status_hbox), ddisp->mainpoint_status,
FALSE, FALSE, 0);
/* Statusbar */
ddisp->modified_status = gtk_statusbar_new ();
gtk_box_pack_start (GTK_BOX (status_hbox), ddisp->modified_status,
TRUE, TRUE, 0);
gtk_table_attach (GTK_TABLE (table), status_hbox, 0, 3, 3, 4,
GTK_FILL, GTK_FILL, 0, 0);
display_rulers_show (ddisp);
gtk_widget_show (ddisp->zoom_status);
gtk_widget_show (zoom_hbox);
gtk_widget_show (zoom_label);
gtk_widget_show (ddisp->grid_status);
gtk_widget_show (ddisp->mainpoint_status);
gtk_widget_show (ddisp->modified_status);
gtk_widget_show (status_hbox);
gtk_widget_show (table);
if (use_mbar)
{
gtk_widget_show (ddisp->menu_bar);
gtk_widget_show (root_vbox);
}
gtk_widget_show (ddisp->shell);
/* before showing up, checking canvas's REAL size */
if (use_mbar && ddisp->hrule->allocation.width > width)
{
/* The menubar is not shrinkable, so the shell will have at least
* the menubar's width. If the diagram's requested width is smaller,
* the canvas will be enlarged to fit the place. In this case, we
* need to adjust the horizontal scrollbar according to the size
* that will be allocated, which the same as the hrule got.
*/
width = ddisp->hrule->allocation.width;
gtk_adjustment_set_upper (ddisp->hsbdata, width);
gtk_adjustment_set_page_increment (ddisp->hsbdata, (width - 1) / 4);
gtk_adjustment_set_page_size (ddisp->hsbdata, width - 1);
gtk_adjustment_changed (GTK_ADJUSTMENT(ddisp->hsbdata));
}
gtk_widget_show (ddisp->canvas);
/* set the focus to the canvas area */
gtk_widget_grab_focus (ddisp->canvas);
}
static GtkWidget *_lib_import_get_extra_widget(dt_lib_module_t *self,dt_lib_import_metadata_t *data, gboolean import_folder)
{
// add extra lines to 'extra'. don't forget to destroy the widgets later.
GtkWidget *expander = gtk_expander_new(_("import options"));
gtk_expander_set_expanded(GTK_EXPANDER(expander), dt_conf_get_bool("ui_last/import_options_expanded"));
GtkWidget *frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
gtk_widget_set_hexpand(frame, TRUE);
GtkWidget *event_box = gtk_event_box_new();
gtk_widget_set_margin_start(event_box, DT_PIXEL_APPLY_DPI(8));
gtk_widget_set_margin_end(event_box, DT_PIXEL_APPLY_DPI(8));
gtk_widget_set_margin_top(event_box, DT_PIXEL_APPLY_DPI(8));
gtk_widget_set_margin_bottom(event_box, DT_PIXEL_APPLY_DPI(8));
gtk_container_add(GTK_CONTAINER(frame), event_box);
gtk_container_add(GTK_CONTAINER(event_box), expander);
GtkWidget *extra;
extra = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add(GTK_CONTAINER(expander), extra);
gtk_widget_set_margin_start(extra, DT_PIXEL_APPLY_DPI(8));
gtk_widget_set_margin_end(extra, DT_PIXEL_APPLY_DPI(8));
gtk_widget_set_margin_top(extra, DT_PIXEL_APPLY_DPI(8));
gtk_widget_set_margin_bottom(extra, DT_PIXEL_APPLY_DPI(8));
GtkWidget *recursive = NULL, *ignore_jpeg = NULL;
if(import_folder == TRUE)
{
// recursive opening.
recursive = gtk_check_button_new_with_label(_("import directories recursively"));
gtk_widget_set_tooltip_text(recursive,
_("recursively import subdirectories. each directory goes into a new film roll."));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(recursive), dt_conf_get_bool("ui_last/import_recursive"));
gtk_box_pack_start(GTK_BOX(extra), recursive, FALSE, FALSE, 0);
// ignoring of jpegs. hack while we don't handle raw+jpeg in the same directories.
ignore_jpeg = gtk_check_button_new_with_label(_("ignore JPEG files"));
gtk_widget_set_tooltip_text(ignore_jpeg, _("do not load files with an extension of .jpg or .jpeg. this "
"can be useful when there are raw+JPEG in a directory."));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ignore_jpeg),
dt_conf_get_bool("ui_last/import_ignore_jpegs"));
gtk_box_pack_start(GTK_BOX(extra), ignore_jpeg, FALSE, FALSE, 0);
}
// default metadata
GtkWidget *apply_metadata;
GtkWidget *grid, *label, *creator, *publisher, *rights, *tags;
apply_metadata = gtk_check_button_new_with_label(_("apply metadata on import"));
gtk_widget_set_tooltip_text(apply_metadata, _("apply some metadata to all newly imported images."));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(apply_metadata),
dt_conf_get_bool("ui_last/import_apply_metadata"));
gtk_box_pack_start(GTK_BOX(extra), apply_metadata, FALSE, FALSE, 0);
GValue value = {
0,
};
g_value_init(&value, G_TYPE_INT);
gtk_widget_style_get_property(apply_metadata, "indicator-size", &value);
gint indicator_size = g_value_get_int(&value);
gtk_widget_style_get_property(apply_metadata, "indicator-spacing", &value);
gint indicator_spacing = g_value_get_int(&value);
g_value_unset(&value);
grid = gtk_grid_new();
gtk_grid_set_row_spacing(GTK_GRID(grid), DT_PIXEL_APPLY_DPI(5));
gtk_grid_set_column_spacing(GTK_GRID(grid), DT_PIXEL_APPLY_DPI(10));
gtk_widget_set_margin_start(grid, 2 * (indicator_spacing + indicator_size));
gtk_box_pack_start(GTK_BOX(extra), grid, FALSE, FALSE, 0);
#ifdef USE_LUA
dt_lib_import_t *d = (dt_lib_import_t *)self->data;
gtk_box_pack_start(GTK_BOX(extra),d->extra_lua_widgets , FALSE, FALSE, 0);
gtk_container_foreach(GTK_CONTAINER(d->extra_lua_widgets),reset_child,NULL);
#endif
creator = gtk_entry_new();
gtk_widget_set_size_request(creator, DT_PIXEL_APPLY_DPI(300), -1);
gchar *str = dt_conf_get_string("ui_last/import_last_creator");
gtk_entry_set_text(GTK_ENTRY(creator), str);
g_free(str);
publisher = gtk_entry_new();
str = dt_conf_get_string("ui_last/import_last_publisher");
gtk_entry_set_text(GTK_ENTRY(publisher), str);
g_free(str);
rights = gtk_entry_new();
str = dt_conf_get_string("ui_last/import_last_rights");
gtk_entry_set_text(GTK_ENTRY(rights), str);
g_free(str);
tags = gtk_entry_new();
str = dt_conf_get_string("ui_last/import_last_tags");
gtk_widget_set_tooltip_text(tags, _("comma separated list of tags"));
gtk_entry_set_text(GTK_ENTRY(tags), str);
g_free(str);
// presets from the metadata plugin
GtkCellRenderer *renderer;
GtkTreeIter iter;
GtkListStore *model = gtk_list_store_new(N_COLUMNS, G_TYPE_STRING /*name*/, G_TYPE_STRING /*creator*/,
G_TYPE_STRING /*publisher*/, G_TYPE_STRING /*rights*/);
GtkWidget *presets = gtk_combo_box_new_with_model(GTK_TREE_MODEL(model));
renderer = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(presets), renderer, FALSE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(presets), renderer, "text", NAME_COLUMN, NULL);
sqlite3_stmt *stmt;
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db),
"select name, op_params from presets where operation = \"metadata\"", -1, &stmt,
NULL);
while(sqlite3_step(stmt) == SQLITE_ROW)
{
void *op_params = (void *)sqlite3_column_blob(stmt, 1);
int32_t op_params_size = sqlite3_column_bytes(stmt, 1);
char *buf = (char *)op_params;
char *title_str = buf;
buf += strlen(title_str) + 1;
char *description_str = buf;
buf += strlen(description_str) + 1;
char *rights_str = buf;
buf += strlen(rights_str) + 1;
char *creator_str = buf;
buf += strlen(creator_str) + 1;
char *publisher_str = buf;
if(op_params_size
== strlen(title_str) + strlen(description_str) + strlen(rights_str) + strlen(creator_str)
+ strlen(publisher_str) + 5)
{
gtk_list_store_append(model, &iter);
gtk_list_store_set(model, &iter, NAME_COLUMN, (char *)sqlite3_column_text(stmt, 0), CREATOR_COLUMN,
creator_str, PUBLISHER_COLUMN, publisher_str, RIGHTS_COLUMN, rights_str, -1);
}
}
sqlite3_finalize(stmt);
g_object_unref(model);
int line = 0;
label = gtk_label_new(_("preset"));
gtk_widget_set_halign(label, GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(grid), label, 0, line++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(grid), presets, label, GTK_POS_RIGHT, 1, 1);
label = gtk_label_new(_("creator"));
gtk_widget_set_halign(label, GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(grid), label, 0, line++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(grid), creator, label, GTK_POS_RIGHT, 1, 1);
label = gtk_label_new(_("publisher"));
gtk_widget_set_halign(label, GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(grid), label, 0, line++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(grid), publisher, label, GTK_POS_RIGHT, 1, 1);
label = gtk_label_new(_("rights"));
gtk_widget_set_halign(label, GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(grid), label, 0, line++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(grid), rights, label, GTK_POS_RIGHT, 1, 1);
label = gtk_label_new(_("tags"));
gtk_widget_set_halign(label, GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(grid), label, 0, line, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(grid), tags, label, GTK_POS_RIGHT, 1, 1);
gtk_widget_show_all(frame);
if(data != NULL)
{
data->frame = frame;
data->recursive = recursive;
data->ignore_jpeg = ignore_jpeg;
data->expander = expander;
data->apply_metadata = apply_metadata;
data->presets = presets;
data->creator = creator;
data->publisher = publisher;
data->rights = rights;
data->tags = tags;
}
g_signal_connect(apply_metadata, "toggled", G_CALLBACK(_lib_import_apply_metadata_toggled), grid);
// needed since the apply_metadata starts being turned off, and setting it to off doesn't emit the 'toggled' signal ...
_lib_import_apply_metadata_toggled(apply_metadata, grid);
g_signal_connect(presets, "changed", G_CALLBACK(_lib_import_presets_changed), data);
g_signal_connect(GTK_ENTRY(creator), "changed", G_CALLBACK(_lib_import_metadata_changed), presets);
g_signal_connect(GTK_ENTRY(publisher), "changed", G_CALLBACK(_lib_import_metadata_changed), presets);
g_signal_connect(GTK_ENTRY(rights), "changed", G_CALLBACK(_lib_import_metadata_changed), presets);
return frame;
}
static void
patrol_dialog_window_constructed (GObject *obj)
{
G_OBJECT_CLASS(patrol_dialog_window_parent_class)->constructed(obj);
PatrolDialogWindow *self = PATROL_DIALOG_WINDOW(obj);
PatrolDialogWindowPrivate *pv = self->pv;
gtk_window_set_title(GTK_WINDOW(self), _("Certificate Patrol"));
gtk_window_set_default_size(GTK_WINDOW(self), 500, 700);
//gtk_window_set_position(GTK_WINDOW(self), GTK_WIN_POS_MOUSE);
/* content area */
GtkWidget *content = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_set_margin_left(GTK_WIDGET(content), 10);
gtk_widget_set_margin_right(GTK_WIDGET(content), 10);
gtk_container_add(GTK_CONTAINER(self), content);
/* messages */
GtkWidget *msgbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start(GTK_BOX(content), msgbox, FALSE, FALSE, 6);
pv->icon = gtk_image_new();
gtk_box_pack_start(GTK_BOX(msgbox), pv->icon, FALSE, FALSE, 6);
pv->msg = gtk_label_new(NULL);
gtk_label_set_line_wrap(GTK_LABEL(pv->msg), TRUE);
gtk_widget_set_halign(GTK_WIDGET(pv->msg), GTK_ALIGN_START);
gtk_widget_set_margin_top(GTK_WIDGET(pv->msg), 25);
gtk_box_pack_start(GTK_BOX(msgbox), pv->msg, FALSE, FALSE, 6);
msgbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start(GTK_BOX(content), msgbox, FALSE, FALSE, 6);
pv->chain_icon = gtk_image_new();
gtk_box_pack_start(GTK_BOX(msgbox), pv->chain_icon, FALSE, FALSE, 6);
pv->chain_msg = gtk_label_new(NULL);
gtk_widget_set_halign(GTK_WIDGET(pv->chain_msg), GTK_ALIGN_START);
gtk_box_pack_start(GTK_BOX(msgbox), pv->chain_msg, FALSE, FALSE, 6);
#ifdef HAVE_GNUTLS_DANE
msgbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start(GTK_BOX(content), msgbox, FALSE, FALSE, 6);
pv->dane_icon = gtk_image_new();
gtk_box_pack_start(GTK_BOX(msgbox), pv->dane_icon, FALSE, FALSE, 6);
pv->dane_msg = gtk_label_new(NULL);
gtk_widget_set_halign(GTK_WIDGET(pv->dane_msg), GTK_ALIGN_START);
gtk_box_pack_start(GTK_BOX(msgbox), pv->dane_msg, FALSE, FALSE, 6);
#endif
/* details: chains & cert viewer */
GtkWidget *details = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
gtk_box_pack_start(GTK_BOX(content), details, TRUE, TRUE, 6);
GtkWidget *chains = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10);
gtk_box_pack_start(GTK_BOX(details), chains, FALSE, FALSE, 0);
GtkWidget *viewport = gtk_viewport_new(NULL, NULL);
gtk_box_pack_start(GTK_BOX(chains), viewport, FALSE, FALSE, 0);
pv->new_chain = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
gtk_widget_set_margin_left(pv->new_chain, 5);
gtk_widget_set_margin_top(pv->new_chain, 5);
gtk_widget_set_margin_bottom(pv->new_chain, 5);
//gtk_box_pack_start(GTK_BOX(chains), pv->new_chain, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(viewport), pv->new_chain);
GtkWidget *frame = gtk_frame_new(NULL);
gtk_box_pack_start(GTK_BOX(chains), frame, TRUE, TRUE, 0);
GtkWidget *scrolled_window = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(frame), scrolled_window);
pv->old_chains = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10);
gtk_widget_set_margin_left(pv->old_chains, 5);
gtk_widget_set_margin_top(pv->old_chains, 5);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_window),
GTK_WIDGET(pv->old_chains));
//gtk_box_pack_start(GTK_BOX(chains), pv->old_chains, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(details), GTK_WIDGET(pv->viewer), TRUE, TRUE, 0);
/* button box */
GtkWidget *bbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
gtk_widget_set_halign(GTK_WIDGET(bbox), GTK_ALIGN_END);
gtk_widget_set_margin_right(GTK_WIDGET(bbox), 6);
gtk_box_set_spacing(GTK_BOX(bbox), 12);
gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
gtk_box_pack_end(GTK_BOX(content), bbox, FALSE, FALSE, 12);
/* accept all checkbox */
GtkWidget *btn = gtk_check_button_new_with_mnemonic(
_("Pin public key for all _hostnames the certificate is valid for "
"(see Subject Name and Subject Alternative Names)"));
gtk_widget_set_tooltip_text(btn, "TODO");
g_signal_connect_object(GTK_TOGGLE_BUTTON(btn), "toggled",
G_CALLBACK(on_all_hostnames_toggled), self, 0);
gtk_box_pack_end(GTK_BOX(content), btn, FALSE, FALSE, 0);
/* additional pin checkbox */
btn = gtk_check_button_new_with_mnemonic(
_("_Store additional pin instead of replacing existing ones"));
g_signal_connect_object(GTK_TOGGLE_BUTTON(btn), "toggled",
G_CALLBACK(on_add_pin_toggled), self, 0);
gtk_box_pack_end(GTK_BOX(content), btn, FALSE, FALSE, 0);
/* reject button */
btn = gtk_button_new_from_stock(GTK_STOCK_NO);
gtk_button_set_label(GTK_BUTTON(btn), _("_Reject"));
gtk_widget_set_tooltip_text(btn, _("Reject public key.\nCauses verification failure."));
gtk_box_pack_start(GTK_BOX(bbox), btn, FALSE, TRUE, 0);
g_signal_connect_object (GTK_BUTTON(btn), "clicked",
G_CALLBACK(on_reject_clicked), self, 0);
/* continue button */
btn = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
gtk_button_set_label(GTK_BUTTON(btn), _("_Continue"));
gtk_widget_set_tooltip_text(btn, _("Temporarily accept public key, but do not pin it."));
gtk_box_pack_start(GTK_BOX(bbox), btn, FALSE, TRUE, 0);
g_signal_connect_object(GTK_BUTTON(btn), "clicked",
G_CALLBACK(on_continue_clicked), self, 0);
gtk_widget_grab_focus(btn);
/* accept button */
btn = gtk_button_new_from_stock(GTK_STOCK_YES);
gtk_button_set_label(GTK_BUTTON(btn), _("_Accept"));
gtk_widget_set_tooltip_text(btn, _("Accept and pin public key.\nReplace or add pin depending on the above setting."));
gtk_box_pack_start(GTK_BOX(bbox), btn, FALSE, TRUE, 0);
g_signal_connect_object(GTK_BUTTON(btn), "clicked",
G_CALLBACK(on_accept_clicked), self, 0);
gtk_widget_show_all(content);
}
/** update the device list */
void _lib_import_ui_devices_update(dt_lib_module_t *self)
{
dt_lib_import_t *d = (dt_lib_import_t *)self->data;
GList *citem;
/* cleanup of widgets in devices container*/
GList *item, *iter;
if((iter = item = gtk_container_get_children(GTK_CONTAINER(d->devices))) != NULL) do
{
gtk_container_remove(GTK_CONTAINER(d->devices), GTK_WIDGET(iter->data));
} while((iter = g_list_next(iter)) != NULL);
g_list_free(item);
uint32_t count = 0;
/* FIXME: Verify that it's safe to access camctl->cameras list here ? */
if((citem = g_list_first(darktable.camctl->cameras)) != NULL)
{
// Add detected supported devices
char buffer[512] = { 0 };
do
{
dt_camera_t *camera = (dt_camera_t *)citem->data;
count++;
/* add camera label */
GtkWidget *label = dt_ui_section_label_new(camera->model);
gtk_widget_set_margin_top(label, DT_PIXEL_APPLY_DPI(15));
gtk_box_pack_start(GTK_BOX(d->devices), label, TRUE, TRUE, 0);
/* set camera summary if available */
if(*camera->summary.text)
{
gtk_widget_set_tooltip_text(label, camera->summary.text);
}
else
{
snprintf(buffer, sizeof(buffer), _("device \"%s\" connected on port \"%s\"."), camera->model,
camera->port);
gtk_widget_set_tooltip_text(label, buffer);
}
/* add camera actions buttons */
GtkWidget *ib = NULL, *tb = NULL;
GtkWidget *vbx = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
if(camera->can_import == TRUE)
{
gtk_box_pack_start(GTK_BOX(vbx), (ib = gtk_button_new_with_label(_("import from camera"))), FALSE,
FALSE, 0);
d->import_camera = GTK_BUTTON(ib);
}
if(camera->can_tether == TRUE)
{
gtk_box_pack_start(GTK_BOX(vbx), (tb = gtk_button_new_with_label(_("tethered shoot"))), FALSE, FALSE,
0);
d->tethered_shoot = GTK_BUTTON(tb);
}
if(ib)
{
g_signal_connect(G_OBJECT(ib), "clicked", G_CALLBACK(_lib_import_from_camera_callback), camera);
gtk_widget_set_halign(gtk_bin_get_child(GTK_BIN(ib)), GTK_ALIGN_START);
}
if(tb)
{
g_signal_connect(G_OBJECT(tb), "clicked", G_CALLBACK(_lib_import_tethered_callback), camera);
gtk_widget_set_halign(gtk_bin_get_child(GTK_BIN(tb)), GTK_ALIGN_START);
}
gtk_box_pack_start(GTK_BOX(d->devices), vbx, FALSE, FALSE, 0);
} while((citem = g_list_next(citem)) != NULL);
}
if(count == 0)
{
// No supported devices is detected lets notice user..
GtkWidget *label = gtk_label_new(_("no supported devices found"));
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
g_object_set(G_OBJECT(label), "xalign", 0.0, NULL);
gtk_box_pack_start(GTK_BOX(d->devices), label, TRUE, TRUE, 0);
}
gtk_widget_show_all(GTK_WIDGET(d->devices));
}
/* Warning! This function is called very often, so it should only do the most necessary things! */
static void on_name_changed (WnckWindow *controlwindow, WindowckPlugin *wckp)
{
gint i, n;
const gchar *title_text;
if (controlwindow
&& ((wnck_window_get_window_type (controlwindow) != WNCK_WINDOW_DESKTOP)
|| wckp->prefs->show_on_desktop))
{
const gchar *title_color, *title_font, *subtitle_font;
gchar **part, *title_markup;
title_text = wnck_window_get_name(controlwindow);
if (wnck_window_is_active(controlwindow))
{
/* window focused */
//~ gtk_widget_set_sensitive(GTK_WIDGET(wckp->title), TRUE);
title_color = wckp->prefs->active_text_color;
}
else {
/* window unfocused */
//~ gtk_widget_set_sensitive(GTK_WIDGET(wckp->title), FALSE);
title_color = wckp->prefs->inactive_text_color;
}
title_font = wckp->prefs->title_font;
subtitle_font = wckp->prefs->subtitle_font;
/* Set tooltips */
if (wckp->prefs->show_tooltips)
{
gtk_widget_set_tooltip_text(GTK_WIDGET(wckp->title), title_text);
}
/* get application and instance names */
if (wckp->prefs->full_name && !wckp->prefs->two_lines)
{
title_markup = g_markup_printf_escaped("<span font=\"%s\" color=\"%s\">%s</span>", title_font, title_color, title_text);
}
else {
/* split title text */
part = g_strsplit (title_text, " - ", 0);
n=0;
for (i=0; part[i]; i++) n++;
if (n > 1)
{
if (wckp->prefs->two_lines)
{
gchar *subtitle = malloc( sizeof(gchar) * ( strlen(title_text) + 1 ) );
strcpy (subtitle, part[0]);
if (wckp->prefs->full_name)
{
for (i=1; i < n - 1; i++)
{
strcat (subtitle, " - ");
strcat (subtitle, part[i]);
}
}
title_markup = g_markup_printf_escaped("<span font=\"%s\" color=\"%s\">%s</span><span font=\"%s\" color=\"%s\">\n%s</span>", title_font, title_color, part[n-1], subtitle_font, title_color, subtitle);
free (subtitle);
}
else
{
title_markup = g_markup_printf_escaped("<span font=\"%s\" color=\"%s\">%s</span>", title_font, title_color, part[n-1]);
}
}
else {
title_markup = g_markup_printf_escaped("<span font=\"%s\" color=\"%s\">%s</span>", title_font, title_color, part[0]);
}
g_strfreev(part);
}
gtk_label_set_markup(wckp->title, title_markup);
if (wckp->prefs->title_alignment == LEFT)
{
gtk_label_set_justify(wckp->title, GTK_JUSTIFY_LEFT);
}
else if (wckp->prefs->title_alignment == CENTER)
{
gtk_label_set_justify(wckp->title, GTK_JUSTIFY_CENTER);
}
else if (wckp->prefs->title_alignment == RIGHT)
{
gtk_label_set_justify(wckp->title, GTK_JUSTIFY_RIGHT);
}
g_free (title_markup);
}
else {
/* hide text */
title_text = "";
gtk_label_set_text(wckp->title, title_text);
}
}
GtkWidget *bar_pane_gps_new(const gchar *id, const gchar *title, const gchar *map_id,
const gint zoom, const gdouble latitude, const gdouble longitude,
gboolean expanded, gint height)
{
PaneGPSData *pgd;
GtkWidget *vbox, *frame;
GtkWidget *gpswidget, *viewport;
GtkWidget *status, *state, *progress, *slider;
ChamplainLayer *layer;
ChamplainView *view;
const gchar *slider_list[] = {GTK_STOCK_ZOOM_IN, GTK_STOCK_ZOOM_OUT, NULL};
const gchar **slider_icons = slider_list;
pgd = g_new0(PaneGPSData, 1);
pgd->pane.pane_set_fd = bar_pane_gps_set_fd;
pgd->pane.pane_notify_selection = bar_pane_gps_notify_selection;
pgd->pane.pane_event = bar_pane_gps_event;
pgd->pane.pane_write_config = bar_pane_gps_write_config;
pgd->pane.title = bar_pane_expander_title(title);
pgd->pane.id = g_strdup(id);
pgd->pane.type = PANE_GPS;
pgd->pane.expanded = expanded;
pgd->height = height;
frame = gtk_frame_new(NULL);
vbox = gtk_vbox_new(FALSE, 0);
gpswidget = gtk_champlain_embed_new();
view = gtk_champlain_embed_get_view(GTK_CHAMPLAIN_EMBED(gpswidget));
gtk_box_pack_start(GTK_BOX(vbox), gpswidget, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(frame), vbox);
status = gtk_hbox_new(FALSE,0);
slider = gtk_scale_button_new(GTK_ICON_SIZE_SMALL_TOOLBAR, 1, 17, 1, slider_icons);
gtk_widget_set_tooltip_text(slider, "Zoom");
gtk_scale_button_set_value(GTK_SCALE_BUTTON(slider), (gdouble)zoom);
progress = gtk_progress_bar_new();
state = gtk_label_new("");
gtk_label_set_justify(GTK_LABEL(state), GTK_JUSTIFY_CENTER);
gtk_box_pack_start(GTK_BOX(status), GTK_WIDGET(slider), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(status), GTK_WIDGET(state), FALSE, FALSE, 5);
gtk_box_pack_end(GTK_BOX(status), GTK_WIDGET(progress), FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(vbox),GTK_WIDGET(status), FALSE, FALSE, 0);
layer = champlain_layer_new();
champlain_view_add_layer(view, layer);
pgd->icon_layer = layer;
pgd->gps_view = CLUTTER_ACTOR(view);
pgd->widget = frame;
pgd->progress = progress;
pgd->slider = slider;
pgd->state = state;
bar_pane_gps_set_map_source(pgd, map_id);
g_object_set(G_OBJECT(view), "scroll-mode", CHAMPLAIN_SCROLL_MODE_KINETIC,
"zoom-level", zoom,
"keep-center-on-resize", TRUE,
/* This seems to be broken, https://bugzilla.gnome.org/show_bug.cgi?id=596419
"decel-rate", 1.0,
*/
"show-license", TRUE,
"zoom-on-double-click", FALSE,
"max-zoom-level", 17,
"min-zoom-level", 1,
NULL);
champlain_view_center_on(view, latitude, longitude);
pgd->centre_map_checked = TRUE;
g_object_set_data(G_OBJECT(pgd->widget), "pane_data", pgd);
g_signal_connect(G_OBJECT(pgd->widget), "destroy", G_CALLBACK(bar_pane_gps_destroy), pgd);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
gtk_widget_set_size_request(pgd->widget, -1, height);
clutter_set_motion_events_enabled(TRUE);
g_signal_connect(G_OBJECT(gpswidget), "button_press_event", G_CALLBACK(bar_pane_gps_map_keypress_cb), pgd);
g_signal_connect(pgd->gps_view, "notify::state", G_CALLBACK(bar_pane_gps_view_state_changed_cb), pgd);
g_signal_connect(pgd->gps_view, "notify::zoom-level", G_CALLBACK(bar_pane_gps_view_state_changed_cb), pgd);
g_signal_connect(G_OBJECT(slider), "value-changed", G_CALLBACK(bar_pane_gps_slider_changed_cb), pgd);
file_data_register_notify_func(bar_pane_gps_notify_cb, pgd, NOTIFY_PRIORITY_LOW);
pgd->create_markers_id = 0;
pgd->enable_markers_checked = TRUE;
pgd->centre_map_checked = TRUE;
return pgd->widget;
}
static void
nemo_status_bar_constructed (GObject *object)
{
NemoStatusBar *bar = NEMO_STATUS_BAR (object);
G_OBJECT_CLASS (nemo_status_bar_parent_class)->constructed (object);
GtkToolbar *toolbar;
GtkWidget *widget_box;
GtkToolItem *item;
GtkWidget *statusbar = gtk_statusbar_new ();
GtkActionGroup *action_group;
GtkStyleContext *context;
bar->real_statusbar = statusbar;
GtkIconSize size = gtk_icon_size_from_name (NEMO_STATUSBAR_ICON_SIZE_NAME);
context = gtk_widget_get_style_context (GTK_WIDGET (bar));
gtk_style_context_add_class (context, GTK_STYLE_CLASS_TOOLBAR);
gtk_container_set_border_width (GTK_CONTAINER (bar), 1);
GtkWidget *button, *icon;
button = gtk_toggle_button_new ();
icon = gtk_image_new_from_icon_name ("sidebar-places-symbolic", size);
gtk_button_set_image (GTK_BUTTON (button), icon);
gtk_widget_set_tooltip_text (GTK_WIDGET (button), _("Show Places"));
bar->places_button = button;
gtk_box_pack_start (GTK_BOX (bar), button, FALSE, FALSE, 2);
g_signal_connect (GTK_BUTTON (button), "clicked",
G_CALLBACK (action_places_toggle_callback), bar);
button = gtk_toggle_button_new ();
icon = gtk_image_new_from_icon_name ("sidebar-tree-symbolic", size);
gtk_button_set_image (GTK_BUTTON (button), icon);
gtk_widget_set_tooltip_text (GTK_WIDGET (button), _("Show Treeview"));
bar->tree_button = button;
gtk_box_pack_start (GTK_BOX (bar), button, FALSE, FALSE, 2);
g_signal_connect (GTK_BUTTON (button), "clicked",
G_CALLBACK (action_treeview_toggle_callback), bar);
GtkWidget *sep = gtk_separator_new (GTK_ORIENTATION_VERTICAL);
gtk_box_pack_start (GTK_BOX (bar), sep, FALSE, FALSE, 6);
gtk_widget_show (sep);
bar->separator = sep;
button = gtk_button_new ();
icon = gtk_image_new_from_icon_name ("sidebar-hide-symbolic", size);
gtk_button_set_image (GTK_BUTTON (button), icon);
gtk_widget_set_tooltip_text (GTK_WIDGET (button), _("Hide the Sidebar (F9)"));
bar->hide_button = button;
gtk_box_pack_start (GTK_BOX (bar), button, FALSE, FALSE, 2);
g_signal_connect (GTK_BUTTON (button), "clicked",
G_CALLBACK (action_hide_sidebar_callback), bar);
button = gtk_button_new ();
icon = gtk_image_new_from_icon_name ("sidebar-show-symbolic", size);
gtk_button_set_image (GTK_BUTTON (button), icon);
gtk_widget_set_tooltip_text (GTK_WIDGET (button), _("Show the Sidebar (F9)"));
bar->show_button = button;
gtk_box_pack_start (GTK_BOX (bar), button, FALSE, FALSE, 2);
g_signal_connect (GTK_BUTTON (button), "clicked",
G_CALLBACK (action_show_sidebar_callback), bar);
gtk_box_pack_start (GTK_BOX (bar), statusbar, TRUE, TRUE, 10);
GtkWidget *zoom_slider = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 6.0, 1.0);
gtk_widget_set_tooltip_text (GTK_WIDGET (zoom_slider), _("Adjust zoom level"));
bar->zoom_slider = zoom_slider;
gtk_box_pack_start (GTK_BOX (bar), zoom_slider, FALSE, FALSE, 2);
gtk_widget_set_size_request (GTK_WIDGET (zoom_slider), SLIDER_WIDTH, 0);
gtk_scale_set_draw_value (GTK_SCALE (zoom_slider), FALSE);
gtk_range_set_increments (GTK_RANGE (zoom_slider), 1.0, 1.0);
gtk_range_set_round_digits (GTK_RANGE (zoom_slider), 0);
gtk_widget_show_all (GTK_WIDGET (bar));
g_signal_connect_object (NEMO_WINDOW (bar->window), "notify::show-sidebar",
G_CALLBACK (sidebar_state_changed_cb), bar, G_CONNECT_AFTER);
g_signal_connect_object (NEMO_WINDOW (bar->window), "notify::sidebar-view-id",
G_CALLBACK (sidebar_type_changed_cb), bar, G_CONNECT_AFTER);
g_signal_connect (GTK_RANGE (zoom_slider), "value-changed",
G_CALLBACK (on_slider_changed_cb), bar);
GtkWidget *cont = gtk_statusbar_get_message_area (GTK_STATUSBAR (statusbar));
GList *children = gtk_container_get_children (GTK_CONTAINER (cont));
gtk_box_set_child_packing (GTK_BOX (cont),
GTK_WIDGET (children->data),
TRUE, FALSE, 10, GTK_PACK_START);
nemo_status_bar_sync_button_states (bar);
}
void gui_init(dt_imageio_module_storage_t *self)
{
self->gui_data = (dt_storage_flickr_gui_data_t *)g_malloc0(sizeof(dt_storage_flickr_gui_data_t));
dt_storage_flickr_gui_data_t *ui = self->gui_data;
self->widget = gtk_grid_new();
gtk_grid_set_row_spacing(GTK_GRID(self->widget), DT_PIXEL_APPLY_DPI(5));
gtk_grid_set_column_spacing(GTK_GRID(self->widget), DT_PIXEL_APPLY_DPI(10));
int line = 0;
GHashTable *table = dt_pwstorage_get("flickr");
gchar *_username = g_strdup(g_hash_table_lookup(table, "username"));
g_hash_table_destroy(table);
GtkWidget *hbox, *label, *button;
label = gtk_label_new(_("flickr user"));
g_object_set(G_OBJECT(label), "xalign", 0.0, NULL);
gtk_grid_attach(GTK_GRID(self->widget), label, 0, line++, 1, 1);
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(8));
ui->user_entry = GTK_ENTRY(gtk_entry_new());
gtk_widget_set_hexpand(GTK_WIDGET(ui->user_entry), TRUE);
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->user_entry));
gtk_entry_set_text(ui->user_entry, _username == NULL ? "" : _username);
g_signal_connect(G_OBJECT(ui->user_entry), "changed", G_CALLBACK(flickr_entry_changed), (gpointer)ui);
gtk_entry_set_width_chars(GTK_ENTRY(ui->user_entry), 0);
button = gtk_button_new_with_label(_("login"));
gtk_widget_set_tooltip_text(button, _("flickr login"));
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(flickr_button1_clicked), (gpointer)ui);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(ui->user_entry), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_grid_attach_next_to(GTK_GRID(self->widget), hbox, label, GTK_POS_RIGHT, 1, 1);
ui->status_label = GTK_LABEL(gtk_label_new(NULL));
gtk_widget_set_halign(GTK_WIDGET(ui->status_label), GTK_ALIGN_START);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(ui->status_label), 1, line++, 1, 1);
ui->export_tags = dt_bauhaus_combobox_new(NULL);
dt_bauhaus_widget_set_label(ui->export_tags, NULL, _("export tags"));
dt_bauhaus_combobox_add(ui->export_tags, _("yes"));
dt_bauhaus_combobox_add(ui->export_tags, _("no"));
dt_bauhaus_combobox_set(ui->export_tags, 0);
gtk_widget_set_hexpand(ui->export_tags, TRUE);
gtk_grid_attach(GTK_GRID(self->widget), ui->export_tags, 0, line++, 2, 1);
ui->permission_list = dt_bauhaus_combobox_new(NULL);
dt_bauhaus_widget_set_label(ui->permission_list, NULL, _("visible to"));
dt_bauhaus_combobox_add(ui->permission_list, _("you"));
dt_bauhaus_combobox_add(ui->permission_list, _("friends"));
dt_bauhaus_combobox_add(ui->permission_list, _("family"));
dt_bauhaus_combobox_add(ui->permission_list, _("friends + family"));
dt_bauhaus_combobox_add(ui->permission_list, _("everyone"));
dt_bauhaus_combobox_set(ui->permission_list, 0); // Set default permission to private
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(ui->permission_list), 0, line++, 2, 1);
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(5));
ui->album_list = dt_bauhaus_combobox_new(NULL); // Available albums
dt_bauhaus_widget_set_label(ui->album_list, NULL, _("photosets"));
g_signal_connect(G_OBJECT(ui->album_list), "value-changed", G_CALLBACK(flickr_album_changed), (gpointer)ui);
gtk_widget_set_sensitive(ui->album_list, FALSE);
gtk_box_pack_start(GTK_BOX(hbox), ui->album_list, TRUE, TRUE, 0);
button = dtgtk_button_new(dtgtk_cairo_paint_refresh, CPF_DO_NOT_USE_BORDER);
gtk_widget_set_tooltip_text(button, _("refresh album list"));
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(flickr_button1_clicked), (gpointer)ui);
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_grid_attach(GTK_GRID(self->widget), hbox, 0, line++, 2, 1);
// the box that gets shown when a new album is to be created
ui->create_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_PIXEL_APPLY_DPI(5)));
gtk_widget_set_no_show_all(GTK_WIDGET(ui->create_box), TRUE);
gtk_grid_attach(GTK_GRID(self->widget), GTK_WIDGET(ui->create_box), 0, line++, 2, 1);
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(10));
label = gtk_label_new(_("title"));
g_object_set(G_OBJECT(label), "xalign", 0.0, NULL);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
ui->title_entry = GTK_ENTRY(gtk_entry_new()); // Album title
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->title_entry));
gtk_entry_set_text(ui->title_entry, _("my new photoset"));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(ui->title_entry), TRUE, TRUE, 0);
gtk_entry_set_width_chars(GTK_ENTRY(ui->title_entry), 0);
gtk_box_pack_start(ui->create_box, hbox, FALSE, FALSE, 0);
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(10));
label = gtk_label_new(_("summary"));
g_object_set(G_OBJECT(label), "xalign", 0.0, NULL);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
ui->summary_entry = GTK_ENTRY(gtk_entry_new()); // Album summary
dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->summary_entry));
gtk_entry_set_text(ui->summary_entry, _("exported from darktable"));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(ui->summary_entry), TRUE, TRUE, 0);
gtk_entry_set_width_chars(GTK_ENTRY(ui->summary_entry), 0);
gtk_box_pack_start(ui->create_box, hbox, TRUE, TRUE, 0);
set_status(ui, _("click login button to start"), "#ffffff");
/**
don't populate the combo on startup, save 3 second
// If username and password is stored, let's populate the combo
if( _username && _password )
{
ui->user_token = _password;
refresh_albums(ui);
}
*/
g_free(_username);
dt_bauhaus_combobox_set(ui->album_list, 0);
}
static void
brasero_song_control_init (BraseroSongControl *object)
{
BraseroSongControlPrivate *priv;
GtkWidget *alignment;
GtkWidget *volume;
gint volume_value;
GtkWidget *image;
GtkWidget *vbox;
GtkWidget *hbox;
gpointer value;
GstBus *bus;
priv = BRASERO_SONG_CONTROL_PRIVATE (object);
/* Pipeline */
priv->pipe = gst_element_factory_make ("playbin2", NULL);
if (priv->pipe) {
GstElement *audio_sink;
audio_sink = gst_element_factory_make ("gconfaudiosink", NULL);
if (audio_sink)
g_object_set (G_OBJECT (priv->pipe),
"audio-sink", audio_sink,
NULL);
}
else
g_warning ("Pipe creation error : can't create pipe.\n");
bus = gst_pipeline_get_bus (GST_PIPELINE (priv->pipe));
gst_bus_add_watch (bus,
(GstBusFunc) brasero_song_control_bus_messages,
object);
gst_object_unref (bus);
/* Widget itself */
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_show (vbox);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 0);
gtk_container_add (GTK_CONTAINER (object), vbox);
/* first line title */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_widget_show (hbox);
gtk_box_pack_start (GTK_BOX (vbox),
hbox,
FALSE,
FALSE,
0);
priv->header = gtk_label_new (_("No file"));
gtk_widget_show (priv->header);
gtk_label_set_use_markup (GTK_LABEL (priv->header), TRUE);
gtk_label_set_justify (GTK_LABEL (priv->header), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (priv->header), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (hbox),
priv->header,
TRUE,
TRUE,
0);
priv->size = gtk_label_new (NULL);
gtk_widget_show (priv->size);
gtk_label_set_justify (GTK_LABEL (priv->size), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (priv->size), 0.0, 0.0);
gtk_box_pack_end (GTK_BOX (hbox),
priv->size,
FALSE,
FALSE,
0);
/* second line : play, progress, volume button */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_widget_show (hbox);
gtk_box_pack_start (GTK_BOX (vbox),
hbox,
FALSE,
FALSE,
0);
alignment = gtk_alignment_new (0.0, 0.0, 0.0, 0.0);
gtk_widget_show (alignment);
priv->button = gtk_toggle_button_new ();
gtk_widget_show (priv->button);
gtk_widget_set_tooltip_text (priv->button, _("Start and stop playing"));
gtk_container_add (GTK_CONTAINER (alignment), priv->button);
gtk_box_pack_start (GTK_BOX (hbox),
alignment,
FALSE,
FALSE,
0);
image = gtk_image_new_from_stock (GTK_STOCK_MEDIA_PLAY, GTK_ICON_SIZE_BUTTON);
gtk_widget_show (image);
gtk_container_add (GTK_CONTAINER (priv->button), image);
g_signal_connect (G_OBJECT (priv->button), "clicked",
G_CALLBACK (brasero_song_control_button_clicked_cb),
object);
priv->progress = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 1, 500000000);
gtk_widget_show (priv->progress);
gtk_scale_set_digits (GTK_SCALE (priv->progress), 0);
gtk_scale_set_draw_value (GTK_SCALE (priv->progress), FALSE);
gtk_widget_set_size_request (priv->progress, 80, -1);
gtk_box_pack_start (GTK_BOX (hbox),
priv->progress,
TRUE,
TRUE,
0);
g_signal_connect (G_OBJECT (priv->progress),
"button-press-event",
G_CALLBACK (brasero_song_control_range_button_pressed_cb), object);
g_signal_connect (G_OBJECT (priv->progress),
"button-release-event",
G_CALLBACK (brasero_song_control_range_button_released_cb), object);
g_signal_connect (G_OBJECT (priv->progress),
"value-changed",
G_CALLBACK (brasero_song_control_range_value_changed),
object);
/* Set saved volume */
brasero_setting_get_value (brasero_setting_get_default (),
BRASERO_SETTING_PLAYER_VOLUME,
&value);
volume_value = GPOINTER_TO_INT (value);
volume_value = CLAMP (volume_value, 0, 100);
g_object_set (priv->pipe,
"volume", (gdouble) volume_value / 100.0,
NULL);
volume = gtk_volume_button_new ();
gtk_widget_show (volume);
gtk_box_pack_start (GTK_BOX (hbox),
volume,
FALSE,
FALSE,
0);
gtk_scale_button_set_value (GTK_SCALE_BUTTON (volume), (gdouble) volume_value / 100.0);
g_signal_connect (volume,
"value-changed",
G_CALLBACK (brasero_song_control_volume_changed_cb),
object);
gtk_alignment_set_padding (GTK_ALIGNMENT (object), 12, 0, 0, 0);
}
/**
* go_color_palette_make_menu:
* @no_color_label: color label
* @default_color: #GOColor
* @cg: #GOColorGroup
* @custom_dialog_title: optional string
* @current_color: #GOColor
*
* Returns: (transfer full): a submenu with a palette of colours. Caller is responsible for
* creating an item to point to the submenu.
**/
GtkWidget *
go_color_palette_make_menu (char const *no_color_label,
GOColor default_color,
GOColorGroup *cg,
char const *custom_dialog_title,
GOColor current_color)
{
int cols = 8;
int rows = 6;
int col, row, pos, table_row = 0;
GONamedColor const *color_names = default_color_set;
GtkWidget *w, *submenu;
submenu = g_object_new (go_menu_color_get_type (), NULL);
if (no_color_label != NULL) {
w = make_colored_menu_item (no_color_label, default_color);
gtk_menu_attach (GTK_MENU (submenu), w, 0, cols, 0, 1);
g_signal_connect (G_OBJECT (w),
"activate",
G_CALLBACK (cb_menu_default_activate), submenu);
table_row++;
}
for (row = 0; row < rows; row++, table_row++) {
for (col = 0; col < cols; col++) {
pos = row * cols + col;
if (color_names [pos].name == NULL)
goto custom_colors;
w = make_colored_menu_item (" ",
color_names [pos].color);
gtk_widget_set_tooltip_text (w, _(color_names[pos].name));
gtk_menu_attach (GTK_MENU (submenu), w,
col, col+1, table_row, table_row+1);
g_signal_connect (G_OBJECT (w),
"activate",
G_CALLBACK (cb_menu_color_activate), submenu);
}
}
custom_colors :
if (col > 0)
row++;
for (col = 0; col < cols && col < GO_COLOR_GROUP_HISTORY_SIZE; col++) {
w = make_colored_menu_item (" ", cg->history[col]);
gtk_menu_attach (GTK_MENU (submenu), w,
col, col+1, table_row, table_row+1);
g_signal_connect (G_OBJECT (w),
"activate",
G_CALLBACK (cb_menu_color_activate), submenu);
}
w = gtk_image_menu_item_new_with_label (_("Custom color..."));
/* Workaround for bug http://bugzilla.gnome.org/show_bug.cgi?id=585421 */
/* We can't have an image in one of the gtk_menu_item, it would lead to an
ugly item spacing. */
/* gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (w),*/
/* gtk_image_new_from_stock (GTK_STOCK_SELECT_COLOR, GTK_ICON_SIZE_MENU));*/
gtk_widget_show_all (w);
gtk_menu_attach (GTK_MENU (submenu), w, 0, cols, row + 2, row + 3);
g_signal_connect (G_OBJECT (w),
"activate",
G_CALLBACK (cb_menu_custom_activate), submenu);
((GOMenuColor *)submenu)->selection = current_color;
((GOMenuColor *)submenu)->default_color = default_color;
g_object_set_data_full (G_OBJECT (submenu), "title",
g_strdup (custom_dialog_title), g_free);
gtk_widget_show (submenu);
return submenu;
}
GtkWidget *
dsn_config_new (void)
{
DsnConfigPrivate *priv;
GtkWidget *dsn;
GtkWidget *label;
GtkWidget *sw;
gchar *title;
GdaDataModel *model;
priv = g_new0 (DsnConfigPrivate, 1);
dsn = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_widget_show (dsn);
gtk_container_set_border_width (GTK_CONTAINER (dsn), 6);
g_object_set_data_full (G_OBJECT (dsn), DSN_CONFIG_DATA, priv,
(GDestroyNotify) free_private_data);
/* title */
title = g_strdup_printf ("<b>%s</b>\n%s", _("Data Sources"),
_("Data sources are the means by which database "
"connections are identified: all "
"the information needed to open a connection to "
"a specific database using a 'provider' is referenced using "
"a unique name."));
priv->title = gdaui_bar_new (title);
g_free (title);
gdaui_bar_set_icon_from_resource (GDAUI_BAR (priv->title), "/images/gdaui-generic.png");
gtk_box_pack_start (GTK_BOX (dsn), priv->title, FALSE, FALSE, 0);
gtk_widget_show (priv->title);
/* horizontal box for the provider list and its properties */
GtkWidget *hbox;
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (dsn), hbox, TRUE, TRUE, 0);
/* left part */
GtkWidget *vbox;
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_set_size_request (vbox, 150, -1);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
/* create the data source list */
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
model = gda_config_list_dsn ();
priv->dsn_list = gdaui_raw_grid_new (model);
gtk_tree_view_move_column_after (GTK_TREE_VIEW (priv->dsn_list),
gtk_tree_view_get_column (GTK_TREE_VIEW (priv->dsn_list), 1),
gtk_tree_view_get_column (GTK_TREE_VIEW (priv->dsn_list), 2));
g_object_unref (model);
g_object_set_data (G_OBJECT (dsn), "grid", priv->dsn_list);
gdaui_data_proxy_column_set_editable (GDAUI_DATA_PROXY (priv->dsn_list), 0, FALSE);
gdaui_data_selector_set_column_visible (GDAUI_DATA_SELECTOR (priv->dsn_list), -1, FALSE);
gdaui_data_selector_set_column_visible (GDAUI_DATA_SELECTOR (priv->dsn_list), 0, TRUE);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (priv->dsn_list), FALSE);
g_object_set (priv->dsn_list, "info-cell-visible", FALSE, NULL);
gtk_container_add (GTK_CONTAINER (sw), priv->dsn_list);
g_signal_connect (priv->dsn_list, "selection-changed",
G_CALLBACK (list_selection_changed_cb), dsn);
g_signal_connect (priv->dsn_list, "populate-popup",
G_CALLBACK (list_popup_cb), dsn);
/* add/delete buttons */
GtkWidget *toolbar;
toolbar = gtk_toolbar_new ();
gtk_toolbar_set_icon_size (GTK_TOOLBAR (toolbar), GTK_ICON_SIZE_SMALL_TOOLBAR);
gtk_style_context_add_class (gtk_widget_get_style_context (toolbar), "inline-toolbar");
gtk_box_pack_start (GTK_BOX (vbox), toolbar, FALSE, FALSE, 0);
GtkToolItem *titem;
titem = gtk_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (titem), "list-add-symbolic");
gtk_actionable_set_action_name (GTK_ACTIONABLE (titem), "win.DatasourceNew");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), titem, -1);
titem = gtk_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (titem), "list-remove-symbolic");
gtk_actionable_set_action_name (GTK_ACTIONABLE (titem), "win.DatasourceDelete");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), titem, -1);
/* create the data source's properties */
GtkWidget *stack;
stack = gtk_stack_new ();
priv->stack = stack;
gtk_box_pack_start (GTK_BOX (hbox), stack, TRUE, TRUE, 10);
label = gtk_label_new (_("No data source selected."));
gtk_stack_add_named (GTK_STACK (stack), label, ST_NOPROP);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_stack_add_named (GTK_STACK (stack), vbox, ST_PROP);
GtkWidget *form;
form = gdaui_dsn_editor_new ();
priv->dsn_editor = GDAUI_DSN_EDITOR (form);
gtk_box_pack_start (GTK_BOX (vbox), form, TRUE, TRUE, 0);
g_signal_connect (priv->dsn_editor, "changed",
G_CALLBACK (dsn_editor_changed_cb), dsn);
/* action buttons */
GtkWidget *hbox2;
hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (vbox), hbox2, FALSE, FALSE, 6);
GtkWidget *bbox;
bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
gtk_widget_set_hexpand (bbox, TRUE);
gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_CENTER);
gtk_box_pack_start (GTK_BOX (hbox2), bbox, FALSE, FALSE, 6);
GtkWidget *button;
button = gtk_toggle_button_new_with_label (_("Definition"));
gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0);
priv->view_buttons [GDAUI_DSN_EDITOR_PANE_DEFINITION] = GTK_TOGGLE_BUTTON (button);
g_signal_connect (button, "toggled",
G_CALLBACK (view_toggled_cb), dsn);
button = gtk_toggle_button_new_with_label (_("Parameters"));
gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0);
priv->view_buttons [GDAUI_DSN_EDITOR_PANE_PARAMS] = GTK_TOGGLE_BUTTON (button);
g_signal_connect (button, "toggled",
G_CALLBACK (view_toggled_cb), dsn);
button = gtk_toggle_button_new_with_label (_("Authentication"));
gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0);
priv->view_buttons [GDAUI_DSN_EDITOR_PANE_AUTH] = GTK_TOGGLE_BUTTON (button);
g_signal_connect (button, "toggled",
G_CALLBACK (view_toggled_cb), dsn);
button = gtk_button_new_from_icon_name ("document-save-symbolic", GTK_ICON_SIZE_BUTTON);
gtk_box_pack_start (GTK_BOX (hbox2), button, FALSE, FALSE, 0);
priv->commit_button = button;
gtk_widget_set_sensitive (button, FALSE);
gtk_widget_set_tooltip_text (button, _("Write changes made to the DSN"));
g_signal_connect (button, "clicked",
G_CALLBACK (save_cb), dsn);
gtk_widget_show_all (hbox);
return dsn;
}
void gweather_applet_create (GWeatherApplet *gw_applet)
{
GtkActionGroup *action_group;
gchar *ui_path;
AtkObject *atk_obj;
gw_applet->gweather_pref.location = NULL;
gw_applet->gweather_pref.update_interval = 1800;
gw_applet->gweather_pref.update_enabled = TRUE;
gw_applet->gweather_pref.detailed = FALSE;
gw_applet->gweather_pref.radar_enabled = TRUE;
gw_applet->gweather_pref.temperature_unit = TEMP_UNIT_INVALID;
gw_applet->gweather_pref.speed_unit = SPEED_UNIT_INVALID;
gw_applet->gweather_pref.pressure_unit = PRESSURE_UNIT_INVALID;
gw_applet->gweather_pref.distance_unit = DISTANCE_UNIT_INVALID;
panel_applet_set_flags (gw_applet->applet, PANEL_APPLET_EXPAND_MINOR);
panel_applet_set_background_widget(gw_applet->applet,
GTK_WIDGET(gw_applet->applet));
g_set_application_name (_("Weather Report"));
gtk_window_set_default_icon_name ("weather-storm");
gw_applet->container = gtk_alignment_new (0.5, 0.5, 0, 0);
gtk_container_add (GTK_CONTAINER (gw_applet->applet), gw_applet->container);
g_signal_connect (G_OBJECT(gw_applet->applet), "change_orient",
G_CALLBACK(change_orient_cb), gw_applet);
g_signal_connect (G_OBJECT(gw_applet->applet), "size_allocate",
G_CALLBACK(size_allocate_cb), gw_applet);
g_signal_connect (G_OBJECT(gw_applet->applet), "destroy",
G_CALLBACK (applet_destroy), gw_applet);
g_signal_connect (G_OBJECT(gw_applet->applet), "button_press_event",
G_CALLBACK(clicked_cb), gw_applet);
g_signal_connect (G_OBJECT(gw_applet->applet), "key_press_event",
G_CALLBACK(key_press_cb), gw_applet);
gtk_widget_set_tooltip_text (GTK_WIDGET(gw_applet->applet), _("GNOME Weather"));
atk_obj = gtk_widget_get_accessible (GTK_WIDGET (gw_applet->applet));
if (GTK_IS_ACCESSIBLE (atk_obj))
atk_object_set_name (atk_obj, _("GNOME Weather"));
gw_applet->size = panel_applet_get_size (gw_applet->applet);
gw_applet->orient = panel_applet_get_orient (gw_applet->applet);
action_group = gtk_action_group_new ("GWeather Applet Actions");
gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
gtk_action_group_add_actions (action_group,
weather_applet_menu_actions,
G_N_ELEMENTS (weather_applet_menu_actions),
gw_applet);
ui_path = g_build_filename (GWEATHER_MENU_UI_DIR, "gweather-applet-menu.xml", NULL);
panel_applet_setup_menu_from_file (gw_applet->applet,
ui_path, action_group);
g_free (ui_path);
if (panel_applet_get_locked_down (gw_applet->applet)) {
GtkAction *action;
action = gtk_action_group_get_action (action_group, "Props");
gtk_action_set_visible (action, FALSE);
}
g_object_unref (action_group);
place_widgets(gw_applet);
#ifdef HAVE_NETWORKMANAGER
setup_network_monitor (gw_applet);
#endif
}
static void
add_binding_info (GtkInspectorPropEditor *editor)
{
GObject *object;
const gchar *name;
GHashTable *bindings;
GHashTableIter iter;
GBinding *binding;
GtkWidget *row;
GtkWidget *button;
gchar *str;
GObject *other;
const gchar *property;
const gchar *direction;
const gchar *tip;
GtkWidget *label;
object = editor->priv->object;
name = editor->priv->name;
/* Note: this is accessing private GBinding details, so keep it
* in sync with the implementation in GObject
*/
bindings = (GHashTable *)g_object_get_data (G_OBJECT (object), "g-binding");
if (!bindings)
return;
g_hash_table_iter_init (&iter, bindings);
while (g_hash_table_iter_next (&iter, (gpointer*)&binding, NULL))
{
if (g_binding_get_source (binding) == object &&
g_str_equal (g_binding_get_source_property (binding), name))
{
other = g_binding_get_target (binding);
property = g_binding_get_target_property (binding);
if (g_binding_get_flags (binding) & G_BINDING_INVERT_BOOLEAN)
{
direction = "↛";
tip = _("inverted");
}
else
{
direction = "→";
tip = NULL;
}
}
else if (g_binding_get_target (binding) == object &&
g_str_equal (g_binding_get_target_property (binding), name))
{
other = g_binding_get_source (binding);
property = g_binding_get_source_property (binding);
if (g_binding_get_flags (binding) & G_BINDING_INVERT_BOOLEAN)
{
direction = "↚";
tip = _("inverted");
}
else
{
direction = "←";
tip = NULL;
}
}
else
continue;
if (g_binding_get_flags (binding) & G_BINDING_BIDIRECTIONAL)
{
if (g_binding_get_flags (binding) & G_BINDING_INVERT_BOOLEAN)
{
direction = "↮";
tip = _("bidirectional, inverted");
}
else
{
direction = "↔";
tip = _("bidirectional");
}
}
row = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
gtk_container_add (GTK_CONTAINER (row), gtk_label_new (_("Binding:")));
label = gtk_label_new (direction);
if (tip)
gtk_widget_set_tooltip_text (label, tip);
gtk_container_add (GTK_CONTAINER (row), label);
str = g_strdup_printf ("%p :: %s", other, property);
label = gtk_label_new (str);
gtk_container_add (GTK_CONTAINER (row), label);
g_free (str);
button = gtk_button_new_with_label (_("Properties"));
g_object_set_data (G_OBJECT (button), "object", other);
g_signal_connect (button, "clicked",
G_CALLBACK (binding_object_properties), editor);
gtk_container_add (GTK_CONTAINER (row), button);
gtk_widget_show_all (row);
gtk_container_add (GTK_CONTAINER (editor), row);
}
}
static void
update_finish (WeatherInfo *info, gpointer data)
{
static int gw_fault_counter = 0;
#ifdef HAVE_LIBNOTIFY
char *message, *detail;
#endif
char *s;
GWeatherApplet *gw_applet = (GWeatherApplet *)data;
gint nxtSunEvent;
const gchar *icon_name;
/* Update timer */
if (gw_applet->timeout_tag > 0)
g_source_remove(gw_applet->timeout_tag);
if (gw_applet->gweather_pref.update_enabled)
{
gw_applet->timeout_tag =
g_timeout_add_seconds (
gw_applet->gweather_pref.update_interval,
timeout_cb, gw_applet);
nxtSunEvent = weather_info_next_sun_event(gw_applet->gweather_info);
if (nxtSunEvent >= 0)
gw_applet->suncalc_timeout_tag =
g_timeout_add_seconds (nxtSunEvent,
suncalc_timeout_cb, gw_applet);
}
if ((TRUE == weather_info_is_valid (info)) ||
(gw_fault_counter >= MAX_CONSECUTIVE_FAULTS))
{
gw_fault_counter = 0;
icon_name = weather_info_get_icon_name (gw_applet->gweather_info);
gtk_image_set_from_icon_name (GTK_IMAGE(gw_applet->image),
icon_name, GTK_ICON_SIZE_BUTTON);
gtk_label_set_text (GTK_LABEL (gw_applet->label),
weather_info_get_temp_summary(
gw_applet->gweather_info));
s = weather_info_get_weather_summary (gw_applet->gweather_info);
gtk_widget_set_tooltip_text (GTK_WIDGET (gw_applet->applet), s);
g_free (s);
/* Update dialog -- if one is present */
if (gw_applet->details_dialog) {
gweather_dialog_update (GWEATHER_DIALOG (gw_applet->details_dialog));
}
/* update applet */
place_widgets(gw_applet);
#ifdef HAVE_LIBNOTIFY
if (panel_applet_gconf_get_bool (gw_applet->applet,
"show_notifications", NULL))
{
NotifyNotification *n;
/* Show notifications if possible */
if (!notify_is_initted ())
notify_init (_("Weather Forecast"));
if (notify_is_initted ())
{
GError *error = NULL;
const char *icon;
/* Show notification */
message = g_strdup_printf ("%s: %s",
weather_info_get_location_name (info),
weather_info_get_sky (info));
detail = g_strdup_printf (
_("City: %s\nSky: %s\nTemperature: %s"),
weather_info_get_location_name (info),
weather_info_get_sky (info),
weather_info_get_temp_summary (info));
icon = weather_info_get_icon_name (gw_applet->gweather_info);
if (icon == NULL)
icon = "stock-unknown";
n = notify_notification_new (message, detail, icon);
notify_notification_show (n, &error);
if (error)
{
g_warning ("%s", error->message);
g_error_free (error);
}
g_free (message);
g_free (detail);
}
}
#endif
}
else
{
/* there has been an error during retrival
* just update the fault counter
*/
gw_fault_counter++;
}
}
static GtkWidget *
property_editor (GObject *object,
GParamSpec *spec,
GtkInspectorPropEditor *editor)
{
GtkWidget *prop_edit;
GtkAdjustment *adj;
gchar *msg;
GType type = G_PARAM_SPEC_TYPE (spec);
if (type == G_TYPE_PARAM_INT)
{
adj = gtk_adjustment_new (G_PARAM_SPEC_INT (spec)->default_value,
G_PARAM_SPEC_INT (spec)->minimum,
G_PARAM_SPEC_INT (spec)->maximum,
1,
MAX ((G_PARAM_SPEC_INT (spec)->maximum - G_PARAM_SPEC_INT (spec)->minimum) / 10, 1),
0.0);
prop_edit = gtk_spin_button_new (adj, 1.0, 0);
g_object_connect_property (object, spec, G_CALLBACK (int_changed), adj, G_OBJECT (adj));
connect_controller (G_OBJECT (adj), "value_changed",
object, spec, G_CALLBACK (int_modified));
}
else if (type == G_TYPE_PARAM_UINT)
{
adj = gtk_adjustment_new (G_PARAM_SPEC_UINT (spec)->default_value,
G_PARAM_SPEC_UINT (spec)->minimum,
G_PARAM_SPEC_UINT (spec)->maximum,
1,
MAX ((G_PARAM_SPEC_UINT (spec)->maximum - G_PARAM_SPEC_UINT (spec)->minimum) / 10, 1),
0.0);
prop_edit = gtk_spin_button_new (adj, 1.0, 0);
g_object_connect_property (object, spec,
G_CALLBACK (uint_changed),
adj, G_OBJECT (adj));
connect_controller (G_OBJECT (adj), "value_changed",
object, spec, G_CALLBACK (uint_modified));
}
else if (type == G_TYPE_PARAM_FLOAT)
{
adj = gtk_adjustment_new (G_PARAM_SPEC_FLOAT (spec)->default_value,
G_PARAM_SPEC_FLOAT (spec)->minimum,
G_PARAM_SPEC_FLOAT (spec)->maximum,
0.1,
MAX ((G_PARAM_SPEC_FLOAT (spec)->maximum - G_PARAM_SPEC_FLOAT (spec)->minimum) / 10, 0.1),
0.0);
prop_edit = gtk_spin_button_new (adj, 0.1, 2);
g_object_connect_property (object, spec,
G_CALLBACK (float_changed),
adj, G_OBJECT (adj));
connect_controller (G_OBJECT (adj), "value_changed",
object, spec, G_CALLBACK (float_modified));
}
else if (type == G_TYPE_PARAM_DOUBLE)
{
adj = gtk_adjustment_new (G_PARAM_SPEC_DOUBLE (spec)->default_value,
G_PARAM_SPEC_DOUBLE (spec)->minimum,
G_PARAM_SPEC_DOUBLE (spec)->maximum,
0.1,
MAX ((G_PARAM_SPEC_DOUBLE (spec)->maximum - G_PARAM_SPEC_DOUBLE (spec)->minimum) / 10, 0.1),
0.0);
prop_edit = gtk_spin_button_new (adj, 0.1, 2);
g_object_connect_property (object, spec,
G_CALLBACK (double_changed),
adj, G_OBJECT (adj));
connect_controller (G_OBJECT (adj), "value_changed",
object, spec, G_CALLBACK (double_modified));
}
else if (type == G_TYPE_PARAM_STRING)
{
prop_edit = gtk_entry_new ();
g_object_connect_property (object, spec,
G_CALLBACK (string_changed),
prop_edit, G_OBJECT (prop_edit));
connect_controller (G_OBJECT (prop_edit), "changed",
object, spec, G_CALLBACK (string_modified));
}
else if (type == G_TYPE_PARAM_BOOLEAN)
{
prop_edit = gtk_toggle_button_new_with_label ("");
g_object_connect_property (object, spec,
G_CALLBACK (bool_changed),
prop_edit, G_OBJECT (prop_edit));
connect_controller (G_OBJECT (prop_edit), "toggled",
object, spec, G_CALLBACK (bool_modified));
}
else if (type == G_TYPE_PARAM_ENUM)
{
{
GtkWidget *box;
GEnumClass *eclass;
GtkWidget *first;
gint j;
prop_edit = gtk_scrolled_window_new (NULL, NULL);
g_object_set (prop_edit,
"expand", TRUE,
"hscrollbar-policy", GTK_POLICY_NEVER,
"vscrollbar-policy", GTK_POLICY_NEVER,
NULL);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_show (box);
gtk_container_add (GTK_CONTAINER (prop_edit), box);
eclass = G_ENUM_CLASS (g_type_class_ref (spec->value_type));
j = 0;
first = NULL;
while (j < eclass->n_values)
{
GtkWidget *b;
b = gtk_radio_button_new_with_label_from_widget ((GtkRadioButton*)first, eclass->values[j].value_name);
if (first == NULL)
first = b;
g_object_set_data (G_OBJECT (b), "index", GINT_TO_POINTER (j));
gtk_widget_show (b);
gtk_box_pack_start (GTK_BOX (box), b, FALSE, FALSE, 0);
connect_controller (G_OBJECT (b), "toggled",
object, spec, G_CALLBACK (enum_modified));
++j;
}
if (j >= 10)
g_object_set (prop_edit, "vscrollbar-policy", GTK_POLICY_AUTOMATIC, NULL);
g_type_class_unref (eclass);
g_object_connect_property (object, spec,
G_CALLBACK (enum_changed),
prop_edit, G_OBJECT (prop_edit));
}
}
else if (type == G_TYPE_PARAM_FLAGS)
{
{
GtkWidget *box;
GFlagsClass *fclass;
gint j;
prop_edit = gtk_scrolled_window_new (NULL, NULL);
g_object_set (prop_edit,
"expand", TRUE,
"hscrollbar-policy", GTK_POLICY_NEVER,
"vscrollbar-policy", GTK_POLICY_NEVER,
NULL);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_show (box);
gtk_container_add (GTK_CONTAINER (prop_edit), box);
fclass = G_FLAGS_CLASS (g_type_class_ref (spec->value_type));
for (j = 0; j < fclass->n_values; j++)
{
GtkWidget *b;
b = gtk_check_button_new_with_label (fclass->values[j].value_name);
g_object_set_data (G_OBJECT (b), "index", GINT_TO_POINTER (j));
gtk_widget_show (b);
gtk_box_pack_start (GTK_BOX (box), b, FALSE, FALSE, 0);
connect_controller (G_OBJECT (b), "toggled",
object, spec, G_CALLBACK (flags_modified));
}
if (j >= 10)
g_object_set (prop_edit, "vscrollbar-policy", GTK_POLICY_AUTOMATIC, NULL);
g_type_class_unref (fclass);
g_object_connect_property (object, spec,
G_CALLBACK (flags_changed),
prop_edit, G_OBJECT (prop_edit));
}
}
else if (type == G_TYPE_PARAM_UNICHAR)
{
prop_edit = gtk_entry_new ();
gtk_entry_set_max_length (GTK_ENTRY (prop_edit), 1);
g_object_connect_property (object, spec,
G_CALLBACK (unichar_changed),
prop_edit, G_OBJECT (prop_edit));
connect_controller (G_OBJECT (prop_edit), "changed",
object, spec, G_CALLBACK (unichar_modified));
}
else if (type == G_TYPE_PARAM_POINTER)
{
prop_edit = gtk_label_new ("");
g_object_connect_property (object, spec,
G_CALLBACK (pointer_changed),
prop_edit, G_OBJECT (prop_edit));
}
else if (type == G_TYPE_PARAM_OBJECT)
{
GtkWidget *label, *button;
prop_edit = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
label = gtk_label_new ("");
button = gtk_button_new_with_label (_("Properties"));
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (object_properties),
editor);
gtk_container_add (GTK_CONTAINER (prop_edit), label);
gtk_container_add (GTK_CONTAINER (prop_edit), button);
gtk_widget_show (label);
gtk_widget_show (button);
g_object_connect_property (object, spec,
G_CALLBACK (object_changed),
prop_edit, G_OBJECT (label));
}
else if (type == G_TYPE_PARAM_BOXED &&
G_PARAM_SPEC_VALUE_TYPE (spec) == GDK_TYPE_RGBA)
{
prop_edit = gtk_color_chooser_widget_new ();
gtk_color_chooser_set_use_alpha (GTK_COLOR_CHOOSER (prop_edit), TRUE);
g_object_connect_property (object, spec,
G_CALLBACK (rgba_changed),
prop_edit, G_OBJECT (prop_edit));
connect_controller (G_OBJECT (prop_edit), "notify::rgba",
object, spec, G_CALLBACK (rgba_modified));
}
else if (type == G_TYPE_PARAM_BOXED &&
G_PARAM_SPEC_VALUE_TYPE (spec) == g_type_from_name ("GdkColor"))
{
prop_edit = gtk_color_chooser_widget_new ();
gtk_color_chooser_set_use_alpha (GTK_COLOR_CHOOSER (prop_edit), FALSE);
g_object_connect_property (object, spec,
G_CALLBACK (color_changed),
prop_edit, G_OBJECT (prop_edit));
connect_controller (G_OBJECT (prop_edit), "notify::rgba",
object, spec, G_CALLBACK (color_modified));
}
else if (type == G_TYPE_PARAM_BOXED &&
G_PARAM_SPEC_VALUE_TYPE (spec) == PANGO_TYPE_FONT_DESCRIPTION)
{
prop_edit = gtk_font_chooser_widget_new ();
g_object_connect_property (object, spec,
G_CALLBACK (font_changed),
prop_edit, G_OBJECT (prop_edit));
connect_controller (G_OBJECT (prop_edit), "notify::font-desc",
object, spec, G_CALLBACK (font_modified));
}
else
{
msg = g_strdup_printf (_("Uneditable property type: %s"),
g_type_name (G_PARAM_SPEC_TYPE (spec)));
prop_edit = gtk_label_new (msg);
g_free (msg);
gtk_widget_set_halign (prop_edit, GTK_ALIGN_START);
gtk_widget_set_valign (prop_edit, GTK_ALIGN_CENTER);
}
if (g_param_spec_get_blurb (spec))
gtk_widget_set_tooltip_text (prop_edit, g_param_spec_get_blurb (spec));
notify_property (object, spec);
return prop_edit;
}
GtkWidget *
fill_stream_info(proto_type type, unsigned int pid, unsigned int seq_id)
{
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *sw;
GtkWidget *treeview;
GtkWidget *next_button, *apply_button, *quit_button;
GtkTreeModel *stream_model;
GtkWidget *frame;
GtkWidget *text_view;
frame = gtk_frame_new(NULL);
gtk_frame_set_label_align(GTK_FRAME(frame), 0.5, 0.5);
gtk_widget_set_size_request(frame, 300, 200);
vbox = gtk_vbox_new(FALSE, 5);
gtk_container_add(GTK_CONTAINER(frame), vbox);
gtk_box_pack_start(GTK_BOX(vbox),
gtk_label_new("Edit Protocol fields"),
FALSE, FALSE, 0);
sw = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw),
GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX(vbox), sw, TRUE, TRUE, 0);
/* create models */
stream_model = create_stream_model(type, pid, seq_id);
/* create tree view */
treeview = gtk_tree_view_new_with_model(stream_model);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(treeview), TRUE);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview)),
GTK_SELECTION_SINGLE);
add_proto_values_column(GTK_TREE_VIEW(treeview), stream_model);
/* Create a multiline text widget. */
text_view = gtk_text_view_new();
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(text_view), 20);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(text_view), 20);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(
text_view), GTK_WRAP_WORD_CHAR);
gtk_text_view_set_pixels_inside_wrap(GTK_TEXT_VIEW(text_view), 0);
gtk_widget_set_tooltip_text(GTK_WIDGET(text_view),
"[L4 HEADER + PAYLOAD]\nInput only hex values(0123456789ABCDEF)");
/* Obtaining the buffer associated with the widget. */
l4_pl_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_view));
/* Set the default buffer text. */
if (type == TYPE_UDP) {
udp_reference = g_object_ref(treeview);
udp_treeview = treeview;
udp_sw = sw;
usr_def_reference = g_object_ref(text_view);
l4_text_view = text_view;
l4_buffer = l4_pl_buffer;
}
g_object_unref(stream_model);
gtk_container_add(GTK_CONTAINER(sw), treeview);
/* some buttons */
hbox = gtk_hbox_new(TRUE, 4);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
next_button = gtk_button_new_with_label("Next");
g_signal_connect(next_button, "clicked",
G_CALLBACK(switch_stream_editor_page), notebook);
gtk_box_pack_start(GTK_BOX(hbox), next_button, TRUE, TRUE, 0);
apply_button = gtk_button_new_with_label("Apply");
g_signal_connect(apply_button, "clicked",
G_CALLBACK(apply_stream_callback), NULL);
gtk_box_pack_start(GTK_BOX(hbox), apply_button, TRUE, TRUE, 0);
quit_button = gtk_button_new_with_label("Close");
g_signal_connect(quit_button,
"clicked",
G_CALLBACK(close_window_callback),
G_OBJECT(stream_window));
gtk_box_pack_start(GTK_BOX(hbox), quit_button, TRUE, TRUE, 0);
/* put everything into a scrolled window */
return GTK_WIDGET(frame);
}
static void
rb_audiocd_source_constructed (GObject *object)
{
RBAudioCdSourcePrivate *priv;
RBAudioCdSource *source;
RBEntryView *entry_view;
GtkCellRenderer *renderer;
GtkTreeViewColumn *extract;
GtkWidget *widget;
GtkAction *action;
RhythmDB *db;
RBPlugin *plugin;
RBShell *shell;
char *ui_file;
int toggle_width;
RB_CHAIN_GOBJECT_METHOD (rb_audiocd_source_parent_class, constructed, object);
source = RB_AUDIOCD_SOURCE (object);
priv = AUDIOCD_SOURCE_GET_PRIVATE (source);
g_object_set (G_OBJECT (source), "name", "Unknown Audio", NULL);
g_object_get (source, "shell", &shell, NULL);
priv->action_group = _rb_source_register_action_group (RB_SOURCE (source),
"AudioCdActions",
NULL, 0, NULL);
_rb_action_group_add_source_actions (priv->action_group,
G_OBJECT (shell),
rb_audiocd_source_actions,
G_N_ELEMENTS (rb_audiocd_source_actions));
g_object_unref (shell);
action = gtk_action_group_get_action (priv->action_group,
"AudioCdCopyTracks");
/* Translators: this is the toolbar button label
for Copy to Library action. */
g_object_set (action, "short-label", _("Extract"), NULL);
#if !defined(HAVE_SJ_METADATA_GETTER)
action = gtk_action_group_get_action (priv->action_group, "AudioCdSourceReloadMetadata");
g_object_set (action, "visible", FALSE, NULL);
#endif
/* we want audio cds to sort by track# by default */
entry_view = rb_source_get_entry_view (RB_SOURCE (source));
rb_entry_view_set_sorting_order (entry_view, "Track", GTK_SORT_ASCENDING);
/* enable in-place editing for titles, artists, and genres */
rb_entry_view_set_column_editable (entry_view, RB_ENTRY_VIEW_COL_TITLE, TRUE);
rb_entry_view_set_column_editable (entry_view, RB_ENTRY_VIEW_COL_ARTIST, TRUE);
rb_entry_view_set_column_editable (entry_view, RB_ENTRY_VIEW_COL_GENRE, TRUE);
/* create the 'extract' column */
renderer = gtk_cell_renderer_toggle_new ();
extract = gtk_tree_view_column_new ();
gtk_tree_view_column_pack_start (extract, renderer, FALSE);
gtk_tree_view_column_set_cell_data_func (extract,
renderer,
(GtkTreeCellDataFunc) extract_cell_data_func,
source,
NULL);
gtk_tree_view_column_set_clickable (extract, TRUE);
widget = gtk_check_button_new ();
g_object_set (widget, "active", TRUE, NULL);
gtk_widget_show_all (widget);
g_signal_connect_object (extract, "clicked", G_CALLBACK (extract_column_clicked_cb), source, 0);
gtk_tree_view_column_set_widget (extract, widget);
g_signal_connect_object (renderer, "toggled", G_CALLBACK (extract_toggled_cb), source, 0);
/* set column width */
gtk_cell_renderer_get_size (renderer, GTK_WIDGET (entry_view), NULL, NULL, NULL, &toggle_width, NULL);
gtk_tree_view_column_set_sizing (extract, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_fixed_width (extract, toggle_width + 5);
rb_entry_view_insert_column_custom (entry_view, extract, "", "Extract", NULL, NULL, NULL, 1);
gtk_widget_set_tooltip_text (gtk_tree_view_column_get_widget (extract),
_("Select tracks to be extracted"));
/* hide the 'album' column */
gtk_tree_view_column_set_visible (rb_entry_view_get_column (entry_view, RB_ENTRY_VIEW_COL_ALBUM), FALSE);
/* handle extra metadata requests for album artist and album artist sortname */
db = get_db_for_source (source);
g_signal_connect_object (G_OBJECT (db), "entry-extra-metadata-request::" RHYTHMDB_PROP_ALBUM_ARTIST,
G_CALLBACK (album_artist_metadata_request_cb), source, 0);
g_signal_connect_object (G_OBJECT (db), "entry-extra-metadata-request::" RHYTHMDB_PROP_ALBUM_ARTIST_SORTNAME,
G_CALLBACK (album_artist_sortname_metadata_request_cb), source, 0);
g_signal_connect_object (G_OBJECT (db), "entry-extra-metadata-gather",
G_CALLBACK (metadata_gather_cb), source, 0);
g_object_unref (db);
/* set up the album info widgets */
g_object_get (source, "plugin", &plugin, NULL);
ui_file = rb_plugin_find_file (plugin, "album-info.ui");
g_object_unref (plugin);
if (ui_file == NULL) {
g_warning ("couldn't find album-info.ui");
} else {
RBAudioCdSourcePrivate *priv;
GtkWidget *table;
GtkBuilder *builder;
#if defined(HAVE_SJ_METADATA_GETTER) && GTK_CHECK_VERSION(2,17,6)
GtkWidget *box;
char *message;
#endif
priv = AUDIOCD_SOURCE_GET_PRIVATE (source);
builder = rb_builder_load (ui_file, NULL);
g_free (ui_file);
table = GTK_WIDGET (gtk_builder_get_object (builder, "album_info"));
g_assert (table != NULL);
#if defined(HAVE_SJ_METADATA_GETTER) && GTK_CHECK_VERSION(2,17,6)
/* Info bar for non-Musicbrainz data */
priv->info_bar = gtk_info_bar_new_with_buttons (_("S_ubmit Album"), GTK_RESPONSE_OK,
_("Hide"), GTK_RESPONSE_CANCEL,
NULL);
message = g_strdup_printf ("<b>%s</b>\n%s", _("Could not find this album on MusicBrainz."),
_("You can improve the MusicBrainz database by adding this album."));
priv->info_bar_label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (priv->info_bar_label), message);
gtk_label_set_justify (GTK_LABEL (priv->info_bar_label), GTK_JUSTIFY_LEFT);
g_free (message);
box = gtk_info_bar_get_content_area (GTK_INFO_BAR (priv->info_bar));
gtk_container_add (GTK_CONTAINER (box), priv->info_bar_label);
gtk_widget_show_all (box);
gtk_widget_set_no_show_all (priv->info_bar, TRUE);
g_signal_connect (G_OBJECT (priv->info_bar), "response",
G_CALLBACK (info_bar_response_cb), source);
gtk_table_attach_defaults (GTK_TABLE (table), priv->info_bar, 0, 2, 0, 1);
#endif
priv->artist_entry = GTK_WIDGET (gtk_builder_get_object (builder, "artist_entry"));
priv->artist_sort_entry = GTK_WIDGET (gtk_builder_get_object (builder, "artist_sort_entry"));
priv->album_entry = GTK_WIDGET (gtk_builder_get_object (builder, "album_entry"));
priv->year_entry = GTK_WIDGET (gtk_builder_get_object (builder, "year_entry"));
priv->genre_entry = GTK_WIDGET (gtk_builder_get_object (builder, "genre_entry"));
priv->disc_number_entry = GTK_WIDGET (gtk_builder_get_object (builder, "disc_number_entry"));
g_signal_connect_object (priv->album_entry, "focus-out-event", G_CALLBACK (update_album_cb), source, 0);
g_signal_connect_object (priv->genre_entry, "focus-out-event", G_CALLBACK (update_genre_cb), source, 0);
g_signal_connect_object (priv->year_entry, "focus-out-event", G_CALLBACK (update_year_cb), source, 0);
g_signal_connect_object (priv->disc_number_entry, "focus-out-event", G_CALLBACK (update_disc_number_cb), source, 0);
gtk_box_pack_start (GTK_BOX (priv->box), table, FALSE, FALSE, 0);
gtk_box_reorder_child (GTK_BOX (priv->box), table, 0);
g_object_unref (builder);
}
g_object_ref (G_OBJECT (source));
g_thread_create ((GThreadFunc)rb_audiocd_load_songs, source, FALSE, NULL);
}
/**
* Create Dialog to allow the user to set the current staff's parameters
*
*/
static gboolean
staff_properties_change (void)
{
DenemoProject *gui = Denemo.project;
DenemoMovement *si = gui->movement;
DenemoStaff *staffstruct = (DenemoStaff *) si->currentstaff->data;
gboolean result = FALSE;
GtkWidget *dialog;
GtkWidget *notebook;
GtkWidget *label;
GtkWidget *main_vbox;
GtkWidget *hbox;
GtkWidget *entrywidget;
static GString *entrycontent;
static GList *instrument_list = NULL;
static struct callbackdata cbdata;
gint i;
if (instrument_list)
{
g_list_free_full (instrument_list, g_free);
instrument_list = NULL;
}
{
gint i;
gchar *name;
gint preset = 0, bank = 0;
gint npresets = ParseSoundfont (Denemo.prefs.fluidsynth_soundfont->str, 0, NULL, NULL, NULL);
if (npresets)
{
gchar **array = g_malloc0 (128 * sizeof (gchar *));
for (i = 0; i < npresets - 1; i++)
{
(void) ParseSoundfont (NULL, i, &name, &preset, &bank);
if (bank == 0) {
array[preset&0x7F] = g_strdup ((gchar *) name);
}
}
for (i = 0; i < 128; i++)
if(array[i])
instrument_list = g_list_append(instrument_list, array[i]);
g_free (array);
}
}
if (!entrycontent)
{
entrycontent = g_string_new (NULL);
}
dialog = gtk_dialog_new_with_buttons (_("Staff Properties"), GTK_WINDOW (Denemo.window), (GtkDialogFlags) (GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT), _("_OK"), GTK_RESPONSE_ACCEPT, _("_Cancel"), GTK_RESPONSE_REJECT, NULL);
//gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
notebook = gtk_notebook_new ();
GtkWidget *content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
gtk_container_add (GTK_CONTAINER (content_area), notebook);
#define NEWPAGE(thelabel) \
main_vbox = gtk_vbox_new (FALSE, 1);\
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), main_vbox, NULL);\
gtk_notebook_set_tab_label_text (GTK_NOTEBOOK (notebook), main_vbox,\
_(thelabel));
#define TEXTENTRY(thelabel, field) \
hbox = gtk_hbox_new (FALSE, 8);\
gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);\
label = gtk_label_new (_(thelabel));\
gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5);\
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);\
entrywidget = gtk_entry_new ();\
g_string_sprintf (entrycontent, "%s", staffstruct->field?staffstruct->field->str:"");\
gtk_entry_set_text (GTK_ENTRY (entrywidget), entrycontent->str);\
gtk_box_pack_start (GTK_BOX (hbox), entrywidget, TRUE, TRUE, 0);\
cbdata.field = entrywidget;
#define INTENTRY_LIMITS(thelabel, field, min, max) \
GtkWidget *field;\
hbox = gtk_hbox_new (FALSE, 8);\
gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);\
label = gtk_label_new (_(thelabel));\
gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5);\
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);\
field = gtk_spin_button_new_with_range (min, max, 1.0);\
gtk_spin_button_set_value (GTK_SPIN_BUTTON (field), staffstruct->field);\
gtk_box_pack_start (GTK_BOX (hbox), field, FALSE, FALSE, 0);\
cbdata.field = field;
#define INTENTRY_LIMITS_1(thelabel, field, min, max) \
GtkWidget *field;\
hbox = gtk_hbox_new (FALSE, 8);\
gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, TRUE, 0);\
label = gtk_label_new (_(thelabel));\
gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5);\
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);\
field = gtk_spin_button_new_with_range (min, max, 1.0);\
gtk_spin_button_set_value (GTK_SPIN_BUTTON (field), staffstruct->field+1);\
gtk_box_pack_start (GTK_BOX (hbox), field, FALSE, FALSE, 0);\
cbdata.field = field;
#define BOOLEANENTRY(thelabel, field) \
GtkWidget *field;\
field =\
gtk_check_button_new_with_label (_(thelabel)); \
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (field),\
staffstruct->field);\
gtk_box_pack_start (GTK_BOX (main_vbox), field, FALSE, TRUE, 0);\
cbdata.field = field;
#if GTK_MAJOR_VERSION==3
#define COMBOBOXENTRY(thelabel, field, thelist, setstring) \
GtkWidget *field;\
hbox = gtk_hbox_new (FALSE, 8);\
gtk_container_add (GTK_CONTAINER(main_vbox), hbox); \
label = gtk_label_new (_(thelabel));\
gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5);\
gtk_container_add (GTK_CONTAINER(hbox), label); \
field = gtk_combo_box_text_new ();\
i=0;\
while (thelist){\
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(field), (gchar *) thelist->data);\
if (!g_strcmp0 (thelist->data, setstring->str))\
gtk_combo_box_set_active(GTK_COMBO_BOX (field),i);\
i++;\
thelist=thelist->next;\
}\
gtk_container_add (GTK_CONTAINER(hbox), field);\
cbdata.field = field;
#else
#define COMBOBOXENTRY(thelabel, field, thelist, setstring) \
GtkWidget *field;\
hbox = gtk_hbox_new (FALSE, 8);\
gtk_container_add (GTK_CONTAINER(main_vbox), hbox); \
label = gtk_label_new (_(thelabel));\
gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5);\
gtk_container_add (GTK_CONTAINER(hbox), label);\
field = gtk_combo_new ();\
gtk_combo_set_popdown_strings(GTK_COMBO(field), thelist); \
gtk_entry_set_text (GTK_ENTRY (GTK_COMBO (field)->entry), setstring->str);\
gtk_container_add (GTK_CONTAINER(hbox), field); \
cbdata.field = GTK_COMBO (field)->entry;
#endif
/* Print appearance tab */
NEWPAGE (_("Typeset Appearance"));
TEXTENTRY (_("Part name:"), denemo_name);
gtk_widget_set_tooltip_text (hbox, _( "All staffs with the same part name will be typeset with the Print Part command. Use a blank part name for staffs that should be printed with every part."));
TEXTENTRY (_("Sub Part name:"), subpart);
gtk_widget_set_tooltip_text (hbox, _( "If a single part (e.g. piano) has more than one staff they should be named here."));
/* Display appearance tab */
NEWPAGE ("Display Appearance");
//gtk_widget_grab_focus (entrywidget);
INTENTRY_LIMITS (_("Space above:"), space_above, 0, MAXEXTRASPACE);
INTENTRY_LIMITS (_("Space below:"), space_below, 0, MAXEXTRASPACE);
INTENTRY_LIMITS (_("Number of Display Staff Lines:"), no_of_lines, 1, 5);
/* MIDI tab */
NEWPAGE (_("MIDI"));
COMBOBOXENTRY (_("MIDI Instrument:"), midi_instrument, instrument_list, staffstruct->midi_instrument);
INTENTRY_LIMITS (_("Transposition:"), transposition, -30, 30);
BOOLEANENTRY (_("Always Full Volume"), override_volume);
INTENTRY_LIMITS (_("Master Volume:"), volume, 0, 127);
// BOOLEANENTRY("Override MIDI Channel/Program", midi_prognum_override);
INTENTRY_LIMITS_1 (_("Channel:"), midi_channel, 1, 16);
INTENTRY_LIMITS_1 (_("Program:"), midi_prognum, 1, 128);
// g_debug ("chan prog %d %d\n", staffstruct->midi_channel, staffstruct->midi_prognum);
// FIXME
// GList *md = device_manager_DevicePort_list();
// if(md) {
//#ifdef _HAVE_JACK_
// COMBOBOXENTRY("Midi Devices", device_port, md, staffstruct->device_port);
//#endif
// }
// else
cbdata.device_port = NULL;
/* Set up the callback data */
#define SETCALLBACKDATA(field) \
cbdata.field = field;
SETCALLBACKDATA (gui);
SETCALLBACKDATA (staffstruct);
/* FIXME
Also set things up so that the callback'll run when you hit enter
* in the text entries */
/*
gtk_entry_set_activates_default (GTK_ENTRY (denemo_name), TRUE);
gtk_entry_set_activates_default (GTK_ENTRY (space_above), TRUE);
gtk_entry_set_activates_default (GTK_ENTRY (space_below), TRUE);
gtk_entry_set_activates_default (GTK_ENTRY (no_of_lines), TRUE);
gtk_entry_set_activates_default (GTK_ENTRY (transposition), TRUE);
*/
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_ACCEPT);
gtk_widget_show_all (dialog);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
{
set_properties (&cbdata);
result = TRUE;
}
gtk_widget_destroy (dialog);
return result;
}
static GObject* pama_source_output_widget_constructor(GType gtype, guint n_properties, GObjectConstructParam *properties)
{
GtkWidget *icon, *name, *alignment;
GtkWidget *inner_box, *source_button, *source_button_image;
GObject *gobject = G_OBJECT_CLASS(pama_source_output_widget_parent_class)->constructor(gtype, n_properties, properties);
PamaSourceOutputWidget *widget = PAMA_SOURCE_OUTPUT_WIDGET(gobject);
PamaSourceOutputWidgetPrivate *priv = PAMA_SOURCE_OUTPUT_WIDGET_GET_PRIVATE(widget);
if (NULL == priv->source_output)
g_error("An attempt was made to create a source_output widget with no source_output.");
if (NULL == priv->context)
g_error("An attempt was made to create a source_output widget with no context.");
if (NULL == priv->icon_sizegroup)
g_error("An attempt was made to create a source_output widget with no icon sizegroup.");
alignment = gtk_alignment_new(0, 0.5, 0, 0);
gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 0, 0, 0, 6);
gtk_box_pack_start(GTK_BOX(widget), alignment, FALSE, FALSE, 0);
icon = gtk_image_new();
gtk_container_add(GTK_CONTAINER(alignment), icon);
gtk_size_group_add_widget(priv->icon_sizegroup, icon);
priv->icon = icon;
name = g_object_new(GTK_TYPE_LABEL,
"ellipsize", PANGO_ELLIPSIZE_MIDDLE,
"wrap", FALSE,
"width-chars", WIDGET_NAME_WIDTH_IN_CHARS,
"xalign", 0.0f,
NULL);
gtk_box_pack_start(GTK_BOX(widget), name, FALSE, FALSE, 0);
priv->name = name;
alignment = gtk_alignment_new(0, 0.5, 0, 0);
gtk_box_pack_end(GTK_BOX(widget), alignment, FALSE, FALSE, 0);
inner_box = gtk_hbox_new(FALSE, 6);
gtk_container_add(GTK_CONTAINER(alignment), inner_box);
source_button = gtk_button_new();
gtk_widget_set_tooltip_text(GTK_WIDGET(source_button), _("Select which input device to use for this application"));
gtk_box_pack_start(GTK_BOX(inner_box), source_button, FALSE, FALSE, 0);
priv->source_button = source_button;
source_button_image = gtk_image_new_from_icon_name("audio-input-microphone", GTK_ICON_SIZE_MENU);
gtk_container_add(GTK_CONTAINER(source_button), source_button_image);
priv->source_button_image = source_button_image;
pama_source_output_widget_update_values(widget);
g_signal_connect(source_button, "clicked", G_CALLBACK(pama_source_output_widget_source_button_clicked), widget);
priv->source_output_notify_handler_id = g_signal_connect(priv->source_output, "notify::source", G_CALLBACK(pama_source_output_widget_source_output_notify), widget);
/* We no longer need to keep a reference to the icon sizegroup */
g_object_unref(priv->icon_sizegroup);
priv->icon_sizegroup = NULL;
return gobject;
}
/**
* create the scheduled part : that widgets are created at the beginning
* and normally never destroyed, they are showed only for
* scheduled transactions
* Cela ne fonctionne pas : tous les widgets sont détruits par la
* fonction gsb_form_create_widgets ( )
*
* \param table a GtkTable with the dimension SCHEDULED_HEIGHT*SCHEDULED_WIDTH to be filled
*
* \return FALSE
* */
gboolean gsb_form_scheduler_create ( GtkWidget *table )
{
gint row, column;
struct_element *element;
devel_debug (NULL);
if (!table)
return FALSE;
/* just in case... be sure that not created */
if (scheduled_element_list)
gsb_form_scheduler_free_list ( );
/* check the dimensions,
* if problem give a warning message but continue the program with changing the values */
g_object_get ( G_OBJECT (table),
"n-columns", &column,
"n-rows", &row,
NULL );
if ( column != SCHEDULED_WIDTH
||
row != SCHEDULED_HEIGHT )
{
warning_debug ( _("gsb_form_scheduler_create is called with a bad table,\n"
"the number of rows or columns is not good.\n"
"The function will resize the table to the correct values but "
"should check that warning."));
gtk_table_resize ( GTK_TABLE (table), SCHEDULED_HEIGHT, SCHEDULED_WIDTH );
}
/* ok, now fill the form
* we play with height and width, but for now it's fix : 6 columns and 1 line */
for ( row=0 ; row < SCHEDULED_HEIGHT ; row++ )
for ( column=0 ; column < SCHEDULED_WIDTH ; column++ )
{
gint element_number;
GtkWidget *widget = NULL;
const gchar *tooltip_text = NULL;
gchar *text_auto [] = { _("Manual"), _("Automatic"), NULL };
gchar *text_frequency [] = { _("Once"), _("Weekly"), _("Monthly"), _("Bimonthly"),
_("Quarterly"), _("Yearly"), _("Custom"), NULL };
gchar *text_frequency_user [] = { _("Days"), _("Weeks"), _("Months"), _("Years"), NULL };
element_number = row*SCHEDULED_WIDTH + column;
switch ( element_number )
{
case SCHEDULED_FORM_ACCOUNT:
widget = gsb_account_create_combo_list ( G_CALLBACK ( gsb_form_scheduler_change_account ),
NULL, FALSE);
gtk_combo_box_set_active ( GTK_COMBO_BOX (widget), 0 );
tooltip_text = _("Choose the account");
break;
case SCHEDULED_FORM_AUTO:
widget = gsb_combo_box_new_with_index ( text_auto, NULL, NULL );
tooltip_text = _("Automatic/manual scheduled transaction");
break;
case SCHEDULED_FORM_FREQUENCY_BUTTON:
widget = gsb_combo_box_new_with_index ( text_frequency,
G_CALLBACK (gsb_form_scheduler_frequency_button_changed), NULL );
tooltip_text = _("Frequency");
break;
case SCHEDULED_FORM_LIMIT_DATE:
widget = gsb_calendar_entry_new (FALSE);
g_signal_connect ( G_OBJECT (widget),
"button-press-event",
G_CALLBACK (gsb_form_scheduler_button_press_event),
GINT_TO_POINTER (element_number));
g_signal_connect ( G_OBJECT (widget),
"focus-in-event",
G_CALLBACK (gsb_form_entry_get_focus),
GINT_TO_POINTER (element_number));
g_signal_connect_after ( G_OBJECT (widget),
"focus-out-event",
G_CALLBACK (gsb_form_scheduler_entry_lose_focus),
GINT_TO_POINTER (element_number));
tooltip_text = _("Limit date");
break;
case SCHEDULED_FORM_FREQUENCY_USER_ENTRY:
widget = gtk_entry_new ();
g_signal_connect ( G_OBJECT (widget),
"focus-in-event",
G_CALLBACK (gsb_form_entry_get_focus),
GINT_TO_POINTER (element_number));
g_signal_connect_after ( G_OBJECT (widget),
"focus-out-event",
G_CALLBACK (gsb_form_scheduler_entry_lose_focus),
GINT_TO_POINTER (element_number));
tooltip_text = _("Own frequency");
break;
case SCHEDULED_FORM_FREQUENCY_USER_BUTTON:
widget = gsb_combo_box_new_with_index ( text_frequency_user,
NULL, NULL );
tooltip_text = _("Custom frequency");
break;
}
if (!widget)
continue;
if (tooltip_text)
gtk_widget_set_tooltip_text ( GTK_WIDGET (widget),
tooltip_text);
/* save the element */
element = g_malloc0 (sizeof (struct_element));
element -> element_number = element_number;
element -> element_widget = widget;
scheduled_element_list = g_slist_append ( scheduled_element_list,
element );
/* set in the form */
gtk_table_attach ( GTK_TABLE (table),
widget,
column, column+1,
row, row+1,
GTK_EXPAND | GTK_FILL,
GTK_EXPAND | GTK_FILL,
0, 0);
}
gsb_form_scheduler_clean ( );
return FALSE;
}
gboolean
save_dialog (void)
{
JpegSaveGui pg;
GtkWidget *dialog;
GtkWidget *vbox;
GtkObject *entry;
GtkWidget *table;
GtkWidget *table2;
GtkWidget *tabledefaults;
GtkWidget *expander;
GtkWidget *frame;
GtkWidget *toggle;
GtkWidget *spinbutton;
GtkWidget *label;
GtkWidget *combo;
GtkWidget *text_view;
GtkTextBuffer *text_buffer;
GtkWidget *scrolled_window;
GtkWidget *button;
gchar *text;
gint row;
dialog = gimp_export_dialog_new (_("JPEG"), PLUG_IN_BINARY, SAVE_PROC);
g_signal_connect (dialog, "response",
G_CALLBACK (save_dialog_response),
&pg);
g_signal_connect (dialog, "destroy",
G_CALLBACK (gtk_main_quit),
NULL);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
gtk_box_pack_start (GTK_BOX (gimp_export_dialog_get_content_area (dialog)),
vbox, TRUE, TRUE, 0);
gtk_widget_show (vbox);
table = gtk_table_new (1, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
gtk_widget_show (table);
pg.quality = entry = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
_("_Quality:"),
SCALE_WIDTH, 0, jsvals.quality,
0.0, 100.0, 1.0, 10.0, 0,
TRUE, 0.0, 0.0,
_("JPEG quality parameter"),
"file-jpeg-save-quality");
g_signal_connect (entry, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
&jsvals.quality);
g_signal_connect (entry, "value-changed",
G_CALLBACK (make_preview),
NULL);
preview_size = gtk_label_new (_("File size: unknown"));
gtk_misc_set_alignment (GTK_MISC (preview_size), 0.0, 0.5);
gtk_label_set_ellipsize (GTK_LABEL (preview_size), PANGO_ELLIPSIZE_END);
gimp_label_set_attributes (GTK_LABEL (preview_size),
PANGO_ATTR_STYLE, PANGO_STYLE_ITALIC,
-1);
gtk_box_pack_start (GTK_BOX (vbox), preview_size, FALSE, FALSE, 0);
gtk_widget_show (preview_size);
gimp_help_set_help_data (preview_size,
_("Enable preview to obtain the file size."), NULL);
pg.preview = toggle =
gtk_check_button_new_with_mnemonic (_("Sho_w preview in image window"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), jsvals.preview);
gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
gtk_widget_show (toggle);
g_signal_connect (toggle, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&jsvals.preview);
g_signal_connect (toggle, "toggled",
G_CALLBACK (make_preview),
NULL);
text = g_strdup_printf ("<b>%s</b>", _("_Advanced Options"));
expander = gtk_expander_new_with_mnemonic (text);
gtk_expander_set_use_markup (GTK_EXPANDER (expander), TRUE);
g_free (text);
gtk_box_pack_start (GTK_BOX (vbox), expander, TRUE, TRUE, 0);
gtk_widget_show (expander);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_add (GTK_CONTAINER (expander), vbox);
gtk_widget_show (vbox);
frame = gimp_frame_new ("<expander>");
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
table = gtk_table_new (4, 8, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_table_set_col_spacing (GTK_TABLE (table), 1, 12);
gtk_container_add (GTK_CONTAINER (frame), table);
table2 = gtk_table_new (1, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table2), 6);
gtk_table_attach (GTK_TABLE (table), table2,
2, 6, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (table2);
pg.smoothing = entry = gimp_scale_entry_new (GTK_TABLE (table2), 0, 0,
_("S_moothing:"),
100, 0, jsvals.smoothing,
0.0, 1.0, 0.01, 0.1, 2,
TRUE, 0.0, 0.0,
NULL,
"file-jpeg-save-smoothing");
g_signal_connect (entry, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
&jsvals.smoothing);
g_signal_connect (entry, "value-changed",
G_CALLBACK (make_preview),
NULL);
restart_markers_label = gtk_label_new (_("Interval (MCU rows):"));
gtk_misc_set_alignment (GTK_MISC (restart_markers_label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), restart_markers_label, 4, 5, 1, 2,
GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);
gtk_widget_show (restart_markers_label);
pg.scale_data = (GtkAdjustment *)
gtk_adjustment_new (((jsvals.restart == 0) ?
DEFAULT_RESTART_MCU_ROWS : jsvals.restart),
1.0, 64.0, 1.0, 1.0, 0);
pg.restart = restart_markers_scale = spinbutton =
gtk_spin_button_new (pg.scale_data, 1.0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE);
gtk_table_attach (GTK_TABLE (table), spinbutton, 5, 6, 1, 2,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (spinbutton);
pg.use_restart_markers = toggle =
gtk_check_button_new_with_mnemonic (_("Use _restart markers"));
gtk_table_attach (GTK_TABLE (table), toggle, 2, 4, 1, 2, GTK_FILL, 0, 0, 0);
gtk_widget_show (toggle);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), jsvals.restart);
gtk_widget_set_sensitive (restart_markers_label, jsvals.restart);
gtk_widget_set_sensitive (restart_markers_scale, jsvals.restart);
g_signal_connect (pg.scale_data, "value-changed",
G_CALLBACK (save_restart_update),
toggle);
pg.handler_id_restart = g_signal_connect_swapped (toggle, "toggled",
G_CALLBACK (save_restart_update),
pg.scale_data);
row = 0;
/* Optimize */
pg.optimize = toggle = gtk_check_button_new_with_mnemonic (_("_Optimize"));
gtk_table_attach (GTK_TABLE (table), toggle, 0, 1,
row, row + 1, GTK_FILL, 0, 0, 0);
gtk_widget_show (toggle);
g_signal_connect (toggle, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&jsvals.optimize);
g_signal_connect (toggle, "toggled",
G_CALLBACK (make_preview),
NULL);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), jsvals.optimize);
if (arithc_supported)
gtk_widget_set_sensitive (toggle, !jsvals.arithmetic_coding);
row++;
if (arithc_supported)
{
/* Arithmetic coding */
pg.arithmetic_coding = toggle = gtk_check_button_new_with_mnemonic
(_("Use arithmetic _coding"));
gtk_widget_set_tooltip_text
(toggle, _("Older software may have trouble opening "
"arithmetic-coded images"));
gtk_table_attach (GTK_TABLE (table), toggle, 0, 1,
row, row + 1, GTK_FILL, 0, 0, 0);
gtk_widget_show (toggle);
g_signal_connect (toggle, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&jsvals.arithmetic_coding);
g_signal_connect (toggle, "toggled",
G_CALLBACK (make_preview),
NULL);
g_signal_connect (toggle, "toggled",
G_CALLBACK (toggle_arithmetic_coding),
pg.optimize);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
jsvals.arithmetic_coding);
row++;
}
/* Progressive */
pg.progressive = toggle =
gtk_check_button_new_with_mnemonic (_("_Progressive"));
gtk_table_attach (GTK_TABLE (table), toggle, 0, 1,
row, row + 1, GTK_FILL, 0, 0, 0);
gtk_widget_show (toggle);
g_signal_connect (toggle, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&jsvals.progressive);
g_signal_connect (toggle, "toggled",
G_CALLBACK (make_preview),
NULL);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
jsvals.progressive);
row++;
/* Save EXIF data */
pg.save_exif = toggle =
gtk_check_button_new_with_mnemonic (_("Save _Exif data"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), jsvals.save_exif);
gtk_table_attach (GTK_TABLE (table), toggle, 0, 1,
row, row + 1, GTK_FILL, 0, 0, 0);
gtk_widget_show (toggle);
g_signal_connect (toggle, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&jsvals.save_exif);
g_signal_connect (toggle, "toggled",
G_CALLBACK (make_preview),
NULL);
gtk_widget_set_sensitive (toggle, TRUE);
row++;
/* Save thumbnail */
pg.save_thumbnail = toggle =
gtk_check_button_new_with_mnemonic (_("Save _thumbnail"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), jsvals.save_thumbnail);
gtk_table_attach (GTK_TABLE (table), toggle, 0, 1,
row, row + 1, GTK_FILL, 0, 0, 0);
gtk_widget_show (toggle);
g_signal_connect (toggle, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&jsvals.save_thumbnail);
g_signal_connect (toggle, "toggled",
G_CALLBACK (make_preview),
NULL);
row++;
/* XMP metadata */
pg.save_xmp = toggle =
gtk_check_button_new_with_mnemonic (_("Save _XMP data"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), jsvals.save_xmp);
gtk_table_attach (GTK_TABLE (table), toggle, 0, 1,
row, row + 1, GTK_FILL, 0, 0, 0);
gtk_widget_show (toggle);
g_signal_connect (toggle, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&jsvals.save_xmp);
g_signal_connect (toggle, "toggled",
G_CALLBACK (make_preview),
NULL);
gtk_widget_set_sensitive (toggle, TRUE);
row++;
/* IPTC metadata */
pg.save_iptc = toggle =
gtk_check_button_new_with_mnemonic (_("Save _IPTC data"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), jsvals.save_iptc);
gtk_table_attach (GTK_TABLE (table), toggle, 0, 1,
row, row + 1, GTK_FILL, 0, 0, 0);
gtk_widget_show (toggle);
g_signal_connect (toggle, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&jsvals.save_iptc);
g_signal_connect (toggle, "toggled",
G_CALLBACK (make_preview),
NULL);
gtk_widget_set_sensitive (toggle, TRUE);
row++;
/* custom quantization tables - now used also for original quality */
pg.use_orig_quality = toggle =
gtk_check_button_new_with_mnemonic (_("_Use quality settings from original "
"image"));
gtk_table_attach (GTK_TABLE (table), toggle, 0, 4,
row, row + 1, GTK_FILL, 0, 0, 0);
gtk_widget_show (toggle);
gimp_help_set_help_data (toggle,
_("If the original image was loaded from a JPEG "
"file using non-standard quality settings "
"(quantization tables), enable this option to "
"get almost the same quality and file size."),
NULL);
g_signal_connect (toggle, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&jsvals.use_orig_quality);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
jsvals.use_orig_quality
&& (orig_quality > 0));
gtk_widget_set_sensitive (toggle, (orig_quality > 0));
/* changing quality disables custom quantization tables, and vice-versa */
g_signal_connect (pg.quality, "value-changed",
G_CALLBACK (quality_changed),
pg.use_orig_quality);
g_signal_connect (pg.use_orig_quality, "toggled",
G_CALLBACK (use_orig_qual_changed),
pg.quality);
/* Subsampling */
label = gtk_label_new_with_mnemonic (_("Su_bsampling:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 2, 3, 2, 3,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
pg.subsmp =
combo = gimp_int_combo_box_new (_("4:4:4 (best quality)"),
JPEG_SUBSAMPLING_1x1_1x1_1x1,
_("4:2:2 horizontal (chroma halved)"),
JPEG_SUBSAMPLING_2x1_1x1_1x1,
_("4:2:2 vertical (chroma halved)"),
JPEG_SUBSAMPLING_1x2_1x1_1x1,
_("4:2:0 (chroma quartered)"),
JPEG_SUBSAMPLING_2x2_1x1_1x1,
NULL);
gtk_table_attach (GTK_TABLE (table), combo, 3, 6, 2, 3,
GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);
gtk_widget_show (combo);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo);
if (gimp_drawable_is_rgb (drawable_ID_global))
{
gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (combo),
jsvals.subsmp,
G_CALLBACK (subsampling_changed),
entry);
g_signal_connect (pg.use_orig_quality, "toggled",
G_CALLBACK (use_orig_qual_changed2),
pg.subsmp);
}
else
{
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (combo),
JPEG_SUBSAMPLING_1x1_1x1_1x1);
gtk_widget_set_sensitive (combo, FALSE);
}
/* DCT method */
label = gtk_label_new_with_mnemonic (_("_DCT method:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 2, 3, 3, 4,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
pg.dct = combo = gimp_int_combo_box_new (_("Fast Integer"), 1,
_("Integer"), 0,
_("Floating-Point"), 2,
NULL);
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (combo), jsvals.dct);
gtk_table_attach (GTK_TABLE (table), combo, 3, 6, 3, 4,
GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);
gtk_widget_show (combo);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo);
g_signal_connect (combo, "changed",
G_CALLBACK (gimp_int_combo_box_get_active),
&jsvals.dct);
g_signal_connect (combo, "changed",
G_CALLBACK (make_preview),
NULL);
frame = gimp_frame_new (_("Comment"));
gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_widget_set_size_request (scrolled_window, 250, 50);
gtk_container_add (GTK_CONTAINER (frame), scrolled_window);
gtk_widget_show (scrolled_window);
pg.text_buffer = text_buffer = gtk_text_buffer_new (NULL);
if (image_comment)
gtk_text_buffer_set_text (text_buffer, image_comment, -1);
text_view = gtk_text_view_new_with_buffer (text_buffer);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (text_view), GTK_WRAP_WORD);
gtk_container_add (GTK_CONTAINER (scrolled_window), text_view);
gtk_widget_show (text_view);
g_object_unref (text_buffer);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
gtk_box_pack_start (GTK_BOX (gimp_export_dialog_get_content_area (dialog)),
vbox, TRUE, TRUE, 0);
gtk_widget_show (vbox);
tabledefaults = gtk_table_new (1, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (tabledefaults), 6);
gtk_box_pack_start (GTK_BOX (vbox), tabledefaults, FALSE, FALSE, 0);
gtk_widget_show (tabledefaults);
button = gtk_button_new_with_mnemonic (_("_Load Defaults"));
gtk_table_attach (GTK_TABLE (tabledefaults),
button, 0, 1, 1, 2, GTK_FILL, 0, 0, 0);
gtk_widget_show (button);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (load_gui_defaults),
&pg);
button = gtk_button_new_with_mnemonic (_("Sa_ve Defaults"));
gtk_table_attach (GTK_TABLE (tabledefaults),
button, 1, 2, 1, 2, GTK_FILL, 0, 0, 0);
gtk_widget_show (button);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (save_defaults),
&pg);
gtk_widget_show (frame);
gtk_widget_show (table);
gtk_widget_show (dialog);
make_preview ();
pg.run = FALSE;
gtk_main ();
destroy_preview ();
return pg.run;
}
void uploader_curl_file (void **apFilesPaths , int ListCount) {
void *pChoosedFile = NULL;
char *FileName = NULL;
long long FileSize = 0;
double TotalTime = 0;
double BatchTotalTime = 0;
float BatchSize = 0;
char buff[256];
bool CancelReq = false;
int i, UpDone = 0;
if(access(PathCurlOut, F_OK ) != -1)
remove(PathCurlOut);
if(ListCount == 0)
return;
BatchLinks = (char*) realloc(BatchLinks,(ListCount*sizeof(RegexMatchURL)));
if(BatchLinks == NULL)
log_error(true,"***Error: Memory error @ L62 - pomfit.c");
for(i = 0 ; i < ListCount; ++i) {
pChoosedFile = apFilesPaths[i];
if(pomfit_check_size(pChoosedFile,ActiveProfile.MaxSize) == 1)
continue;
CURL *curl;
CURLcode res;
struct curl_httppost *post = NULL;
struct curl_httppost *last = NULL;
pChoosedFile = apFilesPaths[i];
FILE *pUploadFile = fopen(pChoosedFile, "rb");
if(!pUploadFile) {
log_error(true,"***Error: Uploader failed to read file %s",pChoosedFile);
pChoosedFile = NULL;
return;
} else {
fseek(pUploadFile, 0 , SEEK_END);
FileSize = ftell(pUploadFile);
rewind(pUploadFile);
}
FILE *pOutputFile;
pOutputFile = fopen(PathCurlOut, "a");
if(!pOutputFile) {
log_error(true,"***Error: Uploader failed to create output file %s",PathCurlOut);
if(pUploadFile)
fclose(pUploadFile);
return;
}
/// Get name from filepath
#ifdef __linux__
FileName = strrchr(pChoosedFile, '/');
#elif _WIN32
FileName = strrchr(pChoosedFile, '\\');
#endif
FileName += 1;
gtk_button_set_relief(GTK_BUTTON(up_but), GTK_RELIEF_NONE);
gtk_button_set_label(GTK_BUTTON(up_but), "Cancel");
IsUploading = TRUE;
TimeUpStarted = time(NULL);
curl = curl_easy_init();
if(curl)
{
if(ActiveProfile.bFormName) {
char *Suffix = strrchr(FileName, '.');
char CustomFileName[512];
sprintf(CustomFileName, "%s%s",ActiveProfile.FormFileName,Suffix);
printf("%s\n",CustomFileName);
curl_formadd(&post, &last,
CURLFORM_COPYNAME, ActiveProfile.FormName,
CURLFORM_FILE, pChoosedFile,
CURLFORM_FILENAME, CustomFileName,
CURLFORM_CONTENTTYPE, ActiveProfile.FormType,
CURLFORM_END);
} else if (!ActiveProfile.bNames){
curl_formadd(&post, &last,
CURLFORM_COPYNAME, ActiveProfile.FormName,
CURLFORM_FILE, pChoosedFile,
CURLFORM_FILENAME, "Pomfit_Upload",
CURLFORM_CONTENTTYPE, ActiveProfile.FormType,
CURLFORM_END);
} else {
curl_formadd(&post, &last,
CURLFORM_COPYNAME, ActiveProfile.FormName,
CURLFORM_FILE, pChoosedFile,
CURLFORM_CONTENTTYPE, ActiveProfile.FormType,
CURLFORM_END);
}
curl_easy_setopt(curl, CURLOPT_URL, ActiveProfile.URL);
curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0L);
curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION, uploader_curl_progress);
curl_easy_setopt(curl, CURLOPT_READDATA, pUploadFile);
curl_easy_setopt(curl, CURLOPT_INFILESIZE_LARGE,
(curl_off_t)FileSize);
curl_easy_setopt(curl, CURLOPT_HTTPPOST, post);
curl_easy_setopt(curl, CURLOPT_USERAGENT, POMFIT_USER_AGENT);
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, true);
curl_easy_setopt(curl, CURLOPT_MAXREDIRS, 50L);
curl_easy_setopt(curl, CURLOPT_TCP_KEEPALIVE, 1L);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, pOutputFile);
if(ActiveProfile.bCookie) {
curl_easy_setopt(curl, CURLOPT_COOKIESESSION, TRUE);
curl_easy_setopt(curl, CURLOPT_COOKIEJAR, PathCookie);
curl_easy_setopt(curl, CURLOPT_COOKIEFILE, PathCookie);
}
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
log_error(true, "***Error: curl_easy_perform() failed: %s\n", curl_easy_strerror(res));
if(ListCount == 1 || strstr(curl_easy_strerror(res),"aborted") || CancelReq) {
gtk_statusbar_push(GTK_STATUSBAR(status_bar),
1,"Uploading canceled.");
gtk_button_set_relief(GTK_BUTTON(up_but),
GTK_RELIEF_NORMAL);
gtk_button_set_label(GTK_BUTTON(up_but), "Upload");
IsUploading = FALSE;
pomfit_notify(curl_easy_strerror(res),"Uploading canceled");
pChoosedFile = NULL;
if(pUploadFile)
fclose(pUploadFile);
if(pOutputFile)
fclose(pOutputFile);
curl_formfree(post);
curl_easy_cleanup(curl);
if(remove(PathCurlOut) != 0)
perror("Error deleting temp file");
return;
} else {
pChoosedFile = NULL;
if(pUploadFile)
fclose(pUploadFile);
if(pOutputFile)
fclose(pOutputFile);
curl_formfree(post);
curl_easy_cleanup(curl);
CancelReq = true;
continue;
}
} else {
fprintf(pOutputFile,"\n");
BatchSize += (float)FileSize/1000000;;
UpDone += 1;
}
curl_easy_getinfo(curl, CURLINFO_TOTAL_TIME, &TotalTime);
curl_formfree(post);
curl_easy_cleanup(curl);
BatchTotalTime += TotalTime;
}
fclose(pOutputFile);
if(pUploadFile)
fclose(pUploadFile);
if (uploader_curl_output(PathCurlOut,pChoosedFile) == 0) {
if(i == 0)
sprintf(BatchLinks,"%s ", RegexMatchURL);
else
sprintf(strchr(BatchLinks, '\0'),"%s ", RegexMatchURL);
RegexMatchURL[0] = '\0';
RegexMatchDEL[0] = '\0';
}
}
if(UpDone == 0)
return;
sprintf(buff, "%d File%s(%.2f MB) in %dmin %dsec",
UpDone,UpDone < 2 ? "" : "s",BatchSize ,
(int)BatchTotalTime > 60 ? (int)BatchTotalTime/60 : 0,
(int)BatchTotalTime%60 > 0 ? (int)BatchTotalTime%60 : 1);
GtkClipboard *clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
gtk_clipboard_set_can_store (clipboard,NULL,0);
gtk_clipboard_set_text(clipboard, BatchLinks, strlen(BatchLinks)-1);
gtk_clipboard_store(clipboard);
gtk_statusbar_push (GTK_STATUSBAR(status_bar), 1, buff);
sprintf(strchr(buff, '\0'),"\nLink%s copied to clipboard ", UpDone < 2 ? "" : "s");
pomfit_notify(buff,"Uploading Finished");
sprintf(buff,"Click to open all links.\nRight click to copy links.");
gtk_widget_set_tooltip_text(link_but, buff);
gtk_link_button_set_uri(GTK_LINK_BUTTON(link_but), BatchLinks);
sprintf(buff,"%d/%d File%s Uploaded",
UpDone, ListCount, UpDone < 2 ? "" : "s");
gtk_button_set_label(GTK_BUTTON(link_but), buff);
gtk_button_set_relief(GTK_BUTTON(up_but), GTK_RELIEF_NORMAL);
gtk_button_set_label(GTK_BUTTON(up_but), "Upload");
IsUploading = FALSE;
pChoosedFile = NULL;
for(i = 0 ; i < ListCount; ++i)
apFilesPaths[i] = NULL;
}
