Example #1
0
void wxGtkFileChooser::SetWildcard( const wxString& wildCard )
{
    m_wildcards.Empty();

    // parse filters
    wxArrayString wildDescriptions, wildFilters;

    if ( !wxParseCommonDialogsFilter( wildCard, wildDescriptions, wildFilters ) )
    {
        wxFAIL_MSG( wxT( "wxGtkFileChooser::SetWildcard - bad wildcard string" ) );
    }
    else
    {
        // Parsing went fine. Set m_wildCard to be returned by wxGtkFileChooserBase::GetWildcard
        GtkFileChooser* chooser = m_widget;

        // empty current filter list:
        GSList* ifilters = gtk_file_chooser_list_filters( chooser );
        GSList* filters = ifilters;

        while ( ifilters )
        {
            gtk_file_chooser_remove_filter( chooser, GTK_FILE_FILTER( ifilters->data ) );
            ifilters = ifilters->next;
        }
        g_slist_free( filters );

        if (!wildCard.empty())
        {
            // add parsed to GtkChooser
            for ( size_t n = 0; n < wildFilters.GetCount(); ++n )
            {
                GtkFileFilter* filter = gtk_file_filter_new();

                gtk_file_filter_set_name( filter, wxGTK_CONV_SYS( wildDescriptions[n] ) );

                wxStringTokenizer exttok( wildFilters[n], wxT( ";" ) );
                
                int n1 = 1;
                while ( exttok.HasMoreTokens() )
                {
                    wxString token = exttok.GetNextToken();
                    gtk_file_filter_add_pattern( filter, wxGTK_CONV_SYS( token ) );
                    
                    if (n1 == 1)
                        m_wildcards.Add( token ); // Only add first pattern to list, used later when saving
                    n1++;
                }

                gtk_file_chooser_add_filter( chooser, filter );
            }

            // Reset the filter index
            SetFilterIndex( 0 );
        }
    }
}
static std::string add_simple_mime_filter_to_gtkchooser(GtkWindow *picker,
							std::string mime,
							std::string filtername)
{
	GtkFileFilter *gfilter = gtk_file_filter_new();
	gtk_file_filter_add_mime_type(gfilter, mime.c_str());
	add_common_filters_to_gtkchooser(gfilter, picker, filtername);
	return filtername;
}
Example #3
0
File: Gtk.cpp Project: koz4k/soccer
bool FileSelector::Execute(bool open, const char *title)
{
	Ctrl::ReleaseCtrlCapture();
	if(!title)
		title = open ? t_("Open") : t_("Save as");
	Ctrl *w = Ctrl::GetActiveWindow();
	GtkWidget *fc = gtk_file_chooser_dialog_new(title, w ? w->gtk() : NULL,
	                                            open ? GTK_FILE_CHOOSER_ACTION_OPEN
	                                                 : GTK_FILE_CHOOSER_ACTION_SAVE,
	                                            GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
	                                            open ? GTK_STOCK_OPEN : GTK_STOCK_SAVE, GTK_RESPONSE_OK,
	                                            NULL);
	gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(fc), confirm);
	gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(fc), true);
	gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(fc), multi);
	gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(fc), hidden);
	
	if(IsFullPath(ipath)) {
		FindFile ff(ipath);
		if(ff)
			if(ff.IsFolder())
				gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(fc), ipath);
			else
				gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(fc), ipath);
		else {
			gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(fc), GetFileFolder(ipath));
			gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(fc), GetFileName(ipath));
		}
	}
	else
		gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(fc), ipath);
	ipath.Clear();
	for(int i = 0; i < type.GetCount(); i++) {
	    GtkFileFilter *filter = gtk_file_filter_new();
	    gtk_file_filter_set_name(filter, type[i].a);
	    gtk_file_filter_add_pattern(filter, type[i].b);
	    gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fc), filter);
	    if(i == activetype)
			gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(fc), filter);
	}
	bool ret = false;
	path.Clear();
	if(gtk_dialog_run(GTK_DIALOG(fc)) == GTK_RESPONSE_OK) {
		GSList *list = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(fc));
		if(list) {
			GSList *l;
			for(l = list; l; l = l->next) {
				path.Add((const char *)l->data);
				g_free(l->data);
			}
			g_slist_free (list);
		}
		ret = true;
	}
	gtk_widget_destroy(fc);
	return ret;
}
Example #4
0
static std::string add_anim_filter_to_gtkchooser(GtkWindow *picker)
{
	GtkFileFilter *gfilter = gtk_file_filter_new();
	gtk_file_filter_add_pattern(gfilter, "*.bvh");
	gtk_file_filter_add_pattern(gfilter, "*.anim");
	std::string filtername = LLTrans::getString("animation_files") + " (*.bvh; *.anim)";
	add_common_filters_to_gtkchooser(gfilter, picker, filtername);
	return filtername;
}
void
seahorse_util_chooser_show_key_files (GtkWidget *dialog)
{
    GtkFileFilter* filter = gtk_file_filter_new ();

    /* Filter for PGP keys. We also include *.asc, as in many
       cases that extension is associated with text/plain */
    gtk_file_filter_set_name (filter, _("All key files"));
    gtk_file_filter_add_mime_type (filter, "application/pgp-keys");
    gtk_file_filter_add_pattern (filter, "*.asc");
    gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
    gtk_file_chooser_set_filter (GTK_FILE_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 (GTK_FILE_CHOOSER (dialog), filter);
}
Example #6
0
static std::string add_simple_pattern_filter_to_gtkchooser(GtkWindow *picker,
							   std::string pattern,
							   std::string filtername)
{
	GtkFileFilter *gfilter = gtk_file_filter_new();
	gtk_file_filter_add_pattern(gfilter, pattern.c_str());
	add_common_filters_to_gtkchooser(gfilter, picker, filtername);
	return filtername;
}
Example #7
0
void
activate_action_open (GtkAction *action,
		      gpointer   data)
{
	GtkWidget     *file_sel;
	FrWindow      *window = data;
	GtkFileFilter *filter;
	int            i;

	file_sel = 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_OK,
						NULL);
	gtk_dialog_set_default_response (GTK_DIALOG (file_sel), GTK_RESPONSE_OK);
	gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (file_sel), FALSE);
	gtk_file_chooser_set_current_folder_file (GTK_FILE_CHOOSER (file_sel), fr_window_get_open_default_dir (window), NULL);
	_gtk_dialog_add_to_window_group (GTK_DIALOG (file_sel));
	gtk_window_set_modal (GTK_WINDOW (file_sel), TRUE);

	filter = gtk_file_filter_new ();
	gtk_file_filter_set_name (filter, _("All archives"));
	for (i = 0; open_type[i] != -1; i++)
		gtk_file_filter_add_mime_type (filter, mime_type_desc[open_type[i]].mime_type);
	gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (file_sel), filter);
	gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (file_sel), 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_sel), filter);

	/**/

	g_object_set_data (G_OBJECT (file_sel), "fr_window", window);

	g_signal_connect (G_OBJECT (file_sel),
			  "response",
			  G_CALLBACK (open_file_response_cb),
			  file_sel);

	gtk_widget_show (file_sel);
}
Example #8
0
/* EDITOR: COLORMAP VIEWER
 * =======================
 * Colormaps differ from lump files in the way that they don't start with a width | height header
 * Otherwise they are identical in how they refer to palette indexes for their color
 */
gint VID_EditorViewColormap(gpointer data)
{
	int i;
	GtkWidget *dialog;
	GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_OPEN;
	gint res;
	loadedfile_t *pic;

	dialog = gtk_file_chooser_dialog_new ("NGUNIXEd - Open Colormap (.lmp) File",
                                      NULL,
                                      action,
                                      ("_Cancel"),
                                      GTK_RESPONSE_CANCEL,
                                      ("_Open"),
                                      GTK_RESPONSE_ACCEPT,
                                      NULL);

	// Set the dialog and the default path (current directory)
	GtkFileChooser *chooser = GTK_FILE_CHOOSER (dialog);
	char path[MAX_OSPATH];
	sprintf(path, "file://%s", get_current_dir_name());
	gtk_file_chooser_set_current_folder_uri(chooser, path);

	// Add the filter for .lmp files
	GtkFileFilter *filter = gtk_file_filter_new ();
	gtk_file_filter_add_pattern (filter, "*.lmp");
	gtk_file_chooser_set_filter (chooser, filter);

	res = gtk_dialog_run (GTK_DIALOG (dialog));
	if (res == GTK_RESPONSE_ACCEPT)
  	{
    		char *filename;
    		filename = gtk_file_chooser_get_filename (chooser);

		pic = COM_LoadFile (filename, 2);
		
		if(pic)
		{	
			Con_Printf("[EDITOR] Previewing Colormap %s\n", filename);
			ed_file = malloc(16385 + (sizeof(int) * 2));

			ed_file->width = 256;
			ed_file->height = 64;

			for(i = 0; i < 256 * 64; i++)
				ed_file->data[i] = pic->data[i];
			
    			gtk_window_resize(ed_window, ed_file->width + ed_palfile->width, ed_file->height + ed_menubar->allocation.height);
		}

    		g_free (filename);
  	}

	gtk_widget_destroy (dialog);
	return 0;
}
// <FS:CR> GTK Import/Export filters
static std::string add_import_filter_to_gtkchooser(GtkWindow *picker)
{
	GtkFileFilter *gfilter = gtk_file_filter_new();
	gtk_file_filter_add_pattern(gfilter, "*.oxp");
	std::string filtername = LLTrans::getString("backup_files") + " (*.oxp)";
	//gtk_file_filter_add_pattern(gfilter, "*.hpa");
	//std::string filtername = LLTrans::getString("backup_files") + " (*.oxp; *.hpa)";
	add_common_filters_to_gtkchooser(gfilter, picker, filtername);
	return filtername;
}
GtkFileFilter *
tls_file_chooser_filter_new (void)
{
	GtkFileFilter *filter;

	filter = gtk_file_filter_new ();
	gtk_file_filter_add_custom (filter, GTK_FILE_FILTER_FILENAME, tls_default_filter, NULL, NULL);
	gtk_file_filter_set_name (filter, _("PEM certificates (*.pem, *.crt, *.key)"));
	return filter;
}
Example #11
0
static std::string add_wav_filter_to_gtkchooser(GtkWindow *picker)
{
	GtkFileFilter *gfilter = gtk_file_filter_new();
	gtk_file_filter_add_pattern(gfilter, "*.wav");
	gtk_file_filter_add_mime_type(gfilter,"audio/x-wav");//not working

	std::string filtername = LLTrans::getString("sound_files") + " (*.wav)";
	add_common_filters_to_gtkchooser(gfilter, picker, filtername);
	return filtername;
}
Example #12
0
static GtkFileFilter *
set_file_filter (GtkFileChooser *dlg, const char *name) {
    if (!name) {
        name = _("Supported sound formats");
    }

    GtkFileFilter* flt;
    flt = gtk_file_filter_new ();
    gtk_file_filter_set_name (flt, name);

    gtk_file_filter_add_custom (flt, GTK_FILE_FILTER_FILENAME, file_filter_func, NULL, NULL);
    gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dlg), flt);
    gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dlg), flt);
    flt = gtk_file_filter_new ();
    gtk_file_filter_set_name (flt, _("All files (*)"));
    gtk_file_filter_add_pattern (flt, "*");
    gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dlg), flt);
    return flt;
}
Example #13
0
/* 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 );
}
Example #14
0
/*
 * diagram_get_file_filter:
 *
 * Return value: a new #GtkFileFilter object for diagrams.
 */
static GtkFileFilter *
diagram_get_file_filter (void)
{
	GtkFileFilter *filter;

	filter = gtk_file_filter_new ();
	gtk_file_filter_set_name (filter, _("Logdiag Diagrams (*.ldd)"));
	gtk_file_filter_add_pattern (filter, "*.ldd");
	return filter;
}
Example #15
0
void
assign_etf_fc_filters(GtkFileChooser *fc) {

        GtkFileFilter *filter_1, *filter_2;

        /* all files filter */
        filter_1 = gtk_file_filter_new();
        gtk_file_filter_add_pattern(filter_1, "*");
        gtk_file_filter_set_name(GTK_FILE_FILTER(filter_1), _("All Files"));
        gtk_file_chooser_add_filter(fc, filter_1);

        /* music store files filter */
        filter_2 = gtk_file_filter_new();
        gtk_file_filter_add_pattern(filter_2, "*.[lL][uU][aA]");
        gtk_file_filter_set_name(GTK_FILE_FILTER(filter_2), _("Lua Extension Files (*.lua)"));
        gtk_file_chooser_add_filter(fc, filter_2);

        gtk_file_chooser_set_filter(fc, filter_2);
}
Example #16
0
void
assign_store_fc_filters(GtkFileChooser *fc) {

        GtkFileFilter *filter_1, *filter_2;

        /* all files filter */
        filter_1 = gtk_file_filter_new();
        gtk_file_filter_add_pattern(filter_1, "*");
        gtk_file_filter_set_name(GTK_FILE_FILTER(filter_1), _("All Files"));
        gtk_file_chooser_add_filter(fc, filter_1);

        /* music store files filter */
        filter_2 = gtk_file_filter_new();
        gtk_file_filter_add_pattern(filter_2, "*.[xX][mM][lL]");
        gtk_file_filter_set_name(GTK_FILE_FILTER(filter_2), _("Music Store Files (*.xml)"));
        gtk_file_chooser_add_filter(fc, filter_2);

        gtk_file_chooser_set_filter(fc, filter_2);
}
Example #17
0
// GTK >= 2.4
static const gchar* create_fsel_2(const gchar *dirname, const gchar *filename, const gchar *ext, gboolean save)
{
	GtkWidget *dialog;
	GtkFileFilter *filter;
	gchar *path, *tmp;
	gchar **sarray;
	gint i;
	gchar *sfilename, *sext;

	// gtk_file_chooser_set_current_name and gtk_file_filter_add_pattern ALWAYS want UTF-8.
	sfilename = filename ? g_filename_to_utf8(filename,-1,NULL,NULL,NULL) : NULL;
	sext = ext ? g_filename_to_utf8(ext,-1,NULL,NULL,NULL) : NULL;
    
	// create box
	dialog = gtk_file_chooser_dialog_new (
					  save ? "Save File" : "Open File",
				      NULL,
					  save ? GTK_FILE_CHOOSER_ACTION_SAVE : GTK_FILE_CHOOSER_ACTION_OPEN,
				      GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
				      GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
				      NULL);

	// set default folder
	tmp = g_strconcat(dirname, G_DIR_SEPARATOR_S, NULL);	// add leading '/' otherwise get_dirname is confused
	path = g_path_get_dirname(tmp);
	g_free(tmp);

	gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), path);
	g_free(path);

	// set default name
	if(filename)
		gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), sfilename);

	// set wildcards
	filter = gtk_file_filter_new();
	sarray = g_strsplit(sext, ";", -1);
	for(i = 0; sarray[i] != NULL; i++)
		gtk_file_filter_add_pattern (filter, sarray[i]);
	g_strfreev(sarray);
	gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter);

	// get result
	g_free(fname);
	if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
		fname = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
	else
		fname = NULL;
	gtk_widget_destroy (dialog);

	g_free(sfilename);
	g_free(sext);

	return fname;
}
Example #18
0
void run_open_dialog()
{
	GtkWidget *file_chooser = gtk_file_chooser_dialog_new("Open Map", GTK_WINDOW(window), 
		GTK_FILE_CHOOSER_ACTION_OPEN,
		GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
		GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
	
	gtk_dialog_set_default_response (GTK_DIALOG (file_chooser), GTK_RESPONSE_ACCEPT);

	GtkFileFilter *filter;
	
	/* Filters */
	filter = gtk_file_filter_new ();
	gtk_file_filter_set_name (filter, "All Emergence Maps");
	gtk_file_filter_add_pattern (filter, "*.map");
	gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (file_chooser), filter);

	/* Make this filter the default */
	gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (file_chooser), 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_chooser), filter);



	

if (gtk_dialog_run (GTK_DIALOG (file_chooser)) == GTK_RESPONSE_ACCEPT)
  {
    char *filename;

    filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (file_chooser));
    open_dialog_ok (filename);
    g_free (filename);
  }

  
gtk_widget_destroy (file_chooser);

}
Example #19
0
File: window.c Project: MiKom/clipt
void ui_open_file_cb(GtkWidget* widget, gpointer data)
{
    GtkWidget* ui_filedialog;
    GtkFileFilter* ui_filefilter;

    ui_filedialog = gtk_file_chooser_dialog_new("Open...",
                    GTK_WINDOW(ui_window),
                    GTK_FILE_CHOOSER_ACTION_OPEN,
                    GTK_STOCK_CANCEL,
                    GTK_RESPONSE_CANCEL,
                    GTK_STOCK_OPEN,
                    GTK_RESPONSE_ACCEPT,
                    NULL);


    GList *formats = io_get_handler_descriptions(IO_LOAD_HANDLER);
    GList *iter;
    for(iter = g_list_first(formats); iter; iter = g_list_next(iter)) {
        io_handler_desc_t *format =
            (io_handler_desc_t *) iter->data;

        ui_filefilter = gtk_file_filter_new();
        gtk_file_filter_set_name(GTK_FILE_FILTER(ui_filefilter),
                                 format->desc);
        GList *f_it;
        for(f_it = g_list_first(format->filters); f_it; f_it = g_list_next(f_it)) {
            gtk_file_filter_add_pattern(
                GTK_FILE_FILTER(ui_filefilter),
                (char *) f_it->data);
        }
        gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(ui_filedialog),
                                    ui_filefilter);
    }
    g_list_free_full(formats, free);

    if( gtk_dialog_run(GTK_DIALOG(ui_filedialog)) == GTK_RESPONSE_ACCEPT) {
        gchar* filename;
        filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(ui_filedialog));

        if( io_load_image(filename) != CLIPT_OK) {
            GtkWidget *err_dialog;
            err_dialog = gtk_message_dialog_new(ui_filedialog,
                                                GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
                                                GTK_MESSAGE_ERROR,
                                                GTK_BUTTONS_OK,
                                                "Cannot open file specified");
            gtk_dialog_run(err_dialog);
            gtk_widget_destroy(err_dialog);
        }
        g_free(filename);
    }
    g_signal_emit(ui_window, ui_new_image_signal, 0);
    gtk_widget_destroy(ui_filedialog);
}
Example #20
0
int main(int argc, char **argv)
{
    GtkBuilder* builder;
    GError* error = NULL;

    /* Starts Gtk+ subsystem */
    gtk_init(&argc, &argv);

    /* Load GUI interface */
    builder = gtk_builder_new();
    if(!gtk_builder_add_from_file(builder, "gui/probwin.glade", &error)) {
        if(error) {
            g_warning("%s", error->message);
            g_error_free(error);
        } else {
            g_warning("Unknown error.");
        }
        return(1);
    }

    /* Get pointers to objects */
    window = GTK_WINDOW(gtk_builder_get_object(builder, "window"));

    format_view = GTK_TREE_VIEW(gtk_builder_get_object(builder, "format_view"));
    format_model = GTK_LIST_STORE(gtk_builder_get_object(builder, "format_model"));

    team_a_name = GTK_ENTRY(gtk_builder_get_object(builder, "team_a_name"));
    team_b_name = GTK_ENTRY(gtk_builder_get_object(builder, "team_b_name"));

    prob_a_home = GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "prob_a_home"));
    prob_a_road = GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "prob_a_road"));
    num_games = GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "num_games"));

    prob_b_home = GTK_LABEL(gtk_builder_get_object(builder, "prob_b_home"));
    prob_b_road = GTK_LABEL(gtk_builder_get_object(builder, "prob_b_road"));

    load_dialog = GTK_FILE_CHOOSER(gtk_builder_get_object(builder, "load_dialog"));
    save_dialog = GTK_FILE_CHOOSER(gtk_builder_get_object(builder, "save_dialog"));

    GtkFileFilter* file_filter = gtk_file_filter_new();
    gtk_file_filter_set_name(file_filter, "Custom data file (*.probwin)");
    gtk_file_filter_add_pattern(file_filter, "*.probwin");
    gtk_file_chooser_add_filter(load_dialog, file_filter);
    gtk_file_chooser_add_filter(save_dialog, file_filter);

    /* Connect signals */
    gtk_builder_connect_signals(builder, NULL);

    g_object_unref(G_OBJECT(builder));
    gtk_widget_show(GTK_WIDGET(window));
    gtk_main();

    return(0);
}
Example #21
0
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;
}
Example #22
0
static gchar *
gnc_plugin_bi_import_getFilename(void)
{
    // prepare file import dialog
    gchar *filename;
    GList *filters;
    GtkFileFilter *filter;
    filters = NULL;
    filter = gtk_file_filter_new ();
    gtk_file_filter_set_name (filter, "comma separated values (*.csv)");
    gtk_file_filter_add_pattern (filter, "*.csv");
    filters = g_list_append( filters, filter );
    filter = gtk_file_filter_new ();
    gtk_file_filter_set_name (filter, "text files (*.txt)");
    gtk_file_filter_add_pattern (filter, "*.txt");
    filters = g_list_append( filters, filter );
    filename = gnc_file_dialog(_("Import Bills or Invoices from csv"), filters, NULL, GNC_FILE_DIALOG_IMPORT);

    return filename;
}
Example #23
0
bool FileDialogImpl::run()
{
    //Init the dialog
    GtkWidget* fileDialog = gtk_file_chooser_dialog_new(
        m_title.c_str(),
        nullptr,
        m_action == FileDialog::Open ? GTK_FILE_CHOOSER_ACTION_OPEN : GTK_FILE_CHOOSER_ACTION_SAVE,
        _("_Cancel"),
        GTK_RESPONSE_CANCEL,
        m_action == FileDialog::Open ? _("_Open") : _("Save"),
        GTK_RESPONSE_ACCEPT,
        nullptr
    );

    //Init the filters
    for(auto it = m_filters.cbegin(); it != m_filters.cend(); ++it)
    {
        GtkFileFilter* filter = gtk_file_filter_new();
        gtk_file_filter_set_name(filter, it->name.c_str());

        for(auto it2 = it->patterns.cbegin(); it2 != it->patterns.cend(); ++it2)
            gtk_file_filter_add_pattern(filter, (*it2).c_str());

        gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileDialog), filter);
    }

    //Set the default filter
    GSList* filtersList = gtk_file_chooser_list_filters(GTK_FILE_CHOOSER(fileDialog));
    if(m_selectedFilter < g_slist_length(filtersList))
        gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(fileDialog), GTK_FILE_FILTER(g_slist_nth_data(filtersList, m_selectedFilter)));

    g_slist_free(filtersList);

    gtk_window_set_keep_above(GTK_WINDOW(fileDialog), TRUE);

    //Run it
    gint result = gtk_dialog_run(GTK_DIALOG(fileDialog));

    if(result == GTK_RESPONSE_ACCEPT)
    {
        char* filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(fileDialog));
        m_selectedFileName = std::string(filename);

        g_free(filename);
    }

    gtk_window_close(GTK_WINDOW(fileDialog));
    gtk_widget_destroy(fileDialog);

    while (gtk_events_pending())
        gtk_main_iteration_do(false);

    return result == GTK_RESPONSE_ACCEPT;
}
Example #24
0
static std::string add_imageload_filter_to_gtkchooser(GtkWindow *picker)
{
	GtkFileFilter *gfilter = gtk_file_filter_new();
	gtk_file_filter_add_pattern(gfilter, "*.tga");
	gtk_file_filter_add_mime_type(gfilter, "image/jpeg");
	gtk_file_filter_add_mime_type(gfilter, "image/png");
	gtk_file_filter_add_mime_type(gfilter, "image/bmp");
	std::string filtername = "Images (*.tga; *.bmp; *.jpg; *.png)";
	add_common_filters_to_gtkchooser(gfilter, picker, filtername);
	return filtername;
}
Example #25
0
static void on_browse_button_clicked(GtkWidget * widget, gpointer data) {
    GtkWidget *file_chooser;
    GtkFileFilter *filter;
    /* Create the selector */

    file_chooser = gtk_file_chooser_dialog_new("Choose exported CRL filename",
                                               GTK_WINDOW(data),
                                               GTK_FILE_CHOOSER_ACTION_SAVE,
                                               GTK_STOCK_CANCEL,
                                               GTK_RESPONSE_CANCEL,
                                               GTK_STOCK_SAVE,
                                               GTK_RESPONSE_ACCEPT, NULL);
    filter = gtk_file_filter_new();
    gtk_file_filter_add_pattern(filter, "*.crl");
    gtk_file_filter_set_name(filter, "*.crl files");
    gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(file_chooser), filter);
    filter = NULL;
    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(file_chooser), filter);
    filter = NULL;

    /* Display that dialog */
    {
        gint result = gtk_dialog_run(GTK_DIALOG(file_chooser));
        if (result == GTK_RESPONSE_ACCEPT) {
            gchar *filename;
            filename =
                gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(file_chooser));
            gtk_entry_set_text(GTK_ENTRY
                               (g_object_get_data(G_OBJECT(widget), "entry")),
                               filename);
            gtk_widget_destroy(file_chooser);
            g_free(filename);
        }
        else {
            gtk_widget_destroy(file_chooser);
        }
    }
}
Example #26
0
/* File->Import Into Skein... */
void
action_import_into_skein(GtkAction *action, I7Story *story)
{
	GError *err = NULL;

	/* Ask the user for a file to import */
	/* TRANSLATORS: File->Import Into Skein... */
	GtkWidget *dialog = gtk_file_chooser_dialog_new(
	  _("Select the file to import into the skein"),
	  GTK_WINDOW(story),
	  GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
	  GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
	gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT);
	/* Create appropriate file filters */
	GtkFileFilter *filter1 = gtk_file_filter_new();
	gtk_file_filter_set_name(filter1, _("Interpreter recording files (*.rec)"));
	gtk_file_filter_add_pattern(filter1, "*.rec");
	GtkFileFilter *filter2 = gtk_file_filter_new();
	gtk_file_filter_set_name(filter2, _("All Files"));
	gtk_file_filter_add_pattern(filter2, "*");
	gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter1);
	gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter2);

	if(gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
		gtk_widget_destroy(dialog);
		return;
	}

	GFile *file = gtk_file_chooser_get_file(GTK_FILE_CHOOSER(dialog));
	gtk_widget_destroy(dialog);
	if(!file)
		return; /* Fail silently */

	/* Provide some visual feedback that the command did something */
	if(!i7_skein_import(i7_story_get_skein(story), file, &err))
		error_dialog_file_operation(GTK_WINDOW(story), file, err, I7_FILE_ERROR_OPEN, NULL);
	else
		i7_story_show_pane(story, I7_PANE_SKEIN);

	g_object_unref(file);
}
Example #27
0
void file_chooser_add_filters(GtkWidget * chooser, FileTypes * filters)
{
    GtkFileFilter *filter;
    gint i;

    for (i = 0; filters[i].name; i++) {
	filter = gtk_file_filter_new();
	gtk_file_filter_add_mime_type(filter, filters[i].mime_type);
	gtk_file_filter_set_name(filter, filters[i].name);
	gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(chooser), filter);
    }
}
Example #28
0
static void
add_filters (GtkFileChooser *dialog)
{
	GtkFileFilter *filter = gtk_file_filter_new ();
	gtk_file_filter_set_name (filter, _("Bridge files"));
	gtk_file_filter_add_pattern (filter, "*.lin");
	gtk_file_filter_add_pattern (filter, "*.pbn");
	gtk_file_chooser_add_filter (dialog, filter);
	filter = gtk_file_filter_new ();
	gtk_file_filter_set_name (filter, _("LIN files"));
	gtk_file_filter_add_pattern (filter, "*.lin");
	gtk_file_chooser_add_filter (dialog, filter);
	filter = gtk_file_filter_new ();
	gtk_file_filter_set_name (filter, _("PBN files"));
	gtk_file_filter_add_pattern (filter, "*.pbn");
	gtk_file_chooser_add_filter (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 (dialog, filter);
}
Example #29
0
//static void on_browse(GtkWidget * widget, gpointer data)
void ladish_run_load_project_dialog(ladish_room_proxy_handle room)
{
  GtkFileFilter * filter;
  GtkWidget * dialog;
  char * filename;

  dialog = gtk_file_chooser_dialog_new(
    _("Load project"),
    NULL,
    GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
    GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
    GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
    NULL);

  gtk_file_chooser_set_create_folders(GTK_FILE_CHOOSER(dialog), FALSE);

  filter = gtk_file_filter_new();
  gtk_file_filter_add_custom(filter, GTK_FILE_FILTER_FILENAME, reject_filter, dialog, NULL); /* reject all files */
  gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter);
  //g_signal_connect(G_OBJECT(dialog), "selection-changed", G_CALLBACK(on_dir_select), dialog);
  g_signal_connect(G_OBJECT(dialog), "current-folder-changed", G_CALLBACK(dir_changed), dialog);

loop:
  if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
  {
    filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));

    if (!is_project_dir(filename))
    {
      GtkWidget * dialog;
      dialog = get_gtk_builder_widget("error_dialog");
      gtk_message_dialog_set_markup(GTK_MESSAGE_DIALOG(dialog), _("<b><big>Not a project dir</big></b>"));
      gtk_message_dialog_format_secondary_markup(GTK_MESSAGE_DIALOG(dialog), "%s", filename);
      gtk_widget_show(dialog);
      gtk_dialog_run(GTK_DIALOG(dialog));
      gtk_widget_hide(dialog);
      goto loop;
    }

    //gtk_entry_set_text(GTK_ENTRY(get_gtk_builder_widget("load_project_path_entry")), filename);
    log_info("Loading project from '%s'", filename);
    if (!ladish_room_proxy_load_project(room, filename))
    {
      log_error("ladish_room_proxy_load_project() failed.");
    }

    g_free(filename);

    //gtk_widget_activate(gtk_dialog_get_widget_for_response(GTK_DIALOG(data), GTK_RESPONSE_OK));
  }
  gtk_widget_destroy(dialog);
  return;
}
Example #30
0
void
on_filechooserbutton_input2_realize    (GtkWidget       *widget,
                                        gpointer         user_data)
{
	GtkFileFilter *filter = NULL;

	filter = gtk_file_filter_new();
	gtk_file_filter_set_name(filter, "*.dbf");
	gtk_file_filter_add_pattern(filter, "*.dbf");
	gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(widget), filter); 

}