← Back to branch summary

~ubuntu-branches/ubuntu/maverick/vice/maverick

« back to all changes in this revision

Viewing changes to src/arch/unix/gui/uifliplist.c

  • Committer: Bazaar Package Importer
  • Author(s): Laszlo Boszormenyi (GCS)
  • Date: 2010-02-11 18:30:16 UTC
  • mfrom: (1.1.8 upstream) (9.2.2 sid)
  • Revision ID: james.westby@ubuntu.com-20100211183016-f6n8usn3tzp0u6dp
Tags: 2.2.dfsg-1
* New upstream release, C64 DTV is included so update package description
  and add it to the menu.
* Drop patch fixing build failure with gcc-4.4 , applied upstream.
* Fix some lintian problems and clean up debian/rules .

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/arch/unix/gui/uifliplist.c
2
2
 * uifliplist.c
3
3
 *
4
4
 * Written by
5
 
 *  Martin Pottendorfer <Martin.Pottendorfer@aut.alcatel.at>
 
5
 *  pottendo <pottendo@gmx.net>
6
6
 *  Andreas Boose <viceteam@t-online.de>
7
7
 *
8
8
 * This file is part of VICE, the Versatile Commodore Emulator.
36
36
#include "lib.h"
37
37
#include "log.h"
38
38
#include "resources.h"
 
39
#include "uiapi.h"
39
40
#include "uifliplist.h"
40
41
#include "uidrive.h"
 
42
#include "uilib.h"
41
43
#include "uimenu.h"
42
44
#include "util.h"
43
45
#include "vsync.h"
44
46
 
45
 
 
46
47
struct cb_data_t {
47
48
    int unit;
48
49
    long data;                  /* should be enough for a pointer */
52
53
    CBD_NEXT, CBD_PREV, CBD_ADD, CBD_REMOVE
53
54
} cbd_enum_t;
54
55
 
55
 
 
56
56
extern char last_attached_images[NUM_DRIVES][256];
57
57
extern ui_drive_enable_t enabled_drives;
58
58
extern UI_CALLBACK(attach_disk);
60
60
 
61
61
static UI_CALLBACK(attach_from_fliplist3)
62
62
{
63
 
    fliplist_attach_head(8, (int)UI_MENU_CB_PARAM);
 
63
    fliplist_attach_head(8, vice_ptr_to_int(UI_MENU_CB_PARAM));
64
64
}
65
65
 
66
66
static UI_CALLBACK(add2fliplist)
80
80
static UI_CALLBACK(load_save_fliplist)
81
81
{
82
82
    char *filename, *title;
83
 
    int what = (int)UI_MENU_CB_PARAM;
 
83
    int what = vice_ptr_to_int(UI_MENU_CB_PARAM);
84
84
    ui_button_t button;
 
85
    uilib_file_filter_enum_t filter[] = { UILIB_FILTER_FLIPLIST, UILIB_FILTER_ALL };
85
86
 
86
87
    vsync_suspend_speed_eval();
87
 
    title = util_concat(what ? _("Load ") : _("Save"), _("Fliplist File"),
88
 
                        NULL);
89
 
    filename = ui_select_file(title, NULL, 0, 0,
90
 
                              load_save_fliplist_last_dir, "*.vfl",
91
 
                              &button, 1, NULL, UI_FC_LOAD);
 
88
    title = util_concat(what ? _("Load ") : _("Save"), _("Fliplist File"), NULL);
 
89
    filename = ui_select_file(title, NULL, 0, load_save_fliplist_last_dir, filter, sizeof(filter) / sizeof(*filter), &button, 1, NULL, UI_FC_LOAD);
92
90
    lib_free(title);
93
91
    switch (button) {
94
 
      case UI_BUTTON_OK:
95
 
        if (what) {
96
 
            if (fliplist_load_list((unsigned int)-1, filename, 0) == 0)
97
 
                ui_message(_("Successfully read `%s'."), filename);
98
 
            else
99
 
                ui_error(_("Error reading `%s'."), filename);
100
 
        } else {
101
 
            if (fliplist_save_list((unsigned int)-1, filename) == 0)
102
 
                ui_message(_("Successfully wrote `%s'."), filename);
103
 
            else
104
 
                ui_error(_("Error writing `%s'."), filename);
105
 
        }
106
 
        if (load_save_fliplist_last_dir)
 
92
        case UI_BUTTON_OK:
 
93
            if (what) {
 
94
                if (fliplist_load_list((unsigned int)-1, filename, 0) == 0) {
 
95
                    ui_message(_("Successfully read `%s'."), filename);
 
96
                } else {
 
97
                    ui_error(_("Error reading `%s'."), filename);
 
98
                }
 
99
            } else {
 
100
                if (fliplist_save_list((unsigned int)-1, filename) == 0) {
 
101
                    ui_message(_("Successfully wrote `%s'."), filename);
 
102
                } else {
 
103
                    ui_error(_("Error writing `%s'."), filename);
 
104
                }
 
105
            }
107
106
            lib_free(load_save_fliplist_last_dir);
108
 
        util_fname_split(filename, &load_save_fliplist_last_dir, NULL);
109
 
        break;
110
 
      default:
111
 
        break;
 
107
            util_fname_split(filename, &load_save_fliplist_last_dir, NULL);
 
108
            break;
 
109
        default:
 
110
            break;
112
111
    }
113
 
 
114
112
}
115
113
 
116
114
ui_menu_entry_t fliplist_submenu[] = {
135
133
 
136
134
static UI_CALLBACK(attach_from_fliplist2)
137
135
{
138
 
    file_system_attach_disk(fliplist_get_unit((void *)UI_MENU_CB_PARAM),
139
 
                            fliplist_get_image((void *)UI_MENU_CB_PARAM));
 
136
    file_system_attach_disk(fliplist_get_unit((void *)UI_MENU_CB_PARAM), fliplist_get_image((void *)UI_MENU_CB_PARAM));
140
137
}
141
138
 
142
139
static UI_CALLBACK(remove_from_fliplist2)
143
140
{
144
 
    fliplist_remove(((struct cb_data_t *)UI_MENU_CB_PARAM)->unit,
145
 
                    (char *) ((struct cb_data_t *)UI_MENU_CB_PARAM)->data);
146
 
    uifliplist_update_menus(((struct cb_data_t *)UI_MENU_CB_PARAM)->unit,
147
 
                            ((struct cb_data_t *)UI_MENU_CB_PARAM)->unit);
 
141
    fliplist_remove(((struct cb_data_t *)UI_MENU_CB_PARAM)->unit, (char *)((struct cb_data_t *)UI_MENU_CB_PARAM)->data);
 
142
    uifliplist_update_menus(((struct cb_data_t *)UI_MENU_CB_PARAM)->unit, ((struct cb_data_t *)UI_MENU_CB_PARAM)->unit);
148
143
}
149
144
 
150
145
static UI_CALLBACK(add2fliplist2)
151
146
{
152
 
    fliplist_set_current(((struct cb_data_t *)UI_MENU_CB_PARAM)->unit,
153
 
                         (char *) ((struct cb_data_t *)UI_MENU_CB_PARAM)->data);
 
147
    fliplist_set_current(((struct cb_data_t *)UI_MENU_CB_PARAM)->unit, (char *)((struct cb_data_t *)UI_MENU_CB_PARAM)->data);
154
148
    fliplist_add_image(((struct cb_data_t *)UI_MENU_CB_PARAM)->unit);
155
 
    uifliplist_update_menus(((struct cb_data_t *)UI_MENU_CB_PARAM)->unit,
156
 
                            ((struct cb_data_t *)UI_MENU_CB_PARAM)->unit);
 
149
    uifliplist_update_menus(((struct cb_data_t *)UI_MENU_CB_PARAM)->unit, ((struct cb_data_t *)UI_MENU_CB_PARAM)->unit);
157
150
}
158
151
 
159
152
static UI_CALLBACK(attach_from_fliplist)
160
153
{
161
 
    fliplist_attach_head(((struct cb_data_t *)UI_MENU_CB_PARAM)->unit,
162
 
                         (int) ((struct cb_data_t *)UI_MENU_CB_PARAM)->data);
 
154
    fliplist_attach_head(((struct cb_data_t *)UI_MENU_CB_PARAM)->unit, (int)((struct cb_data_t *)UI_MENU_CB_PARAM)->data);
163
155
}
164
156
 
165
157
#ifdef USE_GNOMEUI
168
160
#endif
169
161
 
170
162
#define FLIPLIST_MENU_LIMIT 256
 
163
 
171
164
void uifliplist_update_menus(int from_unit, int to_unit)
172
165
{
173
166
    /* Yick, allocate dynamically */
183
176
 
184
177
    resources_get_int("DriveTrueEmulation", &true_emu);
185
178
 
186
 
    for (drive = from_unit - 8;
187
 
        (drive <= to_unit - 8) && (drive < NUM_DRIVES);
188
 
        drive++) {
189
 
 
 
179
    for (drive = from_unit - 8; (drive <= to_unit - 8) && (drive < NUM_DRIVES); drive++) {
190
180
        i = 0;
191
181
        t0 = t1 = t2 = t3 = t4 = t5 = NULL;
192
182
 
194
184
        t0 = lib_msprintf(_("Attach #%d"), drive + 8);
195
185
        flipmenu[drive][i].string = t0;
196
186
        flipmenu[drive][i].callback = (ui_callback_t)attach_disk;
197
 
        flipmenu[drive][i].callback_data = (ui_callback_data_t)(drive + 8);
 
187
        flipmenu[drive][i].callback_data = (ui_callback_data_t)(long)(drive + 8);
198
188
        i++;
199
189
 
200
190
        memset(&(flipmenu[drive][i]), 0, sizeof(ui_menu_entry_t));
201
191
        t5 = lib_msprintf(_("Detach #%d"), drive + 8);
202
192
        flipmenu[drive][i].string = t5;
203
193
        flipmenu[drive][i].callback = (ui_callback_t)detach_disk;
204
 
        flipmenu[drive][i].callback_data = (ui_callback_data_t)(drive + 8);
 
194
        flipmenu[drive][i].callback_data = (ui_callback_data_t)(long)(drive + 8);
205
195
        i++;
206
196
 
207
197
#ifdef USE_GNOMEUI
209
199
        /* this won't work so far for Xaw, because the checkmarks
210
200
           aren't updated when a menu is destroyed, as the flipmenu is
211
201
           dynamically regenerated; The Gnome code is already fixed. */
212
 
        memcpy(&flipmenu[drive][i], (const char *)ui_drive_options_submenu,
213
 
               sizeof(ui_menu_entry_t));
 
202
        memcpy(&flipmenu[drive][i], (const char *)ui_drive_options_submenu, sizeof(ui_menu_entry_t));
214
203
        i++;
215
204
        /* Write protext UI controll */
216
205
        memset(&(flipmenu[drive][i]), 0, sizeof(ui_menu_entry_t));
217
206
        flipmenu[drive][i].string = _("*Write Protect");
218
 
        if (drive == 0)
219
 
            flipmenu[drive][i].callback = 
220
 
                G_CALLBACK(toggle_AttachDevice8Readonly);
221
 
        else
222
 
            flipmenu[drive][i].callback = 
223
 
                G_CALLBACK(toggle_AttachDevice9Readonly);
 
207
        if (drive == 0) {
 
208
            flipmenu[drive][i].callback = G_CALLBACK(toggle_AttachDevice8Readonly);
 
209
        } else {
 
210
            flipmenu[drive][i].callback = G_CALLBACK(toggle_AttachDevice9Readonly);
 
211
        }
224
212
        i++;
225
213
#endif
226
214
 
227
 
        fliplist_start = i;     /* if we take the goto don't free anythin */
 
215
        fliplist_start = i;     /* if we take the goto don't free anything */
228
216
 
229
217
        /* don't update menu deeply when drive has not been enabled
230
218
           or nothing has been attached */
231
219
        if (true_emu) {
232
 
            if (!((1 << drive) & enabled_drives))
 
220
            if (!((1 << drive) & enabled_drives)) {
233
221
                goto update_menu;
 
222
            }
234
223
        } else {
235
 
            if (strcmp(last_attached_images[drive], "") == 0)
 
224
            if (strcmp(last_attached_images[drive], "") == 0) {
236
225
                goto update_menu;
 
226
            }
237
227
        }
238
228
 
239
229
        memset(&(flipmenu[drive][i]), 0, sizeof(ui_menu_entry_t));
247
237
        flipmenu[drive][i].callback = (ui_callback_t)attach_from_fliplist;
248
238
        cb_data[drive][CBD_NEXT].unit = drive + 8;
249
239
        cb_data[drive][CBD_NEXT].data = 1;
250
 
        flipmenu[drive][i].callback_data =
251
 
            (ui_callback_data_t)&(cb_data[drive][CBD_NEXT]);
252
 
        if (dir)
253
 
            lib_free(dir);
254
 
        if (image)
255
 
            lib_free(image);
 
240
        flipmenu[drive][i].callback_data = (ui_callback_data_t)&(cb_data[drive][CBD_NEXT]);
 
241
        lib_free(dir);
 
242
        dir = NULL;
 
243
        lib_free(image);
 
244
        image = NULL;
256
245
        i++;
257
246
 
258
247
        memset(&(flipmenu[drive][i]), 0, sizeof(ui_menu_entry_t));
262
251
        flipmenu[drive][i].callback = (ui_callback_t)attach_from_fliplist;
263
252
        cb_data[drive][CBD_PREV].unit = drive + 8;
264
253
        cb_data[drive][CBD_PREV].data = 0;
265
 
        flipmenu[drive][i].callback_data =
266
 
            (ui_callback_data_t)&(cb_data[drive][CBD_PREV]);
267
 
        if (dir)
268
 
            lib_free(dir);
269
 
        if (image)
270
 
            lib_free(image);
 
254
        flipmenu[drive][i].callback_data = (ui_callback_data_t)&(cb_data[drive][CBD_PREV]);
 
255
        lib_free(dir);
 
256
        dir = NULL;
 
257
        lib_free(image);
 
258
        image = NULL;
271
259
        i++;
272
260
 
273
261
        memset(&(flipmenu[drive][i]), 0, sizeof(ui_menu_entry_t));
277
265
        flipmenu[drive][i].callback = (ui_callback_t)add2fliplist2;
278
266
        cb_data[drive][CBD_ADD].unit = drive + 8;
279
267
        cb_data[drive][CBD_ADD].data = (long) last_attached_images[drive];
280
 
        flipmenu[drive][i].callback_data =
281
 
            (ui_callback_data_t)&(cb_data[drive][CBD_ADD]);
282
 
        if (dir)
283
 
            lib_free(dir);
284
 
        if (image)
285
 
            lib_free(image);
 
268
        flipmenu[drive][i].callback_data = (ui_callback_data_t)&(cb_data[drive][CBD_ADD]);
 
269
        lib_free(dir);
 
270
        dir = NULL;
 
271
        lib_free(image);
 
272
        image = NULL;
286
273
        i++;
287
274
 
288
275
        memset(&(flipmenu[drive][i]), 0, sizeof(ui_menu_entry_t));
292
279
        flipmenu[drive][i].callback = (ui_callback_t)remove_from_fliplist2;
293
280
        cb_data[drive][CBD_REMOVE].unit = drive + 8;
294
281
        cb_data[drive][CBD_REMOVE].data = (long) last_attached_images[drive];
295
 
        flipmenu[drive][i].callback_data =
296
 
            (ui_callback_data_t)&(cb_data[drive][CBD_REMOVE]);
297
 
        if (dir)
298
 
            lib_free(dir);
299
 
        if (image)
300
 
            lib_free(image);
 
282
        flipmenu[drive][i].callback_data = (ui_callback_data_t)&(cb_data[drive][CBD_REMOVE]);
 
283
        lib_free(dir);
 
284
        dir = NULL;
 
285
        lib_free(image);
 
286
        image = NULL;
301
287
        i++;
302
288
 
303
289
        memset(&(flipmenu[drive][i]), 0, sizeof(ui_menu_entry_t));
311
297
            memset(&(flipmenu[drive][i]), 0, sizeof(ui_menu_entry_t));
312
298
            util_fname_split(fliplist_get_image(fl_iterator), &dir, &image);
313
299
            flipmenu[drive][i].string = util_concat(NO_TRANS, image, NULL);
314
 
            flipmenu[drive][i].callback =
315
 
                (ui_callback_t)attach_from_fliplist2;
316
 
            flipmenu[drive][i].callback_data =
317
 
                (ui_callback_data_t)fl_iterator;
 
300
            flipmenu[drive][i].callback = (ui_callback_t)attach_from_fliplist2;
 
301
            flipmenu[drive][i].callback_data = (ui_callback_data_t)fl_iterator;
318
302
 
319
303
            fl_iterator = fliplist_next_iterate(drive + 8);
320
 
            if (dir)
321
 
                lib_free(dir);
322
 
            if (image)
323
 
                lib_free(image);
 
304
            lib_free(dir);
 
305
            dir = NULL;
 
306
            lib_free(image);
 
307
            image = NULL;
324
308
            i++;
325
309
            if (i >= (FLIPLIST_MENU_LIMIT - 1)) {
326
310
                /* the end delimitor must fit */
327
 
                log_warning(LOG_DEFAULT,
328
 
                            "Number of fliplist menu entries exceeded."
329
 
                            "Cutting after %d entries.", i);
 
311
                log_warning(LOG_DEFAULT, "Number of fliplist menu entries exceeded. Cutting after %d entries.", i);
330
312
                break;
331
313
            }
332
314
        }
345
327
        if (drive == 0) {
346
328
            ui_destroy_drive8_menu();
347
329
            /* FIXME: Make sure the widget is really destroyed! */
348
 
            ui_set_drive8_menu(ui_menu_create(menuname /*"LeftDrive8Menu"*/,
349
 
                                              flipmenu[drive], NULL));
 
330
            ui_set_drive8_menu(ui_menu_create(menuname, flipmenu[drive], NULL));
350
331
        } else {
351
332
            ui_destroy_drive9_menu();
352
333
            /* FIXME: Make sure the widget is really destroyed! */
353
 
            ui_set_drive9_menu(ui_menu_create(menuname /*"LeftDrive9Menu"*/,
354
 
                                              flipmenu[drive], NULL));
 
334
            ui_set_drive9_menu(ui_menu_create(menuname, flipmenu[drive], NULL));
355
335
        }
356
336
#endif
357
337
 
358
338
        lib_free(menuname);
359
339
 
360
 
        if (t0)
361
 
            lib_free(t0);
362
 
        if (t1)
363
 
            lib_free(t1);
364
 
        if (t2)
365
 
            lib_free(t2);
366
 
        if (t3)
367
 
            lib_free(t3);
368
 
        if (t4)
369
 
            lib_free(t4);
370
 
        if (t5)
371
 
            lib_free(t5);
 
340
        lib_free(t0);
 
341
        lib_free(t1);
 
342
        lib_free(t2);
 
343
        lib_free(t3);
 
344
        lib_free(t4);
 
345
        lib_free(t5);
372
346
        while (fliplist_start < i) {
373
 
            if (flipmenu[drive][fliplist_start].string)
374
 
                lib_free(flipmenu[drive][fliplist_start].string);
 
347
            lib_free(flipmenu[drive][fliplist_start].string);
 
348
            flipmenu[drive][fliplist_start].string = NULL;
375
349
            fliplist_start++;
376
350
        }
377
351
    }
381
355
{
382
356
    lib_free(load_save_fliplist_last_dir);
383
357
}
384