Пример #1
0
void
rejilla_mime_filter_add_mime (RejillaMimeFilter *filter,
                              const gchar *mime)
{
	GtkFileFilter *item;

	item = g_hash_table_lookup (filter->priv->table, mime);
	if (!item) {
		GIcon *icon;
		GtkTreeIter row;
		gchar *description;
		GtkTreeModel *model;

		description = g_content_type_get_description (mime);
		icon = g_content_type_get_icon (mime);

		/* create the GtkFileFilter */
		item = gtk_file_filter_new ();
		gtk_file_filter_set_name (item, mime);
		gtk_file_filter_add_mime_type (item, mime);
		g_hash_table_insert (filter->priv->table,
				     g_strdup (mime),
				     item);

		g_object_add_toggle_ref (G_OBJECT (item),
		                         (GToggleNotify) rejilla_mime_filter_destroy_item_cb,
		                         filter);

		model = gtk_combo_box_get_model (GTK_COMBO_BOX (filter->combo));
		gtk_list_store_append (GTK_LIST_STORE (model), &row);

		g_object_ref_sink (item);
		gtk_list_store_set (GTK_LIST_STORE (model), &row,
				    REJILLA_MIME_FILTER_DISPLAY_COL, description,
				    REJILLA_MIME_FILTER_ICON_COL, icon,
				    REJILLA_MIME_FILTER_FILTER_COL, item,
				    -1);
		g_object_unref (icon);
		g_free (description);

		/* we check that the first entry at least is visible */
		if (gtk_combo_box_get_active (GTK_COMBO_BOX (filter->combo)) == -1
		&&  gtk_tree_model_get_iter_first (model, &row) == TRUE)
			gtk_combo_box_set_active_iter (GTK_COMBO_BOX (filter->combo),
						       &row);
	}
	else
		g_object_ref (item);
}
Пример #2
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
}
Пример #3
0
void gtkui_file_open() {
	// Open a file using a GTK+ dialog
	GtkWidget *dialog = gtk_file_chooser_dialog_new(
				"Select a ROM",
				GTK_WINDOW(gtkwindow),
				GTK_FILE_CHOOSER_ACTION_OPEN,
				"Cancel", GTK_RESPONSE_CANCEL,
				"Open", GTK_RESPONSE_ACCEPT,
				NULL);
	
	if(conf.misc_last_folder != NULL)
		gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), conf.misc_last_folder);
	
	GtkFileFilter *filter = gtk_file_filter_new();
	
	gtk_file_filter_set_name(filter, "NES ROMs and Archives");
	gtk_file_filter_add_pattern(filter, "*.nes");
	gtk_file_filter_add_pattern(filter, "*.fds");
	gtk_file_filter_add_pattern(filter, "*.unf");
	gtk_file_filter_add_pattern(filter, "*.unif");
	gtk_file_filter_add_pattern(filter, "*.nsf");
	gtk_file_filter_add_pattern(filter, "*.zip");
	gtk_file_filter_add_pattern(filter, "*.7z");
	gtk_file_filter_add_pattern(filter, "*.txz");
	gtk_file_filter_add_pattern(filter, "*.tar.xz");
	gtk_file_filter_add_pattern(filter, "*.xz");
	gtk_file_filter_add_pattern(filter, "*.tgz");
	gtk_file_filter_add_pattern(filter, "*.tar.gz");
	gtk_file_filter_add_pattern(filter, "*.gz");
	gtk_file_filter_add_pattern(filter, "*.tbz");
	gtk_file_filter_add_pattern(filter, "*.tar.bz2");
	gtk_file_filter_add_pattern(filter, "*.bz2");
	
	gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter);
	
	if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
		char *filename;
		filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
		
		if(conf.misc_last_folder != NULL)
			free(conf.misc_last_folder);
			
		conf.misc_last_folder = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(dialog));
		gtk_widget_destroy(dialog);
		nst_load(filename);
		g_free(filename);
	}
	else { gtk_widget_destroy(dialog); }
}
Пример #4
0
static void
set_file_filter_saveplaylist (GtkFileChooser *dlg) {
    GtkFileFilter* flt;
    flt = gtk_file_filter_new ();
    gtk_file_filter_set_name (flt, _("DeaDBeeF playlist files (*.dbpl)"));
    gtk_file_filter_add_pattern (flt, "*.dbpl");
    gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dlg), flt);
    DB_playlist_t **plug = deadbeef->plug_get_playlist_list ();
    for (int i = 0; plug[i]; i++) {
        if (plug[i]->extensions && plug[i]->load) {
            const char **exts = plug[i]->extensions;
            if (exts && plug[i]->save) {
                for (int e = 0; exts[e]; e++) {
                    char s[100];
                    flt = gtk_file_filter_new ();
                    gtk_file_filter_set_name (flt, exts[e]);
                    snprintf (s, sizeof (s), "*.%s", exts[e]);
                    gtk_file_filter_add_pattern (flt, s);
                    gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dlg), flt);
                }
            }
        }
    }
}
Пример #5
0
static GtkFileFilter *
set_file_filter (GtkFileChooser *dlg, const char *name) {
    if (!name) {
        name = _("Supported sound formats");
    }
    static char extlist[10000];

    // Build extension list
    if (extlist[0] == '\0') {
        DB_decoder_t **codecs = deadbeef->plug_get_decoder_list ();
        for (int i = 0; codecs[i]; i++) {
            if (codecs[i]->exts && codecs[i]->insert) {
                const char **exts = codecs[i]->exts;
                for (int e = 0; exts[e]; e++) {
                    char buf[100];
                    snprintf (buf, sizeof (buf), "*.%s;", exts[e]);
                    strcat (extlist, buf);
                }
            }
        }
    }

    GtkFileFilter* flt;

    flt = gtk_file_filter_new ();
    gtk_file_filter_set_name (flt, name);
    gtk_file_filter_add_pattern (flt, extlist);
    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;
}
Пример #6
0
static gboolean create_file_filter(lua_State* L, GtkFileChooser*dlg, const gchar*mask)
{
	gchar **patterns=NULL;
	if (mask && *mask) {
		patterns=g_strsplit(mask, "|", 64);
		if (patterns) {
			gchar**pattern=patterns;
			if (g_strv_length(patterns)%2) {
				g_strfreev(patterns);
				return FALSE;
			}
			while (*pattern) {
				if (!**pattern) {
					g_strfreev(patterns);
					return FALSE;
				}
				pattern++;
			}
			pattern=patterns;
			while (*pattern) {
				gchar*maskname,*wildcard;
				maskname=*pattern;
				pattern++;
				wildcard=*pattern;
				if (maskname && wildcard) {
					GtkFileFilter*filter=gtk_file_filter_new();
					gchar*wc=wildcard;
					gtk_file_filter_set_name(filter, maskname);
					do {
						gchar*sem=strchr(wc,';');
						if (sem) {
							*sem='\0';
							gtk_file_filter_add_pattern(filter,wc);
							wc++;
						} else {
							gtk_file_filter_add_pattern(filter,wc);
							break;
						}
					} while (1);
					gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dlg),filter);
				}
				pattern++;
			}
		}
	}
	if (patterns) { g_strfreev(patterns); }
	return TRUE;
}
Пример #7
0
void FileDialog::SetWildcard(const wxString& wildCard)
{
   // parse filters
   wxArrayString wildDescriptions, wildFilters;
   if (!wxParseCommonDialogsFilter(wildCard, wildDescriptions, wildFilters))
   {
      wxFAIL_MSG( wxT("FileDialog::SetWildCard - bad wildcard string") );
   }
   else
   {
      // Parsing went fine. Set m_wildCard to be returned by FileDialogBase::GetWildcard
      m_wildCard = wildCard;
      
      GtkFileChooser* chooser = GTK_FILE_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);
      
      // 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(wildDescriptions[n]));

         m_patterns.Add(wildFilters[n]);
         wxStringTokenizer exttok(wildFilters[n], wxT(";"));
         while (exttok.HasMoreTokens())
         {
            wxString token = exttok.GetNextToken();
            gtk_file_filter_add_pattern(filter, wxGTK_CONV(token));
         }
         
         gtk_file_chooser_add_filter(chooser, filter);
      }
      
      // Reset the filter index
      SetFilterIndex(0);
   }
}
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);
}
Пример #9
0
void cir_gtk_file_open() {
	// Open a file using a GTK+ dialog
	GtkWidget *dialog = gtk_file_chooser_dialog_new(
				"Select a ROM",
				GTK_WINDOW(mainwindow),
				GTK_FILE_CHOOSER_ACTION_OPEN,
				("_Cancel"), GTK_RESPONSE_CANCEL,
				("_Open"), GTK_RESPONSE_ACCEPT,
				NULL);
	
	GtkFileFilter *filter = gtk_file_filter_new();
	gtk_file_filter_set_name(filter, "NES ROMs");
	gtk_file_filter_add_pattern(filter, "*.nes");
	gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter);
	
	if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
		char *filename;
		filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
		gtk_widget_destroy(dialog);
		
		cir_rom_cleanup(); romloaded = 0;
		
		if (cir_rom_load(filename)) {
			
			cir_gtk_reset_spinbuttons();
			
			// Split the header and the ROM
			cir_rom_split_header_rom();
			
			if (cir_header_validate()) {
				// Check header version
				version = cir_header_get_version();
				cir_gtk_header_parse();
				char message[128];
				snprintf(message, sizeof(message), "Loaded: %s", filename);
				cir_gtk_status_update(message);
				cir_gtk_set_sensitive();
				romloaded = 1;
			}
			else { cir_gtk_message("Invalid File (No NES ROM Header)"); }
		}
		
		g_free(filename);
	}
	else { gtk_widget_destroy(dialog); }
}
Пример #10
0
void fileio_do_movie_load(void)
{
	Nes::Api::Machine machine( emulator );
	Nes::Api::Movie movie( emulator );
	GtkWidget *dialog;
	GtkFileFilter *filter;

	if (moviePlayFile)
	{
		delete moviePlayFile;
		moviePlayFile = NULL;
	}

	dialog = gtk_file_chooser_dialog_new ("Load a movie (.nsv)",
					      GTK_WINDOW(mainwindow),
					      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_set_name(filter, "Nestopia movies");
	gtk_file_filter_add_pattern(filter, "*.nsv");
	gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter);

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

		moviePlayFile = new std::ifstream( filename, std::ifstream::in|std::ifstream::binary ); 

		if (moviePlayFile->is_open())
		{
			movie.Play(*moviePlayFile);
		}
		else
		{
			delete moviePlayFile;
			moviePlayFile = NULL;
		}

		g_free (filename);
	}

	gtk_widget_destroy(dialog);
}
Пример #11
0
int
clip_GTK_FILEFILTERSETNAME(ClipMachine * cm)
{
        C_object  *cfilter = _fetch_co_arg(cm);
        gchar        *name = _clip_parc(cm, 2);

	CHECKCOBJ(cfilter, GTK_IS_FILE_FILTER(cfilter->object));
        CHECKARG(2, CHARACTER_t);

	LOCALE_TO_UTF(name);
	gtk_file_filter_set_name(GTK_FILE_FILTER(cfilter->object), name);
        FREE_TEXT(name);

	return 0;
err:
	return 1;
}
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);
	}
}
Пример #13
0
static void file_open(GtkWidget *w, gpointer data)
{
	GtkWidget *dialog;
	GtkFileFilter *filter;

	dialog = gtk_file_chooser_dialog_new("Open File",
		GTK_WINDOW(main_window),
		GTK_FILE_CHOOSER_ACTION_OPEN,
		GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
		GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
		NULL);
	gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), TRUE);

	filter = gtk_file_filter_new();
	gtk_file_filter_add_pattern(filter, "*.xml");
	gtk_file_filter_add_pattern(filter, "*.XML");
	gtk_file_filter_add_pattern(filter, "*.sda");
	gtk_file_filter_add_pattern(filter, "*.SDA");
	gtk_file_filter_add_mime_type(filter, "text/xml");
	gtk_file_filter_set_name(filter, "XML file");
	gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter);

	if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
		GSList *filenames;
		char *filename;
		filenames = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dialog));
		
		GError *error = NULL;
		while(filenames != NULL) {
			filename = filenames->data;
			parse_xml_file(filename, &error);
			if (error != NULL)
			{
				report_error(error);
				g_error_free(error);
				error = NULL;
			}
			
			g_free(filename);
			filenames = g_slist_next(filenames);
		}
		g_slist_free(filenames);
		report_dives(FALSE);
	}
	gtk_widget_destroy(dialog);
}
static void
on_load_clicked(GtkWidget* widget,
                void*      handle)
{
	FeedbackSuppressorUI* ui = (FeedbackSuppressorUI*)handle;

	/* Create a dialog to select a sample file. */
	GtkWidget* dialog = gtk_file_chooser_dialog_new(
		"Load Sample",
		NULL,
		GTK_FILE_CHOOSER_ACTION_OPEN,
		GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
		GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
		NULL);

	GtkFileFilter *filter = gtk_file_filter_new();
	gtk_file_filter_set_name(filter, "Filter Lists");
	gtk_file_filter_add_pattern(filter,"*.ofs");
	gtk_file_chooser_add_filter((GtkFileChooser *) dialog,filter);

	/* Run the dialog, and return if it is cancelled. */
	if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
		gtk_widget_destroy(dialog);
		return;
	}

	/* Get the file path from the dialog. */
	char* filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));

	/* Got what we need, destroy the dialog and filter. */
	gtk_widget_destroy(dialog);

#define OBJ_BUF_SIZE 1024
	uint8_t obj_buf[OBJ_BUF_SIZE];
	lv2_atom_forge_set_buffer(&ui->forge, obj_buf, OBJ_BUF_SIZE);

	LV2_Atom* msg = write_set_file(&ui->forge, &ui->uris,
	                               filename, strlen(filename));

	ui->write(ui->controller, 0, lv2_atom_total_size(msg),
	          ui->uris.atom_eventTransfer,
	          msg);

	g_free(filename);
}
Пример #15
0
void
on_save_preset_clicked                  (GtkMenuItem       *menuitem,
        gpointer         user_data) {
    GtkWidget *dlg = gtk_file_chooser_dialog_new (_("Save DeaDBeeF EQ Preset"), GTK_WINDOW (mainwin), GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_OK, NULL);

    gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dlg), TRUE);
    gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dlg), "untitled.ddbeq");

    GtkFileFilter* flt;
    flt = gtk_file_filter_new ();
    gtk_file_filter_set_name (flt, _("DeaDBeeF EQ preset files (*.ddbeq)"));
    gtk_file_filter_add_pattern (flt, "*.ddbeq");

    gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dlg), flt);

    if (gtk_dialog_run (GTK_DIALOG (dlg)) == GTK_RESPONSE_OK)
    {
        gchar *fname = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dlg));
        gtk_widget_destroy (dlg);

        if (fname) {
            FILE *fp = fopen (fname, "w+b");
            if (fp) {
                ddb_dsp_context_t *eq = get_supereq ();
                if (eq) {
                    char fv[100];
                    float v;
                    for (int i = 0; i < 18; i++) {
                        eq->plugin->get_param (eq, i+1, fv, sizeof (fv));
                        v = atof (fv);
                        fprintf (fp, "%f\n", v);
                    }
                    eq->plugin->get_param (eq, 0, fv, sizeof (fv));
                    v = atof (fv);
                    fprintf (fp, "%f\n", v);
                }
                fclose (fp);
            }
            g_free (fname);
        }
    }
    else {
        gtk_widget_destroy (dlg);
    }
}
Пример #16
0
static GdkPixbuf *
choose_new_face (void)
{
	GdkPixbuf *res = NULL;
	GtkWidget *filesel, *preview;
	GtkFileFilter *filter;

	filesel = gtk_file_chooser_dialog_new (
				_("Select a Face Picture"),
				NULL,
				GTK_FILE_CHOOSER_ACTION_OPEN,
				GTK_STOCK_CANCEL,
				GTK_RESPONSE_CANCEL,
				GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL);

	gtk_dialog_set_default_response (GTK_DIALOG (filesel), GTK_RESPONSE_OK);

	filter = gtk_file_filter_new ();
	gtk_file_filter_set_name (filter, _("Image files"));
	gtk_file_filter_add_mime_type (filter, "image/*");
	gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (filesel), filter);

	preview = gtk_image_new ();
	gtk_file_chooser_set_preview_widget (GTK_FILE_CHOOSER (filesel), preview);
	g_signal_connect (filesel, "update-preview", G_CALLBACK (update_preview_cb), preview);

	if (GTK_RESPONSE_OK == gtk_dialog_run (GTK_DIALOG (filesel))) {
		gchar *image_filename, *file_contents = NULL;
		gsize length = 0;

		image_filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (filesel));
		gtk_widget_destroy (filesel);

		if (prepare_image (image_filename, &file_contents, &length, &res, TRUE)) {
			set_face_raw (file_contents, length);
		}

		g_free (file_contents);
		g_free (image_filename);
	} else {
		gtk_widget_destroy (filesel);
	}

	return res;
}
Пример #17
0
static void
byzanz_encoder_flv_class_init (ByzanzEncoderFlvClass *klass)
{
  ByzanzEncoderClass *encoder_class = BYZANZ_ENCODER_CLASS (klass);
  ByzanzEncoderGStreamerClass *gstreamer_class = BYZANZ_ENCODER_GSTREAMER_CLASS (klass);

  encoder_class->filter = gtk_file_filter_new ();
  g_object_ref_sink (encoder_class->filter);
  gtk_file_filter_set_name (encoder_class->filter, _("Flash video"));
  gtk_file_filter_add_mime_type (encoder_class->filter, "video/x-flv");
  gtk_file_filter_add_pattern (encoder_class->filter, "*.flv");

  gstreamer_class->pipeline_string = 
    "appsrc name=src ! videoconvert ! avenc_flashsv buffer-size=8388608 ! flvmux ! giostreamsink name=sink";
  gstreamer_class->audio_pipeline_string = 
    "autoaudiosrc name=audiosrc ! audioconvert ! audio/x-raw-int,width=16 ! queue ! flvmux name=muxer ! giostreamsink name=sink "
    "appsrc name=src ! videoconvert ! avenc_flashsv buffer-size=8388608 ! muxer.";
}
Пример #18
0
static void
byzanz_encoder_byzanz_class_init (ByzanzEncoderByzanzClass *klass)
{
  ByzanzEncoderClass *encoder_class = BYZANZ_ENCODER_CLASS (klass);

  /* We don't use the run vfunc and just g_output_stream_slice() here,
   * because this way we get data verification.
   */
  encoder_class->setup = byzanz_encoder_byzanz_setup;
  encoder_class->process = byzanz_encoder_byzanz_process;
  encoder_class->close = byzanz_encoder_byzanz_close;

  encoder_class->filter = gtk_file_filter_new ();
  g_object_ref_sink (encoder_class->filter);
  gtk_file_filter_set_name (encoder_class->filter, _("Byzanz debug files"));
  gtk_file_filter_add_mime_type (encoder_class->filter, "application/x-byzanz");
  gtk_file_filter_add_pattern (encoder_class->filter, "*.byzanz");
}
Пример #19
0
void add_dialog_filters(GtkWidget *dialog, char * const p_types[], uint4 p_type_count )
{
	GtkFileFilter *filter ;
	
	if ( p_type_count >= 1 ) 
	{
		for (uint4 a=0; a < p_type_count; a++)
		{
			char *t_filter_name, *t_filter_masks;
			t_filter_name = get_filter_name(p_types[a]);
			t_filter_masks = get_filter_masks(p_types[a]);

			filter = gtk_file_filter_new();
			gtk_file_filter_set_name(filter, t_filter_name);
			
			if (strcasecmp (t_filter_name, "All files") != 0)
			{
				for ( uint4 m = 0 ; m < get_filter_count(t_filter_masks); m++)
				{
					char *t_filter_mask;
					t_filter_mask = get_filter_mask(m, t_filter_masks);
					
					char *filter_mask;
					filter_mask = nil;
					MCCStringFormat(filter_mask, "*.%s", t_filter_mask);

					gtk_file_filter_add_pattern(filter, filter_mask);

					MCCStringFree(filter_mask);
					delete t_filter_mask;
				}
			}
			else
				gtk_file_filter_add_pattern ( filter, "*" );

			gtk_file_chooser_add_filter ( GTK_FILE_CHOOSER ( dialog ) , filter ) ;

			delete t_filter_name;
			delete t_filter_masks;
		}
	}
		
}
Пример #20
0
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;
}
Пример #21
0
void ui_save_file_cb(GtkWidget* widget, gpointer data)
{
    GtkWidget *filedialog;
    GtkFileFilter *filefilter;

    filedialog = gtk_file_chooser_dialog_new("Save...",
                 GTK_WINDOW(ui_window),
                 GTK_FILE_CHOOSER_ACTION_SAVE,
                 GTK_STOCK_CANCEL,
                 GTK_RESPONSE_CANCEL,
                 GTK_STOCK_SAVE,
                 GTK_RESPONSE_ACCEPT,
                 NULL);

    GList *handlers = io_get_save_handlers();
    GList *iter;

    for(iter = g_list_first(handlers); iter; iter = g_list_next(iter)) {
        plugin_save_handler_t *handler = (plugin_save_handler_t *) iter->data;

        filefilter = gtk_file_filter_new();
        gtk_file_filter_set_name(GTK_FILE_FILTER(filefilter),
                                 handler->desc);
        int i;
        for(i=0; i<handler->nfilters; i++) {
            gtk_file_filter_add_pattern(GTK_FILE_FILTER(filefilter),
                                        (char*) handler->filters[i]);
        }
        gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filedialog),
                                    filefilter);
        g_object_set_data(G_OBJECT(filefilter), "handler", (gpointer) handler);
    }
    g_list_free(handlers);

    if(gtk_dialog_run(GTK_DIALOG(filedialog)) == GTK_RESPONSE_ACCEPT) {
        GtkWidget* filter = gtk_file_chooser_get_filter(GTK_FILE_CHOOSER(filedialog));
        plugin_save_handler_t *handler = g_object_get_data(G_OBJECT(filter), "handler");
        gchar *path = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(filedialog));
        io_save_image(path, handler);
    }
    gtk_widget_destroy(GTK_WIDGET(filedialog));
}
Пример #22
0
static void
byzanz_encoder_webm_class_init (ByzanzEncoderWebmClass *klass)
{
  ByzanzEncoderClass *encoder_class = BYZANZ_ENCODER_CLASS (klass);
  ByzanzEncoderGStreamerClass *gstreamer_class = BYZANZ_ENCODER_GSTREAMER_CLASS (klass);

  encoder_class->filter = gtk_file_filter_new ();
  g_object_ref_sink (encoder_class->filter);
  gtk_file_filter_set_name (encoder_class->filter, _("WebM video"));
  gtk_file_filter_add_mime_type (encoder_class->filter, "video/webm");
  gtk_file_filter_add_pattern (encoder_class->filter, "*.webm");

  gstreamer_class->pipeline_string = 
    "appsrc name=src ! videoconvert ! videorate ! "
    "video/x-raw,format=I420,framerate=25/1 ! vp8enc ! webmmux ! giostreamsink name=sink";
  gstreamer_class->audio_pipeline_string = 
    "autoaudiosrc name=audiosrc ! audioconvert ! vorbisenc ! queue ! webmmux name=muxer ! giostreamsink name=sink "
    "appsrc name=src ! videoconvert ! videorate ! "
    "video/x-raw,format=I420,framerate=25/1 ! vp8enc ! queue ! muxer.";
}
Пример #23
0
static GtkFileFilter*
egg_file_format_filter_new (const gchar *name,
                            gboolean     show_extensions)
{
  GtkFileFilter *filter;
  EggFileFormatFilterInfo *info;

  filter = gtk_file_filter_new ();
  gtk_file_filter_set_name (filter, name);

  info = egg_file_format_filter_info_new (name, show_extensions);

  gtk_file_filter_add_custom (filter, GTK_FILE_FILTER_FILENAME,
                              egg_file_format_filter_filter,
                              info, NULL);
  g_object_set_qdata_full (G_OBJECT (filter),
                           egg_file_format_filter_info_quark (),
                           info, egg_file_format_filter_info_free);

  return filter;
}
Пример #24
0
static void
byzanz_encoder_ogv_class_init (ByzanzEncoderOgvClass *klass)
{
  ByzanzEncoderClass *encoder_class = BYZANZ_ENCODER_CLASS (klass);
  ByzanzEncoderGStreamerClass *gstreamer_class = BYZANZ_ENCODER_GSTREAMER_CLASS (klass);

  encoder_class->filter = gtk_file_filter_new ();
  g_object_ref_sink (encoder_class->filter);
  gtk_file_filter_set_name (encoder_class->filter, _("Theora video"));
  gtk_file_filter_add_mime_type (encoder_class->filter, "video/ogg");
  gtk_file_filter_add_pattern (encoder_class->filter, "*.ogv");
  gtk_file_filter_add_pattern (encoder_class->filter, "*.ogg");

  gstreamer_class->pipeline_string = 
    "appsrc name=src ! videoconvert ! videorate !"
    "video/x-raw,format=Y444,framerate=25/1 ! theoraenc ! oggmux ! giostreamsink name=sink";
  gstreamer_class->audio_pipeline_string = 
    "autoaudiosrc name=audiosrc ! audioconvert ! queue ! oggmux name=muxer ! giostreamsink name=sink "
    "appsrc name=src ! videoconvert ! videorate ! "
    "video/x-raw,format=Y444,framerate=25/1 ! theoraenc ! queue ! muxer.";
}
Пример #25
0
/* See VikDataSourceInterface */
static void datasource_file_add_setup_widgets ( GtkWidget *dialog, VikViewport *vvp, gpointer user_data )
{
  datasource_file_widgets_t *widgets = (datasource_file_widgets_t *)user_data;
  GtkWidget *filename_label, *type_label;

  /* The file selector */
  filename_label = gtk_label_new (_("File:"));
  widgets->file = gtk_file_chooser_button_new (_("File to import"), GTK_FILE_CHOOSER_ACTION_OPEN);
  if (last_folder_uri)
    gtk_file_chooser_set_current_folder_uri ( GTK_FILE_CHOOSER(widgets->file), last_folder_uri);
  /* Add filters */
  g_list_foreach ( a_babel_file_list, add_file_filter, widgets->file );
  GtkFileFilter *all_filter = gtk_file_filter_new ();
  gtk_file_filter_add_pattern ( all_filter, "*" );
  gtk_file_filter_set_name ( all_filter, _("All files") );
  gtk_file_chooser_add_filter ( GTK_FILE_CHOOSER(widgets->file), all_filter );
  if ( last_file_filter == NULL )
    /* No previously selected filter or 'All files' selected */
    gtk_file_chooser_set_filter ( GTK_FILE_CHOOSER(widgets->file), all_filter );

  /* The file format selector */
  type_label = gtk_label_new (_("File type:"));
  /* Propose any readable file */
  BabelMode mode = { 1, 0, 1, 0, 1, 0 };
  widgets->type = a_babel_ui_file_type_selector_new ( mode );
  g_signal_connect ( G_OBJECT(widgets->type), "changed",
      G_CALLBACK(a_babel_ui_type_selector_dialog_sensitivity_cb), dialog );
  gtk_combo_box_set_active ( GTK_COMBO_BOX(widgets->type), last_type );
  /* Manually call the callback to fix the state */
  a_babel_ui_type_selector_dialog_sensitivity_cb ( GTK_COMBO_BOX(widgets->type), dialog );

  /* Packing all these widgets */
  GtkBox *box = GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog)));
  gtk_box_pack_start ( box, filename_label, FALSE, FALSE, 5 );
  gtk_box_pack_start ( box, widgets->file, FALSE, FALSE, 5 );
  gtk_box_pack_start ( box, type_label, FALSE, FALSE, 5 );
  gtk_box_pack_start ( box, widgets->type, FALSE, FALSE, 5 );
  gtk_widget_show_all(dialog);
}
Пример #26
0
static void gwwv_file_def_filters(GtkWidget *dialog, const char *def_name,
	const struct gwwv_filter *filters ) {
    GtkFileFilter *filter, *standard;
    int i;

    g_object_set(G_OBJECT(dialog),"show-hidden",TRUE,NULL);
    if ( def_name!=NULL ) {
	gsize read, written;
	char *temp = g_filename_from_utf8(def_name,-1,&read,&written,NULL);
	char *pt = strrchr( temp,'/');
	if ( pt!=NULL ) {
	    *pt = '\0';
	    gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER( dialog ), temp );
	    gtk_file_chooser_set_current_name( GTK_FILE_CHOOSER( dialog ), pt+1 );
	} else
	    gtk_file_chooser_set_current_name( GTK_FILE_CHOOSER( dialog ), temp );
	free(temp);
    }
    if ( filters!=NULL ) {
	standard = NULL;
	for ( i=0; filters[i].name!=NULL; ++i ) {
	    filter = gtk_file_filter_new();
	    if ( filters[i].filtfunc!=NULL )
		gtk_file_filter_add_custom( filter,GTK_FILE_FILTER_FILENAME,
			filters[i].filtfunc, (gpointer) filters[i].wild, NULL);
	    else
		/* GTK's gtk_file_filter_add_pattern doesn't handled {} wildcards */
		/*  and I depend on those. So I use my own patern matcher */
		gtk_file_filter_add_custom( filter,GTK_FILE_FILTER_FILENAME,
			gwwv_file_pattern_matcher, (gpointer) filters[i].wild, NULL);
	    gtk_file_filter_set_name( filter,filters[i].name );
	    gtk_file_chooser_add_filter( GTK_FILE_CHOOSER( dialog ), filter );
	    if ( i==0 )
		standard = filter;
	}
	if ( standard!=NULL )
	    gtk_file_chooser_set_filter( GTK_FILE_CHOOSER( dialog ), standard );
    }
}
Пример #27
0
void
ol_menu_assign_lrc (GtkWidget *widget, gpointer data)
{
  static char *prev_path = NULL;
  OlMetadata *info = ol_app_get_current_music ();
  GtkFileFilter *lrc_filter = NULL;
  lrc_filter = gtk_file_filter_new ();
  gtk_file_filter_set_name (lrc_filter, _("LRC files"));
  gtk_file_filter_add_pattern (lrc_filter, "*.lrc");
  if (info != NULL)
  {
    ol_debugf ("prev_path: %s\n", prev_path);
    GtkWidget *dialog = NULL;
    dialog = gtk_file_chooser_dialog_new (_("Choose LRC file to assign"),
                                          NULL,
                                          GTK_FILE_CHOOSER_ACTION_OPEN,
                                          GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
                                          GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
                                          NULL);
    gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), lrc_filter);
    
    if (prev_path != NULL)
      gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), prev_path);

    if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
    {
      char *filename;
      filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
      ol_app_assign_lrcfile (info, filename, TRUE);
      g_free (filename);
      if (prev_path != NULL)
        g_free (prev_path);
      prev_path = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (dialog));
    }
    gtk_widget_destroy (dialog);
    dialog = NULL;
  }
}
Пример #28
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("Import Certificate Request",
                                               GTK_WINDOW(data),
                                               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_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, *utf_filename;
            filename =
                gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(file_chooser));
            utf_filename = g_filename_to_utf8(filename, -1, NULL, NULL, NULL);
            g_free(filename);
            gtk_entry_set_text(GTK_ENTRY
                               (g_object_get_data(G_OBJECT(widget), "entry")),
                               utf_filename);
            g_free(utf_filename);
            gtk_widget_destroy(file_chooser);
        }
        else {
            gtk_widget_destroy(file_chooser);
        }
    }
}
Пример #29
0
void gtkui_state_load() {
	// Load a state from the GUI
	GtkWidget *dialog = gtk_file_chooser_dialog_new("Load State (.nst)",
				GTK_WINDOW(gtkwindow),
				GTK_FILE_CHOOSER_ACTION_OPEN,
				GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
				GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
				NULL);

	GtkFileFilter *filter = gtk_file_filter_new();
	gtk_file_filter_set_name(filter, "Nestopia Save States");
	gtk_file_filter_add_pattern(filter, "*.nst");
	gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter);
	gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), nstpaths.statepath);
	
	if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
		char *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
		nst_state_load(filename);
		g_free(filename);
	}
	
	gtk_widget_destroy(dialog);
}
Пример #30
0
void gtkui_cheats_load() {
	// Load cheats from the GUI
	GtkWidget *dialog = gtk_file_chooser_dialog_new("Load cheats (.xml)",
				GTK_WINDOW(gtkwindow),
				GTK_FILE_CHOOSER_ACTION_OPEN,
				"Cancel", GTK_RESPONSE_CANCEL,
				"Open", GTK_RESPONSE_ACCEPT,
				NULL);

	GtkFileFilter *filter = gtk_file_filter_new();
	gtk_file_filter_set_name(filter, "Nestopia cheats");
	gtk_file_filter_add_pattern(filter, "*.xml");
	gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter);
	gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), nstpaths.nstdir);
	
	if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
		char *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
		gtkui_cheats_fill_tree(filename);
		g_free(filename);
	}
	
	gtk_widget_destroy(dialog);
}