static void
um_photo_dialog_select_file (UmPhotoDialog *um)
{
GtkWidget *chooser;
const gchar *folder;
GtkWidget *preview;
chooser = gtk_file_chooser_dialog_new (_("Browse for more pictures"),
GTK_WINDOW (gtk_widget_get_toplevel (um->popup_button)),
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
gtk_window_set_modal (GTK_WINDOW (chooser), TRUE);
preview = gtk_image_new ();
gtk_widget_set_size_request (preview, 128, -1);
gtk_file_chooser_set_preview_widget (GTK_FILE_CHOOSER (chooser), preview);
gtk_file_chooser_set_use_preview_label (GTK_FILE_CHOOSER (chooser), FALSE);
gtk_widget_show (preview);
g_signal_connect (chooser, "update-preview",
G_CALLBACK (update_preview), um->thumb_factory);
folder = g_get_user_special_dir (G_USER_DIRECTORY_PICTURES);
if (folder)
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (chooser),
folder);
g_signal_connect (chooser, "response",
G_CALLBACK (file_chooser_response), um);
gtk_window_present (GTK_WINDOW (chooser));
}
char* get_open_filename( GtkWindow* parent, const char* cwd )
{
char* file = NULL;
GtkFileChooser* dlg = (GtkFileChooser*)gtk_file_chooser_dialog_new( NULL, parent,
GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL );
GtkWidget* img;
GtkFileFilter *filter;
if( cwd )
gtk_file_chooser_set_current_folder( dlg, cwd );
img = gtk_image_new();
gtk_widget_set_size_request( img, 128, 128 );
gtk_file_chooser_set_preview_widget( dlg, img );
g_signal_connect( dlg, "update-preview", G_CALLBACK(on_update_preview), img );
filter = gtk_file_filter_new();
gtk_file_filter_set_name( filter, _("All Supported Images") );
gtk_file_filter_add_pixbuf_formats( filter );
gtk_file_chooser_add_filter( dlg, filter );
filter = gtk_file_filter_new();
gtk_file_filter_set_name( filter, _("All Files") );
gtk_file_filter_add_pattern( filter, "*" );
gtk_file_chooser_add_filter( dlg, filter );
if( gtk_dialog_run( (GtkDialog*)dlg ) == GTK_RESPONSE_OK )
file = gtk_file_chooser_get_filename( dlg );
gtk_widget_destroy( (GtkWidget*)dlg );
return file;
}
void open_image_file_cb ( GtkWidget *widget, AnypaperWindow *window )
{
GtkWidget *dialog;
GtkWidget *preview;
GtkFileFilter *filterImages, *filterAll;
preview = gtk_image_new ();
dialog = gtk_file_chooser_dialog_new ("Open File", GTK_WINDOW(window->priv->window), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
filterImages = gtk_file_filter_new ();
gtk_file_filter_set_name (GTK_FILE_FILTER(filterImages),"JPEG images");
gtk_file_filter_add_mime_type(GTK_FILE_FILTER(filterImages), "image/jpeg/*");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filterImages);
filterAll = gtk_file_filter_new ();
gtk_file_filter_set_name (GTK_FILE_FILTER(filterAll),"All files");
gtk_file_filter_add_pattern(GTK_FILE_FILTER(filterAll), "*");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filterAll);
gtk_file_chooser_set_preview_widget (GTK_FILE_CHOOSER (dialog), preview);
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER (dialog), gtk_entry_get_text (GTK_ENTRY (window->priv->file_entry)));
g_signal_connect (dialog, "update-preview", G_CALLBACK (update_preview_cb), preview);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
{
g_free(window->parameters->file);
window->parameters->file = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
gtk_entry_set_text (GTK_ENTRY (window->priv->file_entry), window->parameters->file);
set_image_common(window);
}
gtk_widget_destroy (dialog);
}
JNIEXPORT void JNICALL
Java_org_gnome_gtk_GtkFileChooser_gtk_1file_1chooser_1set_1preview_1widget
(
JNIEnv* env,
jclass cls,
jlong _self,
jlong _previewWidget
)
{
GtkFileChooser* self;
GtkWidget* previewWidget;
// convert parameter self
self = (GtkFileChooser*) _self;
// convert parameter previewWidget
previewWidget = (GtkWidget*) _previewWidget;
// call function
gtk_file_chooser_set_preview_widget(self, previewWidget);
// cleanup parameter self
// cleanup parameter previewWidget
}
static void
gimp_file_dialog_add_preview (GimpFileDialog *dialog,
Gimp *gimp)
{
if (gimp->config->thumbnail_size <= 0)
return;
gtk_file_chooser_set_use_preview_label (GTK_FILE_CHOOSER (dialog), FALSE);
g_signal_connect (dialog, "selection-changed",
G_CALLBACK (gimp_file_dialog_selection_changed),
dialog);
g_signal_connect (dialog, "update-preview",
G_CALLBACK (gimp_file_dialog_update_preview),
dialog);
dialog->thumb_box = gimp_thumb_box_new (gimp_get_user_context (gimp));
gtk_widget_set_sensitive (GTK_WIDGET (dialog->thumb_box), FALSE);
gtk_file_chooser_set_preview_widget (GTK_FILE_CHOOSER (dialog),
dialog->thumb_box);
gtk_widget_show (dialog->thumb_box);
#ifdef ENABLE_FILE_SYSTEM_ICONS
GIMP_VIEW_RENDERER_IMAGEFILE (GIMP_VIEW (GIMP_THUMB_BOX (dialog->thumb_box)->preview)->renderer)->file_system = _gtk_file_chooser_get_file_system (GTK_FILE_CHOOSER (dialog));
#endif
}
static gulong fm_add_image_preview_to_file_chooser(GtkFileChooser* chooser)
{
GtkWidget* img_preview = gtk_image_new();
gtk_misc_set_alignment(GTK_MISC(img_preview), 0.5, 0.0);
gtk_widget_set_size_request(img_preview, 128, 128);
gtk_file_chooser_set_preview_widget(chooser, img_preview);
return g_signal_connect(chooser, "update-preview", G_CALLBACK(on_update_img_preview), img_preview);
}
static void
screenshot_construct (XfcePanelPlugin * plugin)
{
ScreenshotData *sd = g_new0 (ScreenshotData, 1);
sd->plugin = plugin;
screenshot_read_rc_file (plugin, sd);
sd->button = xfce_create_panel_button ();
sd->counter = 0;
sd->tooltips = gtk_tooltips_new ();
gtk_tooltips_set_tip (sd->tooltips, sd->button, _("Take screenshot"), NULL);
sd->image = gtk_image_new ();
gtk_container_add (GTK_CONTAINER (sd->button), GTK_WIDGET (sd->image));
gtk_widget_show_all (sd->button);
sd->chooser = gtk_file_chooser_dialog_new ( _("Save screenshot as ..."),
NULL,
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
NULL);
#if GTK_CHECK_VERSION(2,8,0)
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (sd->chooser), TRUE);
#endif
gtk_dialog_set_default_response (GTK_DIALOG (sd->chooser), GTK_RESPONSE_ACCEPT);
sd->preview = gtk_image_new ();
gtk_file_chooser_set_preview_widget (GTK_FILE_CHOOSER (sd->chooser), sd->preview);
gtk_container_add (GTK_CONTAINER (plugin), sd->button);
xfce_panel_plugin_add_action_widget (plugin, sd->button);
g_signal_connect (sd->button, "clicked",
G_CALLBACK (button_clicked), sd);
g_signal_connect (plugin, "free-data",
G_CALLBACK (screenshot_free_data), sd);
g_signal_connect (plugin, "size-changed",
G_CALLBACK (screenshot_set_size), sd);
sd->style_id =
g_signal_connect (plugin, "style-set",
G_CALLBACK (screenshot_style_set), sd);
xfce_panel_plugin_menu_show_configure (plugin);
g_signal_connect (plugin, "configure-plugin",
G_CALLBACK (screenshot_properties_dialog), sd);
}
void setupPreview() {
m_preview = gtk_image_new();
gtk_file_chooser_set_use_preview_label(m_chooser, false);
gtk_file_chooser_set_preview_widget(m_chooser, m_preview);
g_signal_connect(
m_chooser, "update-preview",
G_CALLBACK(&FileDialogGTK::s_onUpdatePreview), this);
}
void
wp_create_filechooser (AppearanceData *data)
{
const char *start_dir, *pictures = NULL;
GtkFileFilter *filter;
data->wp_filesel = GTK_FILE_CHOOSER (
gtk_file_chooser_dialog_new (_("Add Wallpaper"),
GTK_WINDOW (appearance_capplet_get_widget (data, "appearance_window")),
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN,
GTK_RESPONSE_OK,
NULL));
gtk_dialog_set_default_response (GTK_DIALOG (data->wp_filesel), GTK_RESPONSE_OK);
gtk_file_chooser_set_select_multiple (data->wp_filesel, TRUE);
gtk_file_chooser_set_use_preview_label (data->wp_filesel, FALSE);
start_dir = g_get_home_dir ();
if (g_file_test ("/usr/share/backgrounds", G_FILE_TEST_IS_DIR)) {
gtk_file_chooser_add_shortcut_folder (data->wp_filesel,
"/usr/share/backgrounds", NULL);
start_dir = "/usr/share/backgrounds";
}
pictures = g_get_user_special_dir (G_USER_DIRECTORY_PICTURES);
if (pictures != NULL && g_file_test (pictures, G_FILE_TEST_IS_DIR)) {
gtk_file_chooser_add_shortcut_folder (data->wp_filesel, pictures, NULL);
start_dir = pictures;
}
gtk_file_chooser_set_current_folder (data->wp_filesel, start_dir);
filter = gtk_file_filter_new ();
gtk_file_filter_add_pixbuf_formats (filter);
gtk_file_filter_set_name (filter, _("Images"));
gtk_file_chooser_add_filter (data->wp_filesel, filter);
filter = gtk_file_filter_new ();
gtk_file_filter_set_name (filter, _("All files"));
gtk_file_filter_add_pattern (filter, "*");
gtk_file_chooser_add_filter (data->wp_filesel, filter);
data->wp_image = gtk_image_new ();
gtk_file_chooser_set_preview_widget (data->wp_filesel, data->wp_image);
gtk_widget_set_size_request (data->wp_image, 128, -1);
gtk_widget_show (data->wp_image);
g_signal_connect (data->wp_filesel, "update-preview",
(GCallback) wp_update_preview, data);
}
static GtkFileChooser *
gui_image_chooser_new (gboolean is_save)
{
GtkFileChooser *fsel;
fsel = GTK_FILE_CHOOSER
(g_object_new (GTK_TYPE_FILE_CHOOSER_DIALOG,
"action", is_save ? GTK_FILE_CHOOSER_ACTION_SAVE : GTK_FILE_CHOOSER_ACTION_OPEN,
"local-only", FALSE,
"use-preview-label", FALSE,
NULL));
gtk_dialog_add_buttons (GTK_DIALOG (fsel),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
is_save ? GTK_STOCK_SAVE : GTK_STOCK_OPEN,
GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (fsel), GTK_RESPONSE_OK);
/* Filters */
{
GtkFileFilter *filter;
filter = gtk_file_filter_new ();
gtk_file_filter_set_name (filter, _("All Files"));
gtk_file_filter_add_pattern (filter, "*");
gtk_file_chooser_add_filter (fsel, filter);
filter = gtk_file_filter_new ();
gtk_file_filter_set_name (filter, _("Images"));
gtk_file_filter_add_custom (filter, GTK_FILE_FILTER_MIME_TYPE,
filter_images, NULL, NULL);
gtk_file_chooser_add_filter (fsel, filter);
/* Make this filter the default */
gtk_file_chooser_set_filter (fsel, filter);
}
/* Preview */
{
GtkWidget *vbox = gtk_vbox_new (FALSE, 2);
GtkWidget *preview_image = gtk_image_new ();
GtkWidget *preview_label = gtk_label_new ("");
g_object_set_data (G_OBJECT (fsel), "image-widget", preview_image);
g_object_set_data (G_OBJECT (fsel), "label-widget", preview_label);
gtk_widget_set_size_request (vbox, PREVIEW_HSIZE, -1);
gtk_box_pack_start (GTK_BOX (vbox), preview_image, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), preview_label, FALSE, FALSE, 0);
gtk_file_chooser_set_preview_widget (fsel, vbox);
g_signal_connect (fsel, "update-preview",
G_CALLBACK (update_preview_cb), NULL);
update_preview_cb (fsel);
}
return fsel;
}
SettingItem * register_img_file_setting(GtkWidget * widget, gchar * section, gchar * key, GtkImage * image)
{
SettingItem * item = register_setting(widget,ST_IMG_FILE,section,key);
gtk_file_chooser_button_set_width_chars(GTK_FILE_CHOOSER_BUTTON(widget),0);
item->image = image;
item->preview = GTK_IMAGE(gtk_image_new());
gtk_file_chooser_set_preview_widget(GTK_FILE_CHOOSER(widget),GTK_WIDGET(item->preview));
g_signal_connect(widget,"update-preview",G_CALLBACK(update_preview_cb),
item->preview);
return item;
}
static void on_load_from_image (GtkWidget *widget, Explorer* self) {
GtkWidget *dialog, *image;
GError *error = NULL;
gchar *filename = NULL;
#if (GTK_CHECK_VERSION(2, 4, 0))
dialog = gtk_file_chooser_dialog_new ("Open Image Parameters",
GTK_WINDOW (glade_xml_get_widget (self->xml, "explorer_window")),
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
image = gtk_image_new ();
gtk_file_chooser_set_preview_widget (GTK_FILE_CHOOSER (dialog), image);
g_signal_connect (G_OBJECT (dialog), "update-preview", G_CALLBACK (update_image_preview), image);
if (file_location)
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), file_location);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK) {
filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
histogram_imager_load_image_file (HISTOGRAM_IMAGER (self->map), filename, &error);
if (file_location)
g_free (file_location);
file_location = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (dialog));
}
#else
dialog = gtk_file_selection_new ("Open Image Parameters");
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK) {
filename = gtk_file_selection_get_filename (GTK_FILE_SELECTION (dialog));
histogram_imager_load_image_file (HISTOGRAM_IMAGER (self->map), filename, &error);
}
#endif
gtk_widget_destroy (dialog);
if (error) {
GtkWidget *dialog, *label;
gchar *text;
dialog = glade_xml_get_widget (self->xml, "error dialog");
label = glade_xml_get_widget (self->xml, "error label");
text = g_strdup_printf ("<span weight=\"bold\" size=\"larger\">Could not load \"%s\"</span>\n\n%s", filename, error->message);
gtk_label_set_markup (GTK_LABEL (label), text);
g_free (text);
g_error_free (error);
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_hide (dialog);
}
g_free (filename);
}
void GtkFileChooserDialog_::set_preview_widget(Php::Parameters ¶meters)
{
GtkWidget *preview_widget;
if(parameters.size() > 0) {
Php::Value object_preview_widget = parameters[0];
GtkWidget_ *phpgtk_preview_widget = (GtkWidget_ *)object_preview_widget.implementation();
preview_widget = GTK_WIDGET(phpgtk_preview_widget->get_instance());
}
gtk_file_chooser_set_preview_widget (GTK_FILE_CHOOSER(instance), preview_widget);
}
static void gtk_openavatarthread(void *UNUSED(args)) {
void *dialog = gtk_file_chooser_dialog_new((const char *)S(SELECT_AVATAR_TITLE), NULL,
GTK_FILE_CHOOSER_ACTION_OPEN,
"_Cancel", GTK_RESPONSE_CANCEL,
"_Open", GTK_RESPONSE_ACCEPT,
NULL);
void *filter = gtk_file_filter_new();
gtk_file_filter_add_mime_type(filter, "image/jpeg");
gtk_file_filter_add_mime_type(filter, "image/png");
gtk_file_filter_add_mime_type(filter, "image/bmp");
gtk_file_filter_add_mime_type(filter, "image/gif");
gtk_file_chooser_set_filter(dialog, filter);
void *preview = gtk_image_new();
gtk_file_chooser_set_preview_widget(dialog, preview);
g_signal_connect_data(dialog, "update-preview", update_image_preview, preview, NULL, 0);
while (gtk_dialog_run(dialog) == GTK_RESPONSE_ACCEPT) {
char *filename = gtk_file_chooser_get_filename(dialog);
int size;
int width, height, bpp;
uint8_t *img = stbi_load(filename, &width, &height, &bpp, 0);
uint8_t *file_data = stbi_write_png_to_mem(img, 0, width, height, bpp, &size);
free(img);
g_free_utox(filename);
if (!file_data) {
void *message_dialog = gtk_message_dialog_new(dialog, 0, 1, 2, (const char *)S(CANT_FIND_FILE_OR_EMPTY));
gtk_dialog_run(message_dialog);
gtk_widget_destroy(message_dialog);
} else if (size > UTOX_AVATAR_MAX_DATA_LENGTH) {
free(file_data);
char_t size_str[16];
int len = sprint_humanread_bytes(size_str, sizeof(size_str), UTOX_AVATAR_MAX_DATA_LENGTH);
void *message_dialog = gtk_message_dialog_new(dialog, 0, 1, 2, "%s%.*s.", S(AVATAR_TOO_LARGE_MAX_SIZE_IS), len, size_str);
gtk_dialog_run(message_dialog);
gtk_widget_destroy(message_dialog);
} else {
postmessage(SELF_AVATAR_SET, size, 0, file_data);
break;
}
}
gtk_widget_destroy(dialog);
while(gtk_events_pending()) {
gtk_main_iteration();
}
gtk_open = false;
}
static GObject *
gimp_profile_chooser_dialog_constructor (GType type,
guint n_params,
GObjectConstructParam *params)
{
GObject *object;
GimpProfileChooserDialog *dialog;
GtkFileFilter *filter;
object = G_OBJECT_CLASS (parent_class)->constructor (type, n_params, params);
dialog = GIMP_PROFILE_CHOOSER_DIALOG (object);
gtk_window_set_role (GTK_WINDOW (dialog), "gimp-profile-chooser-dialog");
gtk_dialog_add_buttons (GTK_DIALOG (dialog),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_ACCEPT,
GTK_RESPONSE_CANCEL,
-1);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_ACCEPT);
gimp_profile_chooser_dialog_add_shortcut (dialog);
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 (dialog), filter);
filter = gtk_file_filter_new ();
gtk_file_filter_set_name (filter, _("ICC color profile (*.icc, *.icm)"));
gtk_file_filter_add_pattern (filter, "*.[Ii][Cc][Cc]");
gtk_file_filter_add_pattern (filter, "*.[Ii][Cc][Mm]");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog), filter);
gtk_file_chooser_set_preview_widget (GTK_FILE_CHOOSER (dialog),
gimp_profile_view_new (dialog->buffer));
g_signal_connect (dialog, "update-preview",
G_CALLBACK (gimp_profile_chooser_dialog_update_preview),
NULL);
return object;
}
static void
gwy_app_file_chooser_add_preview(GwyAppFileChooser *chooser)
{
GtkListStore *store;
GtkIconView *preview;
GtkCellLayout *layout;
GtkCellRenderer *renderer;
GtkWidget *scwin;
gint w;
if (gtk_check_version(2, 8, 0)) {
g_warning("File previews require Gtk+ 2.8");
return;
}
scwin = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scwin),
GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
store = gtk_list_store_new(2, G_TYPE_STRING, GDK_TYPE_PIXBUF);
chooser->preview = gtk_icon_view_new_with_model(GTK_TREE_MODEL(store));
g_object_unref(store);
preview = GTK_ICON_VIEW(chooser->preview);
layout = GTK_CELL_LAYOUT(preview);
gtk_icon_view_set_columns(preview, 1);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(preview), renderer, FALSE);
gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(preview), renderer,
"pixbuf", COLUMN_PIXBUF);
renderer = gtk_cell_renderer_text_new();
g_object_set(renderer,
"wrap-mode", PANGO_WRAP_WORD_CHAR,
"ellipsize", PANGO_ELLIPSIZE_END,
"ellipsize-set", TRUE,
NULL);
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(preview), renderer, FALSE);
gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(preview), renderer,
"markup", COLUMN_FILEINFO);
chooser->renderer_fileinfo = G_OBJECT(renderer);
gtk_icon_view_set_selection_mode(preview, GTK_SELECTION_NONE);
gtk_icon_view_set_item_width(preview, TMS_NORMAL_THUMB_SIZE);
w = TMS_NORMAL_THUMB_SIZE + 2*gtk_icon_view_get_margin(preview);
gtk_widget_set_size_request(chooser->preview, w, -1);
gtk_container_add(GTK_CONTAINER(scwin), chooser->preview);
gtk_widget_show(chooser->preview);
gtk_file_chooser_set_preview_widget(GTK_FILE_CHOOSER(chooser), scwin);
g_signal_connect(chooser, "update-preview",
G_CALLBACK(gwy_app_file_chooser_update_preview), NULL);
}
static void
setup_background_filechooser (GtkWidget *filechooser,
TerminalProfile *profile)
{
GtkFileFilter *filter;
const char *home_dir;
filter = gtk_file_filter_new ();
gtk_file_filter_add_pixbuf_formats (filter);
gtk_file_filter_set_name (filter, _("Images"));
gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (filechooser), filter);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filechooser), TRUE);
/* Start filechooser in $HOME instead of the current dir of the factory which is "/" */
home_dir = g_get_home_dir ();
if (home_dir)
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filechooser), home_dir);
#if 0
GtkWidget *image_preview;
GdkPixbuf *pixbuf = NULL;
image_preview = gtk_image_new ();
/* FIXMchpe this is bogus */
pixbuf = create_preview_pixbuf (terminal_profile_get_property_string (profile, TERMINAL_PROFILE_BACKGROUND_IMAGE_FILE));
if (pixbuf != NULL)
{
gtk_image_set_from_pixbuf (GTK_IMAGE (image_preview), pixbuf);
g_object_unref (pixbuf);
}
else
{
gtk_image_set_from_stock (GTK_IMAGE (image_preview),
"gtk-dialog-question",
GTK_ICON_SIZE_DIALOG);
}
gtk_file_chooser_set_preview_widget (GTK_FILE_CHOOSER (filechooser),
image_preview);
gtk_file_chooser_set_use_preview_label (GTK_FILE_CHOOSER (filechooser),
FALSE);
gtk_widget_set_size_request (image_preview, 128, -1);
gtk_widget_show (image_preview);
g_signal_connect (filechooser, "update-preview",
G_CALLBACK (update_image_preview), NULL);
#endif
}
int
clip_GTK_FILECHOOSERSETPREVIEWWIDGET(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_preview_widget(GTK_FILE_CHOOSER(cchooser->object), GTK_WIDGET(cwid->widget));
return 0;
err:
return 1;
}
static void
add_preview_widget (GtkWidget *widget)
{
GtkWidget *image;
image = gtk_image_new ();
gtk_widget_set_size_request (image, 128, 128);
gtk_file_chooser_set_preview_widget (GTK_FILE_CHOOSER (widget), image);
gtk_image_set_from_pixbuf (GTK_IMAGE (image),
create_preview_pixbuf (imagename));
g_signal_connect (widget, "update-preview",
G_CALLBACK (update_preview_cb), NULL);
}
void
ui_signal_open (GtkMenuItem * item, gpointer data)
{
GtkWidget *dialog;
GtkWidget *window = GET_OBJECT("window");
char * filename;
Hexboard * board;
dialog = gtk_file_chooser_dialog_new (_("Open"),
GTK_WINDOW(window),
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
gtk_widget_set_size_request(GTK_WIDGET(dialog), 800, 600);
/* Configure the previewer widget */
board = HEXBOARD (hexboard_new (10));
gtk_widget_set_size_request(GTK_WIDGET(board), 340, 240);
gtk_file_chooser_set_preview_widget (GTK_FILE_CHOOSER(dialog), GTK_WIDGET(board));
g_signal_connect (dialog, "update-preview", G_CALLBACK (ui_signal_open_update_preview), board);
/* Set filters */
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter_auto);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter_sgf);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter_lg_sgf);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
{
Hexboard * board = HEXBOARD (hexboard);
filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
game_file = filename;
update_window_title();
hex_free (game);
game_format = dialog_selected_format (dialog);
game = hex_load_sgf (game_format, filename);
hexboard_set_size (board, hex_size (game));
g_free (filename);
history_marker = undo_history_marker = hex_history_current (game);
update_hexboard_colors ();
update_hexboard_sensitive();
update_history_buttons();
check_end_of_game();
}
gtk_widget_destroy (dialog);
}
static void
panel_properties_dialog_setup_image_chooser (PanelPropertiesDialog *dialog,
GladeXML *gui)
{
GtkFileFilter *filter;
GtkWidget *chooser_preview;
char *image;
dialog->image_chooser = glade_xml_get_widget (gui, "image_chooser");
filter = gtk_file_filter_new ();
gtk_file_filter_set_name (filter, _("Images"));
gtk_file_filter_add_pixbuf_formats (filter);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog->image_chooser),
filter);
gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog->image_chooser),
filter);
chooser_preview = gtk_image_new ();
gtk_file_chooser_set_preview_widget (GTK_FILE_CHOOSER (dialog->image_chooser),
chooser_preview);
g_signal_connect (dialog->image_chooser, "update-preview",
G_CALLBACK (panel_properties_dialog_chooser_preview_update),
chooser_preview);
image = panel_profile_get_background_image (dialog->toplevel);
if (string_empty (image))
gtk_file_chooser_unselect_all (GTK_FILE_CHOOSER (dialog->image_chooser));
else
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (dialog->image_chooser),
image);
if (image)
g_free (image);
dialog->selection_emitted = 0;
g_signal_connect_swapped (dialog->image_chooser, "selection-changed",
G_CALLBACK (panel_properties_dialog_image_changed),
dialog);
if ( ! panel_profile_is_writable_background_image (dialog->toplevel)) {
gtk_widget_set_sensitive (dialog->image_chooser, FALSE);
gtk_widget_show (dialog->writability_warn_background);
}
}
static GdkPixbuf *
choose_new_face (void)
{
GdkPixbuf *res = NULL;
GtkWidget *filesel, *preview;
GtkFileFilter *filter;
filesel = gtk_file_chooser_dialog_new (
_("Select a Face Picture"),
NULL,
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL);
gtk_dialog_set_default_response (GTK_DIALOG (filesel), GTK_RESPONSE_OK);
filter = gtk_file_filter_new ();
gtk_file_filter_set_name (filter, _("Image files"));
gtk_file_filter_add_mime_type (filter, "image/*");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (filesel), filter);
preview = gtk_image_new ();
gtk_file_chooser_set_preview_widget (GTK_FILE_CHOOSER (filesel), preview);
g_signal_connect (filesel, "update-preview", G_CALLBACK (update_preview_cb), preview);
if (GTK_RESPONSE_OK == gtk_dialog_run (GTK_DIALOG (filesel))) {
gchar *image_filename, *file_contents = NULL;
gsize length = 0;
image_filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (filesel));
gtk_widget_destroy (filesel);
if (prepare_image (image_filename, &file_contents, &length, &res, TRUE)) {
set_face_raw (file_contents, length);
}
g_free (file_contents);
g_free (image_filename);
} else {
gtk_widget_destroy (filesel);
}
return res;
}
static void
add_button_clicked (GtkButton *button,
CcBackgroundPanel *panel)
{
GtkWidget *chooser;
const gchar *folder;
GtkWidget *preview;
GtkFileFilter *filter;
CcBackgroundPanelPrivate *priv;
priv = panel->priv;
filter = gtk_file_filter_new ();
gtk_file_filter_add_mime_type (filter, "image/*");
chooser = gtk_file_chooser_dialog_new (_("Browse for more pictures"),
GTK_WINDOW (gtk_widget_get_toplevel (WID ("background-panel"))),
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (chooser), filter);
gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (chooser), TRUE);
gtk_window_set_modal (GTK_WINDOW (chooser), TRUE);
preview = gtk_image_new ();
gtk_widget_set_size_request (preview, 128, -1);
gtk_file_chooser_set_preview_widget (GTK_FILE_CHOOSER (chooser), preview);
gtk_file_chooser_set_use_preview_label (GTK_FILE_CHOOSER (chooser), FALSE);
gtk_widget_show (preview);
g_signal_connect (chooser, "update-preview",
G_CALLBACK (update_chooser_preview), panel);
folder = g_get_user_special_dir (G_USER_DIRECTORY_PICTURES);
if (folder)
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (chooser),
folder);
g_signal_connect (chooser, "response",
G_CALLBACK (file_chooser_response), panel);
gtk_window_present (GTK_WINDOW (chooser));
}
/* **************************************************************************************************************************** */
gboolean modification_logo_accueil ( )
{
GtkWidget *file_selector;
GtkWidget *preview;
file_selector = gtk_file_chooser_dialog_new ( _("Select a new logo"),
GTK_WINDOW ( fenetre_preferences ),
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_OK,
NULL);
if ( etat.is_pixmaps_dir )
gtk_file_chooser_set_current_folder ( GTK_FILE_CHOOSER (
file_selector ), gsb_dirs_get_pixmaps_dir ( ) );
else
gtk_file_chooser_set_current_folder ( GTK_FILE_CHOOSER (
file_selector ), gsb_file_get_last_path () );
gtk_window_set_position ( GTK_WINDOW ( file_selector ), GTK_WIN_POS_CENTER_ON_PARENT );
/* create the preview */
preview = gtk_image_new ();
gtk_file_chooser_set_preview_widget ( GTK_FILE_CHOOSER ( file_selector ), preview );
g_signal_connect (G_OBJECT (file_selector),
"update-preview",
G_CALLBACK ( preferences_view_update_preview_logo ),
preview );
switch ( gtk_dialog_run ( GTK_DIALOG ( file_selector ) ) )
{
case GTK_RESPONSE_OK:
change_logo_accueil ( file_selector );
gsb_file_update_last_path ( file_selection_get_last_directory (
GTK_FILE_CHOOSER ( file_selector ), TRUE ) );
default:
gtk_widget_destroy ( file_selector );
break;
}
return ( FALSE );
}
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;
}
/**
* exo_gtk_file_chooser_add_thumbnail_preview:
* @chooser : a #GtkFileChooser.
*
* This is a convenience function that adds a preview widget to the @chooser,
* which displays thumbnails for the selected filenames using the thumbnail
* database. The preview widget is also able to generate thumbnails for all
* image formats supported by #GdkPixbuf.
*
* Use this function whenever you display a #GtkFileChooser to ask the user
* to select an image file from the file system.
*
* The preview widget also supports URIs other than file:-URIs to a certain
* degree, but this support is rather limited currently, so you may want to
* use gtk_file_chooser_set_local_only() to ensure that the user can only
* select files from the local file system.
*
* When @chooser is configured to select multiple image files - using the
* gtk_file_chooser_set_select_multiple() method - the behaviour of the
* preview widget is currently undefined, in that it is not defined for
* which of the selected files the preview will be displayed.
*
* Since: 0.3.1.9
**/
void
exo_gtk_file_chooser_add_thumbnail_preview (GtkFileChooser *chooser)
{
GtkWidget *thumbnail_preview;
g_return_if_fail (GTK_IS_FILE_CHOOSER (chooser));
/* add the preview to the file chooser */
thumbnail_preview = _exo_thumbnail_preview_new ();
gtk_file_chooser_set_preview_widget (chooser, thumbnail_preview);
gtk_file_chooser_set_preview_widget_active (chooser, TRUE);
gtk_file_chooser_set_use_preview_label (chooser, FALSE);
gtk_widget_show (thumbnail_preview);
/* update the preview as necessary */
g_signal_connect (G_OBJECT (chooser), "update-preview", G_CALLBACK (update_preview), thumbnail_preview);
/* initially update the preview, in case the file chooser is already setup */
update_preview (chooser, EXO_THUMBNAIL_PREVIEW (thumbnail_preview));
}
static void gtk_opensendthread(void *args) {
uint16_t fid = (size_t)args;
void *dialog = gtk_file_chooser_dialog_new((const char *)S(SEND_FILE), NULL,
GTK_FILE_CHOOSER_ACTION_OPEN,
"_Cancel", GTK_RESPONSE_CANCEL,
"_Open", GTK_RESPONSE_ACCEPT,
NULL);
gtk_file_chooser_set_select_multiple(dialog, true);
void *preview = gtk_image_new();
gtk_file_chooser_set_preview_widget(dialog, preview);
g_signal_connect_data(dialog, "update-preview", update_image_preview, preview, NULL, 0);
int result = gtk_dialog_run(dialog);
if(result == GTK_RESPONSE_ACCEPT) {
char *out = malloc(65536), *outp = out;
GSList *list = gtk_file_chooser_get_filenames(dialog), *p = list;
while(p) {
outp = stpcpy(outp, p->data);
*outp++ = '\n';
g_free_utox(p->data);
p = p->next;
}
*outp = 0;
g_slist_free_utox(list);
debug("files: %s\n", out);
//dont call this from this thread
postmessage_toxcore(TOX_FILE_SEND_NEW, fid, 0xFFFF, out);
}
gtk_widget_destroy(dialog);
while(gtk_events_pending()) {
gtk_main_iteration();
}
gtk_open = false;
}
String XojOpenDlg::showOpenDialog(GtkWindow * win, Settings * settings, bool pdf, bool & attachPdf) {
GtkWidget * dialog = gtk_file_chooser_dialog_new(_("Open file"), 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), true);
GtkFileFilter *filterAll = gtk_file_filter_new();
gtk_file_filter_set_name(filterAll, _("All files"));
gtk_file_filter_add_pattern(filterAll, "*");
GtkFileFilter *filterXoj = gtk_file_filter_new();
gtk_file_filter_set_name(filterXoj, _("Xournal files"));
gtk_file_filter_add_pattern(filterXoj, "*.xoj");
GtkFileFilter *filterPdf = gtk_file_filter_new();
gtk_file_filter_set_name(filterPdf, _("PDF files"));
gtk_file_filter_add_pattern(filterPdf, "*.pdf");
gtk_file_filter_add_pattern(filterPdf, "*.PDF");
GtkFileFilter *filterSupported = gtk_file_filter_new();
gtk_file_filter_set_name(filterSupported, _("Supported files"));
gtk_file_filter_add_pattern(filterSupported, "*.xoj");
gtk_file_filter_add_pattern(filterSupported, "*.pdf");
gtk_file_filter_add_pattern(filterSupported, "*.PDF");
if (!pdf) {
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filterSupported);
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filterXoj);
}
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filterPdf);
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filterAll);
if (!settings->getLastSavePath().isEmpty()) {
gtk_file_chooser_set_current_folder_uri(GTK_FILE_CHOOSER(dialog), settings->getLastSavePath().c_str());
}
GtkWidget * attachOpt = NULL;
if (pdf) {
attachOpt = gtk_check_button_new_with_label(_("Attach file to the journal"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(attachOpt), FALSE);
gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(dialog), attachOpt);
}
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;
}
char * name = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
if (attachOpt) {
attachPdf = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(attachOpt));
}
String filename = name;
char * folder = gtk_file_chooser_get_current_folder_uri(GTK_FILE_CHOOSER(dialog));
settings->setLastSavePath(folder);
g_free(folder);
g_free(name);
gtk_widget_destroy(dialog);
return filename;
}
static void _lib_import_single_image_callback(GtkWidget *widget, gpointer user_data)
{
GtkWidget *win = dt_ui_main_window(darktable.gui->ui);
GtkWidget *filechooser = gtk_file_chooser_dialog_new(
_("import image"), GTK_WINDOW(win), GTK_FILE_CHOOSER_ACTION_OPEN, _("_Cancel"), GTK_RESPONSE_CANCEL,
_("_Open"), GTK_RESPONSE_ACCEPT, (char *)NULL);
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(filechooser), TRUE);
char *last_directory = dt_conf_get_string("ui_last/import_last_directory");
if(last_directory != NULL)
{
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(filechooser), last_directory);
g_free(last_directory);
}
char *cp, **extensions, ext[1024];
GtkFileFilter *filter;
filter = GTK_FILE_FILTER(gtk_file_filter_new());
extensions = g_strsplit(dt_supported_extensions, ",", 100);
for(char **i = extensions; *i != NULL; i++)
{
snprintf(ext, sizeof(ext), "*.%s", *i);
gtk_file_filter_add_pattern(filter, ext);
gtk_file_filter_add_pattern(filter, cp = g_ascii_strup(ext, -1));
g_free(cp);
}
g_strfreev(extensions);
gtk_file_filter_set_name(filter, _("supported images"));
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);
GtkWidget *preview = gtk_image_new();
gtk_file_chooser_set_preview_widget(GTK_FILE_CHOOSER(filechooser), preview);
g_signal_connect(filechooser, "update-preview", G_CALLBACK(_lib_import_update_preview), preview);
dt_lib_import_metadata_t metadata;
gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(filechooser),
_lib_import_get_extra_widget(&metadata, FALSE));
if(gtk_dialog_run(GTK_DIALOG(filechooser)) == GTK_RESPONSE_ACCEPT)
{
dt_conf_set_string("ui_last/import_last_directory",
gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(filechooser)));
_lib_import_evaluate_extra_widget(&metadata, FALSE);
char *filename = NULL;
dt_film_t film;
GSList *list = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(filechooser));
GSList *it = list;
int id = 0;
int filmid = 0;
/* reset filter so that view isn't empty */
dt_view_filter_reset(darktable.view_manager, TRUE);
while(it)
{
filename = (char *)it->data;
gchar *directory = g_path_get_dirname((const gchar *)filename);
filmid = dt_film_new(&film, directory);
id = dt_image_import(filmid, filename, TRUE);
if(!id) dt_control_log(_("error loading file `%s'"), filename);
g_free(filename);
g_free(directory);
it = g_slist_next(it);
}
if(id)
{
dt_film_open(filmid);
// make sure buffers are loaded (load full for testing)
dt_mipmap_buffer_t buf;
dt_mipmap_cache_get(darktable.mipmap_cache, &buf, id, DT_MIPMAP_FULL, DT_MIPMAP_BLOCKING, 'r');
gboolean loaded = (buf.buf != NULL);
dt_mipmap_cache_release(darktable.mipmap_cache, &buf);
if(!loaded)
{
dt_control_log(_("file has unknown format!"));
}
else
{
dt_control_set_mouse_over_id(id);
dt_ctl_switch_mode_to(DT_DEVELOP);
}
}
}
gtk_widget_destroy(metadata.frame);
gtk_widget_destroy(filechooser);
gtk_widget_queue_draw(dt_ui_center(darktable.gui->ui));
}
wxFileDialog::wxFileDialog(wxWindow *parent, const wxString& message,
const wxString& defaultDir,
const wxString& defaultFileName,
const wxString& wildCard,
long style, const wxPoint& pos,
const wxSize& sz,
const wxString& name)
: wxFileDialogBase()
{
parent = GetParentForModalDialog(parent, style);
if (!wxFileDialogBase::Create(parent, message, defaultDir, defaultFileName,
wildCard, style, pos, sz, name))
{
return;
}
if (!PreCreation(parent, pos, wxDefaultSize) ||
!CreateBase(parent, wxID_ANY, pos, wxDefaultSize, style,
wxDefaultValidator, wxT("filedialog")))
{
wxFAIL_MSG( wxT("wxFileDialog creation failed") );
return;
}
GtkFileChooserAction gtk_action;
GtkWindow* gtk_parent = NULL;
if (parent)
gtk_parent = GTK_WINDOW( gtk_widget_get_toplevel(parent->m_widget) );
const gchar* ok_btn_stock;
if ( style & wxFD_SAVE )
{
gtk_action = GTK_FILE_CHOOSER_ACTION_SAVE;
ok_btn_stock = GTK_STOCK_SAVE;
}
else
{
gtk_action = GTK_FILE_CHOOSER_ACTION_OPEN;
ok_btn_stock = GTK_STOCK_OPEN;
}
m_widget = gtk_file_chooser_dialog_new(
wxGTK_CONV(m_message),
gtk_parent,
gtk_action,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
ok_btn_stock, GTK_RESPONSE_ACCEPT,
NULL);
g_object_ref(m_widget);
GtkFileChooser* file_chooser = GTK_FILE_CHOOSER(m_widget);
m_fc.SetWidget(file_chooser);
gtk_dialog_set_default_response(GTK_DIALOG(m_widget), GTK_RESPONSE_ACCEPT);
if ( style & wxFD_MULTIPLE )
gtk_file_chooser_set_select_multiple(file_chooser, true);
// gtk_widget_hide_on_delete is used here to avoid that Gtk automatically
// destroys the dialog when the user press ESC on the dialog: in that case
// a second call to ShowModal() would result in a bunch of Gtk-CRITICAL
// errors...
g_signal_connect(m_widget,
"delete_event",
G_CALLBACK (gtk_widget_hide_on_delete),
this);
// local-only property could be set to false to allow non-local files to be
// loaded. In that case get/set_uri(s) should be used instead of
// get/set_filename(s) everywhere and the GtkFileChooserDialog should
// probably also be created with a backend, e.g. "gnome-vfs", "default", ...
// (gtk_file_chooser_dialog_new_with_backend). Currently local-only is kept
// as the default - true:
// gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(m_widget), true);
g_signal_connect (m_widget, "response",
G_CALLBACK (gtk_filedialog_response_callback), this);
// deal with extensions/filters
SetWildcard(wildCard);
wxString defaultFileNameWithExt = defaultFileName;
if ( !wildCard.empty() && !defaultFileName.empty() &&
!wxFileName(defaultFileName).HasExt() )
{
// append the default extension to the initial file name: GTK won't do
// it for us by default (unlike e.g. MSW)
const wxString defaultExt = m_fc.GetCurrentWildCard().AfterFirst('.');
if ( defaultExt.find_first_of("?*") == wxString::npos )
defaultFileNameWithExt += "." + defaultExt;
}
// 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 ( defaultDir.empty() )
fn.Assign(defaultFileNameWithExt);
else if ( !defaultFileNameWithExt.empty() )
fn.Assign(defaultDir, defaultFileNameWithExt);
else
fn.AssignDir(defaultDir);
// set the initial file name and/or directory
fn.MakeAbsolute(); // GTK+ needs absolute path
const wxString dir = fn.GetPath();
if ( !dir.empty() )
{
gtk_file_chooser_set_current_folder(file_chooser, dir.fn_str());
}
const wxString fname = fn.GetFullName();
if ( style & wxFD_SAVE )
{
if ( !fname.empty() )
{
gtk_file_chooser_set_current_name(file_chooser, fname.fn_str());
}
#if GTK_CHECK_VERSION(2,7,3)
if ((style & wxFD_OVERWRITE_PROMPT) && !gtk_check_version(2,7,3))
gtk_file_chooser_set_do_overwrite_confirmation(file_chooser, true);
#endif
}
else // wxFD_OPEN
{
if ( !fname.empty() )
{
gtk_file_chooser_set_filename(file_chooser,
fn.GetFullPath().fn_str());
}
}
if ( style & wxFD_PREVIEW )
{
GtkWidget *previewImage = gtk_image_new();
gtk_file_chooser_set_preview_widget(file_chooser, previewImage);
g_signal_connect(m_widget, "update-preview",
G_CALLBACK(gtk_filedialog_update_preview_callback),
previewImage);
}
}
