static gboolean
file_filter_to_win32 (GtkFileFilter *filter,
COMDLG_FILTERSPEC *spec)
{
const char *name;
char **patterns;
char *pattern_list;
patterns = _gtk_file_filter_get_as_patterns (filter);
if (patterns == NULL)
return FALSE;
pattern_list = g_strjoinv (";", patterns);
g_strfreev (patterns);
name = gtk_file_filter_get_name (filter);
if (name == NULL)
name = pattern_list;
spec->pszName = g_utf8_to_utf16 (name, -1, NULL, NULL, NULL);
spec->pszSpec = g_utf8_to_utf16 (pattern_list, -1, NULL, NULL, NULL);
g_free (pattern_list);
return TRUE;
}
static void
rejilla_mime_filter_destroy_item_cb (RejillaMimeFilter *filter,
GtkFileFilter *item,
gboolean is_last_ref)
{
GtkTreeModel *model;
GtkFileFilter *item2;
GtkTreeIter row;
g_hash_table_remove (filter->priv->table,
gtk_file_filter_get_name (item));
/* Now we must remove the item from the combo as well */
model = gtk_combo_box_get_model (GTK_COMBO_BOX (filter->combo));
if (!gtk_tree_model_get_iter_first (model, &row))
return;
do {
gtk_tree_model_get (model, &row,
REJILLA_MIME_FILTER_FILTER_COL, &item2,
-1);
if (item == item2) {
gtk_list_store_remove (GTK_LIST_STORE (model), &row);
break;
}
} while (gtk_tree_model_iter_next (model, &row));
/* 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);
}
void
rejilla_mime_filter_add_filter (RejillaMimeFilter *filter,
GtkFileFilter *item)
{
GtkTreeModel *model;
GtkTreeIter row;
const char *name;
name = gtk_file_filter_get_name (item);
model = gtk_combo_box_get_model (GTK_COMBO_BOX (filter->combo));
gtk_list_store_append (GTK_LIST_STORE (model), &row);
g_object_ref (item);
gtk_list_store_set (GTK_LIST_STORE (model), &row,
REJILLA_MIME_FILTER_DISPLAY_COL, name,
REJILLA_MIME_FILTER_FILTER_COL, item,
-1);
g_object_ref_sink (GTK_OBJECT (item));
g_hash_table_insert (filter->priv->table,
g_strdup (name),
item);
filter->priv->custom_filters = g_slist_prepend (filter->priv->custom_filters, item);
/* 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);
}
static void RememberCurrentFilter(GtkFileFilter *filter) {
int i, k;
const char *name;
if ( filter==NULL )
return;
name = gtk_file_filter_get_name(filter);
if ( name==NULL )
return;
for ( i=0; def_font_filters[i].name!=NULL; ++i ) {
if ( strcmp(name,_(def_font_filters[i].name))== 0 ) {
if ( *def_font_filters[i].wild!='\0' )
default_font_filter_index = i;
return;
}
}
if ( user_font_filters!=NULL ) {
for ( k=0; user_font_filters[k].name!=NULL; ++i, ++k ) {
if ( strcmp(name,_(user_font_filters[k].name))== 0 ) {
default_font_filter_index = k;
return;
}
}
}
}
const char * get_current_filter_name ( GtkWidget * dialog )
{
GtkFileFilter *filter ;
filter = gtk_file_chooser_get_filter (GTK_FILE_CHOOSER ( dialog ) );
if ( filter != NULL )
return ( gtk_file_filter_get_name ( filter ) );
else
return "\0" ;
}
static void
gnac_ui_file_chooser_cell_data_func(GtkCellLayout *layout,
GtkCellRenderer *cell,
GtkTreeModel *model,
GtkTreeIter *iter,
gpointer data)
{
GtkFileFilter *filter;
gtk_tree_model_get(model, iter, 0, &filter, -1);
g_object_set(cell, "text", gtk_file_filter_get_name(filter), NULL);
}
gchar *file_chooser_get_extension(GtkWidget * chooser, FileTypes * filters)
{
GtkFileFilter *filter;
const gchar *filter_name;
gint i;
filter = gtk_file_chooser_get_filter(GTK_FILE_CHOOSER(chooser));
filter_name = gtk_file_filter_get_name(filter);
for (i = 0; filters[i].name; i++) {
if (g_str_equal(filter_name, filters[i].name)) {
return filters[i].extension;
}
}
return NULL;
}
int
clip_GTK_FILEFILTERGETNAME(ClipMachine * cm)
{
C_object *cfilter = _fetch_co_arg(cm);
gchar *name ;
CHECKCOBJ(cfilter, GTK_IS_FILE_FILTER(cfilter->object));
name = (gchar *)gtk_file_filter_get_name(GTK_FILE_FILTER(cfilter->object));
LOCALE_FROM_UTF(name);
_clip_retc(cm, name);
FREE_TEXT(name);
return 0;
err:
return 1;
}
static void
import_adapt_extension_callback(GtkWidget *widget)
{
int index = gtk_combo_box_get_active (GTK_COMBO_BOX(widget));
GtkFileFilter *former = NULL;
GSList *list, *elem;
list = gtk_file_chooser_list_filters (GTK_FILE_CHOOSER (opendlg));
for (elem = list; elem != NULL; elem = g_slist_next (elem))
if (strcmp (_("Supported Formats"), gtk_file_filter_get_name (GTK_FILE_FILTER(elem->data))) == 0)
former = GTK_FILE_FILTER(elem->data);
g_slist_free (list);
if (former) {
/* replace the previous filter */
GtkFileFilter *filter = build_gtk_file_filter_from_index (index);
gtk_file_chooser_remove_filter (GTK_FILE_CHOOSER (opendlg), former);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (opendlg), filter);
gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (opendlg), filter);
}
}
static void
fsok(GtkWidget *dlg)
{
struct nGetOpenFileData *data;
char *file, *file2, **farray;
const char *filter_name;
int i, k, len, n;
GStatBuf buf;
GSList *top, *list;
GtkFileFilter *filter;
data = &FileSelection;
top = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dlg));
filter = gtk_file_chooser_get_filter(GTK_FILE_CHOOSER(dlg));
if (filter) {
filter_name = gtk_file_filter_get_name(filter);
} else {
filter_name = NULL;
}
if (filter_name == NULL || strcmp(filter_name, _("All")) == 0) {
data->ext = NULL;
}
n = g_slist_length(top);
farray = g_malloc(sizeof(*farray) * (n + 1));
if (farray == NULL) {
free_str_list(top);
return;
}
data->file = farray;
k = 0;
for (list = top; list; list = list->next) {
char *tmp;
tmp = (char *) list->data;
if (tmp == NULL || strlen(tmp) < 1) {
gdk_beep();
continue;
}
file = get_utf8_filename(tmp);
for (i = strlen(file) - 1; (i > 0) && (file[i] != '/') && (file[i] != '.'); i--);
if ((file[i] != '.') && data->ext) {
len = strlen(data->ext) + 1;
} else {
len = 0;
}
if (len) {
file2 = g_strdup_printf("%s.%s", file, data->ext);
g_free(file);
} else {
file2 = file;
}
if (file2) {
if (data->mustexist) {
if ((nstat(file2, &buf) != 0) || ((buf.st_mode & S_IFMT) != S_IFREG)
|| (naccess(file2, R_OK) != 0)) {
gdk_beep();
error22(NULL, 0, "I/O error", file2);
g_free(file2);
continue;
}
} else {
if ((nstat(file2, &buf) == 0) && ((buf.st_mode & S_IFMT) != S_IFREG)) {
gdk_beep();
error22(NULL, 0, "I/O error", file2);
g_free(file2);
continue;
}
}
farray[k] = file2;
k++;
}
}
if (k == 0)
return;
if (data->changedir && k > 0) {
data->chdir = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->chdir_cb));
if (data->chdir && data->init_dir) {
char *dir;
g_free(*(data->init_dir));
dir = g_path_get_dirname(farray[0]);
*(data->init_dir) = dir;
}
}
farray[k] = NULL;
free_str_list(top);
data->ret = IDOK;
}
const char* file_dialog_show(GtkWidget* parent, bool open, const char* title, const char* path, const char* pattern)
{
filetype_t type;
if(pattern == 0)
{
pattern = "*";
}
FileTypeList typelist;
GlobalFiletypes().getTypeList(pattern, &typelist);
GTKMasks masks(typelist);
if (title == 0)
title = open ? "Open File" : "Save File";
GtkWidget* dialog;
if (open)
{
dialog = gtk_file_chooser_dialog_new(title,
GTK_WINDOW(parent),
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
}
else
{
dialog = gtk_file_chooser_dialog_new(title,
GTK_WINDOW(parent),
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
NULL);
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), "unnamed");
}
gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT);
// we expect an actual path below, if the path is 0 we might crash
if (path != 0 && !string_empty(path))
{
ASSERT_MESSAGE(path_is_absolute(path), "file_dialog_show: path not absolute: " << makeQuoted(path));
Array<char> new_path(strlen(path)+1);
// copy path, replacing dir separators as appropriate
Array<char>::iterator w = new_path.begin();
for(const char* r = path; *r != '\0'; ++r)
{
*w++ = (*r == '/') ? G_DIR_SEPARATOR : *r;
}
// remove separator from end of path if required
if(*(w-1) == G_DIR_SEPARATOR)
{
--w;
}
// terminate string
*w = '\0';
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), new_path.data());
}
// we should add all important paths as shortcut folder...
// gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER(dialog), "/tmp/", NULL);
for(std::size_t i = 0; i < masks.m_filters.size(); ++i)
{
GtkFileFilter* filter = gtk_file_filter_new();
gtk_file_filter_add_pattern(filter, masks.m_filters[i].c_str());
gtk_file_filter_set_name(filter, masks.m_masks[i].c_str());
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter);
}
if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
{
strcpy(g_file_dialog_file, gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)));
if(!string_equal(pattern, "*"))
{
GtkFileFilter* filter = gtk_file_chooser_get_filter(GTK_FILE_CHOOSER(dialog));
if(filter != 0) // no filter set? some file-chooser implementations may allow the user to set no filter, which we treat as 'all files'
{
type = masks.GetTypeForGTKMask(gtk_file_filter_get_name(filter)).m_type;
// last ext separator
const char* extension = path_get_extension(g_file_dialog_file);
// no extension
if(string_empty(extension))
{
strcat(g_file_dialog_file, type.pattern+1);
}
else
{
strcpy(g_file_dialog_file + (extension - g_file_dialog_file), type.pattern+2);
}
}
}
// convert back to unix format
for(char* w = g_file_dialog_file; *w!='\0'; w++)
{
if(*w=='\\')
{
*w = '/';
}
}
}
else
{
g_file_dialog_file[0] = '\0';
}
gtk_widget_destroy(dialog);
// don't return an empty filename
if(g_file_dialog_file[0] == '\0') return NULL;
return g_file_dialog_file;
}
static VALUE
ffil_get_name(VALUE self)
{
return CSTR2RVAL(gtk_file_filter_get_name(_SELF(self)));
}
static void cb_load(raw_box* rb)
{
GtkWidget *msg;
GtkFileFilter* filter;
int err;
char *name = (char *)
gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(rb->dialog));
global_settings* settings = settings_get();
const char* filtername;
mixer_flush_preview();
if (!name)
goto fail;
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(rb->check)))
{
int samplerate = gtk_spin_button_get_value_as_int(
GTK_SPIN_BUTTON(rb->samplerate));
if (patch_sample_load(patch, name, samplerate,
rb->channels,
get_format(rb)) < 0)
{
err = pf_error_get();
goto fail;
}
}
else
{ /* don't repeat load sample */
const Sample* s = patch_sample_data(patch);
if (s->filename && strcmp(name, s->filename) == 0)
return;
if (patch_sample_load(patch, name, 0, 0, 0))
{
err = pf_error_get();
goto fail;
}
}
msg_log(MSG_MESSAGE, "loaded sample '%s' for patch %d '%s'\n",
name, patch, patch_get_name(patch));
if (name)
{
char* dirname = g_path_get_dirname(name);
if (dirname)
{
if (settings->last_sample_dir)
free(settings->last_sample_dir);
settings->last_sample_dir = strdup(dirname);
free(dirname);
}
}
/* propagate certain user-set characteristics of the chooser
* into the global settings
*/
filter = gtk_file_chooser_get_filter(GTK_FILE_CHOOSER(rb->dialog));
filtername = gtk_file_filter_get_name(filter);
if (filtername != 0)
{
if (settings->sample_file_filter)
free(settings->sample_file_filter);
settings->sample_file_filter = strdup(filtername);
}
/* the main menu not the chooser sets the global auto-preview on/off
settings->sample_auto_preview =
gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(rb->auto_preview));
*/
return;
fail:
if (!name)
{ /* I don't really think this is possible, but hey. */
msg_log(MSG_ERROR, "no file selected\n");
msg = gtk_message_dialog_new(GTK_WINDOW(rb->dialog),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE,
"No file selected");
}
else
{
msg_log(MSG_ERROR,
"Failed to load sample %s for patch %d (%s)\n",
name, patch, pf_error_str(err));
/* do our own notification here: */
msg = gtk_message_dialog_new(GTK_WINDOW(rb->dialog),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE,
"Failed to load sample %s", name);
}
gtk_dialog_run (GTK_DIALOG(msg));
gtk_widget_destroy(msg);
}
void create_filters(GtkWidget* chooser)
{
typedef struct snd_fmt_names
{
int sf_fmt;
char* ext;
char* name;
} snd_fmt;
snd_fmt alt_exts[] = {
/* libsndfile only provides a single 'most common' extension for
* each format it is capable of reading. Here are some additional
* extensions for selected formats:
* (followed by sndfile provided extension in comments)
*/
{ SF_FORMAT_AIFF, "aif", 0}, /* aiff */
{ SF_FORMAT_CAF, "caff", 0}, /* caf */
{ SF_FORMAT_OGG, "ogg", 0}, /* oga */
{ SF_FORMAT_SD2, "sd2f", 0}, /* sd2 */
{ SF_FORMAT_NIST, "sph", 0}, /* wav */
{ 0, 0, 0 }};
/* stuff for accessing soundfile format information */
snd_fmt sound_formats[99];
SF_FORMAT_INFO sf_fmt;
int sf_fmt_count;
int n;
/* stuff for improving format information */
snd_fmt* fmt;
snd_fmt* n_fmt;
snd_fmt* alt;
char pat[10];
GtkFileFilter* filter = 0;
GSList* f_list;
GSList* f_item;
global_settings* settings = settings_get();
/* generate format information */
sf_command(0, SFC_GET_FORMAT_MAJOR_COUNT, &sf_fmt_count, sizeof(int));
for (fmt = sound_formats, n = 0; n < sf_fmt_count; ++n, ++fmt)
{
sf_fmt.format = n;
sf_command(0, SFC_GET_FORMAT_MAJOR, &sf_fmt, sizeof(sf_fmt));
snprintf(pat, 10, "*.%s", sf_fmt.extension);
pat[9] = '\0';
fmt->sf_fmt = sf_fmt.format;
fmt->name = strdup(sf_fmt.name);
fmt->ext = strdup(pat);
for (n_fmt = fmt, alt = alt_exts; alt->sf_fmt != 0; ++alt)
{
if (alt->sf_fmt == n_fmt->sf_fmt)
{
snprintf(pat, 10, "*.%s", alt->ext);
pat[9] = '\0';
++fmt;
fmt->sf_fmt = sf_fmt.format;
fmt->name = strdup(n_fmt->name);
fmt->ext = strdup(pat);
}
}
}
fmt->name = 0;
fmt->ext = 0;
/* Audio files filter (specifically: files loadable by sndfile) */
filter = gtk_file_filter_new();
gtk_file_filter_set_name(filter, "All Audio files");
for (fmt = sound_formats; fmt->name != 0 && fmt->ext != 0; ++fmt)
{
#if DEBUG
printf("format ext:%s \tname:%s\n", fmt->ext, fmt->name);
#endif
gtk_file_filter_add_pattern(filter, fmt->ext);
}
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(chooser), filter);
/* Individual filters for formats loadable by sndfile
* NOTE: most formats have one file extension, but some have to be
* arkward and have alternative extensions...
*/
for (fmt = sound_formats; fmt->name != 0 && fmt->ext != 0; fmt = n_fmt)
{
n_fmt = fmt;
filter = gtk_file_filter_new();
gtk_file_filter_set_name(filter, fmt->name);
while (strcmp(fmt->name, n_fmt->name) == 0)
{
gtk_file_filter_add_pattern(filter, n_fmt->ext);
++n_fmt;
if (n_fmt->name == 0)
break;
}
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(chooser), filter);
}
/* All files 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);
for (fmt = sound_formats; fmt->name != 0 && fmt->ext != 0; ++fmt)
{
free(fmt->name);
free(fmt->ext);
}
f_list = gtk_file_chooser_list_filters(GTK_FILE_CHOOSER(chooser));
f_item = f_list;
while(f_item)
{
filter = GTK_FILE_FILTER(f_item->data);
if (strcmp(gtk_file_filter_get_name(filter),
settings->sample_file_filter) == 0)
{
gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(chooser), filter);
break;
}
f_item = f_item->next;
}
g_slist_free(f_list);
}
void gtk_codegraph_save(GtkCodeGraph *box){
g_return_if_fail (GTK_IS_CODEGRAPH (box));
//Создается диалог выбора места сохранения тренда
GtkWidget *_dialog = gtk_file_chooser_dialog_new("Сохранить", NULL, GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_NONE, NULL);
GtkWidget *widget = GTK_WIDGET(box);
gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (_dialog), "Untitled");
//Добавляем фильты по типу файлов
GtkFileFilter *ffilter = gtk_file_filter_new();
ffilter = gtk_file_filter_new();
gtk_file_filter_set_name( ffilter, "Рисунок PNG");
gtk_file_filter_add_pattern( ffilter, "*.png");
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (_dialog), ffilter);
ffilter = gtk_file_filter_new();
gtk_file_filter_set_name( ffilter, "Файл данных MathLab");
gtk_file_filter_add_pattern( ffilter, "*.dat");
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (_dialog), ffilter);
//Отлавливаем конец выбора и работаем
gint result = gtk_dialog_run (GTK_DIALOG (_dialog) );
gchar buff[100];
gchar *fil = NULL;
gchar *dir = NULL;
gchar *filename = NULL;
if (result == GTK_RESPONSE_NONE){
filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (_dialog));
fil =(char*) gtk_file_filter_get_name( gtk_file_chooser_get_filter(GTK_FILE_CHOOSER (_dialog)) );
dir = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (_dialog));
if (!strcmp(fil, "Рисунок PNG" ) )
snprintf(buff,sizeof(buff), "%s.png", filename );
else if (!strcmp(fil, "Файл данных MathLab" ) )
snprintf(buff,sizeof(buff), "%s.dat", filename );
else
snprintf(buff,sizeof(buff), "%s.png", filename );
}
/*Если юзер передумал сохраняться*/
else{
gtk_widget_destroy (_dialog);
return;
}
/*Ошибка при открытии файла */
FILE *fp;
if ((fp=fopen(buff, "w")) == NULL ){
gchar buff[300];
gchar *homedir = (gchar*)getenv("HOME");
snprintf(buff, sizeof(buff), "Отказано в доступе.\nСохранить файл в %s не удалось. \nВыберите, другой каталог, \nнапример: %s",filename, homedir );
GtkWidget* dialog = gtk_message_dialog_new (GTK_WINDOW (NULL),
(GtkDialogFlags)(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT), GTK_MESSAGE_INFO, GTK_BUTTONS_OK,
buff );
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
}
else{
/*Сохраняем картинку*/
cairo_surface_t *surface;
if (!strcmp(fil, "Рисунок PNG" ) ){
fclose(fp);
cairo_surface_t * surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, widget->allocation.width , widget->allocation.height );
cairo_t *cr_save = cairo_create (surface);
gdk_cairo_set_source_pixmap(cr_save, box->priv->backing_pixmap, 0.0, 0.0);
cairo_paint(cr_save);
cairo_destroy (cr_save);
cairo_surface_write_to_png (surface, buff);
cairo_surface_destroy (surface);
}
/*Сохраняем данные*/
if ( !strcmp(fil, "Файл данных MathLab" ) ){
int i; int im=0;
gchar buff[40];
for (i=0; i<box->priv->numPointsText; i+=2 ){
++im;
g_snprintf(buff, sizeof(buff), "%d импульс: %1.3f сек;\n",im ,box->priv->dta[i] );
fwrite(buff, strlen(buff), 1, fp);
g_snprintf(buff, sizeof(buff), "%d интервал: %1.3f сек;\n",im ,box->priv->dta[i+1] );
fwrite(buff, strlen(buff), 1, fp);
}
fclose(fp);
}
}
gtk_widget_destroy (_dialog);
}
/*#
@method get_name GtkFileFilter
@brief Gets the human-readable name for the filter.
@return The human-readable name of the filter, or NULL.
*/
FALCON_FUNC FileFilter::get_name( VMARG )
{
NO_ARGS
vm->retval( UTF8String( gtk_file_filter_get_name( GET_FILEFILTER( vm->self() ) ) ) );
}