← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/gimp/jaunty-security

« back to all changes in this revision

Viewing changes to plug-ins/dbbrowser/gimpprocbrowser.c

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Holbach
  • Date: 2007-05-02 16:33:03 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20070502163303-bvzhjzbpw8qglc4y
Tags: 2.3.16-1ubuntu1
* Resynchronized with Debian, remaining Ubuntu changes:
  - debian/rules: i18n magic.
* debian/control.in:
  - Maintainer: Ubuntu Core Developers <ubuntu-devel@lists.ubuntu.com>
* debian/patches/02_help-message.patch,
  debian/patches/03_gimp.desktop.in.in.patch,
  debian/patches/10_dont_show_wizard.patch: updated.
* debian/patches/04_composite-signedness.patch,
  debian/patches/05_add-letter-spacing.patch: dropped, used upstream.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plug-ins/dbbrowser/gimpprocbrowser.c
1
 
/* The GIMP -- an image manipulation program
2
 
 * Copyright (C) 1995 Spencer Kimball and Peter Mattis
3
 
 *
4
 
 * This program is free software; you can redistribute it and/or modify
5
 
 * it under the terms of the GNU General Public License as published by
6
 
 * the Free Software Foundation; either version 2 of the License, or
7
 
 * (at your option) any later version.
8
 
 *
9
 
 * This program is distributed in the hope that it will be useful,
10
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12
 
 * GNU General Public License for more details.
13
 
 *
14
 
 * You should have received a copy of the GNU General Public License
15
 
 * along with this program; if not, write to the Free Software
16
 
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
17
 
 */
18
 
 
19
 
/*
20
 
 * dbbrowser_utils.c
21
 
 * 0.08  26th sept 97  by Thomas NOEL <thomas@minet.net>
22
 
 *
23
 
 * 98/12/13  Sven Neumann <sven@gimp.org> : added help display
24
 
 */
25
 
 
26
 
#include "config.h"
27
 
 
28
 
#include <string.h>
29
 
 
30
 
#include <gtk/gtk.h>
31
 
 
32
 
#include <libgimp/gimp.h>
33
 
#include <libgimp/gimpui.h>
34
 
 
35
 
#include "gimpprocbox.h"
36
 
#include "gimpprocbrowser.h"
37
 
#include "gimpprocview.h"
38
 
 
39
 
#include "libgimp/stdplugins-intl.h"
40
 
 
41
 
 
42
 
#define RESPONSE_SEARCH       1
43
 
#define RESPONSE_SEARCH_NAME  2
44
 
#define RESPONSE_SEARCH_BLURB 3
45
 
 
46
 
#define DBL_LIST_WIDTH 250
47
 
#define DBL_WIDTH      (DBL_LIST_WIDTH + 400)
48
 
#define DBL_HEIGHT     250
49
 
 
50
 
enum
51
 
{
52
 
  COLUMN_LABEL,
53
 
  COLUMN_PROC_NAME,
54
 
  N_COLUMNS
55
 
};
56
 
 
57
 
typedef struct
58
 
{
59
 
  GtkWidget        *dialog;
60
 
 
61
 
  GtkWidget        *count_label;
62
 
  GtkWidget        *search_entry;
63
 
  GtkWidget        *proc_box;
64
 
 
65
 
  GtkListStore     *store;
66
 
  GtkWidget        *tv;
67
 
  GtkTreeSelection *sel;
68
 
 
69
 
  /* the currently selected procedure */
70
 
  gchar            *proc_name;
71
 
  gchar            *proc_blurb;
72
 
  gchar            *proc_help;
73
 
  gchar            *proc_author;
74
 
  gchar            *proc_copyright;
75
 
  gchar            *proc_date;
76
 
  GimpPDBProcType   proc_type;
77
 
  gint              n_params;
78
 
  gint              n_return_vals;
79
 
  GimpParamDef     *params;
80
 
  GimpParamDef     *return_vals;
81
 
 
82
 
  gboolean                     scheme_names;
83
 
  GimpProcBrowserApplyCallback apply_callback;
84
 
  gpointer                     user_data;
85
 
} GimpDBBrowser;
86
 
 
87
 
 
88
 
/*  local function prototypes  */
89
 
 
90
 
static void   browser_response          (GtkWidget         *widget,
91
 
                                         gint               response_id,
92
 
                                         GimpDBBrowser     *browser);
93
 
static void   browser_selection_changed (GtkTreeSelection  *sel,
94
 
                                         GimpDBBrowser     *browser);
95
 
static void   browser_row_activated     (GtkTreeView       *treeview,
96
 
                                         GtkTreePath       *path,
97
 
                                         GtkTreeViewColumn *column,
98
 
                                         GimpDBBrowser     *browser);
99
 
static void   browser_show_procedure    (GimpDBBrowser     *browser,
100
 
                                         gchar             *proc_name);
101
 
static void   browser_convert_string    (gchar             *str);
102
 
 
103
 
 
104
 
/*  public functions  */
105
 
 
106
 
GtkWidget *
107
 
gimp_proc_browser_dialog_new (gboolean                     scheme_names,
108
 
                              GimpProcBrowserApplyCallback apply_callback,
109
 
                              gpointer                     user_data)
110
 
{
111
 
  GimpDBBrowser   *browser;
112
 
  GtkWidget       *paned;
113
 
  GtkWidget       *hbox;
114
 
  GtkWidget       *vbox;
115
 
  GtkWidget       *label;
116
 
  GtkWidget       *scrolled_window;
117
 
  GtkCellRenderer *renderer;
118
 
 
119
 
  browser = g_new0 (GimpDBBrowser, 1);
120
 
 
121
 
  browser->scheme_names   = scheme_names ? TRUE : FALSE;
122
 
  browser->apply_callback = apply_callback;
123
 
  browser->user_data      = user_data;
124
 
 
125
 
  if (apply_callback)
126
 
    {
127
 
      browser->dialog =
128
 
        gimp_dialog_new (_("Procedure Browser"), "dbbrowser",
129
 
                         NULL, 0,
130
 
                         gimp_standard_help_func, "plug-in-db-browser",
131
 
 
132
 
                         _("Search by _Name"),  RESPONSE_SEARCH_NAME,
133
 
                         _("Search by _Blurb"), RESPONSE_SEARCH_BLURB,
134
 
                         GTK_STOCK_APPLY,       GTK_RESPONSE_APPLY,
135
 
                         GTK_STOCK_CLOSE,       GTK_RESPONSE_CLOSE,
136
 
 
137
 
                         NULL);
138
 
    }
139
 
  else
140
 
    {
141
 
      browser->dialog =
142
 
        gimp_dialog_new (_("Procedure Browser"), "dbbrowser",
143
 
                         NULL, 0,
144
 
                         gimp_standard_help_func, "plug-in-db-browser",
145
 
 
146
 
                         _("Search by _Name"),  RESPONSE_SEARCH_NAME,
147
 
                         _("Search by _Blurb"), RESPONSE_SEARCH_BLURB,
148
 
                         GTK_STOCK_CLOSE,       GTK_RESPONSE_CLOSE,
149
 
 
150
 
                         NULL);
151
 
    }
152
 
 
153
 
  gtk_dialog_set_default_response (GTK_DIALOG (browser->dialog),
154
 
                                   RESPONSE_SEARCH_NAME);
155
 
 
156
 
  g_signal_connect (browser->dialog, "response",
157
 
                    G_CALLBACK (browser_response),
158
 
                    browser);
159
 
 
160
 
  /* paned : left=list ; right=description */
161
 
 
162
 
  paned = gtk_hpaned_new ();
163
 
  gtk_container_set_border_width (GTK_CONTAINER (paned), 12);
164
 
  gtk_container_add (GTK_CONTAINER (GTK_DIALOG (browser->dialog)->vbox),
165
 
                     paned);
166
 
  gtk_widget_show (paned);
167
 
 
168
 
  /* left = vbox : the list and the search entry */
169
 
 
170
 
  vbox = gtk_vbox_new (FALSE, 6);
171
 
  gtk_paned_pack1 (GTK_PANED (paned), vbox, FALSE, TRUE);
172
 
  gtk_widget_show (vbox);
173
 
 
174
 
  browser->count_label = gtk_label_new ("0 Procedures");
175
 
  gtk_misc_set_alignment (GTK_MISC (browser->count_label), 0.0, 0.5);
176
 
  gtk_box_pack_start (GTK_BOX (vbox), browser->count_label, FALSE, FALSE, 0);
177
 
  gtk_widget_show (browser->count_label);
178
 
 
179
 
  /* list : list in a scrolled_win */
180
 
 
181
 
  scrolled_window = gtk_scrolled_window_new (NULL, NULL);
182
 
  gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window),
183
 
                                       GTK_SHADOW_IN);
184
 
  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
185
 
                                  GTK_POLICY_AUTOMATIC,
186
 
                                  GTK_POLICY_ALWAYS);
187
 
  gtk_box_pack_start (GTK_BOX (vbox), scrolled_window, TRUE, TRUE, 0);
188
 
  gtk_widget_show (scrolled_window);
189
 
 
190
 
  browser->tv = gtk_tree_view_new ();
191
 
 
192
 
  renderer = gtk_cell_renderer_text_new ();
193
 
  gtk_cell_renderer_text_set_fixed_height_from_font
194
 
    (GTK_CELL_RENDERER_TEXT (renderer), 1);
195
 
 
196
 
  gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (browser->tv),
197
 
                                               -1, NULL,
198
 
                                               renderer,
199
 
                                               "text", 0,
200
 
                                               NULL);
201
 
  gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (browser->tv), FALSE);
202
 
 
203
 
  if (apply_callback)
204
 
    g_signal_connect (browser->tv, "row_activated",
205
 
                      G_CALLBACK (browser_row_activated),
206
 
                      browser);
207
 
 
208
 
  gtk_widget_set_size_request (browser->tv, DBL_LIST_WIDTH, DBL_HEIGHT);
209
 
  gtk_container_add (GTK_CONTAINER (scrolled_window), browser->tv);
210
 
  gtk_widget_show (browser->tv);
211
 
 
212
 
  browser->sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (browser->tv));
213
 
 
214
 
  g_signal_connect (browser->sel, "changed",
215
 
                    G_CALLBACK (browser_selection_changed),
216
 
                    browser);
217
 
 
218
 
  /* search entry */
219
 
 
220
 
  hbox = gtk_hbox_new (FALSE, 6);
221
 
  gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
222
 
  gtk_widget_show (hbox);
223
 
 
224
 
  label = gtk_label_new_with_mnemonic (_("_Search:"));
225
 
  gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
226
 
  gtk_widget_show (label);
227
 
 
228
 
  browser->search_entry = gtk_entry_new ();
229
 
  gtk_entry_set_activates_default (GTK_ENTRY (browser->search_entry), TRUE);
230
 
  gtk_box_pack_start (GTK_BOX (hbox), browser->search_entry, TRUE, TRUE, 0);
231
 
  gtk_widget_show (browser->search_entry);
232
 
 
233
 
  gtk_label_set_mnemonic_widget (GTK_LABEL (label), browser->search_entry);
234
 
 
235
 
  /* right = description */
236
 
 
237
 
  browser->proc_box = gimp_proc_box_new ();
238
 
  gtk_widget_set_size_request (browser->proc_box,
239
 
                               DBL_WIDTH - DBL_LIST_WIDTH, -1);
240
 
  gtk_paned_pack2 (GTK_PANED (paned), browser->proc_box, TRUE, TRUE);
241
 
  gtk_widget_show (browser->proc_box);
242
 
 
243
 
  /* now build the list */
244
 
 
245
 
  gtk_widget_show (browser->dialog);
246
 
 
247
 
  /* initialize the "return" value (for "apply") */
248
 
 
249
 
  browser->proc_name        = NULL;
250
 
  browser->proc_blurb       = NULL;
251
 
  browser->proc_help        = NULL;
252
 
  browser->proc_author      = NULL;
253
 
  browser->proc_copyright   = NULL;
254
 
  browser->proc_date        = NULL;
255
 
  browser->proc_type        = 0;
256
 
  browser->n_params         = 0;
257
 
  browser->n_return_vals    = 0;
258
 
  browser->params           = NULL;
259
 
  browser->return_vals      = NULL;
260
 
 
261
 
  /* first search (all procedures) */
262
 
  browser_response (browser->dialog, RESPONSE_SEARCH, browser);
263
 
 
264
 
  gtk_widget_grab_focus (browser->search_entry);
265
 
 
266
 
  return browser->dialog;
267
 
}
268
 
 
269
 
 
270
 
/*  private functions  */
271
 
 
272
 
static void
273
 
browser_selection_changed (GtkTreeSelection *sel,
274
 
                           GimpDBBrowser    *browser)
275
 
{
276
 
  GtkTreeIter iter;
277
 
 
278
 
  if (gtk_tree_selection_get_selected (sel, NULL, &iter))
279
 
    {
280
 
      gchar *proc_name;
281
 
 
282
 
      gtk_tree_model_get (GTK_TREE_MODEL (browser->store), &iter,
283
 
                          COLUMN_PROC_NAME, &proc_name,
284
 
                          -1);
285
 
      browser_show_procedure (browser, proc_name);
286
 
      g_free (proc_name);
287
 
    }
288
 
}
289
 
 
290
 
static void
291
 
browser_row_activated (GtkTreeView       *treeview,
292
 
                       GtkTreePath       *path,
293
 
                       GtkTreeViewColumn *column,
294
 
                       GimpDBBrowser     *browser)
295
 
{
296
 
  browser_response (browser->dialog, GTK_RESPONSE_APPLY, browser);
297
 
}
298
 
 
299
 
static void
300
 
browser_show_procedure (GimpDBBrowser *browser,
301
 
                        gchar         *proc_name)
302
 
{
303
 
  g_free (browser->proc_name);
304
 
  browser->proc_name = g_strdup (proc_name);
305
 
 
306
 
  if (browser->scheme_names)
307
 
    browser_convert_string (browser->proc_name);
308
 
 
309
 
  g_free (browser->proc_blurb);
310
 
  g_free (browser->proc_help);
311
 
  g_free (browser->proc_author);
312
 
  g_free (browser->proc_copyright);
313
 
  g_free (browser->proc_date);
314
 
 
315
 
  gimp_destroy_paramdefs (browser->params,      browser->n_params);
316
 
  gimp_destroy_paramdefs (browser->return_vals, browser->n_return_vals);
317
 
 
318
 
  gimp_procedural_db_proc_info (proc_name,
319
 
                                &browser->proc_blurb,
320
 
                                &browser->proc_help,
321
 
                                &browser->proc_author,
322
 
                                &browser->proc_copyright,
323
 
                                &browser->proc_date,
324
 
                                &browser->proc_type,
325
 
                                &browser->n_params,
326
 
                                &browser->n_return_vals,
327
 
                                &browser->params,
328
 
                                &browser->return_vals);
329
 
 
330
 
  gimp_proc_box_set_widget (browser->proc_box,
331
 
                            gimp_proc_view_new (browser->proc_name,
332
 
                                                NULL,
333
 
                                                browser->proc_blurb,
334
 
                                                browser->proc_help,
335
 
                                                browser->proc_author,
336
 
                                                browser->proc_copyright,
337
 
                                                browser->proc_date,
338
 
                                                browser->proc_type,
339
 
                                                browser->n_params,
340
 
                                                browser->n_return_vals,
341
 
                                                browser->params,
342
 
                                                browser->return_vals));
343
 
}
344
 
 
345
 
static void
346
 
browser_response (GtkWidget     *widget,
347
 
                  gint           response_id,
348
 
                  GimpDBBrowser *browser)
349
 
{
350
 
  switch (response_id)
351
 
    {
352
 
    case GTK_RESPONSE_APPLY:
353
 
      browser->apply_callback (browser->proc_name,
354
 
                               browser->proc_blurb,
355
 
                               browser->proc_help,
356
 
                               browser->proc_author,
357
 
                               browser->proc_copyright,
358
 
                               browser->proc_date,
359
 
                               browser->proc_type,
360
 
                               browser->n_params,
361
 
                               browser->n_return_vals,
362
 
                               browser->params,
363
 
                               browser->return_vals,
364
 
                               browser->user_data);
365
 
      break;
366
 
 
367
 
    case RESPONSE_SEARCH:
368
 
    case RESPONSE_SEARCH_NAME:
369
 
    case RESPONSE_SEARCH_BLURB:
370
 
      {
371
 
        gchar       **proc_list;
372
 
        gint          num_procs;
373
 
        gchar        *str;
374
 
        gint          i;
375
 
        const gchar  *query_text;
376
 
        GString      *query;
377
 
        GtkTreeIter   iter;
378
 
 
379
 
        gtk_tree_view_set_model (GTK_TREE_VIEW (browser->tv), NULL);
380
 
 
381
 
        /* search */
382
 
 
383
 
        if (response_id == RESPONSE_SEARCH_NAME)
384
 
          {
385
 
            gimp_proc_box_show_message (browser->proc_box,
386
 
                                        _("Searching by name - please wait"));
387
 
 
388
 
            query = g_string_new ("");
389
 
            query_text = gtk_entry_get_text (GTK_ENTRY (browser->search_entry));
390
 
 
391
 
            while (*query_text)
392
 
              {
393
 
                if ((*query_text == '_') || (*query_text == '-'))
394
 
                  g_string_append (query, "[-_]");
395
 
                else
396
 
                  g_string_append_c (query, *query_text);
397
 
 
398
 
                query_text++;
399
 
              }
400
 
 
401
 
            gimp_procedural_db_query (query->str,
402
 
                                      ".*", ".*", ".*", ".*", ".*", ".*",
403
 
                                      &num_procs, &proc_list);
404
 
 
405
 
            g_string_free (query, TRUE);
406
 
          }
407
 
        else if (response_id == RESPONSE_SEARCH_BLURB)
408
 
          {
409
 
            gimp_proc_box_show_message (browser->proc_box,
410
 
                                        _("Searching by blurb - please wait"));
411
 
 
412
 
            gimp_procedural_db_query (".*",
413
 
                                      (gchar *) gtk_entry_get_text
414
 
                                      (GTK_ENTRY (browser->search_entry)),
415
 
                                      ".*", ".*", ".*", ".*", ".*",
416
 
                                      &num_procs, &proc_list);
417
 
          }
418
 
        else
419
 
          {
420
 
            gimp_proc_box_show_message (browser->proc_box,
421
 
                                        _("Searching - please wait"));
422
 
 
423
 
            gimp_procedural_db_query (".*", ".*", ".*", ".*", ".*", ".*", ".*",
424
 
                                      &num_procs, &proc_list);
425
 
          }
426
 
 
427
 
        if (num_procs == 1)
428
 
          str = g_strdup (_("1 Procedure"));
429
 
        else
430
 
          str = g_strdup_printf (_("%d Procedures"), num_procs);
431
 
 
432
 
        gtk_label_set_text (GTK_LABEL (browser->count_label), str);
433
 
        g_free (str);
434
 
 
435
 
        browser->store = gtk_list_store_new (N_COLUMNS,
436
 
                                             G_TYPE_STRING,
437
 
                                             G_TYPE_STRING);
438
 
        gtk_tree_view_set_model (GTK_TREE_VIEW (browser->tv),
439
 
                                 GTK_TREE_MODEL (browser->store));
440
 
        g_object_unref (browser->store);
441
 
 
442
 
        for (i = 0; i < num_procs; i++)
443
 
          {
444
 
            gchar *label;
445
 
 
446
 
            label = g_strdup (proc_list[i]);
447
 
 
448
 
            if (browser->scheme_names)
449
 
              browser_convert_string (label);
450
 
 
451
 
            gtk_list_store_append (browser->store, &iter);
452
 
            gtk_list_store_set (browser->store, &iter,
453
 
                                COLUMN_LABEL,     label,
454
 
                                COLUMN_PROC_NAME, proc_list[i],
455
 
                                -1);
456
 
 
457
 
            g_free (label);
458
 
            g_free (proc_list[i]);
459
 
          }
460
 
 
461
 
        g_free (proc_list);
462
 
 
463
 
        gtk_tree_view_columns_autosize (GTK_TREE_VIEW (browser->tv));
464
 
 
465
 
        gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (browser->store),
466
 
                                              COLUMN_LABEL, GTK_SORT_ASCENDING);
467
 
 
468
 
        if (num_procs > 0)
469
 
          {
470
 
            gtk_tree_model_get_iter_first (GTK_TREE_MODEL (browser->store),
471
 
                                           &iter);
472
 
            gtk_tree_selection_select_iter (browser->sel, &iter);
473
 
          }
474
 
        else
475
 
          {
476
 
            gimp_proc_box_show_message (browser->proc_box, _("No matches"));
477
 
          }
478
 
      }
479
 
      break;
480
 
 
481
 
    default:
482
 
      if (browser->apply_callback)
483
 
        {
484
 
          /* we are called by another application:
485
 
           * just destroy the dialog box
486
 
           */
487
 
          gtk_widget_destroy (browser->dialog);
488
 
        }
489
 
      else
490
 
        {
491
 
          /* we are in the plug_in:
492
 
           * quit the gtk application
493
 
           */
494
 
          gtk_main_quit ();
495
 
        }
496
 
      break;
497
 
    }
498
 
}
499
 
 
500
 
static void
501
 
browser_convert_string (gchar *str)
502
 
{
503
 
  while (*str)
504
 
    {
505
 
      if (*str == '_')
506
 
        *str = '-';
507
 
 
508
 
      str++;
509
 
    }
510
 
}