← Back to branch summary

~ubuntu-branches/ubuntu/hardy/gnomad2/hardy

« back to all changes in this revision

Viewing changes to src/gnomad2.c

  • Committer: Bazaar Package Importer
  • Author(s): Shaun Jackman
  • Date: 2005-08-19 16:09:28 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20050819160928-l2glu227nh0algdc
Tags: 2.8.0-2
http://bugs.debian.org/324036
Add a versioned dependency for libnjb-dev (>> 2.2). Closes: #324036.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gnomad2.c
23
23
#include "playlists.h"
24
24
#include "prefs.h"
25
25
#include "util.h"
 
26
#if !GTK_CHECK_VERSION(2,6,0)
26
27
#include <libgnomeui/libgnomeui.h>
 
28
#endif
 
29
 
 
30
/* This one should be global really */
 
31
GtkWidget *main_window;
27
32
 
28
33
/* Local variables */
 
34
#if GTK_CHECK_VERSION(2,6,0)
 
35
static GdkPixbuf *icon_pixbuf;
 
36
#endif
 
37
#if !GTK_CHECK_VERSION(2,4,0)
29
38
static GtkWidget *jukeboxowner_dialog;
30
39
static GtkWidget *jukeboxowner_entry;
31
40
static GtkWidget *select_jukebox_dialog;
32
41
static GtkWidget *jukebox_menu;
 
42
#endif
 
43
// The expose() event will be treated JUST ONCE at the first window creation
 
44
static gboolean justonce = TRUE;
33
45
 
34
46
/* Expect these functions */
35
47
void scan_jukebox(gpointer data);
78
90
  return option_menu;
79
91
}
80
92
 
 
93
#if !GTK_CHECK_VERSION(2,4,0)
81
94
static GCallback jukebox_ok_signal(GtkButton *button,
82
95
                                   gpointer data)
83
96
{
89
102
    scan_jukebox(NULL);
90
103
  }
91
104
}
 
105
#endif
92
106
 
93
107
static void create_select_jukebox_dialog(void)
94
108
{
99
113
      int i;
100
114
      GtkWidget *label;
101
115
      // Build a selection menu
 
116
#if GTK_CHECK_VERSION(2,4,0)
 
117
      GtkWidget *select_jukebox_dialog;
 
118
      GtkWidget *jukebox_menu;
 
119
 
 
120
      select_jukebox_dialog = gtk_message_dialog_new (GTK_WINDOW(main_window),
 
121
                                                      GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
 
122
                                                      GTK_MESSAGE_QUESTION,
 
123
                                                      GTK_BUTTONS_OK_CANCEL,
 
124
                                                      _("Select jukebox"));
 
125
      jukebox_menu = create_jukebox_menu(jukeboxes);
 
126
      gtk_window_set_position (GTK_WINDOW(select_jukebox_dialog), GTK_WIN_POS_MOUSE);
 
127
      gtk_box_set_spacing (GTK_BOX(GTK_DIALOG(select_jukebox_dialog)->vbox), 5);
 
128
 
 
129
      label = gtk_label_new(_("Select jukebox to operate:"));
 
130
      gtk_box_pack_start(GTK_BOX(GTK_DIALOG(select_jukebox_dialog)->vbox), 
 
131
                         label, TRUE, TRUE, 0);
 
132
      gtk_widget_show(label);
 
133
      gtk_box_pack_start(GTK_BOX(GTK_DIALOG(select_jukebox_dialog)->vbox), 
 
134
                         jukebox_menu, TRUE, TRUE, 0);
 
135
      gtk_widget_show(jukebox_menu);
 
136
      gtk_widget_show_all(select_jukebox_dialog);
 
137
      i = gtk_dialog_run(GTK_DIALOG(select_jukebox_dialog));
 
138
      if (i == GTK_RESPONSE_OK) {
 
139
        guint selection = gtk_option_menu_get_history(GTK_OPTION_MENU(jukebox_menu));
 
140
        gtk_widget_destroy(select_jukebox_dialog);
 
141
        // Select the first jukebox
 
142
        if (jukebox_select(selection)) {
 
143
          // Initially scan the jukebox
 
144
          scan_jukebox(NULL);
 
145
        }
 
146
      } else {
 
147
        gtk_widget_destroy(select_jukebox_dialog);
 
148
      }
 
149
#else
102
150
      select_jukebox_dialog = gnome_dialog_new(_("Select jukebox"),
103
151
                                               GNOME_STOCK_BUTTON_OK,
104
152
                                               GNOME_STOCK_BUTTON_CANCEL,
118
166
                              G_CALLBACK(gtk_widget_destroy),
119
167
                              GTK_OBJECT(select_jukebox_dialog),
120
168
                              0);
121
 
      label = gtk_label_new(_("Select jukebox to operate"));
 
169
      label = gtk_label_new(_("Select jukebox to operate:"));
122
170
      gtk_box_pack_start(GTK_BOX(GNOME_DIALOG(select_jukebox_dialog)->vbox), 
123
171
                         label, TRUE, TRUE, 0);
124
172
      gtk_widget_show(label);
127
175
      gtk_widget_show(jukebox_menu);
128
176
      gtk_widget_show(select_jukebox_dialog);
129
177
      g_strfreev(jukeboxes);
 
178
#endif
130
179
    } else {
131
180
      // Select the first jukebox
132
181
      if (jukebox_select(0)) {
142
191
                   GtkWidget *event,
143
192
                   gpointer   data)
144
193
{
145
 
  // This will be treated JUST ONCE at the first window creation
146
 
  static gboolean justonce = TRUE;
147
 
 
148
194
  if (justonce) {
 
195
    justonce = FALSE;
149
196
    if (get_prefs_autoscan()) {
150
197
      // This will be treated JUST ONCE at the first window creation
151
198
      create_select_jukebox_dialog();
155
202
        jukebox_synchronize_time();
156
203
      }
157
204
    }
158
 
    justonce = FALSE;
159
205
  }
160
206
  return(FALSE);
161
207
}
172
218
  gchar *translator_credits = _("translator_credits");
173
219
 
174
220
  GtkWidget *about;
 
221
  /*
 
222
   * For a modern GTK+ we remove the use of libgnomeui stuff.
 
223
   */
 
224
#if GTK_CHECK_VERSION(2,6,0)
 
225
  about = gtk_about_dialog_new();
 
226
  gtk_about_dialog_set_name(GTK_ABOUT_DIALOG(about), PACKAGE);
 
227
  gtk_about_dialog_set_version(GTK_ABOUT_DIALOG(about), VERSION);
 
228
  gtk_about_dialog_set_copyright(GTK_ABOUT_DIALOG(about), copystring);
 
229
  gtk_about_dialog_set_comments(GTK_ABOUT_DIALOG(about), aboutstring);
 
230
  gtk_about_dialog_set_license(GTK_ABOUT_DIALOG(about), "GPL version 2");
 
231
  gtk_about_dialog_set_website(GTK_ABOUT_DIALOG(about), "http://gnomad2.sourceforge.net/");
 
232
  gtk_about_dialog_set_website_label(GTK_ABOUT_DIALOG(about), "Gnomad Homepage");
 
233
  gtk_about_dialog_set_authors(GTK_ABOUT_DIALOG(about), authors);
 
234
  if (strcmp(translator_credits, "translator_credits")) {
 
235
    gtk_about_dialog_set_translator_credits(GTK_ABOUT_DIALOG(about), translator_credits);
 
236
  }
 
237
#else
175
238
  about = gnome_about_new(PACKAGE,
176
239
                          VERSION,
177
240
                          copystring,
180
243
                          thanks,
181
244
                          strcmp(translator_credits, "translator_credits") != 0 ? translator_credits : NULL,
182
245
                          NULL);
 
246
#endif
183
247
  gtk_widget_show(about);
184
248
}
185
249
 
203
267
  jukebox_locked = TRUE;
204
268
  cancel_jukebox_operation = FALSE;
205
269
 
206
 
  label = gtk_label_new(_("Retrieveing information from jukebox"));
 
270
#if GTK_CHECK_VERSION(2,4,0)
 
271
  dialog = gtk_message_dialog_new (GTK_WINDOW(main_window),
 
272
                                   GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
 
273
                                   GTK_MESSAGE_INFO,
 
274
                                   GTK_BUTTONS_CLOSE,
 
275
                                   _("Scanning jukebox library"));
 
276
  gtk_window_set_title (GTK_WINDOW (dialog), _("Retrieveing metadata from jukebox"));
 
277
  g_signal_connect_object(GTK_OBJECT(dialog),
 
278
                          "delete_event",
 
279
                          G_CALLBACK(cancel_jukebox_operation_click),
 
280
                          NULL,
 
281
                          0);
 
282
  g_signal_connect_object(GTK_OBJECT(dialog), 
 
283
                          "response",
 
284
                          G_CALLBACK(cancel_jukebox_operation_click), 
 
285
                          NULL,
 
286
                          0);
 
287
  /* A blank label for progress messages */
 
288
  label = gtk_label_new("");
 
289
  gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), label, TRUE, TRUE, 0);
 
290
  gtk_widget_show_all(dialog);
 
291
#else
 
292
  label = gtk_label_new(_("Retrieveing metadata from jukebox"));
207
293
  dialog = gnome_dialog_new(_("Scanning jukebox library"),
208
294
                            GNOME_STOCK_BUTTON_CANCEL,
209
295
                            NULL);
213
299
                              NULL);
214
300
  gtk_box_pack_start (GTK_BOX (GNOME_DIALOG (dialog)->vbox), label, TRUE,
215
301
                      TRUE, 0);
 
302
  /* A blank label for progress messages */
 
303
  label = gtk_label_new("");
 
304
  gtk_box_pack_start (GTK_BOX (GNOME_DIALOG (dialog)->vbox), label, TRUE,
 
305
                      TRUE, 0);
216
306
  gtk_widget_show_all(dialog);
 
307
#endif
217
308
 
218
309
  /* A bunch of arguments needed by the scanning thread */
219
310
  scan_thread_args.dialog = dialog;
224
315
  return;
225
316
}
226
317
 
 
318
#if !GTK_CHECK_VERSION(2,4,0)
227
319
static void set_owner_ok_button (GtkButton *button,
228
320
                                 gpointer data)
229
321
{
238
330
  g_free(owner);
239
331
  gtk_widget_destroy(jukeboxowner_dialog);
240
332
}
 
333
#endif
241
334
 
242
335
/* A dialog to select the owner */
243
336
static void set_jukeboxowner_dialog(gpointer data)
246
339
  gchar *text;
247
340
  gchar *ownerstring;
248
341
 
 
342
#if GTK_CHECK_VERSION(2,4,0)
 
343
  GtkWidget *jukeboxowner_dialog;
 
344
  GtkWidget *jukeboxowner_entry;
 
345
  gint i;
 
346
  gchar *owner;
249
347
 
 
348
  if (!jukebox_selected()) {
 
349
    create_select_jukebox_dialog();
 
350
    return;
 
351
  }
 
352
  jukeboxowner_dialog = gtk_message_dialog_new (GTK_WINDOW(main_window),
 
353
                                                GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
 
354
                                                GTK_MESSAGE_QUESTION,
 
355
                                                GTK_BUTTONS_OK_CANCEL,
 
356
                                                _("Set owner string"));
 
357
  gtk_box_set_spacing (GTK_BOX(GTK_DIALOG(jukeboxowner_dialog)->vbox), 5);
 
358
  
 
359
  label = gtk_label_new(_("Edit the owner of this jukebox:"));
 
360
  gtk_box_pack_start(GTK_BOX(GTK_DIALOG(jukeboxowner_dialog)->vbox), 
 
361
                     label, TRUE, TRUE, 0);
 
362
  gtk_widget_show(label);
 
363
  jukeboxowner_entry = gtk_entry_new();
 
364
  ownerstring = jukebox_get_ownerstring();
 
365
  if (ownerstring != NULL)
 
366
    gtk_entry_set_text(GTK_ENTRY(jukeboxowner_entry), ownerstring);
 
367
  gtk_box_pack_start(GTK_BOX(GTK_DIALOG(jukeboxowner_dialog)->vbox), jukeboxowner_entry, TRUE, TRUE, 0);
 
368
  gtk_widget_show(jukeboxowner_entry);
 
369
  gtk_widget_show_all(jukeboxowner_dialog);
 
370
  i = gtk_dialog_run(GTK_DIALOG(jukeboxowner_dialog));
 
371
  if (i == GTK_RESPONSE_OK) {
 
372
    if (jukebox_locked) {
 
373
      create_error_dialog(_("Jukebox busy - change discarded"));
 
374
      return;
 
375
    }
 
376
    owner = g_strdup(gtk_entry_get_text(GTK_ENTRY(jukeboxowner_entry)));
 
377
    jukebox_set_ownerstring(owner);
 
378
    g_free(owner);
 
379
    gtk_widget_destroy(jukeboxowner_dialog);    
 
380
  } else {
 
381
    gtk_widget_destroy(jukeboxowner_dialog);
 
382
  }
 
383
#else
 
384
  if (!jukebox_selected()) {
 
385
    create_select_jukebox_dialog();
 
386
    return;
 
387
  }
250
388
  jukeboxowner_dialog = gnome_dialog_new(_("Set owner string"),
251
389
                                         GNOME_STOCK_BUTTON_OK,
252
390
                                         GNOME_STOCK_BUTTON_CANCEL,
270
408
  gtk_box_pack_start(GTK_BOX(GNOME_DIALOG(jukeboxowner_dialog)->vbox), jukeboxowner_entry, TRUE, TRUE, 0);
271
409
  gtk_widget_show(jukeboxowner_entry);
272
410
  gtk_widget_show(jukeboxowner_dialog);
 
411
#endif
273
412
}
274
413
 
275
 
static void add_to_dialog(GtkWidget *dialog, GtkWidget *thing)
276
 
{
277
 
  gtk_box_pack_start (GTK_BOX(GNOME_DIALOG(dialog)->vbox), thing, TRUE, TRUE, 0);
278
 
}
279
414
 
280
415
static void information_dialog(gpointer data)
281
416
{
282
 
  GtkWidget *label, *button, *dialog, *hbox;
283
 
  gchar tmp[50];
284
 
#ifdef G_HAVE_GINT64
285
 
  guint64 total, free, used;
286
 
  guint songs, playlists, datafiles;
287
 
#endif
 
417
  GtkWidget *dialog;
288
418
 
289
419
  if (jukebox_locked) {
290
420
    create_error_dialog(_("Cannot view information! Jukebox is busy!"));
291
421
    return;
292
422
  }
293
423
 
294
 
  dialog = gnome_dialog_new(_("Jukebox information"),
295
 
                            GNOME_STOCK_BUTTON_OK,
296
 
                            NULL);
297
 
  gnome_dialog_button_connect_object(GNOME_DIALOG(dialog),
298
 
                                     0,
299
 
                                     GTK_SIGNAL_FUNC(gtk_widget_destroy),
300
 
                                     GTK_OBJECT(dialog));
301
 
  hbox = gtk_hbox_new(FALSE, 0);
302
 
  label = gtk_label_new (_("Unique device ID:"));
303
 
  gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);
304
 
  gtk_widget_show (label);
305
 
  add_empty_hbox (hbox);
306
 
  label = gtk_label_new(jukebox_get_idstring());
307
 
  gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);
308
 
  gtk_widget_show(label);
309
 
  add_to_dialog(dialog, hbox);
310
 
  gtk_widget_show (hbox);
311
 
 
312
 
  hbox = gtk_hbox_new(FALSE, 0);
313
 
  label = gtk_label_new (_("Firmware revision:"));
314
 
  gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);
315
 
  gtk_widget_show (label);
316
 
  add_empty_hbox (hbox);
317
 
  label = gtk_label_new(jukebox_get_firmware());
318
 
  gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);
319
 
  gtk_widget_show(label);
320
 
  add_to_dialog(dialog, hbox);
321
 
  gtk_widget_show (hbox);
322
 
 
323
 
  hbox = gtk_hbox_new(FALSE, 0);
324
 
  label = gtk_label_new (_("Product name:"));
325
 
  gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);
326
 
  gtk_widget_show (label);
327
 
  add_empty_hbox (hbox);
328
 
  label = gtk_label_new(jukebox_get_prodname());
329
 
  gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);
330
 
  gtk_widget_show(label);
331
 
  add_to_dialog(dialog, hbox);
332
 
  gtk_widget_show (hbox);
333
 
 
334
 
  hbox = gtk_hbox_new(FALSE, 0);
335
 
  label = gtk_label_new (_("Power connected:"));
336
 
  gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);
337
 
  gtk_widget_show (label);
338
 
  add_empty_hbox (hbox);
339
 
  label = gtk_label_new((jukebox_get_power()) ? _("Yes") : _("No"));
340
 
  gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);
341
 
  gtk_widget_show(label);
342
 
  add_to_dialog(dialog, hbox);
343
 
  gtk_widget_show (hbox);
344
 
 
345
 
  hbox = gtk_hbox_new(FALSE, 0);
346
 
  label = gtk_label_new (_("Jukebox owner:"));
347
 
  gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);
348
 
  gtk_widget_show (label);
349
 
  add_empty_hbox (hbox);
350
 
  sprintf(tmp, "%s", jukebox_get_ownerstring());
351
 
  label = gtk_label_new(tmp);
352
 
  gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);
353
 
  gtk_widget_show(label);
354
 
  add_to_dialog(dialog, hbox);
355
 
  gtk_widget_show (hbox);
356
 
 
357
 
#ifdef NJB_HASGETTIME
358
 
  hbox = gtk_hbox_new(FALSE, 0);
359
 
  label = gtk_label_new (_("Time on jukebox:"));
360
 
  gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);
361
 
  gtk_widget_show (label);
362
 
  add_empty_hbox (hbox);
363
 
  label = gtk_label_new(jukebox_get_time());
364
 
  gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);
365
 
  gtk_widget_show(label);
366
 
  add_to_dialog(dialog, hbox);
367
 
  gtk_widget_show (hbox);
368
 
#endif
369
 
 
370
 
#ifdef G_HAVE_GINT64
371
 
  jukebox_getusage(&total, &free, &used, &songs, &playlists, &datafiles);
372
 
 
373
 
  hbox = gtk_hbox_new(FALSE, 0);
374
 
  label = gtk_label_new (_("Total bytes on disk:"));
375
 
  gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);
376
 
  gtk_widget_show (label);
377
 
  add_empty_hbox (hbox);
378
 
  sprintf(tmp, "%Lu (%Lu MB)", 
379
 
          total, (guint64) total/G_GINT64_CONSTANT(1048576));
380
 
  label = gtk_label_new(tmp);
381
 
  gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);
382
 
  gtk_widget_show(label);
383
 
  add_to_dialog(dialog, hbox);
384
 
  gtk_widget_show (hbox);
385
 
 
386
 
  hbox = gtk_hbox_new(FALSE, 0);
387
 
  label = gtk_label_new (_("Total free bytes available:"));
388
 
  gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);
389
 
  gtk_widget_show (label);
390
 
  add_empty_hbox (hbox);
391
 
  sprintf(tmp, "%Lu (%Lu MB)", 
392
 
          free, (guint64) free/G_GINT64_CONSTANT(1048576));
393
 
  label = gtk_label_new(tmp);
394
 
  gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);
395
 
  gtk_widget_show(label);
396
 
  add_to_dialog(dialog, hbox);
397
 
  gtk_widget_show (hbox);
398
 
 
399
 
  hbox = gtk_hbox_new(FALSE, 0);
400
 
  label = gtk_label_new (_("Total bytes used:"));
401
 
  gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);
402
 
  gtk_widget_show (label);
403
 
  add_empty_hbox (hbox);
404
 
  sprintf(tmp, "%Lu (%Lu MB)", 
405
 
          used, (guint64) used/G_GINT64_CONSTANT(1048576));
406
 
  label = gtk_label_new(tmp);
407
 
  gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);
408
 
  gtk_widget_show(label);
409
 
  add_to_dialog(dialog, hbox);
410
 
  gtk_widget_show (hbox);
411
 
 
412
 
  hbox = gtk_hbox_new(FALSE, 0);
413
 
  label = gtk_label_new (_("Number of songs:"));
414
 
  gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);
415
 
  gtk_widget_show (label);
416
 
  add_empty_hbox (hbox);
417
 
  sprintf(tmp, "%lu", songs);
418
 
  label = gtk_label_new(tmp);
419
 
  gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);
420
 
  gtk_widget_show(label);
421
 
  add_to_dialog(dialog, hbox);
422
 
  gtk_widget_show (hbox);
423
 
 
424
 
  hbox = gtk_hbox_new(FALSE, 0);
425
 
  label = gtk_label_new (_("Number of playlists:"));
426
 
  gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);
427
 
  gtk_widget_show (label);
428
 
  add_empty_hbox (hbox);
429
 
  sprintf(tmp, "%lu", playlists);
430
 
  label = gtk_label_new(tmp);
431
 
  gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);
432
 
  gtk_widget_show(label);
433
 
  add_to_dialog(dialog, hbox);
434
 
  gtk_widget_show (hbox);
435
 
 
436
 
  hbox = gtk_hbox_new(FALSE, 0);
437
 
  label = gtk_label_new (_("Number of datafiles:"));
438
 
  gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);
439
 
  gtk_widget_show (label);
440
 
  add_empty_hbox (hbox);
441
 
  sprintf(tmp, "%lu", datafiles);
442
 
  label = gtk_label_new(tmp);
443
 
  gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);
444
 
  gtk_widget_show(label);
445
 
  add_to_dialog(dialog, hbox);
446
 
  gtk_widget_show (hbox);
447
 
#endif
448
 
 
449
 
  gtk_widget_show(dialog);  
 
424
  dialog = jukebox_get_deviceinfo_dialog();
 
425
  if (dialog != NULL) {
 
426
    gtk_widget_show(dialog);  
 
427
  } else {
 
428
    create_error_dialog(_("Cannot retrieve jukebox information!"));
 
429
  }
450
430
}
451
431
 
452
432
/***********************************************************************************/
456
436
         char *argv[])
457
437
{
458
438
  const gchar cProgramName[]= PACKAGE " " VERSION;
459
 
  GtkWidget *window;
 
439
#if !GTK_CHECK_VERSION(2,6,0)
460
440
  GnomeProgram *gnomad;
 
441
#endif
461
442
  /* For the menus */
462
443
  GtkWidget *menu;
463
444
  GtkWidget *menu_bar;
477
458
  extern char *optarg;
478
459
  gint opt;
479
460
  gint i;
 
461
  GError *icon_load_error;
480
462
 
481
463
  /* Binds for internationalization (i18n) */
482
464
  bindtextdomain (GETTEXT_PACKAGE, GNOMADLOCALEDIR);
485
467
 
486
468
  g_thread_init(NULL);
487
469
  gdk_threads_init();
488
 
  
 
470
 
 
471
#if GTK_CHECK_VERSION(2,6,0)
 
472
  gtk_init(&argc, &argv);
 
473
#else
489
474
  gnomad = gnome_program_init(PACKAGE, VERSION, LIBGNOMEUI_MODULE, argc, argv, 
490
475
                              GNOME_PARAM_POPT_TABLE, NULL, 
491
476
                              GNOME_PROGRAM_STANDARD_PROPERTIES, NULL);
492
 
  // gnome_init(PACKAGE, VERSION, argc, argv);
493
 
 
 
477
#endif
494
478
  /* Parse extra arguments */
495
479
  gnomad_debug = 0;
496
480
  while ((opt = getopt(argc, argv, "D:")) != -1 ) {
512
496
    gdk_color_black(cmap, &darkblue);
513
497
  }
514
498
 
515
 
  window = gnome_app_new(PACKAGE, cProgramName);
516
 
  gtk_window_set_wmclass(GTK_WINDOW(window), PACKAGE, "main");
517
 
  gtk_widget_set_usize(GTK_WIDGET(window), 640, 480);
 
499
#if GTK_CHECK_VERSION(2,6,0)
 
500
  main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 
501
  gtk_window_set_title (GTK_WINDOW (main_window), cProgramName);
 
502
  icon_pixbuf = gdk_pixbuf_new_from_file(PIXMAPSDIR "/gnomad2-logo.png", &icon_load_error);
 
503
  if (icon_pixbuf != NULL) {
 
504
    gtk_window_set_default_icon(icon_pixbuf);
 
505
  }
 
506
#else
 
507
  main_window = gnome_app_new(PACKAGE, cProgramName);
 
508
#endif
 
509
  gtk_window_set_wmclass(GTK_WINDOW(main_window), PACKAGE, "main");
 
510
  gtk_widget_set_usize(GTK_WIDGET(main_window), 640, 480);
518
511
  
519
 
  g_signal_connect(GTK_OBJECT(window), 
 
512
  g_signal_connect(GTK_OBJECT(main_window), 
520
513
                   "delete_event",
521
514
                   G_CALLBACK(delete),
522
515
                   NULL);
523
516
 
524
 
  g_signal_connect(GTK_OBJECT(window), 
 
517
  g_signal_connect(GTK_OBJECT(main_window), 
525
518
                   "expose_event",
526
519
                   G_CALLBACK(expose),
527
520
                   NULL);
528
521
  
529
 
  gtk_container_set_border_width (GTK_CONTAINER (window), 0);
 
522
  gtk_container_set_border_width (GTK_CONTAINER (main_window), 0);
530
523
 
531
524
  /* Create metadata list stores */
532
525
  create_list_stores();
533
526
 
534
527
  /* Create a GtkAccelGroup and add it to the window. */
535
528
  accel_group = gtk_accel_group_new();
536
 
  gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
 
529
  gtk_window_add_accel_group (GTK_WINDOW (main_window), accel_group);
537
530
 
538
531
  /* Stuff everything into a vertical box */
539
 
  vbox=gtk_vbox_new(FALSE, 5);
 
532
  vbox = gtk_vbox_new(FALSE, 5);
540
533
  gtk_container_set_border_width(GTK_CONTAINER(vbox), 0);
541
 
  gnome_app_set_contents(GNOME_APP(window), vbox);
 
534
#if GTK_CHECK_VERSION(2,6,0)
 
535
  gtk_container_add(GTK_CONTAINER(main_window), vbox);
 
536
#else
 
537
  gnome_app_set_contents(GNOME_APP(main_window), vbox);
 
538
#endif
542
539
  gtk_widget_show(vbox);
543
540
 
544
541
  /* Create the menu bar */
660
657
  gtk_menu_item_set_submenu(GTK_MENU_ITEM(root_menu), menu);
661
658
  gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), root_menu);
662
659
  
663
 
  gtk_widget_show(window);
 
660
  gtk_widget_show(main_window);
664
661
 
665
662
  gdk_threads_enter();
666
663
  gtk_main();