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;
}
static void
on_open_image (GtkButton* button, gpointer user_data)
{
GtkWidget *image = GTK_WIDGET (user_data);
GtkWidget *toplevel = gtk_widget_get_toplevel (image);
GtkFileFilter *filter = gtk_file_filter_new ();
GtkWidget *dialog = gtk_file_chooser_dialog_new (_("Open image"),
GTK_WINDOW (toplevel),
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
NULL);
gtk_file_filter_add_pixbuf_formats (filter);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog),
filter);
switch (gtk_dialog_run (GTK_DIALOG (dialog)))
{
case GTK_RESPONSE_ACCEPT:
{
gchar *filename =
gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
gtk_image_set_from_file (GTK_IMAGE (image), filename);
break;
}
default:
break;
}
gtk_widget_destroy (dialog);
}
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 void pixbufEditor_init(PixbufEditor *e)
{
GtkFileFilter *filter;
filter = gtk_file_filter_new();
gtk_file_filter_add_pixbuf_formats(filter);
gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(e), filter);
g_signal_connect(e, "file-set", G_CALLBACK(pixbufEditor_file_set), e);
if (e->pixbuf == NULL)
e->pixbuf = PIXBUF_EDITOR_GET_CLASS(e)->missing;
}
int
clip_GTK_FILEFILTERADDPIXBUFFORMATS(ClipMachine * cm)
{
C_object *cfilter = _fetch_co_arg(cm);
CHECKCOBJ(cfilter, GTK_IS_FILE_FILTER(cfilter->object));
gtk_file_filter_add_pixbuf_formats(GTK_FILE_FILTER(cfilter->object));
return 0;
err:
return 1;
}
static void
browse_button_cb (GtkWidget *widget, gpointer data)
{
GtkWindow *parent = GTK_WINDOW (data);
GtkFileFilter *filter;
GtkWidget *file_dialog;
file_dialog = gtk_file_chooser_dialog_new (_("Select User Image"),
parent,
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
gtk_file_chooser_set_show_hidden (GTK_FILE_CHOOSER (file_dialog), FALSE);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (file_dialog), TRUE);
gtk_file_chooser_set_use_preview_label (GTK_FILE_CHOOSER (file_dialog), FALSE);
if (facedir && g_file_test (facedir, G_FILE_TEST_IS_DIR)) {
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (file_dialog),
facedir);
gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (file_dialog),
facedir, NULL);
} else {
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (file_dialog),
DATADIR "/pixmaps");
gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (file_dialog),
DATADIR "/pixmaps", NULL);
}
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 (file_dialog), 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 (GTK_FILE_CHOOSER (file_dialog), filter);
if (imagename != NULL) {
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (file_dialog), imagename);
}
add_preview_widget (file_dialog);
g_signal_connect (G_OBJECT (file_dialog), "response",
G_CALLBACK (install_response), NULL);
gtk_widget_show (file_dialog);
}
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
}
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 void open_handler(GSimpleAction* action, GVariant* parameter, main_window* data){
GtkFileFilter* filter = gtk_file_filter_new();
GtkWidget* dialog = gtk_file_chooser_dialog_new(
"Open image",
data->window,
GTK_FILE_CHOOSER_ACTION_OPEN,
"OK", GTK_RESPONSE_ACCEPT,
"Cancel", GTK_RESPONSE_CANCEL, NULL);
gtk_file_filter_add_pixbuf_formats(filter);
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter);
canvas_t* canvas = data->canvas;
if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT){
gchar* filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
// load the image into a pixbuf
GError* error = NULL;
GdkPixbuf* pixbuf = gdk_pixbuf_new_from_file(filename, &error);
if(error){
g_print("%s\n", error->message);
g_error_free(error);
}
cairo_surface_destroy(canvas->image);
// create a surface of the same size as the image
int w = gdk_pixbuf_get_width(pixbuf);
int h = gdk_pixbuf_get_height(pixbuf);
canvas->image = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, w, h);
canvas->width = w;
canvas->height = h;
// set minimal size of the drawing area
gtk_widget_set_size_request(GTK_WIDGET(canvas->darea),
canvas->scale_factor*w, canvas->scale_factor*h);
// draw the image on the surface
cairo_t* cr = cairo_create(canvas->image);
gdk_cairo_set_source_pixbuf(cr, pixbuf, 0, 0);
cairo_paint(cr);
g_object_unref(pixbuf);
}
gtk_widget_destroy(dialog);
}
GFile * ImageOpenDlg::show(GtkWindow * win, Settings * settings, bool localOnly, bool * attach) {
GtkWidget * dialog = gtk_file_chooser_dialog_new(_("Open Image"), win, GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN,
GTK_RESPONSE_OK, NULL);
gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(dialog), localOnly);
GtkFileFilter * filterSupported = gtk_file_filter_new();
gtk_file_filter_set_name(filterSupported, _("Images"));
gtk_file_filter_add_pixbuf_formats(filterSupported);
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filterSupported);
if (!settings->getLastImagePath().isEmpty()) {
gtk_file_chooser_set_current_folder_uri(GTK_FILE_CHOOSER(dialog), settings->getLastImagePath().c_str());
}
GtkWidget * cbAttach = NULL;
if (attach) {
cbAttach = gtk_check_button_new_with_label(_("Attach file to the journal"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cbAttach), false);
gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(dialog), cbAttach);
}
GtkWidget * image = gtk_image_new();
gtk_file_chooser_set_preview_widget(GTK_FILE_CHOOSER(dialog), image);
g_signal_connect(dialog, "update-preview", G_CALLBACK(updatePreviewCallback), NULL);
gtk_window_set_transient_for(GTK_WINDOW(dialog), win);
if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
gtk_widget_destroy(dialog);
return NULL;
}
GFile * file = gtk_file_chooser_get_file(GTK_FILE_CHOOSER(dialog));
if (attach) {
*attach = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cbAttach));
}
char * folder = gtk_file_chooser_get_current_folder_uri(GTK_FILE_CHOOSER(dialog));
settings->setLastImagePath(folder);
g_free(folder);
gtk_widget_destroy(dialog);
return file;
}
void menuOpenRaster(GtkMenuItem* item, gpointer data) {
GtkWidget* d;
GtkFileFilter* f;
gchar* fname = NULL;
d = gtk_file_chooser_dialog_new("Open Raster Map", GTK_WINDOW(data), GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
f = gtk_file_filter_new();
gtk_file_filter_add_pixbuf_formats(f);
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(d), f);
if (gtk_dialog_run(GTK_DIALOG(d)) == GTK_RESPONSE_ACCEPT) {
fname = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(d));
}
gtk_widget_destroy(d);
if (fname == NULL) {
return;
}
setRaster(fname);
g_free(fname);
}
static void
on_open_image (GtkButton* button, gpointer user_data)
{
GtkWidget *image = GTK_WIDGET (user_data);
//getting image widget and saving it to toplevel
GtkWidget *toplevel1 = gtk_widget_get_toplevel (image);
//GtkWidget *toplevel2 = gtk_widget_get_toplevel (image2);
//defining a filter where certain rules can be added such as for image, for cetain patterns etc.
GtkFileFilter *filter = gtk_file_filter_new ();
//defining a dialog window(for opening here)
// args are : 1.tag line. 2.parent window(here where it is to be opened) 3.action. 4th onwards-> all buttons u want to appear onscreen of dialog box.
GtkWidget *dialog = gtk_file_chooser_dialog_new (_("Open image"),
GTK_WINDOW (toplevel1),
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
NULL);
//adding rule for supporting image files in the previously defined filter
gtk_file_filter_add_pixbuf_formats (filter);
//now finally adding filter to the dialog. that means the open dialog will look for images whereever you access the folders.
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog),
filter);
//format for file opening
if(gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
{
gchar *filename ;
filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
//image set from a file
gtk_image_set_from_file (GTK_IMAGE (image), filename);
}
gtk_widget_destroy (dialog);
}
/*#
@method add_pixbuf_formats GtkFileFilter
@brief Adds a rule allowing image files in the formats supported by GdkPixbuf.
*/
FALCON_FUNC FileFilter::add_pixbuf_formats( VMARG )
{
NO_ARGS
gtk_file_filter_add_pixbuf_formats( GET_FILEFILTER( vm->self() ) );
}
void insert_image(GdkEvent *event)
{
GtkTextBuffer *buffer;
GnomeCanvasItem *canvas_item;
GdkColor color;
GtkWidget *dialog;
GtkFileFilter *filt_all;
GtkFileFilter *filt_gdkimage;
char *filename;
GdkPixbuf *pixbuf;
double scale=1;
double pt[2];
dialog = gtk_file_chooser_dialog_new(_("Insert Image"), GTK_WINDOW (winMain),
GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL);
#ifdef FILE_DIALOG_SIZE_BUGFIX
gtk_window_set_default_size(GTK_WINDOW(dialog), 500, 400);
#endif
filt_all = gtk_file_filter_new();
gtk_file_filter_set_name(filt_all, _("All files"));
gtk_file_filter_add_pattern(filt_all, "*");
filt_gdkimage = gtk_file_filter_new();
gtk_file_filter_set_name(filt_gdkimage, _("Image files"));
gtk_file_filter_add_pixbuf_formats(filt_gdkimage);
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_gdkimage);
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (dialog), filt_all);
if (ui.default_image != NULL) gtk_file_chooser_set_filename(GTK_FILE_CHOOSER (dialog), ui.default_image);
if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) {
gtk_widget_destroy(dialog);
return;
}
filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER (dialog));
gtk_widget_destroy(dialog);
if (filename == NULL) return; /* nothing selected */
if (ui.default_image != NULL) g_free(ui.default_image);
ui.default_image = g_strdup(filename);
set_cursor_busy(TRUE);
pixbuf=gdk_pixbuf_new_from_file(filename, NULL);
set_cursor_busy(FALSE);
if(pixbuf==NULL) { /* open failed */
dialog = gtk_message_dialog_new(GTK_WINDOW (winMain), GTK_DIALOG_MODAL,
GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Error opening image '%s'"), filename);
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
g_free(filename);
ui.cur_item = NULL;
ui.cur_item_type = ITEM_NONE;
return;
}
ui.cur_item_type = ITEM_IMAGE;
get_pointer_coords(event, pt);
set_current_page(pt);
create_image_from_pixbuf(pixbuf, pt);
}
void config_missing_letter(GcomprisBoardConf *bconf, GHashTable *config)
{
GtkWidget *frame, *view, *pixmap, *question, *answer, *choice;
GtkWidget *level, *vbox, *hbox, *label;
GtkWidget *bbox, *button, *table;
GtkFileFilter *file_filter;
_config_missing *conf_data;
int i;
conf_data = g_new0(_config_missing,1);
/* frame */
frame = gtk_frame_new("");
gtk_widget_show(frame);
gtk_box_pack_start(GTK_BOX(bconf->main_conf_box), frame, TRUE, TRUE, 8);
vbox = gtk_vbox_new(FALSE, 8);
gtk_widget_show(vbox);
gtk_container_add(GTK_CONTAINER(frame), vbox);
/* hbox */
hbox = gtk_hbox_new(FALSE, 8);
gtk_widget_show(hbox);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 8);
/* combo level */
label = gtk_label_new(_("Level:"));
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 8);
level = gtk_combo_box_new_text();
for(i=1; i< gcomprisBoard_missing->maxlevel; i++)
{
gchar *tmp;
tmp = g_strdup_printf(_("Level %d"), i);
gtk_combo_box_append_text(GTK_COMBO_BOX(level), tmp);
g_free(tmp);
}
gtk_widget_show(level);
gtk_box_pack_start(GTK_BOX(hbox), level, FALSE, FALSE, 8);
/* upper case */
gboolean up_init = FALSE;
gchar *up_init_str = g_hash_table_lookup( config, "uppercase_only");
if (up_init_str && (strcmp(up_init_str, "True")==0))
up_init = TRUE;
gc_board_config_boolean_box(bconf, _("Uppercase only text"),
"uppercase_only",
up_init);
/* list view */
GtkListStore *list = gtk_list_store_new(N_COLUMNS,
G_TYPE_STRING, /*Question */
G_TYPE_STRING, /* Answer */
G_TYPE_STRING, /* Choice */
G_TYPE_STRING, /* pixmap */
GDK_TYPE_PIXBUF /* pixbuf */
);
view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(list));
configure_colummns(GTK_TREE_VIEW(view));
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (view), TRUE);
gtk_tree_view_set_search_column (GTK_TREE_VIEW (view), ANSWER_COLUMN);
gtk_widget_set_size_request(view, -1, 200);
gtk_widget_show(view);
GtkScrolledWindow *scroll = GTK_SCROLLED_WINDOW(gtk_scrolled_window_new(NULL,NULL));
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_widget_show(GTK_WIDGET(scroll));
gtk_container_add(GTK_CONTAINER(scroll), view);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(scroll), TRUE, TRUE, 10);
/* button box */
bbox = gtk_hbutton_box_new();
gtk_widget_show(bbox);
gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, FALSE, 8);
button = gtk_button_new_from_stock(GTK_STOCK_NEW);
gtk_widget_show(button);
gtk_container_add(GTK_CONTAINER(bbox), button);
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(new_clicked), (gpointer) conf_data);
button = gtk_button_new_from_stock(GTK_STOCK_DELETE);
gtk_widget_show(button);
gtk_container_add(GTK_CONTAINER(bbox), button);
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(delete_clicked), (gpointer) conf_data);
button = gtk_button_new_from_stock(GTK_STOCK_SAVE);
gtk_widget_show(button);
gtk_container_add(GTK_CONTAINER(bbox), button);
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(save_clicked), (gpointer) conf_data);
/* table */
table = gtk_table_new(2, 4, FALSE);
gtk_widget_show(table);
gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 8);
/* answer */
label = gtk_label_new(_("Answer"));
gtk_widget_show(label);
gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 0, 1);
answer = gtk_entry_new();
gtk_widget_show(answer);
gtk_table_attach_defaults(GTK_TABLE(table), answer, 1, 2, 0, 1);
/* pixmap */
label = gtk_label_new(_("Picture"));
gtk_widget_show(label);
gtk_table_attach_defaults(GTK_TABLE(table), label, 2, 3, 0, 1);
pixmap = gtk_file_chooser_button_new(_("Filename:"),
GTK_FILE_CHOOSER_ACTION_OPEN);
file_filter = gtk_file_filter_new();
gtk_file_filter_add_pixbuf_formats(file_filter);
gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(pixmap), file_filter);
gtk_widget_show(pixmap);
gtk_table_attach_defaults(GTK_TABLE(table), pixmap, 3, 4, 0, 1);
/* question */
label = gtk_label_new(_("Question"));
gtk_widget_show(label);
gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 1, 2);
question = gtk_entry_new();
gtk_widget_show(question);
gtk_table_attach_defaults(GTK_TABLE(table), question, 1, 2, 1, 2);
gtk_widget_set_tooltip_text(question,
_("Replace the letter to guess "
"by the character '_'.") );
/* choice */
label = gtk_label_new(_("Choice"));
gtk_widget_show(label);
gtk_table_attach_defaults(GTK_TABLE(table), label, 2, 3, 1, 2);
choice = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(choice), MAX_PROPOSAL);
gtk_widget_show(choice);
gtk_table_attach_defaults(GTK_TABLE(table), choice, 3, 4, 1, 2);
gtk_widget_set_tooltip_text(choice, _("Enter here the letter that will be proposed. "
"The first letter here must be the solution."));
conf_data -> combo_level = GTK_COMBO_BOX(level);
conf_data -> view = GTK_TREE_VIEW(view);
conf_data -> pixmap = GTK_FILE_CHOOSER_BUTTON(pixmap);
conf_data -> question = GTK_ENTRY(question);
conf_data -> answer = GTK_ENTRY(answer);
conf_data -> choice = GTK_ENTRY(choice);
GtkTreeSelection *selection;
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
g_signal_connect(G_OBJECT(selection),
"changed",
G_CALLBACK(selection_changed),
(gpointer) conf_data);
g_signal_connect(G_OBJECT(frame), "destroy",
G_CALLBACK(destroy_conf_data), (gpointer) conf_data);
g_signal_connect(G_OBJECT(level), "changed",
G_CALLBACK(level_changed), (gpointer) conf_data);
g_signal_connect(G_OBJECT(question), "changed",
G_CALLBACK(text_changed), (gpointer) conf_data);
g_signal_connect(G_OBJECT(answer), "changed",
G_CALLBACK(text_changed), (gpointer) conf_data);
g_signal_connect(G_OBJECT(choice), "changed",
G_CALLBACK(text_changed), (gpointer) conf_data);
g_signal_connect(G_OBJECT(pixmap), "file-set",
G_CALLBACK(text_changed), (gpointer) conf_data);
gtk_combo_box_set_active(GTK_COMBO_BOX(level), 0);
}
static VALUE
ffil_add_pixbuf_formats(VALUE self)
{
gtk_file_filter_add_pixbuf_formats(_SELF(self));
return self;
}
static void
avatar_chooser_clicked_cb (GtkWidget *button,
EmpathyAvatarChooser *chooser)
{
GtkFileChooser *chooser_dialog;
GtkWidget *image;
gchar *saved_dir = NULL;
const gchar *default_dir = DEFAULT_DIR;
const gchar *pics_dir;
GtkFileFilter *filter;
EmpathyAvatarChooserPriv *priv = GET_PRIV (chooser);
if (priv->chooser_dialog) {
gtk_window_present (GTK_WINDOW (priv->chooser_dialog));
return;
}
priv->chooser_dialog = GTK_FILE_CHOOSER (
gtk_file_chooser_dialog_new (_("Select Your Avatar Image"),
empathy_get_toplevel_window (GTK_WIDGET (chooser)),
GTK_FILE_CHOOSER_ACTION_OPEN,
_("No Image"),
GTK_RESPONSE_NO,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN,
GTK_RESPONSE_OK,
NULL));
chooser_dialog = priv->chooser_dialog;
gtk_window_set_destroy_with_parent (GTK_WINDOW (chooser_dialog), TRUE);
/* Get special dirs */
empathy_conf_get_string (empathy_conf_get (),
EMPATHY_PREFS_UI_AVATAR_DIRECTORY,
&saved_dir);
if (saved_dir && !g_file_test (saved_dir, G_FILE_TEST_IS_DIR)) {
g_free (saved_dir);
saved_dir = NULL;
}
if (!g_file_test (default_dir, G_FILE_TEST_IS_DIR)) {
default_dir = NULL;
}
pics_dir = g_get_user_special_dir (G_USER_DIRECTORY_PICTURES);
if (pics_dir && !g_file_test (pics_dir, G_FILE_TEST_IS_DIR)) {
pics_dir = NULL;
}
/* Set current dir to the last one or to DEFAULT_DIR or to home */
if (saved_dir) {
gtk_file_chooser_set_current_folder (chooser_dialog, saved_dir);
}
else if (pics_dir) {
gtk_file_chooser_set_current_folder (chooser_dialog, pics_dir);
}
else if (default_dir) {
gtk_file_chooser_set_current_folder (chooser_dialog, default_dir);
} else {
gtk_file_chooser_set_current_folder (chooser_dialog, g_get_home_dir ());
}
/* Add shortcuts to special dirs */
if (saved_dir) {
gtk_file_chooser_add_shortcut_folder (chooser_dialog, saved_dir, NULL);
}
else if (pics_dir) {
gtk_file_chooser_add_shortcut_folder (chooser_dialog, pics_dir, NULL);
}
if (default_dir) {
gtk_file_chooser_add_shortcut_folder (chooser_dialog, default_dir, NULL);
}
/* Setup preview image */
image = gtk_image_new ();
gtk_file_chooser_set_preview_widget (chooser_dialog, image);
gtk_widget_set_size_request (image, AVATAR_SIZE_SAVE, AVATAR_SIZE_SAVE);
gtk_widget_show (image);
gtk_file_chooser_set_use_preview_label (chooser_dialog, FALSE);
g_signal_connect (chooser_dialog, "update-preview",
G_CALLBACK (avatar_chooser_update_preview_cb),
chooser);
/* Setup filers */
filter = gtk_file_filter_new ();
gtk_file_filter_set_name (filter, _("Images"));
gtk_file_filter_add_pixbuf_formats (filter);
gtk_file_chooser_add_filter (chooser_dialog, 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 (chooser_dialog, filter);
/* Setup response */
gtk_dialog_set_default_response (GTK_DIALOG (chooser_dialog), GTK_RESPONSE_OK);
g_signal_connect (chooser_dialog, "response",
G_CALLBACK (avatar_chooser_response_cb),
chooser);
gtk_widget_show (GTK_WIDGET (chooser_dialog));
g_free (saved_dir);
}
