/**
* 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;
}
static void
brasero_file_chooser_init (BraseroFileChooser *obj)
{
GtkFileFilter *filter;
obj->priv = g_new0 (BraseroFileChooserPrivate, 1);
obj->priv->chooser = gtk_file_chooser_widget_new (GTK_FILE_CHOOSER_ACTION_OPEN);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (obj->priv->chooser), FALSE);
gtk_widget_show (obj->priv->chooser);
gtk_container_add (GTK_CONTAINER (obj), obj->priv->chooser);
g_signal_connect (obj->priv->chooser,
"file-activated",
G_CALLBACK (brasero_file_chooser_uri_activated_cb),
obj);
g_signal_connect (obj->priv->chooser,
"selection-changed",
G_CALLBACK (brasero_file_chooser_uri_selection_changed_cb),
obj);
gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (obj->priv->chooser), TRUE);
filter = gtk_file_filter_new ();
gtk_file_filter_set_name (filter, _("All files"));
gtk_file_filter_add_pattern (filter, "*");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (obj->priv->chooser), filter);
obj->priv->filter_any = filter;
filter = gtk_file_filter_new ();
gtk_file_filter_set_name (filter, _("Audio files"));
gtk_file_filter_add_mime_type (filter, "audio/*");
gtk_file_filter_add_mime_type (filter, "application/ogg");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (obj->priv->chooser), filter);
obj->priv->filter_audio = filter;
filter = gtk_file_filter_new ();
gtk_file_filter_set_name (filter, _("Movies"));
gtk_file_filter_add_mime_type (filter, "video/*");
gtk_file_filter_add_mime_type (filter, "application/ogg");
gtk_file_filter_add_mime_type (filter, "application/x-flash-video");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (obj->priv->chooser), filter);
obj->priv->filter_video = filter;
filter = gtk_file_filter_new ();
/* Translators: this is an image, a picture, not a "Disc Image" */
gtk_file_filter_set_name (filter, C_("picture", "Image files"));
gtk_file_filter_add_mime_type (filter, "image/*");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (obj->priv->chooser), filter);
/* this is a hack/workaround to add support for multi DND */
gtk_container_foreach (GTK_CONTAINER (obj->priv->chooser),
brasero_file_chooser_customize,
NULL);
}
GtkWidget*
vice_file_entry(const char *title, const char *default_dir,
const char *pat, GtkFileChooserAction action)
{
GtkWidget *fb;
GtkFileFilter *ff = NULL, *allf;
fb = gtk_file_chooser_widget_new(action);
if (default_dir)
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(fb), default_dir);
if (pat)
{
ff = gtk_file_filter_new();
gtk_file_filter_add_pattern(ff, pat);
gtk_file_filter_set_name(ff, pat);
}
allf = gtk_file_filter_new();
gtk_file_filter_add_pattern(allf, "*");
gtk_file_filter_set_name(allf, _("all files"));
if (ff)
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fb), ff);
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fb), allf);
gtk_widget_show(fb);
return fb;
}
static void
test_file_chooser_widget_basic (void)
{
GtkWidget *widget;
/* This test also tests the internal GtkPathBar widget */
g_test_log_set_fatal_handler (ignore_gvfs_warning, NULL);
widget = gtk_file_chooser_widget_new (GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
g_assert (GTK_IS_FILE_CHOOSER_WIDGET (widget));
/* XXX BUG:
*
* Spin the mainloop for a bit, this allows the file operations
* to complete, GtkFileChooserDefault has a bug where it leaks
* GtkTreeRowReferences to the internal shortcuts_model
*
* Since we assert all automated children are finalized we
* can catch this
*/
g_timeout_add (100, main_loop_quit_cb, NULL);
gtk_main();
gtk_widget_destroy (widget);
}
int
clip_GTK_FILECHOOSERWIDGETNEW(ClipMachine * ClipMachineMemory)
{
ClipVar *cv = _clip_spar(ClipMachineMemory, 1);
GtkFileChooserAction action = _clip_parni(ClipMachineMemory, 2);
GtkWidget *wid;
C_widget *cwid;
CHECKOPT2(1, NUMERIC_type_of_ClipVarType, MAP_type_of_ClipVarType);
CHECKARG(2, NUMERIC_type_of_ClipVarType);
wid = gtk_file_chooser_widget_new(action);
if (wid)
{
cwid = _list_get_cwidget(ClipMachineMemory, wid);
if (!cwid)
cwid = _register_widget(ClipMachineMemory, wid, cv);
if (cwid)
_clip_mclone(ClipMachineMemory, RETPTR(ClipMachineMemory), &cwid->obj);
}
return 0;
err:
return 1;
}
void DialogManagerX11::_showFolderDialog(FB::PluginWindow* win, bool multi, const PathCallback& cb)
{
FB::VariantList out;
// Create the dialog. Do it the hard way so we can override the default
// behavior which does not allow files and directories to be selected together.
GtkWidget *dialog = gtk_dialog_new_with_buttons("Open", NULL, GTK_DIALOG_MODAL,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
GtkWidget *action_area = gtk_dialog_get_action_area(GTK_DIALOG(dialog));
GtkWidget *content_area = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
// Some nicer formatting
gtk_box_set_spacing(GTK_BOX(content_area), 2);
gtk_container_set_border_width(GTK_CONTAINER(dialog), 5);
gtk_container_set_border_width(GTK_CONTAINER(action_area), 5);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
// Create the file chooser widget
GtkWidget *chooser = gtk_file_chooser_widget_new(GTK_FILE_CHOOSER_ACTION_OPEN);
if (multi)
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(chooser), TRUE);
// And add it to the dialog
gtk_container_add(GTK_CONTAINER(content_area), chooser);
gtk_widget_show(chooser);
// for the life of me I can't figure out how to get the filechooserwidget
// to return an actual requested size. Going with the simple hard coded
// size until that can be figured out.
gtk_window_resize(GTK_WINDOW(dialog), 600, 400);
// run the dialog
gint result = gtk_dialog_run(GTK_DIALOG(dialog));
if (result == GTK_RESPONSE_ACCEPT) {
char *buffer;
std::string filename;
GSList *filenames, *iterator;
filenames = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(chooser));
iterator = filenames;
while (iterator) {
buffer = (char *)g_slist_nth_data(iterator, 0);
filename = std::string(buffer);
g_free(buffer);
// append a trailing slash if the name is a directory
if (fs::is_directory(filename))
filename.push_back('/');
out.push_back(filename);
iterator = g_slist_next(iterator);
}
g_slist_free(filenames);
}
gtk_widget_destroy(dialog);
// call the callback with the results
cb(out);
}
/*
* display the file open dialog
*/
void gtkui_plugin_load(GSimpleAction *action, GVariant *value, gpointer data)
{
GtkWidget *dialog, *chooser, *content;
gchar *filename;
int response = 0;
#ifdef OS_WINDOWS
char *path = get_full_path("/lib/", "");
#else
char *path = INSTALL_LIBDIR "/" PROGRAM "/";
#endif
(void) action;
(void) value;
(void) data;
DEBUG_MSG("gtk_plugin_load");
dialog = gtk_dialog_new_with_buttons("Select a plugin...",
GTK_WINDOW(window),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_USE_HEADER_BAR,
"_Cancel", GTK_RESPONSE_CANCEL,
"_OK", GTK_RESPONSE_OK,
NULL);
gtk_container_set_border_width(GTK_CONTAINER(dialog), 10);
content = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
chooser = gtk_file_chooser_widget_new(GTK_FILE_CHOOSER_ACTION_OPEN);
gtk_container_add(GTK_CONTAINER(content), chooser);
gtk_widget_show(chooser);
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(chooser), path);
#ifdef OS_WINDOWS
SAFE_FREE(path);
#endif
response = gtk_dialog_run (GTK_DIALOG (dialog));
if (response == GTK_RESPONSE_OK) {
gtk_widget_hide(dialog);
filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(chooser));
gtkui_load_plugin(filename);
/* update the list */
gtkui_create_plug_array();
g_free(filename);
}
gtk_widget_destroy (dialog);
}
/* See VikDataSourceInterface */
static void datasource_geotag_add_setup_widgets ( GtkWidget *dialog, VikViewport *vvp, gpointer user_data )
{
datasource_geotag_user_data_t *userdata = (datasource_geotag_user_data_t *)user_data;
/* The files selector */
userdata->files = gtk_file_chooser_widget_new ( GTK_FILE_CHOOSER_ACTION_OPEN );
// try to make it a nice size - otherwise seems to default to something impractically small
gtk_window_set_default_size ( GTK_WINDOW (dialog) , 600, 300 );
if ( last_folder_uri )
gtk_file_chooser_set_current_folder_uri ( GTK_FILE_CHOOSER(userdata->files), last_folder_uri );
GtkFileChooser *chooser = GTK_FILE_CHOOSER ( userdata->files );
/* Add filters */
GtkFileFilter *filter;
filter = gtk_file_filter_new ();
gtk_file_filter_set_name ( filter, _("All") );
gtk_file_filter_add_pattern ( filter, "*" );
gtk_file_chooser_add_filter ( chooser, filter );
filter = gtk_file_filter_new ();
gtk_file_filter_set_name ( filter, _("JPG") );
gtk_file_filter_add_mime_type ( filter, "image/jpeg");
gtk_file_chooser_add_filter ( chooser, filter );
// Default to jpgs
gtk_file_chooser_set_filter ( chooser, filter );
// Allow selecting more than one
gtk_file_chooser_set_select_multiple ( chooser, TRUE );
// Could add code to setup a default symbol (see dialog.c for symbol usage)
// Store in user_data type and then apply when creating the waypoints
// However not much point since these will have images associated with them!
/* Packing all widgets */
GtkBox *box = GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog)));
gtk_box_pack_start ( box, userdata->files, TRUE, TRUE, 0 );
gtk_widget_show_all ( dialog );
}
static void datasource_geojson_add_setup_widgets ( GtkWidget *dialog, VikViewport *vvp, gpointer user_data )
{
datasource_geojson_user_data_t *ud = (datasource_geojson_user_data_t *)user_data;
ud->files = gtk_file_chooser_widget_new ( GTK_FILE_CHOOSER_ACTION_OPEN );
// try to make it a nice size - otherwise seems to default to something impractically small
gtk_window_set_default_size ( GTK_WINDOW (dialog) , 600, 300 );
if ( last_folder_uri )
gtk_file_chooser_set_current_folder_uri ( GTK_FILE_CHOOSER(ud->files), last_folder_uri );
GtkFileChooser *chooser = GTK_FILE_CHOOSER ( ud->files );
// Add filters
GtkFileFilter *filter;
filter = gtk_file_filter_new ();
gtk_file_filter_set_name ( filter, _("All") );
gtk_file_filter_add_pattern ( filter, "*" );
gtk_file_chooser_add_filter ( chooser, filter );
filter = gtk_file_filter_new ();
gtk_file_filter_set_name ( filter, _("GeoJSON") );
gtk_file_filter_add_pattern ( filter, "*.geojson" );
gtk_file_chooser_add_filter ( chooser, filter );
// Default to geojson
gtk_file_chooser_set_filter ( chooser, filter );
// Allow selecting more than one
gtk_file_chooser_set_select_multiple ( chooser, TRUE );
// Packing all widgets
GtkBox *box = GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog)));
gtk_box_pack_start ( box, ud->files, TRUE, TRUE, 0 );
gtk_widget_show_all ( dialog );
}
static void
run_filebrowser_gtk2style(gboolean play_button, gboolean show)
{
static GtkWidget *window = NULL;
GtkWidget *vbox, *hbox, *bbox;
GtkWidget *chooser;
GtkWidget *action_button, *close_button;
GtkWidget *toggle;
gchar *window_title, *toggle_text;
gpointer action_stock, storage;
if (!show) {
if (window){
gtk_widget_hide(window);
return;
}
else
return;
}
else {
if (window) {
gtk_window_present(GTK_WINDOW(window)); /* raise filebrowser */
return;
}
}
window_title = play_button ? _("Open Files") : _("Add Files");
toggle_text = play_button ?
_("Close dialog on Open") : _("Close dialog on Add");
action_stock = play_button ? GTK_STOCK_OPEN : GTK_STOCK_ADD;
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_type_hint (GTK_WINDOW (window), GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_window_set_title(GTK_WINDOW(window), window_title);
gtk_window_set_default_size(GTK_WINDOW(window), 700, 450);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_container_set_border_width(GTK_CONTAINER(window), 10);
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), vbox);
chooser = gtk_file_chooser_widget_new(GTK_FILE_CHOOSER_ACTION_OPEN);
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(chooser), TRUE);
gchar * path = aud_get_string ("audgui", "filesel_path");
if (path[0])
gtk_file_chooser_set_current_folder ((GtkFileChooser *) chooser, path);
g_free (path);
gtk_box_pack_start(GTK_BOX(vbox), chooser, TRUE, TRUE, 3);
hbox = gtk_hbox_new(TRUE, 0);
gtk_box_pack_end(GTK_BOX(vbox), hbox, FALSE, FALSE, 3);
toggle = gtk_check_button_new_with_label(toggle_text);
gtk_toggle_button_set_active ((GtkToggleButton *) toggle, aud_get_bool
("audgui", "close_dialog_open"));
gtk_box_pack_start(GTK_BOX(hbox), toggle, TRUE, TRUE, 3);
bbox = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing(GTK_BOX(bbox), 6);
gtk_box_pack_end(GTK_BOX(hbox), bbox, TRUE, TRUE, 3);
close_button = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
action_button = gtk_button_new_from_stock(action_stock);
gtk_container_add(GTK_CONTAINER(bbox), close_button);
gtk_container_add(GTK_CONTAINER(bbox), action_button);
gtk_widget_set_can_default (action_button, TRUE);
gtk_widget_grab_default (action_button);
/* this storage object holds several other objects which are used in the
* callback functions
*/
storage = g_object_new(G_TYPE_OBJECT, NULL);
g_object_set_data(storage, "window", window);
g_object_set_data(storage, "chooser", chooser);
g_object_set_data(storage, "toggle-button", toggle);
g_object_set_data(storage, "play-button", GINT_TO_POINTER(play_button));
g_signal_connect(chooser, "file-activated",
G_CALLBACK(action_button_cb), storage);
g_signal_connect(action_button, "clicked",
G_CALLBACK(action_button_cb), storage);
g_signal_connect(close_button, "clicked",
G_CALLBACK(close_button_cb), window);
g_signal_connect(window, "destroy",
G_CALLBACK(gtk_widget_destroyed), &window);
audgui_destroy_on_escape (window);
gtk_widget_show_all (window);
}
void
pragha_application_open_files (PraghaApplication *pragha)
{
PraghaPreferences *preferences;
GtkWidget *window, *hbox, *vbox, *chooser, *bbox, *toggle, *close_button, *add_button;
gpointer storage;
gint i = 0;
GtkFileFilter *media_filter, *playlist_filter, *all_filter;
const gchar *last_folder = NULL;
/* Create a file chooser dialog */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_type_hint (GTK_WINDOW (window), GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_window_set_title(GTK_WINDOW(window), (_("Select a file to play")));
gtk_window_set_default_size(GTK_WINDOW(window), 700, 450);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_widget_set_name (GTK_WIDGET(window), "GtkFileChooserDialog");
gtk_container_set_border_width(GTK_CONTAINER(window), 0);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_set_name (GTK_WIDGET(vbox), "dialog-vbox1");
gtk_container_add(GTK_CONTAINER(window), vbox);
chooser = gtk_file_chooser_widget_new(GTK_FILE_CHOOSER_ACTION_OPEN);
/* Set various properties */
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(chooser), TRUE);
preferences = pragha_application_get_preferences (pragha);
last_folder = pragha_preferences_get_last_folder (preferences);
if (string_is_not_empty(last_folder))
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(chooser), last_folder);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_set_border_width(GTK_CONTAINER(hbox), 6);
toggle = gtk_check_button_new_with_label(_("Add files recursively"));
if(pragha_preferences_get_add_recursively (preferences))
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle), TRUE);
bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing(GTK_BOX(bbox), 4);
close_button = gtk_button_new_with_mnemonic (_("_Cancel"));
add_button = gtk_button_new_with_mnemonic (_("_Add"));
gtk_container_add(GTK_CONTAINER(bbox), close_button);
gtk_container_add(GTK_CONTAINER(bbox), add_button);
gtk_box_pack_start(GTK_BOX(hbox), toggle, TRUE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(hbox), bbox, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(vbox), chooser, TRUE, TRUE, 0);
/* Create file filters */
media_filter = gtk_file_filter_new();
gtk_file_filter_set_name(GTK_FILE_FILTER(media_filter), _("Supported media"));
while (mime_wav[i])
gtk_file_filter_add_mime_type(GTK_FILE_FILTER(media_filter),
mime_wav[i++]);
i = 0;
while (mime_mpeg[i])
gtk_file_filter_add_mime_type(GTK_FILE_FILTER(media_filter),
mime_mpeg[i++]);
i = 0;
while (mime_flac[i])
gtk_file_filter_add_mime_type(GTK_FILE_FILTER(media_filter),
mime_flac[i++]);
i = 0;
while (mime_ogg[i])
gtk_file_filter_add_mime_type(GTK_FILE_FILTER(media_filter),
mime_ogg[i++]);
i = 0;
while (mime_asf[i])
gtk_file_filter_add_mime_type(GTK_FILE_FILTER(media_filter),
mime_asf[i++]);
i = 0;
while (mime_mp4[i])
gtk_file_filter_add_mime_type(GTK_FILE_FILTER(media_filter),
mime_mp4[i++]);
i = 0;
while (mime_ape[i])
gtk_file_filter_add_mime_type(GTK_FILE_FILTER(media_filter),
mime_ape[i++]);
i = 0;
while (mime_tracker[i])
gtk_file_filter_add_mime_type(GTK_FILE_FILTER(media_filter),
mime_tracker[i++]);
#ifdef HAVE_PLPARSER
i = 0;
while (mime_playlist[i])
gtk_file_filter_add_mime_type(GTK_FILE_FILTER(media_filter),
mime_playlist[i++]);
i = 0;
while (mime_dual[i])
gtk_file_filter_add_mime_type(GTK_FILE_FILTER(media_filter),
mime_dual[i++]);
#else
gtk_file_filter_add_pattern(GTK_FILE_FILTER(media_filter), "*.m3u");
gtk_file_filter_add_pattern(GTK_FILE_FILTER(media_filter), "*.M3U");
gtk_file_filter_add_pattern(GTK_FILE_FILTER(media_filter), "*.pls");
gtk_file_filter_add_pattern(GTK_FILE_FILTER(media_filter), "*.PLS");
gtk_file_filter_add_pattern(GTK_FILE_FILTER(media_filter), "*.xspf");
gtk_file_filter_add_pattern(GTK_FILE_FILTER(media_filter), "*.XSPF");
gtk_file_filter_add_pattern(GTK_FILE_FILTER(media_filter), "*.wax");
gtk_file_filter_add_pattern(GTK_FILE_FILTER(media_filter), "*.WAX");
#endif
playlist_filter = gtk_file_filter_new();
#ifdef HAVE_PLPARSER
i = 0;
while (mime_playlist[i])
gtk_file_filter_add_mime_type(GTK_FILE_FILTER(playlist_filter),
mime_playlist[i++]);
i = 0;
while (mime_dual[i])
gtk_file_filter_add_mime_type(GTK_FILE_FILTER(playlist_filter),
mime_dual[i++]);
#else
gtk_file_filter_add_pattern(GTK_FILE_FILTER(playlist_filter), "*.m3u");
gtk_file_filter_add_pattern(GTK_FILE_FILTER(playlist_filter), "*.M3U");
gtk_file_filter_add_pattern(GTK_FILE_FILTER(playlist_filter), "*.pls");
gtk_file_filter_add_pattern(GTK_FILE_FILTER(playlist_filter), "*.PLS");
gtk_file_filter_add_pattern(GTK_FILE_FILTER(playlist_filter), "*.xspf");
gtk_file_filter_add_pattern(GTK_FILE_FILTER(playlist_filter), "*.XSPF");
gtk_file_filter_add_pattern(GTK_FILE_FILTER(playlist_filter), "*.wax");
gtk_file_filter_add_pattern(GTK_FILE_FILTER(playlist_filter), "*.WAX");
#endif
gtk_file_filter_set_name(GTK_FILE_FILTER(playlist_filter), _("Playlists"));
all_filter = gtk_file_filter_new ();
gtk_file_filter_set_name (GTK_FILE_FILTER(all_filter), _("All files"));
gtk_file_filter_add_pattern (GTK_FILE_FILTER(all_filter), "*");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(chooser),
GTK_FILE_FILTER(media_filter));
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(chooser),
GTK_FILE_FILTER(playlist_filter));
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(chooser),
GTK_FILE_FILTER(all_filter));
gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(chooser),
GTK_FILE_FILTER(media_filter));
storage = g_object_new(G_TYPE_OBJECT, NULL);
g_object_set_data(storage, "window", window);
g_object_set_data(storage, "chooser", chooser);
g_object_set_data(storage, "toggle-button", toggle);
g_object_set_data(storage, "pragha", pragha);
g_signal_connect (add_button, "clicked",
G_CALLBACK(pragha_open_files_dialog_add_button_cb), storage);
g_signal_connect (chooser, "file-activated",
G_CALLBACK(pragha_open_files_dialog_add_button_cb), storage);
g_signal_connect (close_button, "clicked",
G_CALLBACK(pragha_open_files_dialog_close_button_cb), window);
g_signal_connect (window, "destroy",
G_CALLBACK(gtk_widget_destroy), window);
g_signal_connect (window, "key-press-event",
G_CALLBACK(pragha_open_files_dialog_keypress), NULL);
gtk_window_set_transient_for(GTK_WINDOW (window), GTK_WINDOW(pragha_application_get_window(pragha)));
gtk_window_set_destroy_with_parent (GTK_WINDOW (window), TRUE);
gtk_widget_show_all(window);
}
/*******************************************************
* 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;
}
/*******************************************************
* 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;
gchar *mnemonic_desc = NULL;
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 style context for this dialog so it can be easily manipulated with css
gnc_widget_set_style_context (GTK_WIDGET(window), "GncAssistAccountImport");
/* 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_with_mnemonic (_("_OK"));
gtk_widget_set_size_request (button, 100, -1);
gtk_widget_show (button);
h_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_set_homogeneous (GTK_BOX (h_box), TRUE);
gtk_widget_set_hexpand (GTK_WIDGET(h_box), TRUE);
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"));
/* Comma Separated file default */
info->regexp = g_string_new ("");
create_regex (info->regexp, ",");
/* 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 (); \
mnemonic_desc = mnemonic_escape (_(description)); \
column = gtk_tree_view_column_new_with_attributes (mnemonic_desc, 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); \
g_free (mnemonic_desc);
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 (GNC_PREFS_GROUP, GTK_WINDOW(info->window));
gtk_builder_connect_signals (builder, info);
g_object_unref (G_OBJECT(builder));
return window;
}
/*******************************************************
* Create the Assistant
*******************************************************/
static GtkWidget *
csv_export_assistant_create (CsvExportInfo *info)
{
GtkBuilder *builder;
GtkWidget *window;
GtkWidget *box, *h_box;
GtkWidget *button;
GtkWidget *table, *hbox;
time64 start_time, end_time;
builder = gtk_builder_new();
gnc_builder_add_from_file (builder , "assistant-csv-export.glade", "CSV Export Assistant");
window = GTK_WIDGET(gtk_builder_get_object (builder, "CSV Export Assistant"));
info->window = window;
/* Set the assistant colors */
gnc_assistant_set_colors (GTK_ASSISTANT (info->window));
/* Load default settings */
load_settings (info);
/* Start Page */
info->start_page = GTK_WIDGET(gtk_builder_get_object(builder, "start_page"));
info->start_label = GTK_WIDGET(gtk_builder_get_object(builder, "start_label"));
info->custom_entry = GTK_WIDGET(gtk_builder_get_object(builder, "custom_entry"));
gtk_widget_set_sensitive (info->custom_entry, FALSE);
/* Account Page */
info->account_page = GTK_WIDGET(gtk_builder_get_object(builder, "account_page"));
if (info->export_type == XML_EXPORT_TREE)
gtk_widget_destroy (info->account_page);
else
{
GtkTreeView *tree_view;
GtkTreeSelection *selection;
GtkWidget *box, *label;
info->csva.acct_info = GTK_WIDGET(gtk_builder_get_object (builder, "acct_info_vbox"));
info->csva.num_acct_label = GTK_WIDGET(gtk_builder_get_object (builder, "num_accounts_label"));
tree_view = gnc_tree_view_account_new (FALSE);
info->csva.account_treeview = GTK_WIDGET(tree_view);
selection = gtk_tree_view_get_selection (tree_view);
gtk_tree_selection_set_mode (selection, GTK_SELECTION_EXTENDED);
g_signal_connect (G_OBJECT(selection), "changed",
G_CALLBACK(csv_export_account_changed_cb), info);
gtk_widget_show (info->csva.account_treeview);
box = GTK_WIDGET(gtk_builder_get_object (builder, "account_scroll"));
gtk_container_add (GTK_CONTAINER(box), info->csva.account_treeview);
label = GTK_WIDGET(gtk_builder_get_object (builder, "accounts_label"));
gtk_label_set_mnemonic_widget (GTK_LABEL(label), GTK_WIDGET(tree_view));
/* select subaccounts button */
button = GTK_WIDGET(gtk_builder_get_object (builder, "select_subaccounts_button"));
info->csva.select_button = button;
g_signal_connect (G_OBJECT(button), "clicked",
G_CALLBACK(csv_export_select_subaccounts_clicked_cb), info);
g_signal_connect (G_OBJECT(info->csva.account_treeview), "cursor_changed",
G_CALLBACK(csv_export_cursor_changed_cb), info);
/* Set the date info */
button = GTK_WIDGET(gtk_builder_get_object (builder, "show_range"));
/* Earliest and Latest in Book */
start_time = get_earliest_in_book (gnc_get_current_book());
end_time = gnc_time (NULL);
info->csvd.start_time = start_time;
info->csvd.end_time = end_time;
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(button), FALSE);
table = GTK_WIDGET(gtk_builder_get_object (builder, "select_range_table"));
info->csvd.table = table;
gtk_widget_set_sensitive (GTK_WIDGET(table), FALSE);
info->csvd.start_date_choose = GTK_WIDGET(gtk_builder_get_object (builder, "start_date_choose"));
info->csvd.start_date_today = GTK_WIDGET(gtk_builder_get_object (builder, "start_date_today"));
info->csvd.end_date_choose = GTK_WIDGET(gtk_builder_get_object (builder, "end_date_choose"));
info->csvd.end_date_today = GTK_WIDGET(gtk_builder_get_object (builder, "end_date_today"));
/* Start date info */
info->csvd.start_date = gnc_date_edit_new (gnc_time (NULL), FALSE, FALSE);
hbox = GTK_WIDGET(gtk_builder_get_object (builder, "start_date_hbox"));
gtk_box_pack_start (GTK_BOX(hbox), info->csvd.start_date, TRUE, TRUE, 0);
gtk_widget_show (info->csvd.start_date);
gnc_date_edit_set_time (GNC_DATE_EDIT(info->csvd.start_date), start_time);
g_signal_connect (G_OBJECT(info->csvd.start_date), "date-changed",
G_CALLBACK(csv_export_date_changed_cb), info);
/* End date info */
info->csvd.end_date = gnc_date_edit_new (gnc_time (NULL), FALSE, FALSE);
hbox = GTK_WIDGET(gtk_builder_get_object (builder, "end_date_hbox"));
gtk_box_pack_start (GTK_BOX(hbox), info->csvd.end_date, TRUE, TRUE, 0);
gtk_widget_show (info->csvd.end_date);
gnc_date_edit_set_time (GNC_DATE_EDIT(info->csvd.end_date), end_time);
g_signal_connect (G_OBJECT (info->csvd.end_date), "date-changed",
G_CALLBACK (csv_export_date_changed_cb), info);
/* Load Accounts */
show_acct_type_accounts (info);
update_accounts_tree (info);
}
/* File chooser Page */
info->file_page = GTK_WIDGET(gtk_builder_get_object(builder, "file_page"));
info->file_chooser = gtk_file_chooser_widget_new (GTK_FILE_CHOOSER_ACTION_SAVE);
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_export_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);
/* 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_page"));
g_signal_connect (G_OBJECT(window), "destroy",
G_CALLBACK(csv_export_assistant_destroy_cb), info);
gnc_restore_window_size (GNC_PREFS_GROUP, GTK_WINDOW(info->window));
if (gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_SAVE_GEOMETRY))
{
GObject *object = gtk_builder_get_object (builder, "paned");
gnc_prefs_bind (GNC_PREFS_GROUP, GNC_PREF_PANED_POS, object, "position");
}
gtk_builder_connect_signals (builder, info);
g_object_unref (G_OBJECT(builder));
return window;
}
static void
saa_export_dialog_init (SaaExportDialog * d) {
const gchar * path = g_get_user_special_dir(G_USER_DIRECTORY_PICTURES);
GtkWidget * vbox = GTK_DIALOG(d)->vbox;
GtkWidget * table = gtk_table_new(4, 2, FALSE);
GtkWidget * label_f = gtk_label_new(_("Format:"));
GtkWidget * label_s = gtk_label_new(_("Scale:"));
GtkWidget * label_t = gtk_label_new(_("Edge name:"));
GtkWidget * label_l = gtk_label_new(_("Tongue:"));
GtkObject * adj_s = gtk_adjustment_new(200, 100, 500, 1, 10, 0);
GtkWidget * hsep = gtk_hseparator_new();
d->chooser = gtk_file_chooser_widget_new(GTK_FILE_CHOOSER_ACTION_SAVE);
d->format = gtk_combo_box_new_text();
d->echelle = gtk_hscale_new(GTK_ADJUSTMENT(adj_s));
d->texte = gtk_combo_box_new_text();
d->languette = gtk_combo_box_new_text();
gtk_window_set_title(GTK_WINDOW(d), _("Generate a pattern"));
gtk_window_set_default_size(GTK_WINDOW(d), 700, 650);
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(d->chooser), path);
gtk_container_set_border_width(GTK_CONTAINER(d), 10);
gtk_table_set_col_spacings(GTK_TABLE(table), 10);
gtk_table_set_row_spacings(GTK_TABLE(table), 10);
gtk_widget_show(table);
gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, TRUE, 5);
gtk_widget_show(hsep);
gtk_box_pack_start(GTK_BOX(vbox), hsep, FALSE, TRUE, 5);
gtk_widget_show(d->chooser);
gtk_box_pack_start_defaults(GTK_BOX(vbox), d->chooser);
gtk_widget_show(label_f);
gtk_table_attach_defaults(GTK_TABLE(table), label_f, 0, 1, 0, 1);
gtk_widget_show(d->format);
gtk_table_attach_defaults(GTK_TABLE(table), d->format, 1, 2, 0, 1);
gtk_combo_box_append_text(GTK_COMBO_BOX(d->format), "PostScript (*.ps)");
gtk_combo_box_append_text(GTK_COMBO_BOX(d->format), "SVG 1.0 (*.svg)");
gtk_combo_box_append_text(GTK_COMBO_BOX(d->format), "SVG 1.2 (multipage) (*.svg)");
gtk_widget_show(label_s);
gtk_table_attach_defaults(GTK_TABLE(table), label_s, 0, 1, 1, 2);
gtk_widget_show(d->echelle);
gtk_table_attach_defaults(GTK_TABLE(table), d->echelle, 1, 2, 1, 2);
gtk_widget_show(label_t);
gtk_table_attach_defaults(GTK_TABLE(table), label_t, 0, 1, 2, 3);
gtk_widget_show(d->texte);
gtk_table_attach_defaults(GTK_TABLE(table), d->texte, 1, 2, 2, 3);
gtk_combo_box_append_text(GTK_COMBO_BOX(d->texte), _("None"));
gtk_combo_box_append_text(GTK_COMBO_BOX(d->texte), _("Upside the edge"));
gtk_combo_box_append_text(GTK_COMBO_BOX(d->texte), _("Downside the edge"));
gtk_widget_show(label_l);
gtk_table_attach_defaults(GTK_TABLE(table), label_l, 0, 1, 3, 4);
gtk_widget_show(d->languette);
gtk_table_attach_defaults(GTK_TABLE(table), d->languette, 1, 2, 3, 4);
gtk_combo_box_append_text(GTK_COMBO_BOX(d->languette), _("None"));
gtk_combo_box_append_text(GTK_COMBO_BOX(d->languette), _("Regular"));
gtk_combo_box_append_text(GTK_COMBO_BOX(d->languette), _("On the greatest wing"));
gtk_combo_box_append_text(GTK_COMBO_BOX(d->languette), _("On the smallest wing"));
gtk_combo_box_append_text(GTK_COMBO_BOX(d->languette), _("All"));
gtk_dialog_add_buttons (GTK_DIALOG (d),
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
NULL);
g_signal_connect_swapped ((gpointer)d->format, "changed",
G_CALLBACK (saa_export_dialog_format_changed),
d);
}
/* This creates all the GTK+ widgets that compose our application, and registers the callbacks */
static GtkWidget* create_player_ui (CustomData *data, guint decknumber) {
GtkWidget *stop_button; /* Buttons */
GtkWidget *title;
GtkWidget *myGrid;
myGrid = gtk_grid_new();
data->playPauseButton = _create_media_button (GTK_STOCK_MEDIA_PAUSE);
g_signal_connect (G_OBJECT (data->playPauseButton), "clicked", G_CALLBACK (playpause_cb), data);
stop_button = _create_media_button (GTK_STOCK_MEDIA_STOP);
g_signal_connect (G_OBJECT (stop_button), "clicked", G_CALLBACK (stop_cb), data);
data->slider = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 100, 1);
gtk_scale_set_draw_value (GTK_SCALE (data->slider), 0);
data->slider_update_signal_id = g_signal_connect (G_OBJECT (data->slider), "value-changed", G_CALLBACK (slider_cb), data);
g_signal_connect (G_OBJECT (data->slider), "move-slider", G_CALLBACK (slider_cb), data);
data->timelabel = gtk_label_new ("");
update_timelabel(data, "Time remaining");
data->taglabel = gtk_label_new ("Selected filename");
{
data->filechooser = gtk_file_chooser_widget_new (GTK_FILE_CHOOSER_ACTION_OPEN);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (data->filechooser), TRUE);
gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (data->filechooser), FALSE);
gtk_file_chooser_set_use_preview_label (GTK_FILE_CHOOSER (data->filechooser), FALSE);
if (NULL != data->last_folder_uri) {
gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (data->filechooser),
data->last_folder_uri);
} else {
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (data->filechooser),
g_get_home_dir());
}
GtkFileFilter *filter = gtk_file_filter_new();
gtk_file_filter_add_mime_type (filter, "audio/*");
gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (data->filechooser), filter);
data->file_selection_signal_id =
g_signal_connect (G_OBJECT (data->filechooser), "selection-changed", G_CALLBACK (file_selection_cb), data);
/* block signal to prevent false selection on startup*/
g_signal_handler_block (data->filechooser, data->file_selection_signal_id);
}
{
gchar *titlename = g_strdup_printf ("Deck %u\n", decknumber + 1);
title = gtk_label_new (titlename);
g_free (titlename);
}
/* arrange all elements into myGrid */
gtk_grid_attach (GTK_GRID (myGrid), data->filechooser, 0, 0, 1, 3);
gtk_grid_attach_next_to (GTK_GRID (myGrid), title, data->filechooser, GTK_POS_TOP, 1, 3);
gtk_grid_attach_next_to (GTK_GRID (myGrid), data->playPauseButton, data->filechooser, GTK_POS_RIGHT, 1, 1);
gtk_grid_attach_next_to (GTK_GRID (myGrid), stop_button, data->playPauseButton, GTK_POS_BOTTOM, 1, 1);
gtk_grid_attach_next_to (GTK_GRID (myGrid), data->taglabel, data->filechooser, GTK_POS_BOTTOM, 2, 1);
gtk_grid_attach_next_to (GTK_GRID (myGrid), data->timelabel, data->taglabel, GTK_POS_BOTTOM, 2, 1);
gtk_grid_attach_next_to (GTK_GRID (myGrid), data->slider, data->timelabel, GTK_POS_BOTTOM, 2, 1);
/* allow at least one expanding child, so all uppper widgets will resize
* when maximising the window
*/
gtk_widget_set_hexpand (data->filechooser, TRUE);
gtk_widget_set_vexpand (data->filechooser, TRUE);
gtk_label_set_line_wrap(GTK_LABEL (data->taglabel), TRUE);
return myGrid;
}
GtkWidget*
create_window_gshpvoronoi (void)
{
GtkWidget *window_gshpvoronoi;
GtkWidget *vbox1;
GtkWidget *menubar1;
GtkWidget *menuitem1;
GtkWidget *menuitem1_menu;
GtkWidget *separatormenuitem1;
GtkWidget *quit_gshpvoronoi;
GtkWidget *menuitem4;
GtkWidget *menuitem4_menu;
GtkWidget *help_gshpvoronoi;
GtkWidget *separator1;
GtkWidget *about_gshpvoronoi;
GtkWidget *frame_input;
GtkWidget *alignment2;
GtkWidget *filechooserbutton_input;
GtkWidget *label_input;
GtkWidget *frame1;
GtkWidget *alignment1;
GtkWidget *filechooserwidget_output;
GtkWidget *label_output;
GtkWidget *hbuttonbox1;
GtkWidget *button_cancel;
GtkWidget *button_ok;
GtkWidget *statusbar_gshpvoronoi;
GtkAccelGroup *accel_group;
accel_group = gtk_accel_group_new ();
window_gshpvoronoi = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window_gshpvoronoi), _("gshpvoronoi"));
gtk_window_set_icon_name (GTK_WINDOW (window_gshpvoronoi), "gtk-execute");
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox1);
gtk_container_add (GTK_CONTAINER (window_gshpvoronoi), vbox1);
menubar1 = gtk_menu_bar_new ();
gtk_widget_show (menubar1);
gtk_box_pack_start (GTK_BOX (vbox1), menubar1, FALSE, FALSE, 0);
menuitem1 = gtk_menu_item_new_with_mnemonic (_("_File"));
gtk_widget_show (menuitem1);
gtk_container_add (GTK_CONTAINER (menubar1), menuitem1);
menuitem1_menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem1), menuitem1_menu);
separatormenuitem1 = gtk_separator_menu_item_new ();
gtk_widget_show (separatormenuitem1);
gtk_container_add (GTK_CONTAINER (menuitem1_menu), separatormenuitem1);
gtk_widget_set_sensitive (separatormenuitem1, FALSE);
quit_gshpvoronoi = gtk_image_menu_item_new_from_stock ("gtk-quit", accel_group);
gtk_widget_show (quit_gshpvoronoi);
gtk_container_add (GTK_CONTAINER (menuitem1_menu), quit_gshpvoronoi);
menuitem4 = gtk_menu_item_new_with_mnemonic (_("_Help"));
gtk_widget_show (menuitem4);
gtk_container_add (GTK_CONTAINER (menubar1), menuitem4);
menuitem4_menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem4), menuitem4_menu);
help_gshpvoronoi = gtk_image_menu_item_new_from_stock ("gtk-help", accel_group);
gtk_widget_show (help_gshpvoronoi);
gtk_container_add (GTK_CONTAINER (menuitem4_menu), help_gshpvoronoi);
separator1 = gtk_separator_menu_item_new ();
gtk_widget_show (separator1);
gtk_container_add (GTK_CONTAINER (menuitem4_menu), separator1);
gtk_widget_set_sensitive (separator1, FALSE);
about_gshpvoronoi = gtk_menu_item_new_with_mnemonic (_("_About"));
gtk_widget_show (about_gshpvoronoi);
gtk_container_add (GTK_CONTAINER (menuitem4_menu), about_gshpvoronoi);
frame_input = gtk_frame_new (NULL);
gtk_widget_show (frame_input);
gtk_box_pack_start (GTK_BOX (vbox1), frame_input, FALSE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (frame_input), 4);
alignment2 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment2);
gtk_container_add (GTK_CONTAINER (frame_input), alignment2);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment2), 0, 0, 12, 0);
filechooserbutton_input = gtk_file_chooser_button_new (_("Select A File"), GTK_FILE_CHOOSER_ACTION_OPEN);
gtk_widget_show (filechooserbutton_input);
gtk_container_add (GTK_CONTAINER (alignment2), filechooserbutton_input);
label_input = gtk_label_new (_("<b>Input</b>"));
gtk_widget_show (label_input);
gtk_frame_set_label_widget (GTK_FRAME (frame_input), label_input);
gtk_label_set_use_markup (GTK_LABEL (label_input), TRUE);
frame1 = gtk_frame_new (NULL);
gtk_widget_show (frame1);
gtk_box_pack_start (GTK_BOX (vbox1), frame1, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (frame1), 4);
alignment1 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment1);
gtk_container_add (GTK_CONTAINER (frame1), alignment1);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment1), 0, 0, 12, 0);
filechooserwidget_output = gtk_file_chooser_widget_new (GTK_FILE_CHOOSER_ACTION_SAVE);
gtk_widget_show (filechooserwidget_output);
gtk_container_add (GTK_CONTAINER (alignment1), filechooserwidget_output);
label_output = gtk_label_new (_("<b>Output</b>"));
gtk_widget_show (label_output);
gtk_frame_set_label_widget (GTK_FRAME (frame1), label_output);
gtk_label_set_use_markup (GTK_LABEL (label_output), TRUE);
hbuttonbox1 = gtk_hbutton_box_new ();
gtk_widget_show (hbuttonbox1);
gtk_box_pack_start (GTK_BOX (vbox1), hbuttonbox1, FALSE, TRUE, 0);
gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox1), GTK_BUTTONBOX_END);
button_cancel = gtk_button_new_from_stock ("gtk-cancel");
gtk_widget_show (button_cancel);
gtk_container_add (GTK_CONTAINER (hbuttonbox1), button_cancel);
GTK_WIDGET_SET_FLAGS (button_cancel, GTK_CAN_DEFAULT);
button_ok = gtk_button_new_from_stock ("gtk-ok");
gtk_widget_show (button_ok);
gtk_container_add (GTK_CONTAINER (hbuttonbox1), button_ok);
GTK_WIDGET_SET_FLAGS (button_ok, GTK_CAN_DEFAULT);
statusbar_gshpvoronoi = gtk_statusbar_new ();
gtk_widget_show (statusbar_gshpvoronoi);
gtk_box_pack_start (GTK_BOX (vbox1), statusbar_gshpvoronoi, FALSE, FALSE, 0);
g_signal_connect ((gpointer) quit_gshpvoronoi, "activate",
G_CALLBACK (gtk_main_quit),
NULL);
g_signal_connect ((gpointer) help_gshpvoronoi, "activate",
G_CALLBACK (on_help_gshpvoronoi_activate),
NULL);
g_signal_connect ((gpointer) about_gshpvoronoi, "activate",
G_CALLBACK (on_about_gshpvoronoi_activate),
NULL);
g_signal_connect ((gpointer) filechooserbutton_input, "realize",
G_CALLBACK (on_filechooserbutton_input_realize),
NULL);
g_signal_connect_swapped ((gpointer) button_cancel, "clicked",
G_CALLBACK (gtk_main_quit),
GTK_OBJECT (window_gshpvoronoi));
g_signal_connect ((gpointer) button_ok, "clicked",
G_CALLBACK (on_button_ok_clicked),
NULL);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (window_gshpvoronoi, window_gshpvoronoi, "window_gshpvoronoi");
GLADE_HOOKUP_OBJECT (window_gshpvoronoi, vbox1, "vbox1");
GLADE_HOOKUP_OBJECT (window_gshpvoronoi, menubar1, "menubar1");
GLADE_HOOKUP_OBJECT (window_gshpvoronoi, menuitem1, "menuitem1");
GLADE_HOOKUP_OBJECT (window_gshpvoronoi, menuitem1_menu, "menuitem1_menu");
GLADE_HOOKUP_OBJECT (window_gshpvoronoi, separatormenuitem1, "separatormenuitem1");
GLADE_HOOKUP_OBJECT (window_gshpvoronoi, quit_gshpvoronoi, "quit_gshpvoronoi");
GLADE_HOOKUP_OBJECT (window_gshpvoronoi, menuitem4, "menuitem4");
GLADE_HOOKUP_OBJECT (window_gshpvoronoi, menuitem4_menu, "menuitem4_menu");
GLADE_HOOKUP_OBJECT (window_gshpvoronoi, help_gshpvoronoi, "help_gshpvoronoi");
GLADE_HOOKUP_OBJECT (window_gshpvoronoi, separator1, "separator1");
GLADE_HOOKUP_OBJECT (window_gshpvoronoi, about_gshpvoronoi, "about_gshpvoronoi");
GLADE_HOOKUP_OBJECT (window_gshpvoronoi, frame_input, "frame_input");
GLADE_HOOKUP_OBJECT (window_gshpvoronoi, alignment2, "alignment2");
GLADE_HOOKUP_OBJECT (window_gshpvoronoi, filechooserbutton_input, "filechooserbutton_input");
GLADE_HOOKUP_OBJECT (window_gshpvoronoi, label_input, "label_input");
GLADE_HOOKUP_OBJECT (window_gshpvoronoi, frame1, "frame1");
GLADE_HOOKUP_OBJECT (window_gshpvoronoi, alignment1, "alignment1");
GLADE_HOOKUP_OBJECT (window_gshpvoronoi, filechooserwidget_output, "filechooserwidget_output");
GLADE_HOOKUP_OBJECT (window_gshpvoronoi, label_output, "label_output");
GLADE_HOOKUP_OBJECT (window_gshpvoronoi, hbuttonbox1, "hbuttonbox1");
GLADE_HOOKUP_OBJECT (window_gshpvoronoi, button_cancel, "button_cancel");
GLADE_HOOKUP_OBJECT (window_gshpvoronoi, button_ok, "button_ok");
GLADE_HOOKUP_OBJECT (window_gshpvoronoi, statusbar_gshpvoronoi, "statusbar_gshpvoronoi");
gtk_window_add_accel_group (GTK_WINDOW (window_gshpvoronoi), accel_group);
return window_gshpvoronoi;
}
/* Method that create the "save dialog" */
void create_save_document(GtkMenuItem *button, MinimoBrowser *browser, gchar *location)
{
GtkWidget *fs, *ok_button, *cancel_button, *hbox;
GtkWidget *SaveDialog, *scrolled_window;
OpenDialogParams *dialogParams;
G_CONST_RETURN gchar *file_name = NULL;
g_return_if_fail(browser->mozEmbed != NULL);
if (location)
location = gtk_moz_embed_get_location(GTK_MOZ_EMBED (browser->mozEmbed));
if (location) file_name = g_basename(location);
dialogParams = (OpenDialogParams*) malloc(sizeof(OpenDialogParams));
fs = gtk_file_chooser_widget_new (GTK_FILE_CHOOSER_ACTION_SAVE);
SaveDialog = gtk_dialog_new ();
gtk_widget_set_size_request (SaveDialog, 240, 320);
gtk_window_set_title (GTK_WINDOW (SaveDialog), ("Save as"));
gtk_window_set_position (GTK_WINDOW (SaveDialog), GTK_WIN_POS_CENTER_ON_PARENT);
gtk_window_set_modal (GTK_WINDOW (SaveDialog), TRUE);
gtk_window_set_default_size (GTK_WINDOW (SaveDialog), 240, 320);
gtk_window_set_resizable (GTK_WINDOW (SaveDialog), FALSE);
gtk_window_set_decorated (GTK_WINDOW (SaveDialog), TRUE);
gtk_window_set_skip_taskbar_hint (GTK_WINDOW (SaveDialog), TRUE);
gtk_window_set_skip_pager_hint (GTK_WINDOW (SaveDialog), TRUE);
gtk_window_set_type_hint (GTK_WINDOW (SaveDialog), GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_window_set_gravity (GTK_WINDOW (SaveDialog), GDK_GRAVITY_NORTH_EAST);
gtk_window_set_transient_for(GTK_WINDOW(SaveDialog), GTK_WINDOW(browser->topLevelWindow));
scrolled_window = gtk_scrolled_window_new(NULL,NULL);
gtk_widget_show(scrolled_window);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG (SaveDialog)->vbox),scrolled_window,TRUE,TRUE,0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_add_with_viewport ( GTK_SCROLLED_WINDOW (scrolled_window) ,fs);
g_object_set_data(G_OBJECT(fs), "minimo", browser);
/* adding extra button into the widget -> 'Ok and Cancel' Button */
ok_button = gtk_button_new_with_label ("Ok");
gtk_widget_modify_font(GTK_BIN(ok_button)->child, getOrCreateDefaultMinimoFont());
cancel_button = gtk_button_new_with_label ("Cancel");
gtk_widget_modify_font(GTK_BIN(cancel_button)->child, getOrCreateDefaultMinimoFont());
hbox = gtk_hbox_new(FALSE, 10);
gtk_box_pack_start(GTK_BOX (hbox), ok_button, FALSE, TRUE, 10);
gtk_box_pack_start(GTK_BOX (hbox), cancel_button, FALSE, TRUE, 10);
gtk_widget_show_all (hbox);
gtk_file_chooser_set_extra_widget ( GTK_FILE_CHOOSER (fs), GTK_WIDGET (hbox));
dialogParams->main_combo= fs;
dialogParams->dialog_combo= SaveDialog;
/* connecting callbacks into the extra buttons */
g_signal_connect(G_OBJECT(ok_button), "clicked", G_CALLBACK(on_save_ok_cb), dialogParams);
gtk_widget_show(fs);
gtk_widget_show_all(SaveDialog);
return;
}
void
ags_desk_init(AgsDesk *desk)
{
GtkHBox *hbox;
GtkAlignment *alignment;
GtkHBox *balance_hbox;
desk->name = NULL;
desk->xml_type = "ags-desk";
/* create widgets */
desk->vbox = (GtkVBox *) gtk_vbox_new(FALSE,
0);
gtk_container_add((GtkContainer*) gtk_bin_get_child((GtkBin *) desk),
(GtkWidget *) desk->vbox);
hbox = (GtkHBox *) gtk_hbox_new(FALSE,
0);
gtk_box_pack_start((GtkBox *) desk->vbox,
(GtkWidget *) hbox,
FALSE, FALSE,
0);
/* left pad */
desk->left_pad = ags_desk_input_pad_new(NULL);
gtk_box_pack_start((GtkBox *) hbox,
(GtkWidget *) desk->left_pad,
FALSE, FALSE,
0);
/* console */
alignment = gtk_alignment_new(0.0,
0.0,
0.0,
0.0);
gtk_box_pack_start((GtkBox *) hbox,
(GtkWidget *) alignment,
FALSE, FALSE,
0);
desk->console = (GtkVBox *) gtk_vbox_new(FALSE,
0);
gtk_container_add((GtkContainer *) alignment,
(GtkWidget *) desk->console);
balance_hbox = (GtkHBox *) gtk_hbox_new(FALSE,
0);
gtk_box_pack_start((GtkBox *) desk->console,
(GtkWidget *) balance_hbox,
FALSE, FALSE,
0);
desk->move_left = (GtkButton *) gtk_button_new_with_label(i18n("left"));
gtk_box_pack_start((GtkBox *) balance_hbox,
(GtkWidget *) desk->move_left,
FALSE, FALSE,
0);
desk->balance = (GtkScale *) gtk_hscale_new_with_range(-1.0, 1.0, 0.1);
gtk_widget_set_size_request((GtkWidget *) desk->balance,
200, -1);
gtk_box_pack_start((GtkBox *) balance_hbox,
(GtkWidget *) desk->balance,
FALSE, FALSE,
0);
desk->move_right = (GtkButton *) gtk_button_new_with_label(i18n("right"));
gtk_box_pack_start((GtkBox *) balance_hbox,
(GtkWidget *) desk->move_right,
FALSE, FALSE,
0);
/* left pad */
desk->right_pad = ags_desk_input_pad_new(NULL);
gtk_box_pack_start((GtkBox *) hbox,
(GtkWidget *) desk->right_pad,
FALSE, FALSE,
0);
/* file chooser */
desk->file_chooser = gtk_file_chooser_widget_new(GTK_FILE_CHOOSER_ACTION_OPEN);
gtk_widget_set_size_request((GtkWidget *) desk->file_chooser,
-1, 400);
gtk_box_pack_start((GtkBox *) desk->vbox,
(GtkWidget *) desk->file_chooser,
FALSE, FALSE,
0);
}
static void
gnc_ui_file_access( int type )
{
FileAccessWindow *faw;
GladeXML* xml;
GtkWidget* box;
GList* ds_node;
GtkButton* op;
GtkWidget* align;
GtkFileChooserWidget* fileChooser;
GtkFileChooserAction fileChooserAction = GTK_FILE_CHOOSER_ACTION_OPEN;
GList* list;
GList* node;
GtkWidget* uri_type_container;
gboolean need_access_method_file = FALSE;
gboolean need_access_method_mysql = FALSE;
gboolean need_access_method_postgres = FALSE;
gboolean need_access_method_sqlite3 = FALSE;
gboolean need_access_method_xml = FALSE;
gint access_method_index = -1;
gint active_access_method_index = -1;
const gchar* default_db;
const gchar *button_label = NULL;
g_return_if_fail( type == FILE_ACCESS_OPEN || type == FILE_ACCESS_SAVE_AS );
faw = g_new0(FileAccessWindow, 1);
g_return_if_fail( faw != NULL );
faw->type = type;
/* Open the dialog */
xml = gnc_glade_xml_new( "dialog-file-access.glade", "File Access" );
faw->dialog = glade_xml_get_widget( xml, "File Access" );
g_object_set_data_full( G_OBJECT(faw->dialog), "FileAccessWindow", faw,
g_free );
faw->frame_file = glade_xml_get_widget( xml, "frame_file" );
faw->frame_database = glade_xml_get_widget( xml, "frame_database" );
faw->tf_host = GTK_ENTRY(glade_xml_get_widget( xml, "tf_host" ));
gtk_entry_set_text( faw->tf_host, DEFAULT_HOST );
faw->tf_database = GTK_ENTRY(glade_xml_get_widget( xml, "tf_database" ));
default_db = get_default_database();
gtk_entry_set_text( faw->tf_database, default_db );
faw->tf_username = GTK_ENTRY(glade_xml_get_widget( xml, "tf_username" ));
faw->tf_password = GTK_ENTRY(glade_xml_get_widget( xml, "tf_password" ));
switch ( type )
{
case FILE_ACCESS_OPEN:
gtk_window_set_title(GTK_WINDOW(faw->dialog), _("Open..."));
button_label = "gtk-open";
fileChooserAction = GTK_FILE_CHOOSER_ACTION_OPEN;
break;
case FILE_ACCESS_SAVE_AS:
gtk_window_set_title(GTK_WINDOW(faw->dialog), _("Save As..."));
button_label = "gtk-save-as";
fileChooserAction = GTK_FILE_CHOOSER_ACTION_SAVE;
break;
}
op = GTK_BUTTON(glade_xml_get_widget( xml, "pb_op" ));
if ( op != NULL )
{
gtk_button_set_label( op, button_label );
gtk_button_set_use_stock( op, TRUE );
}
align = glade_xml_get_widget( xml, "alignment_file_chooser" );
fileChooser = GTK_FILE_CHOOSER_WIDGET(gtk_file_chooser_widget_new( fileChooserAction ));
faw->fileChooser = GTK_FILE_CHOOSER(fileChooser);
gtk_container_add( GTK_CONTAINER(align), GTK_WIDGET(fileChooser) );
g_object_connect( G_OBJECT(faw->fileChooser), "signal::file-activated",
gnc_ui_file_access_file_activated_cb, faw, NULL );
uri_type_container = glade_xml_get_widget( xml, "vb_uri_type_container" );
faw->cb_uri_type = GTK_COMBO_BOX(gtk_combo_box_new_text());
gtk_container_add( GTK_CONTAINER(uri_type_container), GTK_WIDGET(faw->cb_uri_type) );
gtk_box_set_child_packing( GTK_BOX(uri_type_container), GTK_WIDGET(faw->cb_uri_type),
/*expand*/TRUE, /*fill*/FALSE, /*padding*/0, GTK_PACK_START );
g_object_connect( G_OBJECT(faw->cb_uri_type),
"signal::changed", cb_uri_type_changed_cb, NULL,
NULL );
/* Autoconnect signals */
glade_xml_signal_autoconnect_full( xml, gnc_glade_autoconnect_full_func,
faw->dialog );
/* See what qof backends are available and add appropriate ones to the combo box */
list = qof_backend_get_registered_access_method_list();
for ( node = list; node != NULL; node = node->next )
{
const gchar* access_method = node->data;
/* For the different access methods, "mysql" and "postgres" are added if available. Access
methods "xml" and "sqlite3" are compressed to "file" if opening a file, but when saving a file,
both access methods are added. */
if ( strcmp( access_method, "mysql" ) == 0 )
{
need_access_method_mysql = TRUE;
}
else if ( strcmp( access_method, "postgres" ) == 0 )
{
need_access_method_postgres = TRUE;
}
else if ( strcmp( access_method, "xml" ) == 0 )
{
if ( type == FILE_ACCESS_OPEN )
{
need_access_method_file = TRUE;
}
else
{
need_access_method_xml = TRUE;
}
}
else if ( strcmp( access_method, "sqlite3" ) == 0 )
{
if ( type == FILE_ACCESS_OPEN )
{
need_access_method_file = TRUE;
}
else
{
need_access_method_sqlite3 = TRUE;
}
}
}
g_list_free(list);
/* Now that the set of access methods has been ascertained, add them to the list, and set the
default. */
access_method_index = -1;
if ( need_access_method_file )
{
gtk_combo_box_append_text( faw->cb_uri_type, "file" );
active_access_method_index = ++access_method_index;
}
if ( need_access_method_mysql )
{
gtk_combo_box_append_text( faw->cb_uri_type, "mysql" );
++access_method_index;
}
if ( need_access_method_postgres )
{
gtk_combo_box_append_text( faw->cb_uri_type, "postgres" );
++access_method_index;
}
if ( need_access_method_sqlite3 )
{
gtk_combo_box_append_text( faw->cb_uri_type, "sqlite3" );
active_access_method_index = ++access_method_index;
}
if ( need_access_method_xml )
{
gtk_combo_box_append_text( faw->cb_uri_type, "xml" );
++access_method_index;
// Set XML as default if it is offered (which mean we are in
// the "Save As" dialog)
active_access_method_index = access_method_index;
}
g_assert( active_access_method_index >= 0 );
/* Clean up the xml data structure when the dialog is destroyed */
g_object_set_data_full( G_OBJECT(faw->dialog), "dialog-file-access.glade",
xml, g_object_unref );
/* Run the dialog */
gtk_widget_show_all( faw->dialog );
/* Hide the frame that's not required for the active access method so either only
* the File or only the Database frame are presented. */
gtk_combo_box_set_active( faw->cb_uri_type, active_access_method_index );
set_widget_sensitivity_for_uri_type( faw, gtk_combo_box_get_active_text( faw->cb_uri_type ) );
}
bool wxGtkFileCtrl::Create( wxWindow *parent,
wxWindowID id,
const wxString& defaultDirectory,
const wxString& defaultFileName,
const wxString& wildCard,
long style,
const wxPoint& pos,
const wxSize& size,
const wxString& name )
{
if ( !PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ) )
{
wxFAIL_MSG( wxT( "wxGtkFileCtrl creation failed" ) );
return false;
}
GtkFileChooserAction gtkAction = GTK_FILE_CHOOSER_ACTION_OPEN;
if ( style & wxFC_SAVE )
gtkAction = GTK_FILE_CHOOSER_ACTION_SAVE;
m_widget = gtk_alignment_new ( 0, 0, 1, 1 );
g_object_ref(m_widget);
m_fcWidget = GTK_FILE_CHOOSER( gtk_file_chooser_widget_new(gtkAction) );
gtk_widget_show ( GTK_WIDGET( m_fcWidget ) );
gtk_container_add ( GTK_CONTAINER ( m_widget ), GTK_WIDGET( m_fcWidget ) );
m_focusWidget = GTK_WIDGET( m_fcWidget );
g_signal_connect ( m_fcWidget, "file-activated",
G_CALLBACK ( gtkfilechooserwidget_file_activated_callback ),
this );
g_signal_connect ( m_fcWidget, "current-folder-changed",
G_CALLBACK ( gtkfilechooserwidget_folder_changed_callback ),
this );
g_signal_connect ( m_fcWidget, "selection-changed",
G_CALLBACK ( gtkfilechooserwidget_selection_changed_callback ),
this );
m_fc.SetWidget( m_fcWidget );
if ( style & wxFC_MULTIPLE )
gtk_file_chooser_set_select_multiple( m_fcWidget, true );
SetWildcard( wildCard );
// if defaultDir is specified it should contain the directory and
// defaultFileName should contain the default name of the file, however if
// directory is not given, defaultFileName contains both
wxFileName fn;
if ( defaultDirectory.empty() )
fn.Assign( defaultFileName );
else if ( !defaultFileName.empty() )
fn.Assign( defaultDirectory, defaultFileName );
else
fn.AssignDir( defaultDirectory );
// set the initial file name and/or directory
const wxString dir = fn.GetPath();
if ( !dir.empty() )
{
gtk_file_chooser_set_current_folder( m_fcWidget,
dir.fn_str() );
}
const wxString fname = fn.GetFullName();
if ( style & wxFC_SAVE )
{
if ( !fname.empty() )
{
gtk_file_chooser_set_current_name( m_fcWidget,
fname.fn_str() );
}
}
else // wxFC_OPEN
{
if ( !fname.empty() )
{
gtk_file_chooser_set_filename( m_fcWidget,
fn.GetFullPath().fn_str() );
}
}
m_parent->DoAddChild( this );
PostCreation( size );
return TRUE;
}
NedMidiImportDialog::NedMidiImportDialog(GtkWindow *parent, char **folder, char **filename) : m_with_triplets(true),
m_tempo_change_density(20), m_volume_change_density(20), m_last_folder(folder), m_filename(filename) {
GtkWidget *dialog;
GtkWidget *tempo_sensity_frame;
GtkWidget *volume_sensity_frame;
GtkWidget *main_vbox;
GtkWidget *main_hbox;
GtkWidget *left_vbox;
GtkWidget *right_vbox;
dialog = gtk_dialog_new_with_buttons(_("MIDI import"), parent, (GtkDialogFlags) (GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT),
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL);
g_signal_connect(dialog, "response", G_CALLBACK (OnClose), (void *) this);
m_file_chooser = gtk_file_chooser_widget_new(GTK_FILE_CHOOSER_ACTION_OPEN);
if (*m_last_folder != NULL) {
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(m_file_chooser), *m_last_folder);
}
if (*m_filename != NULL) {
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(m_file_chooser), *m_filename);
}
GtkFileFilter *file_filter1 = gtk_file_filter_new();
gtk_file_filter_set_name(file_filter1, ".mid,.midi (MIDI-Files)");
gtk_file_filter_add_pattern(file_filter1, "*.mid");
gtk_file_filter_add_pattern(file_filter1, "*.midi");
GtkFileFilter *file_filter2 = gtk_file_filter_new();
gtk_file_filter_set_name(file_filter2, "* (All Files)");
gtk_file_filter_add_pattern(file_filter2, "*");
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(m_file_chooser), file_filter1);
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(m_file_chooser), file_filter2);
left_vbox = gtk_vbox_new(FALSE, 2);
right_vbox = gtk_vbox_new(FALSE, 2);
m_with_triplet_button = gtk_toggle_button_new_with_label(_("triplet recognition"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_with_triplet_button), TRUE);
m_sort_instruments_button = gtk_toggle_button_new_with_label(_("sort instruments"));
m_force_piano_button = gtk_toggle_button_new_with_label(_("force piano"));
m_dont_split_button = gtk_toggle_button_new_with_label(_("don't split tracks"));
g_signal_connect(m_force_piano_button, "toggled", G_CALLBACK (OnPianoForcePressed), (void *) this);
g_signal_connect(m_dont_split_button, "toggled", G_CALLBACK (OnDontSplitPressed), (void *) this);
gtk_container_add (GTK_CONTAINER(left_vbox), m_with_triplet_button);
gtk_container_add (GTK_CONTAINER(left_vbox), m_sort_instruments_button);
gtk_container_add (GTK_CONTAINER(left_vbox), m_force_piano_button);
gtk_container_add (GTK_CONTAINER(left_vbox), m_dont_split_button);
tempo_sensity_frame = gtk_frame_new(_("tempo density"));
m_tempo_change_density_scale = gtk_hscale_new_with_range(0.0, 100.0, 1.0);
gtk_range_set_value(GTK_RANGE(m_tempo_change_density_scale), 20.0);
gtk_container_add (GTK_CONTAINER(tempo_sensity_frame), m_tempo_change_density_scale);
volume_sensity_frame = gtk_frame_new(_("volume density"));
m_volume_change_density_scale = gtk_hscale_new_with_range(0.0, 100.0, 1.0);
gtk_range_set_value(GTK_RANGE(m_volume_change_density_scale), 20.0);
gtk_container_add (GTK_CONTAINER(volume_sensity_frame), m_volume_change_density_scale);
gtk_box_pack_start(GTK_BOX(right_vbox), tempo_sensity_frame, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(right_vbox), volume_sensity_frame, FALSE, TRUE, 0);
main_hbox = gtk_hbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(main_hbox), left_vbox, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(main_hbox), right_vbox, TRUE, TRUE, 0);
main_vbox = gtk_vbox_new(FALSE, 2);
gtk_box_pack_start (GTK_BOX(main_vbox), main_hbox, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(main_vbox), m_file_chooser, TRUE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox), main_vbox);
gtk_window_set_default_size (GTK_WINDOW (dialog), MIDIIMPORT_DIALOG_WIDTH, MIDIIMPORT_DIALOG_HEIGHT);
gtk_widget_show_all (dialog);
gtk_dialog_run(GTK_DIALOG(dialog));
}
