~ubuntu-branches/ubuntu/maverick/xfce4-terminal/maverick

« back to all changes in this revision

Viewing changes to terminal/terminal-helper-dialog.c

  • Committer: Bazaar Package Importer
  • Author(s): Lionel Le Folgoc
  • Date: 2007-12-08 14:51:31 UTC
  • mfrom: (1.1.11 upstream)
  • Revision ID: james.westby@ubuntu.com-20071208145131-2mcjfdnkkigad605
Tags: 0.2.8-1ubuntu1
* Merge with Debian unstable, remaining Ubuntu changes:
  - Adhere to DebianMaintainerField
  - Keep using xfce.mk
  - debian/patches/01_desktop_category.patch: show under the Accessories not
    the System menu.
* debian/compat: bump to 5.
* debian/control: bump debhelper b-d to (>= 5), add autotools-dev, drop chrpath.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
/* $Id: terminal-helper-dialog.c 21730 2006-05-20 16:23:40Z benny $ */
2
 
/*-
3
 
 * Copyright (c) 2004-2006 os-cillation e.K.
4
 
 *
5
 
 * Written by Benedikt Meurer <benny@xfce.org>.
6
 
 *
7
 
 * This program is free software; you can redistribute it and/or modify it
8
 
 * under the terms of the GNU General Public License as published by the Free
9
 
 * Software Foundation; either version 2 of the License, or (at your option)
10
 
 * any later version.
11
 
 *
12
 
 * This program is distributed in the hope that it will be useful, but WITHOUT
13
 
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14
 
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
15
 
 * more details.
16
 
 *
17
 
 * You should have received a copy of the GNU General Public License along with
18
 
 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
19
 
 * Place, Suite 330, Boston, MA  02111-1307  USA.
20
 
 */
21
 
 
22
 
#ifdef HAVE_CONFIG_H
23
 
#include <config.h>
24
 
#endif
25
 
 
26
 
#ifdef HAVE_MEMORY_H
27
 
#include <memory.h>
28
 
#endif
29
 
#ifdef HAVE_STRING_H
30
 
#include <string.h>
31
 
#endif
32
 
 
33
 
#include <exo/exo.h>
34
 
 
35
 
#include <terminal/terminal-enum-types.h>
36
 
#include <terminal/terminal-helper-dialog.h>
37
 
#include <terminal/terminal-helper.h>
38
 
#include <terminal/terminal-preferences.h>
39
 
 
40
 
 
41
 
 
42
 
enum
43
 
{
44
 
  PROP_0,
45
 
  PROP_ACTIVE,
46
 
  PROP_CATEGORY,
47
 
};
48
 
 
49
 
static const gchar *category_titles[] =
50
 
{
51
 
  N_ ("Web Browser"),
52
 
  N_ ("Mail Reader"),
53
 
};
54
 
 
55
 
static const gchar *category_descriptions[] =
56
 
{
57
 
  N_ ("Choose your preferred Web Browser. The preferred\n"
58
 
      "Web Browser opens when you right-click on a URL\n"
59
 
      "and select Open Link from the context menu."),
60
 
  N_ ("Choose your preferred Mail Reader. The preferred\n"
61
 
      "Mail Reader opens when you right-click on an email\n"
62
 
      "address and select Compose Email from the context\n"
63
 
      "menu."),
64
 
};
65
 
 
66
 
 
67
 
 
68
 
static void     terminal_helper_chooser_class_init          (TerminalHelperChooserClass *klass);
69
 
static void     terminal_helper_chooser_init                (TerminalHelperChooser      *chooser);
70
 
static void     terminal_helper_chooser_finalize            (GObject                    *object);
71
 
static void     terminal_helper_chooser_get_property        (GObject                    *object,
72
 
                                                             guint                       prop_id,
73
 
                                                             GValue                     *value,
74
 
                                                             GParamSpec                 *pspec);
75
 
static void     terminal_helper_chooser_set_property        (GObject                    *object,
76
 
                                                             guint                       prop_id,
77
 
                                                             const GValue               *value,
78
 
                                                             GParamSpec                 *pspec);
79
 
static void     terminal_helper_chooser_pressed             (GtkButton                  *button,
80
 
                                                             TerminalHelperChooser      *chooser);
81
 
static void     terminal_helper_chooser_update_state        (TerminalHelperChooser      *chooser);
82
 
 
83
 
 
84
 
 
85
 
struct _TerminalHelperChooserClass
86
 
{
87
 
  GtkHBoxClass __parent__;
88
 
};
89
 
 
90
 
struct _TerminalHelperChooser
91
 
{
92
 
  GtkHBox                 __parent__;
93
 
 
94
 
  GtkWidget              *image;
95
 
  GtkWidget              *label;
96
 
  GtkTooltips            *tooltips;
97
 
 
98
 
  TerminalHelperDatabase *database;
99
 
 
100
 
  gchar                  *active;
101
 
  TerminalHelperCategory  category;
102
 
};
103
 
 
104
 
 
105
 
 
106
 
G_DEFINE_TYPE (TerminalHelperChooser, terminal_helper_chooser, GTK_TYPE_HBOX);
107
 
 
108
 
 
109
 
 
110
 
static void
111
 
terminal_helper_chooser_class_init (TerminalHelperChooserClass *klass)
112
 
{
113
 
  GObjectClass   *gobject_class;
114
 
 
115
 
  gobject_class = G_OBJECT_CLASS (klass);
116
 
  gobject_class->finalize = terminal_helper_chooser_finalize;
117
 
  gobject_class->get_property = terminal_helper_chooser_get_property;
118
 
  gobject_class->set_property = terminal_helper_chooser_set_property;
119
 
 
120
 
  /**
121
 
   * TerminalHelperChooser:active:
122
 
   **/
123
 
  g_object_class_install_property (gobject_class,
124
 
                                   PROP_ACTIVE,
125
 
                                   g_param_spec_string ("active",
126
 
                                                        "Active helper",
127
 
                                                        "The currently selected helper",
128
 
                                                        NULL,
129
 
                                                        G_PARAM_READWRITE));
130
 
 
131
 
  /**
132
 
   * TerminalHelperChooser:category:
133
 
   **/
134
 
  g_object_class_install_property (gobject_class,
135
 
                                   PROP_CATEGORY,
136
 
                                   g_param_spec_enum ("category",
137
 
                                                      "Helper category",
138
 
                                                      "Helper category",
139
 
                                                      TERMINAL_TYPE_HELPER_CATEGORY,
140
 
                                                      TERMINAL_HELPER_WEBBROWSER,
141
 
                                                      G_PARAM_READWRITE));
142
 
}
143
 
 
144
 
 
145
 
 
146
 
static void
147
 
terminal_helper_chooser_init (TerminalHelperChooser *chooser)
148
 
{
149
 
  GtkWidget *separator;
150
 
  GtkWidget *button;
151
 
  GtkWidget *arrow;
152
 
  GtkWidget *hbox;
153
 
 
154
 
  chooser->database = terminal_helper_database_get ();
155
 
 
156
 
  chooser->tooltips = gtk_tooltips_new ();
157
 
  g_object_ref (G_OBJECT (chooser->tooltips));
158
 
  gtk_object_sink (GTK_OBJECT (chooser->tooltips));
159
 
 
160
 
  gtk_widget_push_composite_child ();
161
 
 
162
 
  button = gtk_button_new ();
163
 
  g_signal_connect (G_OBJECT (button), "pressed",
164
 
                    G_CALLBACK (terminal_helper_chooser_pressed), chooser);
165
 
  gtk_tooltips_set_tip (chooser->tooltips, button,
166
 
                        _("Click here to change the selected application "
167
 
                          "or to disable this feature."), NULL);
168
 
  gtk_container_add (GTK_CONTAINER (chooser), button);
169
 
  gtk_widget_show (button);
170
 
 
171
 
  hbox = gtk_hbox_new (FALSE, 4);
172
 
  gtk_container_add (GTK_CONTAINER (button), hbox);
173
 
  gtk_widget_show (hbox);
174
 
 
175
 
  chooser->image = gtk_image_new ();
176
 
  gtk_box_pack_start (GTK_BOX (hbox), chooser->image, FALSE, FALSE, 0);
177
 
  gtk_widget_show (chooser->image);
178
 
 
179
 
  chooser->label = g_object_new (GTK_TYPE_LABEL, "xalign", 0.0, "yalign", 0.0, NULL);
180
 
  gtk_box_pack_start (GTK_BOX (hbox), chooser->label, TRUE, TRUE, 0);
181
 
  gtk_widget_show (chooser->label);
182
 
 
183
 
  separator = g_object_new (GTK_TYPE_VSEPARATOR, "height-request", 16, NULL);
184
 
  gtk_box_pack_start (GTK_BOX (hbox), separator, FALSE, FALSE, 0);
185
 
  gtk_widget_show (separator);
186
 
 
187
 
  arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_NONE);
188
 
  gtk_box_pack_start (GTK_BOX (hbox), arrow, FALSE, FALSE, 0);
189
 
  gtk_widget_show (arrow);
190
 
 
191
 
  gtk_widget_pop_composite_child ();
192
 
 
193
 
  terminal_helper_chooser_update_state (chooser);
194
 
}
195
 
 
196
 
 
197
 
 
198
 
static void
199
 
terminal_helper_chooser_finalize (GObject *object)
200
 
{
201
 
  TerminalHelperChooser *chooser = TERMINAL_HELPER_CHOOSER (object);
202
 
 
203
 
  g_object_unref (G_OBJECT (chooser->database));
204
 
  g_object_unref (G_OBJECT (chooser->tooltips));
205
 
  g_free (chooser->active);
206
 
 
207
 
  (*G_OBJECT_CLASS (terminal_helper_chooser_parent_class)->finalize) (object);
208
 
}
209
 
 
210
 
 
211
 
 
212
 
static void
213
 
terminal_helper_chooser_get_property (GObject    *object,
214
 
                                      guint       prop_id,
215
 
                                      GValue     *value,
216
 
                                      GParamSpec *pspec)
217
 
{
218
 
  TerminalHelperChooser *chooser = TERMINAL_HELPER_CHOOSER (object);
219
 
 
220
 
  switch (prop_id)
221
 
    {
222
 
    case PROP_ACTIVE:
223
 
      g_value_set_string (value, terminal_helper_chooser_get_active (chooser));
224
 
      break;
225
 
 
226
 
    case PROP_CATEGORY:
227
 
      g_value_set_enum (value, terminal_helper_chooser_get_category (chooser));
228
 
      break;
229
 
 
230
 
    default:
231
 
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
232
 
      break;
233
 
   }
234
 
}
235
 
 
236
 
 
237
 
 
238
 
static void
239
 
terminal_helper_chooser_set_property (GObject      *object,
240
 
                                      guint         prop_id,
241
 
                                      const GValue *value,
242
 
                                      GParamSpec   *pspec)
243
 
{
244
 
  TerminalHelperChooser *chooser = TERMINAL_HELPER_CHOOSER (object);
245
 
 
246
 
  switch (prop_id)
247
 
    {
248
 
    case PROP_ACTIVE:
249
 
      terminal_helper_chooser_set_active (chooser, g_value_get_string (value));
250
 
      break;
251
 
 
252
 
    case PROP_CATEGORY:
253
 
      terminal_helper_chooser_set_category (chooser, g_value_get_enum (value));
254
 
      break;
255
 
 
256
 
    default:
257
 
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
258
 
      break;
259
 
   }
260
 
}
261
 
 
262
 
 
263
 
 
264
 
static void
265
 
menu_activate (GtkWidget             *item,
266
 
               TerminalHelperChooser *chooser)
267
 
{
268
 
  TerminalHelper *helper;
269
 
  const gchar    *id;
270
 
 
271
 
  helper = g_object_get_data (G_OBJECT (item), "terminal-helper");
272
 
  if (G_LIKELY (helper != NULL))
273
 
    {
274
 
      id = terminal_helper_get_id (helper);
275
 
      terminal_helper_chooser_set_active (chooser, id);
276
 
    }
277
 
  else
278
 
    {
279
 
      terminal_helper_chooser_set_active (chooser, "disabled");
280
 
    }
281
 
}
282
 
 
283
 
 
284
 
 
285
 
static void
286
 
entry_changed (GtkEditable *editable,
287
 
               GtkDialog   *dialog)
288
 
{
289
 
  gchar *text;
290
 
 
291
 
  text = gtk_editable_get_chars (editable, 0, -1);
292
 
  gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog),
293
 
                                     GTK_RESPONSE_OK,
294
 
                                     *text != '\0');
295
 
  g_free (text);
296
 
}
297
 
 
298
 
 
299
 
 
300
 
static void
301
 
browse_clicked (GtkWidget *button,
302
 
                GtkWidget *entry)
303
 
{
304
 
  GtkWidget *toplevel;
305
 
  GtkWidget *dialog;
306
 
  gchar     *filename;
307
 
 
308
 
  toplevel = gtk_widget_get_toplevel (entry);
309
 
  dialog = gtk_file_chooser_dialog_new (_("Select application"),
310
 
                                        GTK_WINDOW (toplevel),
311
 
                                        GTK_FILE_CHOOSER_ACTION_OPEN,
312
 
                                        GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
313
 
                                        GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
314
 
                                        NULL);
315
 
  gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (dialog), TRUE);
316
 
 
317
 
  filename = gtk_editable_get_chars (GTK_EDITABLE (entry), 0, -1);
318
 
  if (G_LIKELY (filename != NULL && *filename != '\0'))
319
 
    {
320
 
      gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (dialog), filename);
321
 
    }
322
 
  else
323
 
    {
324
 
      /* set Terminal's bindir as default folder */
325
 
      gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), BINDIR);
326
 
    }
327
 
  g_free (filename);
328
 
 
329
 
  if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
330
 
    {
331
 
      filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
332
 
      gtk_entry_set_text (GTK_ENTRY (entry), filename);
333
 
      g_free (filename);
334
 
    }
335
 
 
336
 
  gtk_widget_destroy (dialog);
337
 
}
338
 
 
339
 
 
340
 
 
341
 
static void
342
 
menu_activate_other (GtkWidget             *item,
343
 
                     TerminalHelperChooser *chooser)
344
 
{
345
 
  static const gchar *browse_titles[] =
346
 
  {
347
 
    N_ ("Choose a custom Web Browser"),
348
 
    N_ ("Choose a custom Mail Reader"),
349
 
  };
350
 
 
351
 
  static const gchar *browse_messages[] =
352
 
  {
353
 
    N_ ("Specify the application you want to use as\nWeb Browser in Terminal:"),
354
 
    N_ ("Specify the application you want to use as\nMail Reader in Terminal:"),
355
 
  };
356
 
 
357
 
  TerminalHelper  *helper;
358
 
  const gchar     *command;
359
 
  const gchar     *id;
360
 
  GEnumClass      *enum_class;
361
 
  GEnumValue      *enum_value;
362
 
  GtkWidget       *toplevel;
363
 
  GtkWidget       *dialog;
364
 
  GtkWidget       *hbox;
365
 
  GtkWidget       *image;
366
 
  GtkWidget       *vbox;
367
 
  GtkWidget       *label;
368
 
  GtkWidget       *entry;
369
 
  GtkWidget       *button;
370
 
  gchar           *stock;
371
 
 
372
 
  /* sanity check the category values */
373
 
  g_assert (TERMINAL_HELPER_WEBBROWSER == 0);
374
 
  g_assert (TERMINAL_HELPER_MAILREADER == 1);
375
 
 
376
 
  toplevel = gtk_widget_get_toplevel (GTK_WIDGET (chooser));
377
 
 
378
 
  dialog = gtk_dialog_new_with_buttons (dgettext (GETTEXT_PACKAGE, browse_titles[chooser->category]),
379
 
                                        GTK_WINDOW (toplevel),
380
 
                                        GTK_DIALOG_DESTROY_WITH_PARENT
381
 
                                        | GTK_DIALOG_NO_SEPARATOR
382
 
                                        | GTK_DIALOG_MODAL,
383
 
                                        GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
384
 
                                        GTK_STOCK_OK, GTK_RESPONSE_OK,
385
 
                                        NULL);
386
 
  gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
387
 
  gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), GTK_RESPONSE_OK, FALSE);
388
 
  gtk_container_set_border_width (GTK_CONTAINER (dialog), 6);
389
 
  gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), 12);
390
 
  gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
391
 
 
392
 
  hbox = g_object_new (GTK_TYPE_HBOX, "border-width", 5, "spacing", 12, NULL);
393
 
  gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, TRUE, TRUE, 0);
394
 
  gtk_widget_show (hbox);
395
 
 
396
 
  /* determine the stock icon for the helper category */
397
 
  enum_class = g_type_class_ref (TERMINAL_TYPE_HELPER_CATEGORY);
398
 
  enum_value = g_enum_get_value (enum_class, chooser->category);
399
 
  stock = g_strconcat ("terminal-", enum_value->value_nick, NULL);
400
 
  g_type_class_unref (enum_class);
401
 
 
402
 
  image = gtk_image_new_from_stock (stock, GTK_ICON_SIZE_DIALOG);
403
 
  gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.0);
404
 
  gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0);
405
 
  gtk_widget_show (image);
406
 
  g_free (stock);
407
 
 
408
 
  vbox = gtk_vbox_new (FALSE, 6);
409
 
  gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
410
 
  gtk_widget_show (vbox);
411
 
 
412
 
  label = g_object_new (GTK_TYPE_LABEL, 
413
 
                        "label", dgettext (GETTEXT_PACKAGE, browse_messages[chooser->category]),
414
 
                        "xalign", 0.0,
415
 
                        "yalign", 0.0,
416
 
                        NULL);
417
 
  gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, TRUE, 0);
418
 
  gtk_widget_show (label);
419
 
 
420
 
  hbox = gtk_hbox_new (FALSE, 6);
421
 
  gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
422
 
  gtk_widget_show (hbox);
423
 
 
424
 
  entry = g_object_new (GTK_TYPE_ENTRY, "activates-default", TRUE, NULL);
425
 
  g_signal_connect (G_OBJECT (entry), "changed", G_CALLBACK (entry_changed), dialog);
426
 
  gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
427
 
  gtk_widget_show (entry);
428
 
 
429
 
  button = gtk_button_new_with_mnemonic (_("_Browse..."));
430
 
  g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (browse_clicked), entry);
431
 
  gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
432
 
  gtk_widget_show (button);
433
 
 
434
 
  /* set the current custom command (if any) */
435
 
  helper = terminal_helper_database_get_custom (chooser->database, chooser->category);
436
 
  if (G_LIKELY (helper != NULL))
437
 
    {
438
 
      command = terminal_helper_get_command (helper);
439
 
      gtk_entry_set_text (GTK_ENTRY (entry), command);
440
 
    }
441
 
 
442
 
  if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK)
443
 
    {
444
 
      /* change the custom command in the database */
445
 
      command = gtk_entry_get_text (GTK_ENTRY (entry));
446
 
      terminal_helper_database_set_custom (chooser->database, chooser->category, command);
447
 
 
448
 
      /* reload the custom helper */
449
 
      helper = terminal_helper_database_get_custom (chooser->database, chooser->category);
450
 
      if (G_LIKELY (helper != NULL))
451
 
        {
452
 
          id = terminal_helper_get_id (helper);
453
 
          terminal_helper_chooser_set_active (chooser, id);
454
 
        }
455
 
    }
456
 
 
457
 
  gtk_widget_destroy (dialog);
458
 
}
459
 
 
460
 
 
461
 
 
462
 
static void
463
 
menu_position (GtkMenu    *menu,
464
 
               gint       *x,
465
 
               gint       *y,
466
 
               gboolean   *push_in,
467
 
               gpointer    chooser)
468
 
{
469
 
  GtkRequisition chooser_request;
470
 
  GtkRequisition menu_request;
471
 
  GdkRectangle   geometry;
472
 
  GdkScreen     *screen;
473
 
  GtkWidget     *toplevel = gtk_widget_get_toplevel (chooser);
474
 
  gint           monitor;
475
 
  gint           x0;
476
 
  gint           y0;
477
 
 
478
 
  gtk_widget_translate_coordinates (GTK_WIDGET (chooser), toplevel, 0, 0, &x0, &y0);
479
 
 
480
 
  gtk_widget_size_request (GTK_WIDGET (chooser), &chooser_request);
481
 
  gtk_widget_size_request (GTK_WIDGET (menu), &menu_request);
482
 
 
483
 
  gdk_window_get_position (GTK_WIDGET (chooser)->window, x, y);
484
 
 
485
 
  *y += y0;
486
 
  *x += x0;
487
 
 
488
 
  /* verify the the menu is on-screen */
489
 
  screen = gtk_widget_get_screen (GTK_WIDGET (chooser));
490
 
  if (G_LIKELY (screen != NULL))
491
 
    {
492
 
      monitor = gdk_screen_get_monitor_at_point (screen, *x, *y);
493
 
      gdk_screen_get_monitor_geometry (screen, monitor, &geometry);
494
 
      if (*y + menu_request.height > geometry.y + geometry.height)
495
 
        *y -= menu_request.height - chooser_request.height;
496
 
    }
497
 
 
498
 
  *push_in = TRUE;
499
 
}
500
 
 
501
 
 
502
 
 
503
 
static void
504
 
terminal_helper_chooser_pressed (GtkButton             *button,
505
 
                                 TerminalHelperChooser *chooser)
506
 
{
507
 
  TerminalHelper *helper;
508
 
  GMainLoop      *loop;
509
 
  GtkWidget      *menu;
510
 
  GtkWidget      *item;
511
 
  GtkWidget      *image;
512
 
  GdkCursor      *cursor;
513
 
  GSList         *helpers;
514
 
  GSList         *lp;
515
 
  guint           n_helpers;
516
 
 
517
 
  /* set a watch cursor while loading the menu */
518
 
  if (G_LIKELY (GTK_WIDGET (button)->window != NULL))
519
 
    {
520
 
      cursor = gdk_cursor_new (GDK_WATCH);
521
 
      gdk_window_set_cursor (GTK_WIDGET (button)->window, cursor);
522
 
      gdk_cursor_unref (cursor);
523
 
      gdk_flush ();
524
 
    }
525
 
 
526
 
  menu = gtk_menu_new ();
527
 
 
528
 
  item = gtk_menu_item_new_with_label (_("Disable this feature"));
529
 
  g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (menu_activate), chooser);
530
 
  gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
531
 
  gtk_widget_show (item);
532
 
 
533
 
  item = gtk_separator_menu_item_new ();
534
 
  gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
535
 
  gtk_widget_show (item);
536
 
 
537
 
  helpers = terminal_helper_database_lookup_all (chooser->database, chooser->category);
538
 
  for (lp = helpers, n_helpers = 0; lp != NULL; lp = lp->next)
539
 
    {
540
 
      /* skip hidden helpers (like custom ones) */
541
 
      helper = TERMINAL_HELPER (lp->data);
542
 
      if (terminal_helper_is_hidden (helper))
543
 
        {
544
 
          g_object_unref (G_OBJECT (helper));
545
 
          continue;
546
 
        }
547
 
 
548
 
      item = gtk_image_menu_item_new_with_label (terminal_helper_get_name (helper));
549
 
      g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (menu_activate), chooser);
550
 
      g_object_set_data_full (G_OBJECT (item), "terminal-helper", helper, g_object_unref);
551
 
      gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
552
 
      gtk_widget_show (item);
553
 
 
554
 
      image = gtk_image_new_from_icon_name (terminal_helper_get_icon (helper), GTK_ICON_SIZE_MENU);
555
 
      gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
556
 
      gtk_widget_show (image);
557
 
 
558
 
      ++n_helpers;
559
 
    }
560
 
  g_slist_free (helpers);
561
 
 
562
 
  if (G_LIKELY (n_helpers > 0))
563
 
    {
564
 
      item = gtk_separator_menu_item_new ();
565
 
      gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
566
 
      gtk_widget_show (item);
567
 
    }
568
 
 
569
 
  item = gtk_menu_item_new_with_label (_("Other..."));
570
 
  g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (menu_activate_other), chooser);
571
 
  gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
572
 
  gtk_widget_show (item);
573
 
 
574
 
  /* reset the watch cursor on the chooser */
575
 
  if (G_LIKELY (GTK_WIDGET (button)->window != NULL))
576
 
    gdk_window_set_cursor (GTK_WIDGET (button)->window, NULL);
577
 
 
578
 
  loop = g_main_loop_new (NULL, FALSE);
579
 
 
580
 
  gtk_menu_set_screen (GTK_MENU (menu), gtk_widget_get_screen (GTK_WIDGET (chooser)));
581
 
  g_signal_connect_swapped (G_OBJECT (menu), "deactivate", G_CALLBACK (g_main_loop_quit), loop);
582
 
 
583
 
  /* make sure the menu has atleast the same width as the chooser */
584
 
  if (menu->allocation.width < GTK_WIDGET (chooser)->allocation.width)
585
 
    gtk_widget_set_size_request (menu, GTK_WIDGET (chooser)->allocation.width, -1);
586
 
 
587
 
  gtk_grab_add (menu);
588
 
  gtk_menu_popup (GTK_MENU (menu), NULL, NULL, menu_position,
589
 
                  GTK_WIDGET (button), 0, gtk_get_current_event_time ());
590
 
  g_main_loop_run (loop);
591
 
  gtk_grab_remove (menu);
592
 
  g_main_loop_unref (loop);
593
 
 
594
 
  gtk_object_sink (GTK_OBJECT (menu));
595
 
 
596
 
  gtk_button_released (button);
597
 
}
598
 
 
599
 
 
600
 
 
601
 
static void
602
 
terminal_helper_chooser_update_state (TerminalHelperChooser *chooser)
603
 
{
604
 
  TerminalHelper *helper;
605
 
 
606
 
  if (exo_str_is_equal (chooser->active, "disabled"))
607
 
    {
608
 
      gtk_image_set_from_pixbuf (GTK_IMAGE (chooser->image), NULL);
609
 
      gtk_label_set_text (GTK_LABEL (chooser->label), _("Disabled"));
610
 
      return;
611
 
    }
612
 
  else if (chooser->active != NULL)
613
 
    {
614
 
      helper = terminal_helper_database_lookup (chooser->database,
615
 
                                                chooser->category,
616
 
                                                chooser->active);
617
 
      if (G_LIKELY (helper != NULL))
618
 
        {
619
 
          gtk_image_set_from_icon_name (GTK_IMAGE (chooser->image), terminal_helper_get_icon (helper), GTK_ICON_SIZE_MENU);
620
 
          gtk_label_set_text (GTK_LABEL (chooser->label), terminal_helper_get_name (helper));
621
 
          return;
622
 
        }
623
 
    }
624
 
 
625
 
  gtk_image_set_from_pixbuf (GTK_IMAGE (chooser->image), NULL);
626
 
  gtk_label_set_text (GTK_LABEL (chooser->label), _("No application selected"));
627
 
}
628
 
 
629
 
 
630
 
 
631
 
/**
632
 
 * terminal_helper_chooser_get_active:
633
 
 * @chooser : A #TerminalHelperChooser.
634
 
 *
635
 
 * Return value:
636
 
 **/
637
 
const gchar*
638
 
terminal_helper_chooser_get_active (TerminalHelperChooser *chooser)
639
 
{
640
 
  g_return_val_if_fail (TERMINAL_IS_HELPER_CHOOSER (chooser), NULL);
641
 
  return chooser->active;
642
 
}
643
 
 
644
 
 
645
 
 
646
 
/**
647
 
 * terminal_helper_chooser_set_active:
648
 
 * @chooser : A #TerminalHelperChooser.
649
 
 * @active  : 
650
 
 **/
651
 
void
652
 
terminal_helper_chooser_set_active (TerminalHelperChooser *chooser,
653
 
                                    const gchar           *active)
654
 
{
655
 
  g_return_if_fail (TERMINAL_IS_HELPER_CHOOSER (chooser));
656
 
 
657
 
  if (!exo_str_is_equal (chooser->active, active))
658
 
    {
659
 
      g_free (chooser->active);
660
 
      chooser->active = g_strdup (active);
661
 
      g_object_notify (G_OBJECT (chooser), "active");
662
 
    }
663
 
 
664
 
  terminal_helper_chooser_update_state (chooser);
665
 
}
666
 
 
667
 
 
668
 
 
669
 
/**
670
 
 * terminal_helper_chooser_get_category:
671
 
 * @chooser : A #TerminalHelperChooser.
672
 
 *
673
 
 * Return value: 
674
 
 **/
675
 
TerminalHelperCategory
676
 
terminal_helper_chooser_get_category (TerminalHelperChooser *chooser)
677
 
{
678
 
  g_return_val_if_fail (TERMINAL_IS_HELPER_CHOOSER (chooser),
679
 
                        TERMINAL_HELPER_WEBBROWSER);
680
 
  return chooser->category;
681
 
}
682
 
 
683
 
 
684
 
 
685
 
/**
686
 
 * terminal_helper_chooser_set_category:
687
 
 * @chooser : A #TerminalHelperChooser.
688
 
 * @category:
689
 
 **/
690
 
void
691
 
terminal_helper_chooser_set_category (TerminalHelperChooser *chooser,
692
 
                                      TerminalHelperCategory category)
693
 
{
694
 
  g_return_if_fail (TERMINAL_IS_HELPER_CHOOSER (chooser));
695
 
  g_return_if_fail (category >= TERMINAL_HELPER_WEBBROWSER
696
 
                 && category <= TERMINAL_HELPER_MAILREADER);
697
 
  
698
 
  if (chooser->category != category)
699
 
    {
700
 
      chooser->category = category;
701
 
      g_object_notify (G_OBJECT (chooser), "category");
702
 
    }
703
 
 
704
 
  terminal_helper_chooser_update_state (chooser);
705
 
}
706
 
 
707
 
 
708
 
 
709
 
 
710
 
struct _TerminalHelperDialogClass
711
 
{
712
 
  GtkDialogClass __parent__;
713
 
};
714
 
 
715
 
struct _TerminalHelperDialog
716
 
{
717
 
  GtkDialog               __parent__;
718
 
  TerminalPreferences    *preferences;
719
 
};
720
 
 
721
 
 
722
 
 
723
 
static void terminal_helper_dialog_class_init (TerminalHelperDialogClass *klass);
724
 
static void terminal_helper_dialog_init       (TerminalHelperDialog      *dialog);
725
 
static void terminal_helper_dialog_finalize   (GObject                   *object);
726
 
static void terminal_helper_dialog_response   (GtkDialog                 *dialog,
727
 
                                               gint                       response_id);
728
 
 
729
 
 
730
 
 
731
 
G_DEFINE_TYPE (TerminalHelperDialog, terminal_helper_dialog, GTK_TYPE_DIALOG);
732
 
 
733
 
 
734
 
 
735
 
static void
736
 
terminal_helper_dialog_class_init (TerminalHelperDialogClass *klass)
737
 
{
738
 
  GtkDialogClass *gtkdialog_class;
739
 
  GObjectClass   *gobject_class;
740
 
 
741
 
  gobject_class = G_OBJECT_CLASS (klass);
742
 
  gobject_class->finalize = terminal_helper_dialog_finalize;
743
 
 
744
 
  gtkdialog_class = GTK_DIALOG_CLASS (klass);
745
 
  gtkdialog_class->response = terminal_helper_dialog_response;
746
 
}
747
 
 
748
 
 
749
 
 
750
 
static void
751
 
terminal_helper_dialog_init (TerminalHelperDialog *dialog)
752
 
{
753
 
  TerminalHelperCategory category;
754
 
  const gchar           *text;
755
 
  GEnumClass            *enum_class;
756
 
  GEnumValue            *enum_value;
757
 
  GtkWidget             *vbox;
758
 
  GtkWidget             *frame;
759
 
  GtkWidget             *label;
760
 
  GtkWidget             *box;
761
 
  GtkWidget             *chooser;
762
 
  gchar                 *name;
763
 
 
764
 
  /* sanity check the category values */
765
 
  g_assert (TERMINAL_HELPER_WEBBROWSER == 0);
766
 
  g_assert (TERMINAL_HELPER_MAILREADER == 1);
767
 
 
768
 
  dialog->preferences = terminal_preferences_get ();
769
 
 
770
 
  gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_HELP, GTK_RESPONSE_HELP);
771
 
  gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_CLOSE, GTK_RESPONSE_CANCEL);
772
 
  gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_CANCEL);
773
 
  gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
774
 
 
775
 
  gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
776
 
  gtk_window_set_title (GTK_WINDOW (dialog), _("Preferred Applications"));
777
 
 
778
 
  vbox = g_object_new (GTK_TYPE_VBOX, "border-width", 12, "spacing", 12, NULL);
779
 
  gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), vbox, TRUE, TRUE, 0);
780
 
  gtk_widget_show (vbox);
781
 
 
782
 
  for (category = 0; category < 2; ++category)
783
 
    {
784
 
      frame = g_object_new (GTK_TYPE_FRAME, "border-width", 0, "shadow-type", GTK_SHADOW_NONE, NULL);
785
 
      gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
786
 
      gtk_widget_show (frame);
787
 
 
788
 
      text = dgettext (GETTEXT_PACKAGE, category_titles[category]);
789
 
      name = g_strdup_printf ("<b>%s</b>", text);
790
 
      label = g_object_new (GTK_TYPE_LABEL, "label", name, "use-markup", TRUE, NULL);
791
 
      gtk_frame_set_label_widget (GTK_FRAME (frame), label);
792
 
      gtk_widget_show (label);
793
 
      g_free (name);
794
 
 
795
 
      box = g_object_new (GTK_TYPE_VBOX, "border-width", 12, "spacing", 12, NULL);
796
 
      gtk_container_add (GTK_CONTAINER (frame), box);
797
 
      gtk_widget_show (box);
798
 
 
799
 
      text = dgettext (GETTEXT_PACKAGE, category_descriptions[category]);
800
 
      label = g_object_new (GTK_TYPE_LABEL, "label", text, "xalign", 0.0, "yalign", 0.0, NULL);
801
 
      gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0);
802
 
      gtk_widget_show (label);
803
 
 
804
 
      chooser = g_object_new (TERMINAL_TYPE_HELPER_CHOOSER, "category", category, NULL);
805
 
      gtk_box_pack_start (GTK_BOX (box), chooser, FALSE, FALSE, 0);
806
 
      gtk_widget_show (chooser);
807
 
 
808
 
      /* determine the name for the helper setting name */
809
 
      enum_class = g_type_class_ref (TERMINAL_TYPE_HELPER_CATEGORY);
810
 
      enum_value = g_enum_get_value (enum_class, category);
811
 
      name = g_strconcat ("helper-", enum_value->value_nick, NULL);
812
 
      exo_mutual_binding_new (G_OBJECT (dialog->preferences), name, G_OBJECT (chooser), "active");
813
 
      g_type_class_unref (enum_class);
814
 
      g_free (name);
815
 
    }
816
 
}
817
 
 
818
 
 
819
 
 
820
 
static void
821
 
terminal_helper_dialog_finalize (GObject *object)
822
 
{
823
 
  TerminalHelperDialog *dialog = TERMINAL_HELPER_DIALOG (object);
824
 
 
825
 
  g_object_unref (G_OBJECT (dialog->preferences));
826
 
 
827
 
  (*G_OBJECT_CLASS (terminal_helper_dialog_parent_class)->finalize) (object);
828
 
}
829
 
 
830
 
 
831
 
 
832
 
static void
833
 
terminal_helper_dialog_response (GtkDialog *dialog,
834
 
                                 gint       response_id)
835
 
{
836
 
  if (response_id == GTK_RESPONSE_CLOSE)
837
 
    gtk_widget_destroy (GTK_WIDGET (dialog));
838
 
}
839
 
 
840
 
 
841
 
 
842