static void reset_filter (GtkWidget *widget, GParamSpec *spec, gpointer user_data)
{
	if (!gtk_file_chooser_get_filter (GTK_FILE_CHOOSER (widget))) {
		g_signal_handlers_block_by_func (widget, reset_filter, user_data);
		gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (widget), GTK_FILE_FILTER (user_data));
		g_signal_handlers_unblock_by_func (widget, reset_filter, user_data);
	}
}
示例#2
0
void GtkToolkitFileChooser::SetDefaultFilter(int id)
{
	GtkFileFilter* filter = GetFilterById(id);
	if (!filter)
		return;

	gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(m_dialog), filter);
}
示例#3
0
文件: Gtk.cpp 项目: 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;
}
示例#4
0
int run_save_dialog()	// returns 0 if user canceled
{
	GtkWidget *file_chooser = gtk_file_chooser_dialog_new("Save Map", GTK_WINDOW(window), 
		GTK_FILE_CHOOSER_ACTION_SAVE,
		GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, 
		GTK_STOCK_SAVE, 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);

	gchar *current_folder = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER (file_chooser));
	
	struct string_t *rel_filename = arb_abs2rel(map_filename->text, current_folder);

	if(rel_filename)
		gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (file_chooser), rel_filename->text);
	
	g_free(current_folder);
	free_string(rel_filename);


	int retval;

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

    filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (file_chooser));
    save_dialog_ok (filename);
    g_free (filename);
	  retval = 1;
  }
  else
	  retval = 0;

  
gtk_widget_destroy (file_chooser);


return retval;
}
示例#5
0
文件: editor.c 项目: eukos16/NGUNIX
/* 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;
}
示例#6
0
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;
}
示例#7
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;
}
示例#8
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;
}
示例#9
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;
}
示例#10
0
void GTKFileDialog::AddFilters(const std::vector<const char *> &FileTypes, const std::vector<const char *> &FileTypeNames)
{
	for (uint32_t i = 0; i < FileTypes.size(); i++)
	{
		Filter = gtk_file_filter_new();
		gtk_file_filter_add_pattern(Filter, FileTypes[i]);
		gtk_file_filter_set_name(Filter, FileTypeNames[i]);
		gtk_file_chooser_add_filter(FileDialog, Filter);
		if (i == 0)
			gtk_file_chooser_set_filter(FileDialog, Filter);
	}
}
示例#11
0
/**
 * ev_document_factory_add_filters:
 * @chooser: a #GtkFileChooser
 * @document: a #EvDocument, or %NULL
 *
 * Adds some file filters to @chooser.
 
 * Always add a "All documents" format.
 * 
 * If @document is not %NULL, adds a #GtkFileFilter for @document's MIME type.
 *
 * If @document is %NULL, adds a #GtkFileFilter for each document type that atril
 * can handle.
 */
void
ev_document_factory_add_filters (GtkWidget *chooser, EvDocument *document)
{
	GList         *all_types;
	GtkFileFilter *filter;
	GtkFileFilter *default_filter;
	GtkFileFilter *document_filter;

        g_return_if_fail (GTK_IS_FILE_CHOOSER (chooser));
        g_return_if_fail (document == NULL || EV_IS_DOCUMENT (document));

	all_types = ev_backends_manager_get_all_types_info ();
	
	default_filter = document_filter = filter = gtk_file_filter_new ();
	gtk_file_filter_set_name (filter, _("All Documents"));
	g_list_foreach (all_types, (GFunc)file_filter_add_mime_types, filter);
	gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);

	if (document) {
		EvTypeInfo *info;

		info = ev_backends_manager_get_document_type_info (document);
		default_filter = filter = gtk_file_filter_new ();
		gtk_file_filter_set_name (filter, info->desc);
		file_filter_add_mime_types (info, filter);
		g_free (info);
		gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);
	} else {
		GList *l;

		for (l = all_types; l; l = g_list_next (l)){
			EvTypeInfo *info;

			info = (EvTypeInfo *)l->data;

			default_filter = filter = gtk_file_filter_new ();
			gtk_file_filter_set_name (filter, info->desc);
			file_filter_add_mime_types (info, filter);
			gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter);
		}
	}

	g_list_foreach (all_types, (GFunc)g_free, NULL);
	g_list_free (all_types);

	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 (chooser), filter);

	gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (chooser),
				     document == NULL ? document_filter : default_filter);
}
void GtkFileChooserDialog_::set_filter(Php::Parameters &parameters)
{
	GtkFileFilter *filter;
	if(parameters.size() > 0) {
		Php::Value object_filter = parameters[0];
		GtkFileFilter_ *phpgtk_filter = (GtkFileFilter_ *)object_filter.implementation();
		filter = GTK_FILE_FILTER(phpgtk_filter->get_instance());
	}

	gtk_file_chooser_set_filter (GTK_FILE_CHOOSER(instance), filter);

}
示例#13
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;
}
static void
brasero_file_chooser_set_context (BraseroLayoutObject *object,
				  BraseroLayoutType type)
{
	BraseroFileChooser *self;

	self = BRASERO_FILE_CHOOSER (object);
	if (type == self->priv->type)
		return;

	if (type == BRASERO_LAYOUT_AUDIO)
		gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (self->priv->chooser),
					     self->priv->filter_audio);
	else if (type == BRASERO_LAYOUT_VIDEO)
		gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (self->priv->chooser),
					     self->priv->filter_video);
	else
		gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (self->priv->chooser),
					     self->priv->filter_any);

	self->priv->type = type;
}
示例#15
0
static void add_common_filters_to_gtkchooser(GtkFileFilter *gfilter,
					     GtkWindow *picker,
					     std::string filtername)
{	
	gtk_file_filter_set_name(gfilter, filtername.c_str());
	gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(picker),
				    gfilter);
	GtkFileFilter *allfilter = gtk_file_filter_new();
	gtk_file_filter_add_pattern(allfilter, "*");
	gtk_file_filter_set_name(allfilter, "All Files");
	gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(picker), allfilter);
	gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(picker), gfilter);
}
static void
rejilla_file_chooser_set_context (RejillaLayoutObject *object,
				  RejillaLayoutType type)
{
	RejillaFileChooser *self;

	self = REJILLA_FILE_CHOOSER (object);
	if (type == self->priv->type)
		return;

	if (type == REJILLA_LAYOUT_AUDIO)
		gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (self->priv->chooser),
					     self->priv->filter_audio);
	else if (type == REJILLA_LAYOUT_VIDEO)
		gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (self->priv->chooser),
					     self->priv->filter_video);
	else
		gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (self->priv->chooser),
					     self->priv->filter_any);

	self->priv->type = type;
}
void SludgeProjectManager::postNew()
{
	GtkWidget *dialog;
	GtkFileFilter *filter;
	gboolean success = FALSE;

	dialog = gtk_file_chooser_dialog_new("New SLUDGE Project",
				      NULL,
				      GTK_FILE_CHOOSER_ACTION_SAVE,
				      GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
				      GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
				      NULL);
	gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER (dialog), TRUE);

	filter = gtk_file_filter_new();
	gtk_file_filter_set_name(filter, getFilterName());
	gtk_file_filter_add_pattern(filter, getFilterPattern());
	gtk_file_chooser_set_filter(GTK_FILE_CHOOSER (dialog), filter);

	gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER (dialog), getUntitledFilename());

	if (currentFolder[0] != 0)
	{
		gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (dialog), currentFolder);
	}

	if (gtk_dialog_run(GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
	{
		char *filename;
		filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER (dialog));
		flipBackslashes(&filename);

		doNewProject(filename, fileList, &fileListNum);
		listChanged(FILE_TREEVIEW);
		listChanged(RESOURCE_TREEVIEW);
		gtk_list_store_clear(errorsListStore);
		gtk_widget_set_sensitive(projectRunGameItem, FALSE);

		setFilename(filename);
		setFolderFromFilename(filename);

		g_free(filename);
		success = TRUE;
	}
	gtk_widget_destroy(dialog);

	if (success)
		on_project_settings();

	setupButtons();
}
示例#18
0
文件: gtk.c 项目: Chuongv/uTox
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;
}
示例#20
0
static void
exporter_display_chooser (GcrCertificateExporter *self)
{
	GtkFileFilter* filter;
	GtkWidget *dialog;
	gchar *filename;

	g_assert (!self->pv->chooser_dialog);

	dialog = gtk_file_chooser_dialog_new (_("Export certificate"),
	                     NULL, GTK_FILE_CHOOSER_ACTION_SAVE,
	                     _("_Cancel"), GTK_RESPONSE_CANCEL,
	                     _("_Save"), GTK_RESPONSE_ACCEPT,
	                     NULL);

	self->pv->chooser_dialog = g_object_ref_sink(dialog);
	gtk_dialog_set_default_response (GTK_DIALOG (dialog),
	                                 GTK_RESPONSE_ACCEPT);
	gtk_file_chooser_set_local_only (self->pv->chooser_dialog, FALSE);

	filter = gtk_file_filter_new ();
	gtk_file_filter_set_name (filter, _("Certificate files"));
	gtk_file_filter_add_mime_type (filter, "application/x-x509-ca-cert");
	gtk_file_filter_add_mime_type (filter, "application/x-x509-user-cert");
	gtk_file_filter_add_mime_type (filter, "application/pkix-cert");
	gtk_file_filter_add_pattern (filter, "*.cer");
	gtk_file_filter_add_pattern (filter, "*.crt");
	g_object_set_data (G_OBJECT (filter), "prepare-data-func", prepare_data_for_der);
	gtk_file_chooser_add_filter (self->pv->chooser_dialog, filter);
	gtk_file_chooser_set_filter (self->pv->chooser_dialog, filter);

	filter = gtk_file_filter_new ();
	gtk_file_filter_set_name (filter, _("PEM files"));
	gtk_file_filter_add_mime_type (filter, "text/plain");
	gtk_file_filter_add_pattern (filter, "*.pem");
	g_object_set_data (G_OBJECT (filter), "prepare-data-func", prepare_data_for_pem);
	gtk_file_chooser_add_filter (self->pv->chooser_dialog, filter);

	filename = g_strconcat (self->pv->label, ".crt", NULL);
	g_strdelimit (filename, BAD_FILENAME_CHARS, '_');
	gtk_file_chooser_set_current_name (self->pv->chooser_dialog, filename);
	g_free (filename);

	g_signal_connect (self->pv->chooser_dialog, "response",
	                  G_CALLBACK (on_chooser_dialog_response), self);
	if (self->pv->cancellable)
		g_cancellable_connect (self->pv->cancellable,
		                       G_CALLBACK (on_cancel_chooser_dialog), self, NULL);

	gtk_widget_show (GTK_WIDGET (self->pv->chooser_dialog));
}
示例#21
0
void
on_style_add_clicked(GtkButton *button, I7App *app)
{
	/* From gedit/dialogs/gedit-preferences-dialog.c */
	GtkWidget *chooser = gtk_file_chooser_dialog_new(_("Add Color Scheme"),
		GTK_WINDOW(app->prefs->window),	GTK_FILE_CHOOSER_ACTION_OPEN,
		GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
		GTK_STOCK_ADD, GTK_RESPONSE_ACCEPT,
		NULL);
	gtk_window_set_destroy_with_parent(GTK_WINDOW(chooser), TRUE);

	/* Filters */
	GtkFileFilter *filter = gtk_file_filter_new();
	gtk_file_filter_set_name(filter, _("Color Scheme Files"));
	gtk_file_filter_add_pattern(filter, "*.xml");
	gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(chooser), filter);
	gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(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(chooser), filter);

	gtk_dialog_set_default_response(GTK_DIALOG(chooser), GTK_RESPONSE_ACCEPT);

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

	GFile *file = gtk_file_chooser_get_file(GTK_FILE_CHOOSER(chooser));
	if(!file)
		return;

	gtk_widget_destroy(chooser);

	const char *scheme_id = i7_app_install_color_scheme(app, file);
	g_object_unref(file);

	if(!scheme_id) {
		error_dialog(GTK_WINDOW(app->prefs->window), NULL, _("The selected color scheme cannot be installed."));
		return;
	}

	populate_schemes_list(app->prefs->schemes_list);

	I7App *theapp = i7_app_get();
	GSettings *prefs = i7_app_get_prefs(theapp);
	g_settings_set_string(prefs, PREFS_STYLE_SCHEME, scheme_id);
}
示例#22
0
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
}
示例#23
0
static void
open_cb (GSimpleAction *action,
	 GVariant      *parameter,
	 gpointer       app)
{
	GtkWidget     *dialog;
	GtkWindow     *win;
	const char    *home_path;
	GFile	      *home;
	GtkFileFilter *filter_audio;
	GtkFileFilter *filter_all;
	gchar         *uri = NULL;

	win = gtk_application_get_active_window (app);
	dialog = gtk_file_chooser_dialog_new (
			_("Open Audio File"),
			win,
			GTK_FILE_CHOOSER_ACTION_OPEN,
			_("_Cancel"), GTK_RESPONSE_CANCEL,
			_("_Open"), GTK_RESPONSE_ACCEPT,
			NULL);

	/* Set current folder to user's home directory */
	home_path = g_get_home_dir ();
	home = g_file_new_for_path (home_path);
	gtk_file_chooser_set_current_folder_file (GTK_FILE_CHOOSER (dialog), home, NULL);

	filter_audio = gtk_file_filter_new ();
	filter_all = gtk_file_filter_new ();
	gtk_file_filter_set_name (filter_audio, _("Audio files"));
	gtk_file_filter_set_name (filter_all, _("All files"));
	gtk_file_filter_add_mime_type (filter_audio, "audio/*");
	gtk_file_filter_add_pattern (filter_all, "*");
	gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter_audio);
	gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter_all);
	gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog), filter_audio);

	if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) {
		uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (dialog));
	}

	g_object_unref (home);
	gtk_widget_destroy (dialog);

	if (uri) {
		pt_window_open_file (PT_WINDOW (win), uri);
		g_free (uri);
	}
}
示例#24
0
static void
gwy_app_file_chooser_filter_toggled(GwyAppFileChooser *chooser,
                                    GtkToggleButton *check)
{
    gboolean active;
    gchar *key;

    active = gtk_toggle_button_get_active(check);
    gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(chooser),
                                active ? chooser->filter : chooser->no_filter);
    key = g_strconcat(chooser->prefix, "/filter", NULL);
    gwy_container_set_boolean_by_name(gwy_app_settings_get(), key, active);
    g_free(key);
    gwy_app_file_chooser_update_expander(chooser);
}
示例#25
0
static void
set_file_filter_loadplaylist(GtkFileChooser *dlg)
{
    GtkFileFilter* flt;
    flt = gtk_file_filter_new ();
    gtk_file_filter_set_name (flt, _("Supported playlist formats"));
    gtk_file_filter_add_custom (flt, GTK_FILE_FILTER_FILENAME, playlist_filter_func, NULL, NULL);
    gtk_file_filter_add_pattern (flt, "*.dbpl");
    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, _("Other files (*)"));
    gtk_file_filter_add_pattern (flt, "*");
    gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dlg), flt);
}
示例#26
0
int
clip_GTK_FILECHOOSERSETFILTER(ClipMachine * ClipMachineMemory)
{
   C_object *cchooser = _fetch_co_arg(ClipMachineMemory);

   C_object *cfilter = _fetch_cobject(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2));

   CHECKCOBJ(cchooser, GTK_IS_FILE_CHOOSER(cchooser->object));
   CHECKCOBJ(cfilter, GTK_IS_FILE_FILTER(cfilter->object));

   gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(cchooser->object), GTK_FILE_FILTER(cfilter->object));

   return 0;
 err:
   return 1;
}
ZLGtkOpenFileDialog::ZLGtkOpenFileDialog(const std::string &title, const std::string &directoryPath, const std::string &filePath, const Filter &filter) {
	myDialog = GTK_DIALOG(gtk_file_chooser_dialog_new(
		title.c_str(), 0, GTK_FILE_CHOOSER_ACTION_OPEN,
		gtkString(ZLDialogManager::buttonName(ZLDialogManager::CANCEL_BUTTON)).c_str(),
			GTK_RESPONSE_CANCEL,
		gtkString(ZLDialogManager::buttonName(ZLDialogManager::OK_BUTTON)).c_str(),
			GTK_RESPONSE_ACCEPT,
		0
	));
	GtkFileChooser *chooser = GTK_FILE_CHOOSER(myDialog);
	gtk_file_chooser_set_current_folder(chooser, directoryPath.c_str());
	gtk_file_chooser_set_filename(chooser, filePath.c_str());
	GtkFileFilter *gtkFilter = gtk_file_filter_new();
	gtk_file_filter_add_custom(gtkFilter, (GtkFileFilterFlags)(GTK_FILE_FILTER_FILENAME | GTK_FILE_FILTER_MIME_TYPE), filterHandler, (void*)&filter, 0);
	gtk_file_chooser_set_filter(chooser, gtkFilter);
}
示例#28
0
void
gdb_on_printer_add (GtkButton *button, gpointer user_data)
{
	PreferenceDialog *dlg = (PreferenceDialog *)user_data;
	GtkWidget *chooser;
	GtkFileFilter *filter;
	
	chooser = gtk_file_chooser_dialog_new (_("Select a pretty printer file"),
					GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (button))),
					GTK_FILE_CHOOSER_ACTION_OPEN,
					GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
					GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
					NULL);
	filter = gtk_file_filter_new ();
	gtk_file_filter_add_mime_type (filter, "text/x-python");
	gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (chooser), TRUE);
	gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (chooser),filter);

	if (gtk_dialog_run (GTK_DIALOG (chooser)) == GTK_RESPONSE_ACCEPT)
	{
		GSList *filenames;
		GSList *item;
		
		filenames = gtk_file_chooser_get_filenames (GTK_FILE_CHOOSER (chooser));

		for (item = filenames; item != NULL; item = g_slist_next (item))
		{
			GtkTreeIter iter;
			gchar *path = (gchar *)item->data;
			gchar *function;
			
			function = gdb_find_register_function (path);
			
			gtk_list_store_append (dlg->model, &iter);
			gtk_list_store_set (dlg->model, &iter, GDB_PP_ACTIVE_COLUMN, TRUE,
												GDB_PP_FILENAME_COLUMN, path,
												GDB_PP_REGISTER_COLUMN, function,
												-1);
			g_free (path);
			g_free (function);
			
			gdb_check_register_function (dlg, &iter);
		}
		g_slist_free (filenames);
	}
	gtk_widget_destroy (chooser);
}
示例#29
0
static GtkWidget *
cdisplay_proof_file_chooser_dialog_new (void)
{
  GtkWidget     *dialog;
  GtkFileFilter *filter;

  dialog = gtk_file_chooser_dialog_new (_("Choose an ICC Color Profile"),
                                        NULL,
                                        GTK_FILE_CHOOSER_ACTION_OPEN,

                                        GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
                                        GTK_STOCK_OPEN,   GTK_RESPONSE_ACCEPT,

                                        NULL);

  gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
                                           GTK_RESPONSE_ACCEPT,
                                           GTK_RESPONSE_CANCEL,
                                           -1);

  gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_ACCEPT);

#ifndef G_OS_WIN32
  {
    const gchar folder[] = "/usr/share/color/icc";

    if (g_file_test (folder, G_FILE_TEST_IS_DIR))
      gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (dialog),
                                            folder, NULL);
  }
#endif

  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);

  return dialog;
}
void SludgeApplication::saveToFile()
{
	GtkWidget *dialog;
	GtkFileFilter *filter;

	dialog = gtk_file_chooser_dialog_new ("Save File",
				      NULL,
				      GTK_FILE_CHOOSER_ACTION_SAVE,
				      GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
				      GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
				      NULL);
	gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);

	filter = gtk_file_filter_new();
	gtk_file_filter_set_name(filter, getFilterName());
	gtk_file_filter_add_pattern(filter, getFilterPattern());
	gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog), filter);

	if (currentShortname[0] != 0)
	{
		gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), currentShortname);
	}
	if (currentFolder[0] != 0)
	{
		gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), currentFolder);
	}

	if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
	{
		char *filename;
		filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
		flipBackslashes(&filename);

		if (!saveFile (filename))
		{
			errorBox ("Error", "Saving file failed.");
		}
		else
		{
			setFilename(filename);
			setFolderFromFilename(filename);
		}

		g_free (filename);
	}
	gtk_widget_destroy (dialog);
}