← Back to branch summary

~ubuntu-branches/ubuntu/breezy/tiemu/breezy

« back to all changes in this revision

Viewing changes to src/gui/filesel.c

  • Committer: Bazaar Package Importer
  • Author(s): Julien BLACHE
  • Date: 2005-06-02 16:50:15 UTC
  • mfrom: (1.2.1 upstream) (2.1.1 sarge)
  • Revision ID: james.westby@ubuntu.com-20050602165015-59ab24414tl2wzol
Tags: 1.99+svn1460-1
* New snapshot.
* debian/control:
  + Updated build-depends.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gui/filesel.c
 
1
/* Hey EMACS -*- linux-c -*- */
 
2
/* $Id: filesel.c 1455 2005-05-31 18:38:03Z roms $ */
 
3
 
 
4
/*  TiEmu - an TI emulator
 
5
 *
 
6
 *  Copyright (c) 2000-2001, Thomas Corvazier, Romain Lievin
 
7
 *  Copyright (c) 2001-2003, Romain Lievin
 
8
 *  Copyright (c) 2003, Julien Blache
 
9
 *  Copyright (c) 2004, Romain Li�vin
 
10
 *  Copyright (c) 2005, Romain Li�vin, Kevin Kofler
 
11
 *
 
12
 *  This program is free software; you can redistribute it and/or modify
 
13
 *  it under the terms of the GNU General Public License as published by
 
14
 *  the Free Software Foundation; either version 2 of the License, or
 
15
 *  (at your option) any later version.
 
16
 *  This program is distributed in the hope that it will be useful,
 
17
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
18
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
19
 *  GNU General Public License for more details. *
 
20
 *  You should have received a copy of the GNU General Public License
 
21
 *  along with this program; if not, write to the Free Software
 
22
 *  Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
 
23
 */
 
24
 
 
25
#ifdef HAVE_CONFIG_H
 
26
#  include <config.h>
 
27
#endif                          /*  */
 
28
 
 
29
#include <stdio.h>
 
30
#include <gtk/gtk.h>
 
31
#include <string.h>
 
32
 
 
33
#ifdef __WIN32__
 
34
#include <windows.h>
 
35
#endif
 
36
 
 
37
#if WITH_KDE
 
38
#include "kde.h"
 
39
#endif
 
40
 
 
41
#include "intl.h"
 
42
#include "filesel.h"
 
43
#include "refresh.h"
 
44
#include "struct.h"
 
45
 
 
46
/* Single file selectors */
 
47
 
 
48
static gchar *fname = NULL;
 
49
static gint action = 0;
 
50
 
 
51
static void store_filename(GtkFileSelection * file_selector,
 
52
                           gpointer user_data)
 
53
{
 
54
        fname = g_strdup((gchar *)gtk_file_selection_get_filename(GTK_FILE_SELECTION(user_data)));
 
55
        action = 1;
 
56
} 
 
57
 
 
58
static void cancel_filename(GtkButton * button, gpointer user_data)
 
59
{
 
60
        fname = NULL;
 
61
        action = 2;
 
62
} 
 
63
 
 
64
// GTK 1.x/2.x (x < 4)
 
65
static const gchar* create_fsel_1(gchar *dirname, gchar *filename, gchar *ext, gboolean save)
 
66
{
 
67
        GtkWidget *fs;
 
68
    
 
69
        fs = gtk_file_selection_new("Select a file...");
 
70
 
 
71
        gtk_file_selection_set_filename (GTK_FILE_SELECTION(fs), dirname);
 
72
        gtk_file_selection_complete(GTK_FILE_SELECTION(fs), filename ? filename : ext);
 
73
 
 
74
        g_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(fs)->ok_button),
 
75
                         "clicked", G_CALLBACK(store_filename), fs);
 
76
 
 
77
        g_signal_connect(GTK_OBJECT
 
78
                         (GTK_FILE_SELECTION(fs)->cancel_button),
 
79
                         "clicked", G_CALLBACK(cancel_filename), fs);
 
80
 
 
81
        g_signal_connect_swapped(GTK_OBJECT
 
82
                                 (GTK_FILE_SELECTION(fs)->ok_button),
 
83
                                 "clicked",
 
84
                                 G_CALLBACK(gtk_widget_destroy),
 
85
                                 (gpointer) fs);
 
86
 
 
87
        g_signal_connect_swapped(GTK_OBJECT
 
88
                                 (GTK_FILE_SELECTION(fs)->cancel_button),
 
89
                                 "clicked", G_CALLBACK(gtk_widget_destroy),
 
90
                                 (gpointer) fs);
 
91
 
 
92
        gtk_widget_show(fs);
 
93
 
 
94
        g_free(fname);
 
95
        for(action = 0; !action; )
 
96
                GTK_REFRESH();
 
97
 
 
98
        return fname;
 
99
}
 
100
 
 
101
// GTK >= 2.4
 
102
static const gchar* create_fsel_2(gchar *dirname, gchar *filename, gchar *ext, gboolean save)
 
103
{
 
104
        GtkWidget *dialog;
 
105
        GtkFileFilter *filter;
 
106
        gchar *path;
 
107
        gchar **sarray;
 
108
        gint i;
 
109
    
 
110
        // create box
 
111
        dialog = gtk_file_chooser_dialog_new (
 
112
                                          save ? "Save File" : "Open File",
 
113
                                      NULL,
 
114
                                          save ? GTK_FILE_CHOOSER_ACTION_SAVE : GTK_FILE_CHOOSER_ACTION_OPEN,
 
115
                                      GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 
116
                                      GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
 
117
                                      NULL);
 
118
 
 
119
        // set default folder
 
120
        path = g_path_get_dirname(dirname);
 
121
        gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), path);
 
122
        g_free(path);
 
123
 
 
124
        // set default name
 
125
        if(filename)
 
126
                gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), filename);
 
127
 
 
128
        // set wildcards
 
129
        filter = gtk_file_filter_new();
 
130
        sarray = g_strsplit(ext, ";", -1);
 
131
        for(i = 0; sarray[i] != NULL; i++)
 
132
                gtk_file_filter_add_pattern (filter, sarray[i]);
 
133
        g_strfreev(sarray);
 
134
        gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter);
 
135
 
 
136
        // get result
 
137
        g_free(fname);
 
138
        if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
 
139
                fname = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
 
140
        else
 
141
                fname = NULL;
 
142
        gtk_widget_destroy (dialog);
 
143
 
 
144
        return fname;
 
145
}
 
146
 
 
147
// WIN32
 
148
static const gchar* create_fsel_3(gchar *dirname, gchar *filename, gchar *ext, gboolean save)
 
149
{
 
150
#ifdef WIN32
 
151
        OPENFILENAME o;
 
152
        char lpstrFile[1024] = "\0";
 
153
        char lpstrFilter[256];
 
154
        char *p;
 
155
        gchar **sarray;
 
156
        int i, n;
 
157
 
 
158
        // clear structure
 
159
        memset (&o, 0, sizeof(OPENFILENAME));
 
160
 
 
161
        // set default filename
 
162
        if(filename)
 
163
                strcpy(lpstrFile, filename);
 
164
 
 
165
        // format filter
 
166
        sarray = g_strsplit(ext, "|", -1);
 
167
        for(n = 0; sarray[n] != NULL; n++);
 
168
 
 
169
        for(i = 0, p = lpstrFilter; i < n; i++)
 
170
        {
 
171
                strcpy(p, sarray[i]);
 
172
                p += strlen(sarray[i]);
 
173
                *p++ = '\0';
 
174
 
 
175
                strcpy(p, sarray[i]);
 
176
                p += strlen(sarray[i]);
 
177
                *p++ = '\0';
 
178
        }
 
179
        *p++ = '\0';
 
180
        g_strfreev(sarray);
 
181
 
 
182
        // set structure
 
183
        o.lStructSize = sizeof (o);     
 
184
        o.lpstrFilter = lpstrFilter;    //"All\0*.*\0Text\0*.TXT\0";
 
185
        o.lpstrFile = lpstrFile;
 
186
        o.nMaxFile = sizeof(lpstrFile);
 
187
        o.lpstrInitialDir = dirname;
 
188
        o.Flags = 0x02000000 | OFN_FILEMUSTEXIST | OFN_HIDEREADONLY |
 
189
                                 OFN_NOCHANGEDIR | OFN_EXPLORER | OFN_LONGNAMES | OFN_NONETWORKBUTTON;
 
190
 
 
191
        // open/close
 
192
        if(save)
 
193
        {
 
194
                if(!GetSaveFileName(&o))
 
195
                        return filename = NULL;
 
196
        }
 
197
        else
 
198
        {
 
199
                if(!GetOpenFileName(&o))
 
200
                        return filename = NULL;
 
201
        }
 
202
 
 
203
        return fname = g_strdup(lpstrFile);
 
204
#endif
 
205
 
 
206
        return NULL;
 
207
}
 
208
 
 
209
// KDE
 
210
static const gchar* create_fsel_4(gchar *dirname, gchar *filename, gchar *ext, gboolean save)
 
211
{
 
212
#if WITH_KDE
 
213
        gchar *p;
 
214
        gchar *extspaces = g_strdup(ext);
 
215
 
 
216
        p = extspaces;
 
217
        while ((p = strchr(p, ';'))) *p = ' ';
 
218
 
 
219
        if(save)
 
220
        {
 
221
                if (filename)
 
222
                        dirname = g_strconcat(dirname, filename, NULL);
 
223
                fname = sp_kde_get_write_filename(dirname, extspaces, _("Save file"));
 
224
        }
 
225
        else
 
226
                fname = sp_kde_get_open_filename(dirname, extspaces, _("Open file"));
 
227
 
 
228
        g_free(extspaces);
 
229
        return fname;
 
230
#endif
 
231
 
 
232
        return NULL;
 
233
}
 
234
 
 
235
// Front-end
 
236
const gchar *create_fsel(gchar *dirname, gchar *filename, gchar *ext, gboolean save)
 
237
{
 
238
#ifndef __WIN32__
 
239
        if(options.fs_type == 2)
 
240
                options.fs_type = 1;
 
241
#endif
 
242
#if !WITH_KDE
 
243
        if(options.fs_type == 3)
 
244
                options.fs_type = 1;
 
245
#endif
 
246
        //printf("%i: <%s> <%s> <%s> %i\n", options.fs_type, dirname, filename, ext, save);
 
247
 
 
248
        switch(options.fs_type)
 
249
        {
 
250
        case 0: return create_fsel_1(dirname, filename, ext, save);
 
251
        case 1: return create_fsel_2(dirname, filename, ext, save);
 
252
        case 2: return create_fsel_3(dirname, filename, ext, save);
 
253
        case 3: return create_fsel_4(dirname, filename, ext, save);
 
254
        default: return NULL;
 
255
        }
 
256
 
 
257
        return NULL;
 
258
}
 
259
 
 
260
/* Multiple files selectors */
 
261
 
 
262
static gchar** filenames = NULL;
 
263
static gint actions = 0;
 
264
 
 
265
static void store_filenames(GtkFileSelection * file_selector,
 
266
                           gpointer user_data)
 
267
{
 
268
        filenames = gtk_file_selection_get_selections(GTK_FILE_SELECTION(user_data));
 
269
        actions = 1;
 
270
} 
 
271
 
 
272
static void cancel_filenames(GtkButton * button, gpointer user_data)
 
273
{
 
274
        filenames = NULL;
 
275
        actions = 2;
 
276
} 
 
277
 
 
278
// GTK 1.x/2.x (x < 4)
 
279
static gchar** create_fsels_1(gchar *dirname, gchar *filename, gchar *ext)
 
280
{
 
281
        GtkWidget *fs;
 
282
    
 
283
        fs = gtk_file_selection_new("Select a file...");
 
284
 
 
285
        gtk_file_selection_set_select_multiple(GTK_FILE_SELECTION(fs), TRUE);
 
286
        gtk_file_selection_set_filename (GTK_FILE_SELECTION(fs), dirname);
 
287
        gtk_file_selection_complete(GTK_FILE_SELECTION(fs), filename ? filename : ext);
 
288
 
 
289
        g_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(fs)->ok_button),
 
290
                         "clicked", G_CALLBACK(store_filenames), fs);
 
291
 
 
292
        g_signal_connect(GTK_OBJECT
 
293
                         (GTK_FILE_SELECTION(fs)->cancel_button),
 
294
                         "clicked", G_CALLBACK(cancel_filenames), fs);
 
295
 
 
296
        g_signal_connect_swapped(GTK_OBJECT
 
297
                                 (GTK_FILE_SELECTION(fs)->ok_button),
 
298
                                 "clicked",
 
299
                                 G_CALLBACK(gtk_widget_destroy),
 
300
                                 (gpointer) fs);
 
301
 
 
302
        g_signal_connect_swapped(GTK_OBJECT
 
303
                                 (GTK_FILE_SELECTION(fs)->cancel_button),
 
304
                                 "clicked", G_CALLBACK(gtk_widget_destroy),
 
305
                                 (gpointer) fs);
 
306
 
 
307
        gtk_widget_show(fs);
 
308
        for(actions = 0; !actions; )
 
309
                GTK_REFRESH();
 
310
 
 
311
        return filenames;
 
312
}
 
313
 
 
314
// GTK >= 2.4
 
315
static gchar** create_fsels_2(gchar *dirname, gchar *filename, gchar *ext)
 
316
{
 
317
        GtkWidget *dialog;
 
318
        GtkFileFilter *filter;
 
319
        gchar *path;
 
320
        gchar **sarray;
 
321
        gint i;
 
322
    
 
323
        // create box
 
324
        dialog = gtk_file_chooser_dialog_new ("Open File",
 
325
                                      NULL,
 
326
                                          GTK_FILE_CHOOSER_ACTION_OPEN,
 
327
                                      GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 
328
                                      GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
 
329
                                      NULL);
 
330
 
 
331
        // set default folder
 
332
        path = g_path_get_dirname(dirname);
 
333
        gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), path);
 
334
        g_free(path);
 
335
 
 
336
        // set multiple selection
 
337
        gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), TRUE);
 
338
 
 
339
        // set default name
 
340
        if(filename)
 
341
                gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), filename);
 
342
 
 
343
        // set wildcards
 
344
        filter = gtk_file_filter_new();
 
345
        sarray = g_strsplit(ext, ";", -1);
 
346
        for(i = 0; sarray[i] != NULL; i++)
 
347
                gtk_file_filter_add_pattern (filter, sarray[i]);
 
348
        g_strfreev(sarray);
 
349
        gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter);
 
350
 
 
351
        // get result
 
352
        g_free(filename);
 
353
        if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
 
354
        {
 
355
                GSList *list, *p;
 
356
                gchar **q;
 
357
                
 
358
                // convert list into string array
 
359
                list = gtk_file_chooser_get_filenames (GTK_FILE_CHOOSER (dialog));
 
360
                filenames = g_malloc0(g_slist_length(list)+1);
 
361
 
 
362
                for(p = list, q = filenames; p; p = g_slist_next(p), q++)
 
363
                {
 
364
                        *q = g_malloc0(strlen(p->data) + 1);
 
365
                        strcpy(*q, p->data);
 
366
                }
 
367
                *q = NULL;
 
368
        }
 
369
        else
 
370
                filename = NULL;
 
371
        gtk_widget_destroy (dialog);
 
372
 
 
373
        return filenames;
 
374
}
 
375
 
 
376
// WIN32
 
377
static gchar** create_fsels_3(gchar *dirname, gchar *filename, gchar *ext)
 
378
{
 
379
#ifdef WIN32
 
380
        OPENFILENAME o;
 
381
        char lpstrFile[1024] = "\0";
 
382
        char lpstrFilter[256];
 
383
        char *p;
 
384
        gchar **sarray;
 
385
        int i, n;
 
386
 
 
387
        // clear structure
 
388
        memset (&o, 0, sizeof(OPENFILENAME));
 
389
 
 
390
        // set default filename
 
391
        if(filename)
 
392
                strncpy(lpstrFile, filename, sizeof(lpstrFile));
 
393
 
 
394
        // format filter
 
395
        sarray = g_strsplit(ext, "|", -1);
 
396
        for(n = 0; sarray[n] != NULL; n++);
 
397
 
 
398
        for(i = 0, p = lpstrFilter; i < n; i++)
 
399
        {
 
400
                strcpy(p, sarray[i]);
 
401
                p += strlen(sarray[i]);
 
402
                *p++ = '\0';
 
403
 
 
404
                strcpy(p, sarray[i]);
 
405
                p += strlen(sarray[i]);
 
406
                *p++ = '\0';
 
407
        }
 
408
        *p++ = '\0';
 
409
        g_strfreev(sarray);
 
410
 
 
411
        // set structure
 
412
        o.lStructSize = sizeof (o);     
 
413
        o.lpstrFilter = lpstrFilter;    //"All\0*.*\0Text\0*.TXT\0";
 
414
        o.lpstrFile = lpstrFile;                //"C:\msvc\tilp\0foo.txt\0bar.txt"
 
415
        o.nMaxFile = sizeof(lpstrFile);
 
416
        o.lpstrInitialDir = dirname;
 
417
        o.Flags = 0x02000000 | OFN_FILEMUSTEXIST | OFN_HIDEREADONLY |
 
418
                                 OFN_NOCHANGEDIR | OFN_EXPLORER | OFN_LONGNAMES | OFN_NONETWORKBUTTON |
 
419
                                 OFN_ALLOWMULTISELECT;
 
420
 
 
421
        // open selector
 
422
        if(!GetOpenFileName(&o))
 
423
                return NULL;
 
424
        filenames = NULL;
 
425
 
 
426
        // converts resulting string
 
427
        for(p = lpstrFile, i=0; *p; p += strlen(p)+1, i++)
 
428
        {
 
429
                if(i)   // skip directory
 
430
                {
 
431
                        filenames = g_realloc(filenames, (i+1) * sizeof(gchar *));
 
432
                        filenames[i-1] = g_strconcat(lpstrFile, G_DIR_SEPARATOR_S, p, NULL);
 
433
                }
 
434
        }
 
435
 
 
436
        // one file selected ?
 
437
        if(i == 1)
 
438
        {
 
439
                filenames = g_malloc(2 * sizeof(gchar *));
 
440
                filenames[0] = g_strdup(lpstrFile);
 
441
                filenames[1] = NULL;
 
442
        }
 
443
        else
 
444
                filenames[i-1] = NULL;
 
445
 
 
446
        return filenames;
 
447
#endif
 
448
 
 
449
        return NULL;
 
450
}
 
451
 
 
452
static gchar** create_fsels_4(gchar *dirname, gchar *filename, gchar *ext)
 
453
{
 
454
#if WITH_KDE
 
455
        gchar *p;
 
456
        gchar *extspaces = g_strdup(ext);
 
457
        p = extspaces;
 
458
        while ((p = strchr(p, ';'))) *p = ' ';
 
459
        filenames = sp_kde_get_open_filenames(dirname, extspaces, _("Open file"));
 
460
        g_free(extspaces);
 
461
        return filenames;
 
462
#endif
 
463
 
 
464
        return NULL;
 
465
}
 
466
 
 
467
// Front-end
 
468
gchar** create_fsels(gchar *dirname, gchar *filename, gchar *ext)
 
469
{
 
470
#ifndef __WIN32__
 
471
        if(options.fs_type == 2)
 
472
                options.fs_type = 1;
 
473
#endif
 
474
#if !WITH_KDE
 
475
        if(options.fs_type == 3)
 
476
                options.fs_type = 1;
 
477
#endif
 
478
        //printf("%i: <%s> <%s> <%s>\n", options.fs_type, dirname, filename, ext);
 
479
 
 
480
        switch(options.fs_type)
 
481
        {
 
482
        case 0: return create_fsels_1(dirname, filename, ext);
 
483
        case 1: return create_fsels_2(dirname, filename, ext);
 
484
        case 2: return create_fsels_3(dirname, filename, ext);
 
485
        case 3: return create_fsels_4(dirname, filename, ext);
 
486
        default: return NULL;
 
487
        }
 
488
 
 
489
        return NULL;
 
490
}
 
491
 
 
492