JNIEXPORT void JNICALL
Java_org_gnome_gtk_GtkFileChooser_gtk_1file_1chooser_1set_1extra_1widget
(
JNIEnv* env,
jclass cls,
jlong _self,
jlong _extraWidget
)
{
GtkFileChooser* self;
GtkWidget* extraWidget;
// convert parameter self
self = (GtkFileChooser*) _self;
// convert parameter extraWidget
extraWidget = (GtkWidget*) _extraWidget;
// call function
gtk_file_chooser_set_extra_widget(self, extraWidget);
// cleanup parameter self
// cleanup parameter extraWidget
}
static void
gimp_file_dialog_add_proc_selection (GimpFileDialog *dialog,
Gimp *gimp,
GSList *file_procs,
const gchar *automatic,
const gchar *automatic_help_id)
{
GtkWidget *scrolled_window;
dialog->proc_expander = gtk_expander_new_with_mnemonic (NULL);
gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (dialog),
dialog->proc_expander);
gtk_widget_show (dialog->proc_expander);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_SHADOW_IN);
gtk_container_add (GTK_CONTAINER (dialog->proc_expander), scrolled_window);
gtk_widget_show (scrolled_window);
gtk_widget_set_size_request (scrolled_window, -1, 200);
dialog->proc_view = gimp_file_proc_view_new (gimp, file_procs, automatic,
automatic_help_id);
gtk_container_add (GTK_CONTAINER (scrolled_window), dialog->proc_view);
gtk_widget_show (dialog->proc_view);
g_signal_connect (dialog->proc_view, "changed",
G_CALLBACK (gimp_file_dialog_proc_changed),
dialog);
gimp_file_proc_view_set_proc (GIMP_FILE_PROC_VIEW (dialog->proc_view), NULL);
}
void FileDialog::AddChildGTK(wxWindowGTK* child)
{
// allow dialog to be resized smaller horizontally
gtk_widget_set_size_request(
child->m_widget, child->GetMinWidth(), child->m_height);
// In GTK 3+, adding our container as the extra widget can cause the
// the filter combo to grow to the same height as our container. This
// makes for a very odd looking filter combo. So, we manually add our
// container below the action bar.
#if GTK_CHECK_VERSION(3,0,0)
GtkWidget *actionbar = find_widget(m_widget, "GtkActionBar", 0);
if (actionbar)
{
GtkWidget *vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add(GTK_CONTAINER(vbox), child->m_widget);
gtk_box_set_child_packing(GTK_BOX(vbox), child->m_widget, TRUE, TRUE, 0, GTK_PACK_START);
gtk_widget_show(vbox);
GtkWidget *abparent = gtk_widget_get_parent(actionbar);
gtk_container_add(GTK_CONTAINER(abparent), vbox);
gtk_box_set_child_packing(GTK_BOX(abparent), vbox, FALSE, FALSE, 0, GTK_PACK_END);
gtk_box_reorder_child(GTK_BOX(abparent), actionbar, -2);
}
#else
gtk_file_chooser_set_extra_widget(
GTK_FILE_CHOOSER(m_widget), child->m_widget);
#endif
}
char *gwwv_save_filename_with_gadget(const char *title, const char *def_name,
const struct gwwv_filter *filters, GtkWidget *extra ) {
GtkWidget *dialog;
char *filename = NULL;
gsize read, written;
dialog = gtk_file_chooser_dialog_new (title,
NULL,
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
NULL);
gwwv_file_def_filters(dialog,def_name,filters);
if ( extra != NULL )
gtk_file_chooser_set_extra_widget( GTK_FILE_CHOOSER( dialog ), extra );
filename = NULL;
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) {
char *temp = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
filename = g_filename_to_utf8(temp,-1,&read,&written,NULL);
free(temp);
}
gtk_widget_destroy (dialog);
return( filename );
}
void wxFileDialog::AddChildGTK(wxWindowGTK* child)
{
g_signal_connect_after(child->m_widget, "size_request",
G_CALLBACK(extra_widget_size_request), child);
gtk_file_chooser_set_extra_widget(
GTK_FILE_CHOOSER(m_widget), child->m_widget);
}
static GtkFileChooser *
get_file_chooser (const gchar *title,
GtkFileChooserAction action,
gboolean select_multiple)
{
#ifdef USE_GTK_NATIVE_FILE_CHOOSER
GtkFileChooserNative *dlg = gtk_file_chooser_native_new (title, GTK_WINDOW (mainwin), action, NULL, NULL);
#else
GtkWidget *dlg = gtk_file_chooser_dialog_new (title, GTK_WINDOW (mainwin), action, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
if (action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER) {
GtkWidget *box = gtk_hbox_new (FALSE, 8);
gtk_widget_show (box);
GtkWidget *check = gtk_check_button_new_with_mnemonic (_("Follow symlinks"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), deadbeef->conf_get_int ("add_folders_follow_symlinks", 0));
g_signal_connect ((gpointer) check, "toggled",
G_CALLBACK (on_follow_symlinks_toggled),
NULL);
gtk_widget_show (check);
gtk_box_pack_start (GTK_BOX (box), check, FALSE, FALSE, 0);
gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (dlg), box);
}
#endif
gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (dlg), select_multiple);
return GTK_FILE_CHOOSER (dlg);
}
/**
* create the page 3 of the assistant
* this page permit to choose a name for the archive
* and choose the format to export
*
* \param assistant the GtkWidget assistant
*
* \return a GtkWidget containing the page
* */
static GtkWidget *gsb_assistant_archive_export_page_name ( GtkWidget *assistant )
{
GtkWidget * vbox, * hbox;
vbox = gtk_vbox_new ( FALSE, 6 );
gtk_container_set_border_width ( GTK_CONTAINER(vbox), 12 );
archive_export_label = gtk_label_new ( NULL );
gtk_misc_set_alignment ( GTK_MISC ( archive_export_label ), 0, 0.5);
gtk_label_set_justify ( GTK_LABEL ( archive_export_label ), GTK_JUSTIFY_LEFT );
gtk_box_pack_start ( GTK_BOX ( vbox ), archive_export_label, FALSE, FALSE, 0 );
/* Layout */
hbox = gtk_hbox_new ( FALSE, 6 );
gtk_box_pack_start ( GTK_BOX ( hbox ),
gtk_label_new ( _("Export format: ") ),
FALSE, FALSE, 0 );
/* Combo box */
archive_export_combobox = gtk_combo_box_new_text();
gtk_combo_box_append_text ( GTK_COMBO_BOX(archive_export_combobox), _("Grisbi (GSB) format" ) );
gtk_combo_box_append_text ( GTK_COMBO_BOX(archive_export_combobox), _("QIF format" ) );
gtk_combo_box_append_text ( GTK_COMBO_BOX(archive_export_combobox), _("CSV format" ) );
gtk_box_pack_start ( GTK_BOX ( hbox ), archive_export_combobox, TRUE, TRUE, 0 );
archive_export_filechooser = gtk_file_chooser_widget_new ( GTK_FILE_CHOOSER_ACTION_SAVE );
gtk_file_chooser_set_extra_widget ( GTK_FILE_CHOOSER(archive_export_filechooser), hbox );
gtk_box_pack_start ( GTK_BOX ( vbox ), archive_export_filechooser, TRUE, TRUE, 0 );
gtk_combo_box_set_active ( GTK_COMBO_BOX(archive_export_combobox), 0 );
return vbox;
}
GtkWidget*
gtr_torrent_open_from_file_dialog_new( GtkWindow * parent, TrCore * core )
{
GtkWidget * w;
GtkWidget * c;
const char * folder;
w = gtk_file_chooser_dialog_new( _( "Open a Torrent" ), parent,
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL );
gtk_dialog_set_alternative_button_order( GTK_DIALOG( w ),
GTK_RESPONSE_ACCEPT,
GTK_RESPONSE_CANCEL,
-1 );
gtk_file_chooser_set_select_multiple( GTK_FILE_CHOOSER( w ), TRUE );
addTorrentFilters( GTK_FILE_CHOOSER( w ) );
g_signal_connect( w, "response", G_CALLBACK( onOpenDialogResponse ), core );
if( ( folder = gtr_pref_string_get( PREF_KEY_OPEN_DIALOG_FOLDER ) ) )
gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER( w ), folder );
c = gtk_check_button_new_with_mnemonic( _( "Show _options dialog" ) );
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( c ),
gtr_pref_flag_get( PREF_KEY_OPTIONS_PROMPT ) );
gtk_file_chooser_set_extra_widget( GTK_FILE_CHOOSER( w ), c );
gtk_widget_show( c );
return w;
}
CMasterBiasDlg::CMasterBiasDlg(GtkWindow *pParent):m_pParent(pParent), m_InFiles(0),
m_FileList(NULL), m_FilePath(NULL)
{
GtkWidget *vbox, *xbox, *bbox;
GSList *group;
GtkFileFilter *filters[2];
// Dialog with buttons
m_pDlg = gtk_file_chooser_dialog_new("Master bias frame", pParent,
GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, GTK_STOCK_HELP, GTK_RESPONSE_HELP, NULL);
gtk_file_chooser_standard_tooltips(GTK_FILE_CHOOSER(m_pDlg));
gtk_dialog_set_tooltip_by_response(GTK_DIALOG(m_pDlg), GTK_RESPONSE_ACCEPT, "Create a master bias frame and save it to the specified file");
g_signal_connect(G_OBJECT(m_pDlg), "response", G_CALLBACK(response_dialog), this);
gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(m_pDlg), true);
// Filters
filters[0] = gtk_file_filter_new();
gtk_file_filter_add_pattern(filters[0], "*." FILE_EXTENSION_FITS);
gtk_file_filter_set_name(filters[0], "FITS files");
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(m_pDlg), filters[0]);
filters[1] = gtk_file_filter_new();
gtk_file_filter_add_pattern(filters[1], "*");
gtk_file_filter_set_name(filters[1], "All files");
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(m_pDlg), filters[1]);
gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(m_pDlg), filters[0]);
// Dialog icon
gchar *icon = get_icon_file("masterbias");
gtk_window_set_icon(GTK_WINDOW(m_pDlg), gdk_pixbuf_new_from_file(icon, NULL));
g_free(icon);
// Frame selection
xbox = gtk_vbox_new(FALSE, 8);
m_ProcFrame = gtk_frame_new("Process");
gtk_box_pack_start(GTK_BOX(xbox), m_ProcFrame, FALSE, TRUE, 0);
vbox = gtk_vbox_new(FALSE, 4);
gtk_container_add(GTK_CONTAINER(m_ProcFrame), vbox);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 4);
m_AllBtn = gtk_radio_button_new_with_label(NULL, "all files in current project");
gtk_widget_set_tooltip_text(m_AllBtn, "Include all frames in the current project");
gtk_box_pack_start(GTK_BOX(vbox), m_AllBtn, TRUE, TRUE, 0);
group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(m_AllBtn));
m_SelBtn = gtk_radio_button_new_with_label(group, "selected files only");
gtk_widget_set_tooltip_text(m_SelBtn, "Include frames that are selected in the main window");
gtk_box_pack_start(GTK_BOX(vbox), m_SelBtn, TRUE, TRUE, 0);
// Options
bbox = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_START);
gtk_box_pack_start(GTK_BOX(xbox), bbox, FALSE, TRUE, 0);
m_OptionsBtn = gtk_button_new_with_label("Options");
gtk_widget_set_tooltip_text(m_OptionsBtn, "Edit project settings");
gtk_box_pack_start(GTK_BOX(bbox), m_OptionsBtn, FALSE, TRUE, 0);
g_signal_connect(G_OBJECT(m_OptionsBtn), "clicked", G_CALLBACK(button_clicked), this);
gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(m_pDlg), xbox);
gtk_widget_show_all(xbox);
}
void wxFileDialog::AddChildGTK(wxWindowGTK* child)
{
// allow dialog to be resized smaller horizontally
gtk_widget_set_size_request(
child->m_widget, child->GetMinWidth(), child->m_height);
gtk_file_chooser_set_extra_widget(
GTK_FILE_CHOOSER(m_widget), child->m_widget);
}
void ui_import_csv(void) {
GtkWidget *dia_file_import;
GtkWidget *vbox;
GtkWidget *radio_comma, *radio_tab;
import_ *import;
import = malloc(sizeof(import_));
import->delimiter = ',';
dia_file_import = gtk_file_chooser_dialog_new(
"Import character separated file",
GTK_WINDOW(win_main),
GTK_FILE_CHOOSER_ACTION_OPEN,
NULL);
gtk_dialog_add_buttons(
GTK_DIALOG(dia_file_import),
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
NULL);
/* Build options widget */
radio_comma = gtk_radio_button_new_with_mnemonic(NULL, "_Comma separated");
radio_tab = gtk_radio_button_new_with_mnemonic_from_widget(
GTK_RADIO_BUTTON(radio_comma),
"_Tab separated");
g_signal_connect(
radio_comma,
"toggled",
GTK_SIGNAL_FUNC(ui_import_delimiter_comma_cb),
import);
g_signal_connect(
radio_tab,
"toggled",
GTK_SIGNAL_FUNC(ui_import_delimiter_tab_cb),
import);
vbox = gtk_vbox_new(FALSE, 3);
gtk_box_pack_start(GTK_BOX(vbox), radio_comma, FALSE, FALSE, 3);
gtk_box_pack_start(GTK_BOX(vbox), radio_tab, FALSE, FALSE, 3);
gtk_widget_show_all(vbox);
/* Prepare import dialog and show */
gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(dia_file_import), vbox);
if (gtk_dialog_run(GTK_DIALOG(dia_file_import)) == GTK_RESPONSE_ACCEPT) {
list_clear(list);
list = list_create();
import->filename = strdup(gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dia_file_import)));
list_import_csv(list, import->filename, import->delimiter);
free(import->filename);
}
gtk_widget_destroy(dia_file_import);
free(import);
}
wxFileDialog::~wxFileDialog()
{
if (m_extraControl)
{
// get chooser to drop its reference right now, allowing wxWindow dtor
// to verify that ref count drops to zero
gtk_file_chooser_set_extra_widget(
GTK_FILE_CHOOSER(m_widget), NULL);
}
}
static GtkWidget *create_file_selector(FileInfo *selected_fi)
{
GtkWidget *selector;
GtkWidget *align;
GtkWidget *table;
GtkWidget *label;
GtkWidget *option_menu_charset;
GtkWidget *option_menu_lineend;
const gchar *title;
title = mode ? _("Open") : _("Save As");
#if ENABLE_CHOOSER
selector = gtk_file_chooser_dialog_new(title, NULL,
mode ? GTK_FILE_CHOOSER_ACTION_OPEN : GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
mode ? GTK_STOCK_OPEN : GTK_STOCK_SAVE, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response(GTK_DIALOG(selector), GTK_RESPONSE_OK);
#else
selector = gtk_file_selection_new(title);
#endif
// align = gtk_alignment_new(0.5, 0, 0, 0);
align = gtk_alignment_new(1, 0, 0, 0);
#if ENABLE_CHOOSER
gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(selector), align);
#else
gtk_box_pack_end(GTK_BOX(GTK_FILE_SELECTION(selector)->main_vbox),
align, FALSE, FALSE, 0);
#endif
table = gtk_table_new(2, 2, FALSE);
gtk_container_add(GTK_CONTAINER(align), table);
option_menu_charset = create_charset_menu(selected_fi);
label = gtk_label_new_with_mnemonic(_("C_haracter Coding:"));
gtk_label_set_mnemonic_widget(GTK_LABEL(label), option_menu_charset);
gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 0, 1);
// gtk_table_set_row_spacings(GTK_TABLE(table), 5);
gtk_table_set_col_spacing(GTK_TABLE(table), 0, 8);
gtk_table_attach_defaults(GTK_TABLE(table), option_menu_charset, 1, 2, 0, 1);
if (mode == SAVE) {
option_menu_lineend = create_lineend_menu(selected_fi);
gtk_table_attach_defaults(GTK_TABLE(table), option_menu_lineend, 2, 3, 0, 1);
}
gtk_widget_show_all(align);
if (selected_fi->filename)
#if ENABLE_CHOOSER
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(selector), selected_fi->filename);
#else
gtk_file_selection_set_filename(GTK_FILE_SELECTION(selector), selected_fi->filename);
#endif
return selector;
}
/* Return the filename in filename encoding. */
static gchar*
gpa_backup_operation_dialog_run (GtkWidget *parent, const gchar *key_id,
int is_x509)
{
static GtkWidget *dialog;
GtkResponseType response;
gchar *default_comp;
gchar *filename = NULL;
gchar *id_text;
GtkWidget *id_label;
if (! dialog)
{
dialog = gtk_file_chooser_dialog_new
(_("Backup key to file"), GTK_WINDOW (parent),
GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_OK, NULL);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
gtk_file_chooser_set_do_overwrite_confirmation
(GTK_FILE_CHOOSER (dialog), TRUE);
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog),
g_get_home_dir ());
}
/* Set the label with more explanations. */
id_text = g_strdup_printf (_("Generating backup of key: 0x%s"), key_id);
id_label = gtk_label_new (id_text);
g_free (id_text);
gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (dialog), id_label);
/* Set the default file name. I am not sure whether ".p12" or
".pem" is better for an _armored_ pkcs#12. */
default_comp = g_strdup_printf ("%s%csecret-key-%s.%s",
gnupg_homedir,
G_DIR_SEPARATOR,
key_id,
is_x509? "p12":"asc");
gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), default_comp);
g_free (default_comp);
response = gtk_dialog_run (GTK_DIALOG (dialog));
if (response == GTK_RESPONSE_OK)
{
filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
if (filename)
g_strdup (filename);
}
gtk_widget_hide (dialog);
return filename;
}
void GtkFileChooserDialog_::set_extra_widget(Php::Parameters ¶meters)
{
GtkWidget *extra_widget;
if(parameters.size() > 0) {
Php::Value object_extra_widget = parameters[0];
GtkWidget_ *phpgtk_extra_widget = (GtkWidget_ *)object_extra_widget.implementation();
extra_widget = GTK_WIDGET(phpgtk_extra_widget->get_instance());
}
gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER(instance), extra_widget);
}
int
clip_GTK_FILECHOOSERSETEXTRAWIDGET(ClipMachine * ClipMachineMemory)
{
C_object *cchooser = _fetch_co_arg(ClipMachineMemory);
C_widget *cwid = _fetch_cwidget(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2));
CHECKCOBJ(cchooser, GTK_IS_FILE_CHOOSER(cchooser->object));
CHECKCWID(cwid, GTK_IS_WIDGET);
gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(cchooser->object), GTK_WIDGET(cwid->widget));
return 0;
err:
return 1;
}
static int
af_create_open_file_selection (FsDialogData *fsdata )
{
GtkWidget *dialog;
gint response;
GtkWidget *frame;
GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_OPEN;
gchar *button_text = _("_Open");
if ( fsdata->option == FILE_WRITE_OP ){
action = GTK_FILE_CHOOSER_ACTION_SAVE;
button_text = _("_Save");
}
dialog = gtk_file_chooser_dialog_new (_("Select file"),
GTK_WINDOW (fsdata->ud->window),
action,
_("_Cancel"), GTK_RESPONSE_REJECT,
button_text, GTK_RESPONSE_ACCEPT,
NULL);
if ( fsdata->option == FILE_READ_OP ){
gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (dialog), TRUE);
}
frame = af_create_fmt_radio_widget(GTK_FILE_CHOOSER (dialog), fsdata);
gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (dialog), frame);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
if ( fsdata->filename ) {
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (dialog), fsdata->filename);
}
response = gtk_dialog_run (GTK_DIALOG (dialog));
if (response == GTK_RESPONSE_ACCEPT) {
fsdata->files = gtk_file_chooser_get_filenames (GTK_FILE_CHOOSER (dialog));
#ifdef TRACE_MEM
GSList *list = fsdata->files;
while (list) {
GSList *next = list->next;
tmem_alloced(list->data, 0); /* trace mem */
list = next;
}
#endif
}
gtk_widget_destroy (dialog);
return response;
}
int FileDialog::ShowModal()
{
if ( !m_buttonlabel.IsEmpty() )
{
GtkWidget *widget;
wxString label = m_buttonlabel;
label.Replace(wxT("&"), wxT("_"));
widget = gtk_button_new_with_mnemonic(wxGTK_CONV(label));
gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(m_widget), widget);
g_signal_connect(G_OBJECT(widget), "clicked",
G_CALLBACK(gtk_filedialog_extra_callback), (gpointer)this);
}
return wxDialog::ShowModal();
}
GtkWidget *CreateDirChooser(const char *title)
{
GtkWidget *dialog = gtk_file_chooser_dialog_new(title, NULL, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN,
GTK_RESPONSE_ACCEPT, NULL);
GtkWidget *hbox = gtk_hbox_new(FALSE, 0);
gtk_widget_show(hbox);
GtkWidget *rootbutton = CreateButton(gtk_label_new(GetTranslation("Create directory as root")));
g_signal_connect(G_OBJECT(rootbutton), "clicked", G_CALLBACK(CreateRootDirCB), dialog);
gtk_widget_show(rootbutton);
gtk_box_pack_end(GTK_BOX(hbox), rootbutton, FALSE, FALSE, 0);
gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(dialog), hbox);
return dialog;
}
GFile * ImageOpenDlg::show(GtkWindow * win, Settings * settings, bool localOnly, bool * attach) {
GtkWidget * dialog = gtk_file_chooser_dialog_new(_("Open Image"), win, GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN,
GTK_RESPONSE_OK, NULL);
gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(dialog), localOnly);
GtkFileFilter * filterSupported = gtk_file_filter_new();
gtk_file_filter_set_name(filterSupported, _("Images"));
gtk_file_filter_add_pixbuf_formats(filterSupported);
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filterSupported);
if (!settings->getLastImagePath().isEmpty()) {
gtk_file_chooser_set_current_folder_uri(GTK_FILE_CHOOSER(dialog), settings->getLastImagePath().c_str());
}
GtkWidget * cbAttach = NULL;
if (attach) {
cbAttach = gtk_check_button_new_with_label(_("Attach file to the journal"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cbAttach), false);
gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(dialog), cbAttach);
}
GtkWidget * image = gtk_image_new();
gtk_file_chooser_set_preview_widget(GTK_FILE_CHOOSER(dialog), image);
g_signal_connect(dialog, "update-preview", G_CALLBACK(updatePreviewCallback), NULL);
gtk_window_set_transient_for(GTK_WINDOW(dialog), win);
if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
gtk_widget_destroy(dialog);
return NULL;
}
GFile * file = gtk_file_chooser_get_file(GTK_FILE_CHOOSER(dialog));
if (attach) {
*attach = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cbAttach));
}
char * folder = gtk_file_chooser_get_current_folder_uri(GTK_FILE_CHOOSER(dialog));
settings->setLastImagePath(folder);
g_free(folder);
gtk_widget_destroy(dialog);
return file;
}
/*
* GtkFileChooser to select a directory to scan
*/
gchar *
dir_select (gboolean SEARCH, GtkWidget *parent)
{
static GtkWidget *file_chooser = NULL;
GtkWidget *toggle;
if (file_chooser == NULL) {
file_chooser = gtk_file_chooser_dialog_new (_("Select Folder"),
GTK_WINDOW (parent),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN,
GTK_RESPONSE_OK, NULL);
gtk_file_chooser_set_show_hidden (GTK_FILE_CHOOSER (file_chooser), FALSE);
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (file_chooser),
g_get_home_dir ());
/* add extra widget */
toggle = gtk_check_button_new_with_mnemonic (_("_Show hidden folders"));
gtk_widget_show (toggle);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), FALSE);
g_signal_connect ((gpointer) toggle, "toggled",
G_CALLBACK (on_toggled), file_chooser);
gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (file_chooser),
toggle);
g_signal_connect (file_chooser, "response",
G_CALLBACK (filechooser_cb), NULL);
g_signal_connect (file_chooser, "destroy",
G_CALLBACK (gtk_widget_destroyed), &file_chooser);
gtk_window_set_modal (GTK_WINDOW (file_chooser), TRUE);
gtk_window_set_position (GTK_WINDOW (file_chooser), GTK_WIN_POS_CENTER_ON_PARENT);
}
gtk_widget_show (GTK_WIDGET (file_chooser));
return NULL;
}
int FileDialog::ShowModal()
{
if ( !m_buttonlabel.IsEmpty() )
{
GtkWidget *widget;
wxString label = m_buttonlabel;
label.Replace(wxT("&"), wxT("_"));
widget = gtk_button_new_with_mnemonic(wxGTK_CONV(label));
gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(m_widget), widget);
g_signal_connect(G_OBJECT(widget), "clicked",
GTK_SIGNAL_FUNC(gtk_filedialog_extra_callback), (gpointer)this);
}
#if defined(__WXGTK24__) && (!defined(__WXGPE__))
if (!gtk_check_version(2,4,0))
return wxDialog::ShowModal();
else
#endif
return wxGenericFileDialog::ShowModal();
}
static GSList *
do_filechooser (void)
{
GSList *ret = NULL;
GtkWidget *dialog;
GtkWidget *ro_checkbutton;
ret = NULL;
dialog = gtk_file_chooser_dialog_new (_("Select Disk Image(s) to Mount"),
NULL, /* parent window */
GTK_FILE_CHOOSER_ACTION_OPEN,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_Mount"), GTK_RESPONSE_ACCEPT,
NULL);
gdu_utils_configure_file_chooser_for_disk_images (GTK_FILE_CHOOSER (dialog),
TRUE, /* set_file_types */
FALSE); /* allow_compressed */
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (dialog), FALSE);
/* Add a RO check button that defaults to RO */
ro_checkbutton = gtk_check_button_new_with_mnemonic (_("Set up _read-only mount"));
gtk_widget_set_tooltip_markup (ro_checkbutton, _("If checked, the mount will be read-only. This is useful if you don’t want the underlying disk image to be modified"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ro_checkbutton), !opt_writable);
gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (dialog), TRUE);
gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (dialog), ro_checkbutton);
//gtk_widget_show_all (dialog);
if (gtk_dialog_run (GTK_DIALOG (dialog)) != GTK_RESPONSE_ACCEPT)
goto out;
ret = gtk_file_chooser_get_uris (GTK_FILE_CHOOSER (dialog));
opt_writable = ! gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (ro_checkbutton));
out:
gtk_widget_destroy (dialog);
return ret;
}
GtkWidget *
create_dspdesc_window(ggobid *gg, PluginInstance *inst)
{
GtkWidget *window, *hb, *label, *entry;
GtkTooltips *tips = gtk_tooltips_new ();
dspdescd *desc = dspdescFromInst (inst);
window = gtk_file_chooser_dialog_new("Save display description", NULL,
GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
GTK_STOCK_CLOSE, GTK_RESPONSE_REJECT, NULL);
desc->window = window;
/* label and entry widget for main title */
hb = gtk_hbox_new (false, 1);
label = gtk_label_new_with_mnemonic ("Figure _title: ");
gtk_box_pack_start (GTK_BOX (hb), label, false, false, 2);
entry = gtk_entry_new ();
gtk_label_set_mnemonic_widget(GTK_LABEL(label), entry);
g_object_set_data(G_OBJECT(window), "TITLE", entry);
gtk_tooltips_set_tip (GTK_TOOLTIPS (tips), entry,
"Type in the figure title", NULL);
gtk_box_pack_start (GTK_BOX (hb), entry, true, true, 2);
gtk_widget_show_all(hb);
gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(window), hb);
if (gtk_dialog_run(GTK_DIALOG(window)) == GTK_RESPONSE_ACCEPT)
desc_write(inst);
plugin_destroy(inst);
return(window);
}
static void
html_plugin_export (GtkAction *action,
gpointer user_data)
{
PlannerPlugin *plugin;
MrpProject *project;
const gchar *uri;
gchar *filename;
gchar *basename;
gint res;
GtkWidget *filechooser;
GtkWidget *dialog;
GtkWidget *show_button;
gboolean show;
plugin = PLANNER_PLUGIN (user_data);
filechooser = gtk_file_chooser_dialog_new (_("Export to HTML"),
GTK_WINDOW (plugin->main_window),
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (filechooser), GTK_RESPONSE_OK);
project = planner_window_get_project (plugin->main_window);
uri = mrp_project_get_uri (project);
if (!uri) {
gchar *cwd, *tmp;
cwd = g_get_current_dir ();
tmp = g_strconcat (_("Unnamed"), ".html", NULL);
filename = g_build_filename (cwd, tmp, NULL);
g_free (cwd);
g_free (tmp);
} else {
gchar *tmp;
if (g_str_has_suffix (uri, ".planner")) {
tmp = g_strndup (uri, strlen (uri) - strlen (".planner"));
}
else if (g_str_has_suffix (uri, ".mrproject")) {
tmp = g_strndup (uri, strlen (uri) - strlen (".mrproject"));
} else {
tmp = g_strdup (uri);
}
filename = g_strconcat (tmp, ".html", NULL);
g_free (tmp);
}
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filechooser),
filename);
basename = g_path_get_basename (filename);
gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (filechooser), basename);
show_button = gtk_check_button_new_with_label (_("Show result in browser"));
gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filechooser), show_button);
g_free (basename);
g_free (filename);
try_again:
res = gtk_dialog_run (GTK_DIALOG (filechooser));
switch (res) {
case GTK_RESPONSE_OK:
filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (filechooser));
if (g_file_test (filename, G_FILE_TEST_EXISTS)) {
dialog = gtk_message_dialog_new (GTK_WINDOW (filechooser),
GTK_DIALOG_MODAL |
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_WARNING,
GTK_BUTTONS_YES_NO,
_("File \"%s\" exists, do you want to overwrite it?"),
filename);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_YES);
res = gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
switch (res) {
case GTK_RESPONSE_YES:
break;
case GTK_RESPONSE_NO:
case GTK_RESPONSE_DELETE_EVENT:
g_free (filename);
goto try_again;
default:
g_assert_not_reached ();
}
}
show = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (show_button));
gtk_widget_destroy (filechooser);
html_plugin_export_do (plugin, filename, show);
g_free (filename);
break;
case GTK_RESPONSE_CANCEL:
gtk_widget_destroy (filechooser);
break;
}
}
GtkWidget *
gtkam_save_new (GtkWindow *main_window)
{
GtkamSave *save;
GtkWidget *hbox, *frame, *main_vbox, *check, *label, *entry, *button;
GtkObject *a;
GtkTooltips *tooltips;
save = g_object_new (GTKAM_TYPE_SAVE, NULL);
button = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
gtk_widget_show (button);
g_signal_connect (GTK_OBJECT (button),
"clicked", GTK_SIGNAL_FUNC (on_cancel_clicked), save);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (save)->action_area),
button);
button = gtk_button_new_from_stock (GTK_STOCK_OK);
gtk_widget_show (button);
g_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (on_ok_clicked), save);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (save)->action_area),
button);
tooltips = gtk_tooltips_new ();
frame = gtk_frame_new (_("What to save:"));
gtk_widget_show (frame);
gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (save), frame);
main_vbox = gtk_vbox_new (TRUE, 5);
gtk_widget_show (main_vbox);
gtk_container_add (GTK_CONTAINER (frame), main_vbox);
hbox = gtk_hbox_new (TRUE, 5);
gtk_widget_show (hbox);
gtk_container_add (GTK_CONTAINER (main_vbox), hbox);
check = gtk_check_button_new_with_label (_("Save photos"));
gtk_widget_show (check);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
gtk_box_pack_start (GTK_BOX (hbox), check, TRUE, TRUE, 0);
gtk_tooltips_set_tip (tooltips, check, _("Photos will be saved if "
"this is checked"), NULL);
save->priv->toggle_normal = GTK_TOGGLE_BUTTON (check);
check = gtk_check_button_new_with_label (_("Save raw data"));
gtk_widget_show (check);
gtk_box_pack_start (GTK_BOX (hbox), check, TRUE, TRUE, 0);
gtk_tooltips_set_tip (tooltips, check, _("Raw data will be "
"saved if this is checked"), NULL);
save->priv->toggle_raw = GTK_TOGGLE_BUTTON (check);
check = gtk_check_button_new_with_label (_("Save audio data"));
gtk_widget_show (check);
gtk_box_pack_start (GTK_BOX (hbox), check, TRUE, TRUE, 0);
gtk_tooltips_set_tip (tooltips, check, _("Audio data will be "
"saved if this is checked"), NULL);
save->priv->toggle_audio = GTK_TOGGLE_BUTTON (check);
check = gtk_check_button_new_with_label (_("Save thumbnails"));
gtk_widget_show (check);
gtk_box_pack_start (GTK_BOX (hbox), check, TRUE, TRUE, 0);
gtk_tooltips_set_tip (tooltips, check, _("Thumbnails will be "
"saved if this is checked"), NULL);
save->priv->toggle_preview = GTK_TOGGLE_BUTTON (check);
check = gtk_check_button_new_with_label (_("Save EXIF data"));
gtk_widget_show (check);
gtk_box_pack_start (GTK_BOX (hbox), check, TRUE, TRUE, 0);
gtk_tooltips_set_tip (tooltips, check, _("EXIF data will be "
"saved if this is checked"), NULL);
save->priv->toggle_exif = GTK_TOGGLE_BUTTON (check);
hbox = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox);
gtk_box_pack_start (GTK_BOX (main_vbox),
hbox, TRUE, TRUE, 0);
label = gtk_label_new (_("Open image(s) with: "));
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
entry = gtk_entry_new ();
gtk_widget_show (entry);
gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
gtk_tooltips_set_tip (tooltips, entry, _("Type in the name of the "
"program you want to run, leave blank "
"for none"), NULL);
save->priv->program = GTK_ENTRY (entry);
/* Filenames provided by camera */
check = gtk_check_button_new_with_label (_("Use filename(s) provided by the camera"));
gtk_widget_show (check);
gtk_box_pack_start (GTK_BOX (main_vbox),
check, TRUE, TRUE, 0);
gtk_tooltips_set_tip (tooltips, check, _("Choose whether to use the "
"filename provided by the camera"), NULL);
save->priv->toggle_filename_camera = GTK_TOGGLE_BUTTON (check);
gtk_toggle_button_set_active (save->priv->toggle_filename_camera, TRUE);
g_signal_connect (G_OBJECT (check), "toggled",
G_CALLBACK (on_filename_camera_toggled), save);
hbox = gtk_hbox_new (FALSE, 5);
gtk_widget_show (hbox);
gtk_box_pack_start (GTK_BOX (main_vbox),
hbox, TRUE, TRUE, 0);
save->priv->hbox_prefix = hbox;
label = gtk_label_new (_("Filename prefix: "));
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
save->priv->prefix_entry = gtk_entry_new ();
gtk_widget_show (save->priv->prefix_entry);
gtk_box_pack_start (GTK_BOX (hbox), save->priv->prefix_entry,
TRUE, TRUE, 0);
label = gtk_label_new (_("Start numbering with: "));
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
a = gtk_adjustment_new (1.0, 1.0, 10000.0, 1.0, 10.0, 10.0);
save->priv->spin_entry = gtk_spin_button_new (GTK_ADJUSTMENT (a),
1.0, 0);
gtk_widget_show (save->priv->spin_entry);
gtk_box_pack_start (GTK_BOX (hbox), save->priv->spin_entry,
FALSE, FALSE, 0);
load_save_settings(save);
/* Remember the main window (if given) */
save->priv->main_window = main_window ? main_window : GTK_WINDOW (save);
return (GTK_WIDGET (save));
}
void
ags_machine_open_extended_response_callback(GtkWidget *widget, gint response, AgsMachine *machine)
{
GtkFileChooserDialog *file_chooser;
AgsFileSelection *file_selection;
GtkCheckButton *overwrite;
GtkCheckButton *create;
GSList *filenames;
gchar *current_folder;
GError *error;
file_chooser = (GtkFileChooserDialog *) gtk_widget_get_toplevel(widget);
if(response == GTK_RESPONSE_ACCEPT){
filenames = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(file_chooser));
overwrite = g_object_get_data((GObject *) widget, "overwrite");
create = g_object_get_data((GObject *) widget, "create");
current_folder = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(file_chooser));
//TODO:JK: you need to check against recently used
//TODO:JK: add more file types to AgsFileSelection
/* check for supported packed audio files */
file_selection = (AgsFileSelection *) gtk_file_chooser_get_extra_widget(GTK_FILE_CHOOSER(file_chooser));
if(file_selection != NULL && g_strcmp0(file_selection->directory, current_folder)){
gtk_widget_destroy(GTK_WIDGET(file_selection));
file_selection = NULL;
}
if(file_selection == NULL ||
(AGS_FILE_SELECTION_COMPLETED & (file_selection->flags)) == 0){
if((AGS_MACHINE_ACCEPT_SOUNDFONT2 & (machine->file_input_flags)) != 0){
GDir *current_directory;
GList *new_entry, *old_entry;
GSList *slist;
gchar *current_filename;
slist = filenames;
new_entry = NULL;
while(slist != NULL){
if(g_str_has_suffix(slist->data,
".sf2")){
AgsFileSelectionEntry *entry;
entry = ags_file_selection_entry_alloc();
entry->filename = slist->data;
new_entry = g_list_prepend(new_entry,
entry);
}
slist = slist->next;
}
old_entry = NULL;
if(file_selection == NULL){
if(new_entry != NULL){
file_selection = ags_file_selection_new();
gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(file_chooser),
GTK_WIDGET(file_selection));
ags_file_selection_set_entry(file_selection,
new_entry);
ags_connectable_connect(AGS_CONNECTABLE(file_selection));
gtk_widget_show_all(GTK_WIDGET(file_selection));
return;
}
}else if(AGS_IS_FILE_SELECTION(file_selection)){
GList *really_new_entry;
GList *list;
old_entry = file_selection->entry;
list = new_entry;
really_new_entry = NULL;
/* check against existing entries */
if(new_entry != NULL){
while(list != NULL){
if(g_list_find(old_entry, list->data) == NULL){
really_new_entry = g_list_prepend(really_new_entry,
list->data);
}else{
free(list->data);
}
list = list->next;
}
g_list_free(new_entry);
}
ags_file_selection_set_entry(file_selection,
really_new_entry);
/* adding lost files */
//TODO:JK: figure out if you need to copy the GSList of filenames
gtk_file_chooser_select_all(GTK_FILE_CHOOSER(file_chooser));
current_directory = g_dir_open(current_folder,
0,
&error);
while((current_filename = (gchar *) g_dir_read_name(current_directory)) != NULL){
if(!g_strcmp0(".", current_filename) ||
!g_strcmp0("..", current_filename))
continue;
if(!ags_file_selection_contains_file(file_selection,
current_filename) &&
g_slist_find(filenames, current_filename) == NULL){
gtk_file_chooser_unselect_filename(GTK_FILE_CHOOSER(file_chooser),
current_filename);
}
}
g_dir_close(current_directory);
return;
}
}
}
//TODO:JK: fix GSList filenames memory leak
ags_machine_open_files(machine,
filenames,
overwrite->toggle_button.active,
create->toggle_button.active);
}
}
/*******************************************************
* Create the Assistant
*******************************************************/
static GtkWidget *
csv_import_assistant_create (CsvImportInfo *info)
{
GtkBuilder *builder;
GtkWidget *window;
GtkWidget *box, *h_box;
GtkWidget *button;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
builder = gtk_builder_new();
gnc_builder_add_from_file (builder , "assistant-csv-account-import.glade", "num_hrows_adj");
gnc_builder_add_from_file (builder , "assistant-csv-account-import.glade", "CSV Account Import Assistant");
window = GTK_WIDGET(gtk_builder_get_object (builder, "CSV Account Import Assistant"));
info->window = window;
/* Set the assistant colors */
gnc_assistant_set_colors (GTK_ASSISTANT (info->window));
/* Load default settings */
load_settings (info);
/* Enable buttons on all page. */
gtk_assistant_set_page_complete (GTK_ASSISTANT (window),
GTK_WIDGET(gtk_builder_get_object(builder, "start_page")),
TRUE);
gtk_assistant_set_page_complete (GTK_ASSISTANT (window),
GTK_WIDGET(gtk_builder_get_object(builder, "file_page")),
FALSE);
gtk_assistant_set_page_complete (GTK_ASSISTANT (window),
GTK_WIDGET(gtk_builder_get_object(builder, "import_tree_page")),
TRUE);
gtk_assistant_set_page_complete (GTK_ASSISTANT (window),
GTK_WIDGET(gtk_builder_get_object(builder, "end_page")),
FALSE);
gtk_assistant_set_page_complete (GTK_ASSISTANT (window),
GTK_WIDGET(gtk_builder_get_object(builder, "summary_page")),
TRUE);
/* Start Page */
/* File chooser Page */
info->file_chooser = gtk_file_chooser_widget_new (GTK_FILE_CHOOSER_ACTION_OPEN);
g_signal_connect (G_OBJECT (info->file_chooser), "file-activated",
G_CALLBACK (csv_import_file_chooser_confirm_cb), info);
button = gtk_button_new_from_stock(GTK_STOCK_OK);
gtk_widget_set_size_request (button, 100, -1);
gtk_widget_show (button);
h_box = gtk_hbox_new(TRUE, 0);
gtk_box_pack_start(GTK_BOX(h_box), button, FALSE, FALSE, 0);
gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER(info->file_chooser), h_box);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (csv_import_file_chooser_confirm_cb), info);
box = GTK_WIDGET(gtk_builder_get_object(builder, "file_page"));
gtk_box_pack_start (GTK_BOX (box), info->file_chooser, TRUE, TRUE, 6);
gtk_widget_show (info->file_chooser);
/* Account Tree Page */
info->header_row_spin = GTK_WIDGET(gtk_builder_get_object (builder, "num_hrows"));
info->tree_view = GTK_WIDGET(gtk_builder_get_object (builder, "treeview"));
info->regexp = g_string_new ( "^(?<type>[^;]*);(?<full_name>[^;]*);(?<name>[^;]*);(?<code>[^;]*);?(?<description>[^;]*);?(?<color>[^;]*);?(?<notes>[^;]*);?(?<commoditym>[^;]*);?(?<commodityn>[^;]*);?(?<hidden>[^;]*);?(?<tax>[^;]*);?(?<place_holder>[^;]*)$");
/* create model and bind to view */
info->store = gtk_list_store_new (N_COLUMNS,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
gtk_tree_view_set_model( GTK_TREE_VIEW(info->tree_view), GTK_TREE_MODEL(info->store) );
#define CREATE_COLUMN(description,column_id) \
renderer = gtk_cell_renderer_text_new (); \
column = gtk_tree_view_column_new_with_attributes (mnemonic_escape(_(description)), renderer, "text", column_id, NULL); \
gtk_tree_view_column_add_attribute(column, renderer, "background", ROW_COLOR); \
gtk_tree_view_column_set_resizable (column, TRUE); \
gtk_tree_view_append_column (GTK_TREE_VIEW (info->tree_view), column);
CREATE_COLUMN ("type", TYPE);
CREATE_COLUMN ("full_name", FULL_NAME);
CREATE_COLUMN ("name", NAME);
CREATE_COLUMN ("code", CODE);
CREATE_COLUMN ("description", DESCRIPTION);
CREATE_COLUMN ("color", COLOR);
CREATE_COLUMN ("notes", NOTES);
CREATE_COLUMN ("commoditym", COMMODITYM);
CREATE_COLUMN ("commodityn", COMMODITYN);
CREATE_COLUMN ("hidden", HIDDEN);
CREATE_COLUMN ("tax", TAX);
CREATE_COLUMN ("place_holder", PLACE_HOLDER);
/* Finish Page */
info->finish_label = GTK_WIDGET(gtk_builder_get_object(builder, "end_page"));
/* Summary Page */
info->summary_label = GTK_WIDGET(gtk_builder_get_object(builder, "summary_label"));
info->summary_error_view = GTK_WIDGET(gtk_builder_get_object(builder, "summary_error_view"));
g_signal_connect (G_OBJECT(window), "destroy",
G_CALLBACK (csv_import_assistant_destroy_cb), info);
gnc_restore_window_size (GCONF_SECTION, GTK_WINDOW(info->window));
gtk_builder_connect_signals(builder, info);
g_object_unref(G_OBJECT(builder));
return window;
}
static void _lib_geotagging_gpx_callback(GtkWidget *widget, dt_lib_module_t *self)
{
dt_lib_geotagging_t *d = (dt_lib_geotagging_t *)self->data;
/* bring a filechooser to select the gpx file to apply to selection */
GtkWidget *win = dt_ui_main_window(darktable.gui->ui);
GtkWidget *filechooser = gtk_file_chooser_dialog_new(
_("open GPX file"), GTK_WINDOW(win), GTK_FILE_CHOOSER_ACTION_OPEN, _("_cancel"), GTK_RESPONSE_CANCEL,
_("_open"), GTK_RESPONSE_ACCEPT, (char *)NULL);
char *last_directory = dt_conf_get_string("ui_last/gpx_last_directory");
if(last_directory != NULL)
{
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(filechooser), last_directory);
g_free(last_directory);
}
GtkFileFilter *filter;
filter = GTK_FILE_FILTER(gtk_file_filter_new());
gtk_file_filter_add_custom(filter, GTK_FILE_FILTER_FILENAME | GTK_FILE_FILTER_MIME_TYPE,
_lib_geotagging_filter_gpx, NULL, NULL);
gtk_file_filter_set_name(filter, _("GPS data exchange format"));
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filechooser), filter);
filter = GTK_FILE_FILTER(gtk_file_filter_new());
gtk_file_filter_add_pattern(filter, "*");
gtk_file_filter_set_name(filter, _("all files"));
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filechooser), filter);
// add time zone selection
GtkWidget *extra_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
GtkWidget *label = gtk_label_new(_("camera time zone"));
gtk_widget_set_tooltip_text(label, _("most cameras don't store the time zone in EXIF. "
"give the correct time zone so the GPX data can be correctly matched"));
GtkWidget *tz_selection = gtk_combo_box_text_new();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(tz_selection), "UTC");
gtk_combo_box_set_active(GTK_COMBO_BOX(tz_selection), 0);
GList *iter = d->timezones;
int i = 0;
gchar *old_tz = dt_conf_get_string("plugins/lighttable/geotagging/tz");
if(iter)
{
do
{
i++;
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(tz_selection), (gchar *)iter->data);
if(!strcmp((gchar *)iter->data, old_tz)) gtk_combo_box_set_active(GTK_COMBO_BOX(tz_selection), i);
} while((iter = g_list_next(iter)) != NULL);
}
g_free(old_tz);
gtk_box_pack_start(GTK_BOX(extra_box), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(extra_box), tz_selection, FALSE, FALSE, 0);
gtk_widget_show_all(extra_box);
gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(filechooser), extra_box);
if(gtk_dialog_run(GTK_DIALOG(filechooser)) == GTK_RESPONSE_ACCEPT)
{
gchar *folder = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(filechooser));
dt_conf_set_string("ui_last/gpx_last_directory", folder);
g_free(folder);
gchar *tz = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(tz_selection));
dt_conf_set_string("plugins/lighttable/geotagging/tz", tz);
gchar *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(filechooser));
dt_control_gpx_apply(filename, -1, tz);
g_free(filename);
g_free(tz);
}
gtk_widget_destroy(extra_box);
gtk_widget_destroy(filechooser);
// dt_control_queue_redraw_center();
}
static void
gwy_app_file_chooser_add_type_list(GwyAppFileChooser *chooser)
{
GtkWidget *vbox, *scwin;
GtkTreeView *treeview;
GtkFileChooserAction action;
GtkRequisition req;
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkListStore *store;
GtkTreeIter iter;
gboolean expanded = FALSE;
gboolean filter = FALSE;
gchar *key;
g_object_get(chooser, "action", &action, NULL);
key = g_strconcat(chooser->prefix, "/type", NULL);
chooser->type_key = g_quark_from_string(key);
g_free(key);
store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING);
gtk_list_store_append(store, &iter);
switch (action) {
case GTK_FILE_CHOOSER_ACTION_SAVE:
gtk_list_store_set(store, &iter,
COLUMN_FILETYPE, "",
COLUMN_LABEL, _("Automatic by extension"),
-1);
gwy_app_file_chooser_add_types(store, GWY_FILE_OPERATION_SAVE);
gwy_app_file_chooser_add_types(store, GWY_FILE_OPERATION_EXPORT);
break;
case GTK_FILE_CHOOSER_ACTION_OPEN:
gtk_list_store_set(store, &iter,
COLUMN_FILETYPE, "",
COLUMN_LABEL, _("Automatically detected"),
-1);
gwy_app_file_chooser_add_types(store, GWY_FILE_OPERATION_LOAD);
break;
default:
g_assert_not_reached();
break;
}
chooser->expander = gtk_expander_new(NULL);
gtk_expander_set_use_underline(GTK_EXPANDER(chooser->expander), TRUE);
gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(chooser),
chooser->expander);
key = g_strconcat(chooser->prefix, "/expanded", NULL);
gwy_container_gis_boolean_by_name(gwy_app_settings_get(), key, &expanded);
g_free(key);
gtk_expander_set_expanded(GTK_EXPANDER(chooser->expander), expanded);
g_signal_connect_swapped(chooser->expander, "notify::expanded",
G_CALLBACK(gwy_app_file_chooser_expanded),
chooser);
vbox = gtk_vbox_new(FALSE, 4);
gtk_container_add(GTK_CONTAINER(chooser->expander), vbox);
scwin = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scwin),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX(vbox), scwin, TRUE, TRUE, 0);
chooser->type_list = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
treeview = GTK_TREE_VIEW(chooser->type_list);
g_object_unref(store);
gtk_tree_view_set_headers_visible(treeview, FALSE);
gtk_container_add(GTK_CONTAINER(scwin), chooser->type_list);
column = gtk_tree_view_column_new();
gtk_tree_view_append_column(treeview, column);
renderer = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(column), renderer, TRUE);
gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(column), renderer,
"text", COLUMN_LABEL);
selection = gtk_tree_view_get_selection(treeview);
gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
g_signal_connect_swapped(selection, "changed",
G_CALLBACK(gwy_app_file_chooser_type_changed),
chooser);
if (action == GTK_FILE_CHOOSER_ACTION_OPEN) {
chooser->filter_enable
= gtk_check_button_new_with_mnemonic(_("Show only loadable "
"files of selected type"));
key = g_strconcat(chooser->prefix, "/filter", NULL);
gwy_container_gis_boolean_by_name(gwy_app_settings_get(), key, &filter);
g_free(key);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(chooser->filter_enable),
filter);
gtk_box_pack_start(GTK_BOX(vbox), chooser->filter_enable,
FALSE, FALSE, 0);
g_signal_connect_swapped(chooser->filter_enable, "toggled",
G_CALLBACK(gwy_app_file_chooser_filter_toggled),
chooser);
gwy_app_file_chooser_filter_toggled(chooser,
GTK_TOGGLE_BUTTON(chooser->filter_enable));
}
/* Give it some reasonable size. FIXME: hack. */
gtk_widget_show_all(vbox);
gtk_widget_size_request(scwin, &req);
gtk_widget_set_size_request(scwin, -1, 3*req.height + 20);
gwy_app_file_chooser_select_type(chooser);
gwy_app_file_chooser_type_changed(chooser, selection);
}
