← Back to branch summary

~ubuntu-branches/ubuntu/karmic/mergeant/karmic

« back to all changes in this revision

Viewing changes to src/ws-datatypes.c

  • Committer: Bazaar Package Importer
  • Author(s): Gustavo R. Montesino
  • Date: 2007-11-29 08:44:48 UTC
  • mfrom: (2.1.4 hardy)
  • Revision ID: james.westby@ubuntu.com-20071129084448-6aon73d22bv6hzfw
Tags: 0.67-3
* Re-enable installation of the mime files in mergeant.install
* mergeant.dirs: create usr/share/mime/packages to make dh_installmime add
  the update-mime-database code snippets

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/ws-datatypes.c
 
1
/* ws-datatypes.c
 
2
 *
 
3
 * Copyright (C) 2004 - 2007 Vivien Malerba
 
4
 *
 
5
 * This program is free software; you can redistribute it and/or
 
6
 * modify it under the terms of the GNU General Public License as
 
7
 * published by the Free Software Foundation; either version 2 of the
 
8
 * License, or (at your option) any later version.
 
9
 *
 
10
 * This program is distributed in the hope that it will be useful,
 
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
 * GNU General Public License for more details.
 
14
 *
 
15
 * You should have received a copy of the GNU General Public License
 
16
 * along with this program; if not, write to the Free Software
 
17
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
 
18
 * USA
 
19
 */
 
20
 
 
21
#include <libgnomedb-extra/libgnomedb-extra.h>
 
22
#include "ws-datatypes.h"
 
23
#include "workspace-page.h"
 
24
#include <string.h>
 
25
#include <glib-object.h>
 
26
#include <gtk/gtk.h>
 
27
#include <glib/gi18n-lib.h>
 
28
 
 
29
/* 
 
30
 * Main static functions 
 
31
 */
 
32
static void ws_datatypes_class_init (WsDatatypesClass * class);
 
33
static void ws_datatypes_init (WsDatatypes *ws);
 
34
static void ws_datatypes_dispose (GObject *object);
 
35
static void ws_datatypes_finalize (GObject *object);
 
36
 
 
37
/* WorkspacePage interface */
 
38
static void         ws_datatypes_page_init       (WorkspacePageIface *iface);
 
39
static gchar       *ws_datatypes_get_name        (WorkspacePage *iface);
 
40
static gchar       *ws_datatypes_get_description (WorkspacePage *iface);
 
41
static GtkWidget   *ws_datatypes_get_sel_button    (WorkspacePage *iface);
 
42
static GtkWidget   *ws_datatypes_get_selector    (WorkspacePage *iface);
 
43
static GtkWidget   *ws_datatypes_get_work_area   (WorkspacePage *iface);
 
44
 
 
45
/* get a pointer to the parents to be able to call their destructor */
 
46
static GObjectClass  *parent_class = NULL;
 
47
 
 
48
/* private structure */
 
49
struct _WsDatatypesPrivate
 
50
{
 
51
        GdaDict        *dict;
 
52
        GtkWidget      *selector;
 
53
        GtkWidget      *work_area;
 
54
 
 
55
        GtkWidget      *notebook;
 
56
        GtkWidget      *description;
 
57
        GtkWidget      *synonyms;
 
58
        gint            filter_mode;
 
59
        GtkTextBuffer  *textbuffer;
 
60
 
 
61
        GObject        *sel_obj;
 
62
};
 
63
 
 
64
GType
 
65
ws_datatypes_get_type (void)
 
66
{
 
67
        static GType type = 0;
 
68
 
 
69
        if (!type) {
 
70
                static const GTypeInfo info = {
 
71
                        sizeof (WsDatatypesClass),
 
72
                        (GBaseInitFunc) NULL,
 
73
                        (GBaseFinalizeFunc) NULL,
 
74
                        (GClassInitFunc) ws_datatypes_class_init,
 
75
                        NULL,
 
76
                        NULL,
 
77
                        sizeof (WsDatatypes),
 
78
                        0,
 
79
                        (GInstanceInitFunc) ws_datatypes_init
 
80
                };
 
81
 
 
82
                static const GInterfaceInfo workspace_page_info = {
 
83
                        (GInterfaceInitFunc) ws_datatypes_page_init,
 
84
                        NULL,
 
85
                        NULL
 
86
                };
 
87
 
 
88
                type = g_type_register_static (G_TYPE_OBJECT, "WsDatatypes", &info, 0);
 
89
                g_type_add_interface_static (type, WORKSPACE_PAGE_TYPE, &workspace_page_info);
 
90
        }
 
91
        return type;
 
92
}
 
93
 
 
94
static void 
 
95
ws_datatypes_page_init (WorkspacePageIface *iface)
 
96
{
 
97
        iface->get_name = ws_datatypes_get_name;
 
98
        iface->get_description = ws_datatypes_get_description;
 
99
        iface->get_sel_button = ws_datatypes_get_sel_button;
 
100
        iface->get_selector = ws_datatypes_get_selector;
 
101
        iface->get_work_area = ws_datatypes_get_work_area;
 
102
}
 
103
 
 
104
static void
 
105
ws_datatypes_class_init (WsDatatypesClass * class)
 
106
{
 
107
        GObjectClass   *object_class = G_OBJECT_CLASS (class);
 
108
 
 
109
        parent_class = g_type_class_peek_parent (class);
 
110
 
 
111
        object_class->dispose = ws_datatypes_dispose;
 
112
        object_class->finalize = ws_datatypes_finalize;
 
113
}
 
114
 
 
115
static void
 
116
ws_datatypes_init (WsDatatypes *ws)
 
117
{
 
118
        ws->priv = g_new0 (WsDatatypesPrivate, 1);
 
119
}
 
120
 
 
121
static void ws_datatypes_initialize (WsDatatypes *ws);
 
122
 
 
123
/**
 
124
 * ws_datatypes_new
 
125
 * @dict: a #GdaDict object
 
126
 *
 
127
 * Creates a new WsDatatypes object
 
128
 *
 
129
 * Returns: the new object
 
130
 */
 
131
GObject*
 
132
ws_datatypes_new (GdaDict *dict)
 
133
{
 
134
        GObject  *obj;
 
135
        WsDatatypes *ws;
 
136
 
 
137
        g_return_val_if_fail (dict && GDA_IS_DICT (dict), NULL);
 
138
 
 
139
        obj = g_object_new (WS_DATATYPES_TYPE, NULL);
 
140
        ws = WS_DATATYPES (obj);
 
141
        ws->priv->dict = dict;
 
142
        g_object_ref (G_OBJECT (dict));
 
143
 
 
144
        ws_datatypes_initialize (ws);
 
145
 
 
146
        return obj;
 
147
}
 
148
 
 
149
 
 
150
static void
 
151
ws_datatypes_dispose (GObject *object)
 
152
{
 
153
        WsDatatypes *ws;
 
154
 
 
155
        g_return_if_fail (object != NULL);
 
156
        g_return_if_fail (IS_WS_DATATYPES (object));
 
157
 
 
158
        ws = WS_DATATYPES (object);
 
159
        if (ws->priv) {
 
160
                if (ws->priv->selector) {
 
161
                        gtk_widget_destroy (ws->priv->selector);
 
162
                        ws->priv->selector = NULL;
 
163
                }
 
164
 
 
165
                if (ws->priv->work_area) {
 
166
                        gtk_widget_destroy (ws->priv->work_area);
 
167
                        ws->priv->work_area = NULL;
 
168
                }
 
169
 
 
170
                if (ws->priv->dict) {
 
171
                        g_object_unref (G_OBJECT (ws->priv->dict));
 
172
                        ws->priv->dict = NULL;
 
173
                }
 
174
        }
 
175
 
 
176
        /* parent class */
 
177
        parent_class->dispose (object);
 
178
}
 
179
 
 
180
static void
 
181
ws_datatypes_finalize (GObject   * object)
 
182
{
 
183
        WsDatatypes *ws;
 
184
 
 
185
        g_return_if_fail (object != NULL);
 
186
        g_return_if_fail (IS_WS_DATATYPES (object));
 
187
 
 
188
        ws = WS_DATATYPES (object);
 
189
        if (ws->priv) {
 
190
                g_free (ws->priv);
 
191
                ws->priv = NULL;
 
192
        }
 
193
 
 
194
        /* parent class */
 
195
        parent_class->finalize (object);
 
196
}
 
197
 
 
198
 
 
199
 
 
200
static void selector_selection_changed_cb (GnomeDbSelector *mgsel, GObject *sel_object, WsDatatypes *ws);
 
201
static void dtypes_filter_mode_changed_cb (GtkWidget *wid, WsDatatypes *ws);
 
202
static void dtype_updated_cb (GdaConnection *srv, GdaDictType *dtype, WsDatatypes *ws);
 
203
static void
 
204
ws_datatypes_initialize (WsDatatypes *ws)
 
205
{
 
206
        GtkWidget *label, *vbox, *wid, *nb, *vbox2, *bbox, *hbox, *sw;
 
207
        GtkWidget *rd1, *rd2, *rd3;
 
208
 
 
209
        /* Selector part */
 
210
        wid = gnome_db_selector_new (ws->priv->dict, NULL,
 
211
                               GNOME_DB_SELECTOR_DATA_TYPES, 0);
 
212
        ws->priv->selector = wid;
 
213
        g_signal_connect (G_OBJECT (ws->priv->selector), "selection_changed", 
 
214
                          G_CALLBACK (selector_selection_changed_cb), ws);
 
215
 
 
216
        /* WorkArea part */
 
217
        vbox = gtk_vbox_new (FALSE, 5);
 
218
        ws->priv->work_area = vbox;
 
219
        
 
220
        nb = gtk_notebook_new ();
 
221
        gtk_notebook_set_show_border (GTK_NOTEBOOK (nb), FALSE);
 
222
        gtk_notebook_set_show_tabs (GTK_NOTEBOOK (nb), FALSE);
 
223
        gtk_box_pack_start (GTK_BOX (vbox), nb, TRUE, TRUE, 0);
 
224
        gtk_widget_show (nb);
 
225
        ws->priv->notebook = nb;
 
226
        
 
227
        label = gtk_label_new (_("Please select a data type from the list on the left"));
 
228
        gtk_notebook_append_page (GTK_NOTEBOOK (nb), label, NULL);
 
229
        gtk_widget_show (label);
 
230
        
 
231
        vbox2 = gtk_vbox_new (FALSE, 5);
 
232
        gtk_notebook_append_page (GTK_NOTEBOOK (nb), vbox2, NULL);
 
233
        gtk_widget_show (vbox2);
 
234
 
 
235
        label = gtk_label_new (NULL);
 
236
        gtk_label_set_markup (GTK_LABEL (label), _("<b>Description:</b>"));
 
237
        gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, FALSE, 0);
 
238
        gtk_widget_show (label);
 
239
        gtk_misc_set_alignment (GTK_MISC (label), 0., -1);
 
240
 
 
241
        hbox = gtk_hbox_new (FALSE, 0); /* HIG */
 
242
        gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0);
 
243
        gtk_widget_show (hbox);
 
244
        label = gtk_label_new ("    ");
 
245
        gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
 
246
        gtk_widget_show (label);
 
247
 
 
248
        label = gtk_label_new (NULL);
 
249
        gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
 
250
        gtk_misc_set_alignment (GTK_MISC (label), 0., -1);
 
251
        gtk_widget_show (label);
 
252
        ws->priv->description = label;
 
253
 
 
254
        label = gtk_label_new (NULL);
 
255
        gtk_label_set_markup (GTK_LABEL (label), _("<b>Synonyms:</b>"));
 
256
        gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, FALSE, 0);
 
257
        gtk_widget_show (label);
 
258
        gtk_misc_set_alignment (GTK_MISC (label), 0., -1);
 
259
 
 
260
        hbox = gtk_hbox_new (FALSE, 0); /* HIG */
 
261
        gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0);
 
262
        gtk_widget_show (hbox);
 
263
        label = gtk_label_new ("    ");
 
264
        gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
 
265
        gtk_widget_show (label);
 
266
 
 
267
        label = gtk_label_new (NULL);
 
268
        gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
 
269
        gtk_misc_set_alignment (GTK_MISC (label), 0., -1);
 
270
        gtk_widget_show (label);
 
271
        ws->priv->synonyms = label;
 
272
        
 
273
        label = gtk_label_new (NULL);
 
274
        gtk_label_set_markup (GTK_LABEL (label), _("<b>Select a filter option:</b>"));
 
275
        gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, FALSE, 0);
 
276
        gtk_widget_show (label);
 
277
        gtk_misc_set_alignment (GTK_MISC (label), 0., -1);
 
278
 
 
279
        hbox = gtk_hbox_new (FALSE, 0); /* HIG */
 
280
        gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0);
 
281
        gtk_widget_show (hbox);
 
282
        label = gtk_label_new ("    ");
 
283
        gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
 
284
        gtk_widget_show (label);
 
285
 
 
286
        bbox = gtk_vbutton_box_new ();
 
287
        gtk_box_pack_start (GTK_BOX (hbox), bbox, FALSE, FALSE, 0);
 
288
        gtk_widget_show (bbox);
 
289
 
 
290
        rd1 = gtk_radio_button_new_with_label (NULL, _("Functions returning this data type"));
 
291
        gtk_box_pack_start (GTK_BOX (bbox), rd1, FALSE, FALSE, 0);
 
292
        gtk_widget_show (rd1);
 
293
        g_object_set_data (G_OBJECT (rd1), "mode", GINT_TO_POINTER (0));
 
294
        g_signal_connect (G_OBJECT (rd1), "toggled",
 
295
                          G_CALLBACK (dtypes_filter_mode_changed_cb), ws);
 
296
 
 
297
        rd2 = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (rd1),
 
298
                                                           _("Functions using this data type"));
 
299
        gtk_box_pack_start (GTK_BOX (bbox), rd2, FALSE, FALSE, 0);
 
300
        gtk_widget_show (rd2);
 
301
        g_object_set_data (G_OBJECT (rd2), "mode", GINT_TO_POINTER (1));
 
302
        g_signal_connect (G_OBJECT (rd2), "toggled",
 
303
                          G_CALLBACK (dtypes_filter_mode_changed_cb), ws);
 
304
 
 
305
        rd3 = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (rd1),
 
306
                                                           _("Aggregates using this data type"));
 
307
        gtk_box_pack_start (GTK_BOX (bbox), rd3, FALSE, FALSE, 0);
 
308
        gtk_widget_show (rd3);
 
309
        g_object_set_data (G_OBJECT (rd3), "mode", GINT_TO_POINTER (2));
 
310
        g_signal_connect (G_OBJECT (rd3), "toggled",
 
311
                          G_CALLBACK (dtypes_filter_mode_changed_cb), ws);
 
312
 
 
313
        label = gtk_label_new (NULL);
 
314
        gtk_label_set_markup (GTK_LABEL (label), _("<b>Result of filter:</b>"));
 
315
        gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, FALSE, 0);
 
316
        gtk_widget_show (label);
 
317
        gtk_misc_set_alignment (GTK_MISC (label), 0., -1);
 
318
 
 
319
        hbox = gtk_hbox_new (FALSE, 0); /* HIG */
 
320
        gtk_box_pack_start (GTK_BOX (vbox2), hbox, TRUE, TRUE, 0);
 
321
        gtk_widget_show (hbox);
 
322
        label = gtk_label_new ("    ");
 
323
        gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
 
324
        gtk_widget_show (label);
 
325
 
 
326
        sw = gtk_scrolled_window_new (NULL, NULL);
 
327
        gtk_box_pack_start (GTK_BOX (hbox), sw, TRUE, TRUE, 0);
 
328
        gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC,
 
329
                                        GTK_POLICY_AUTOMATIC);
 
330
        gtk_widget_show (sw);
 
331
 
 
332
        wid = gtk_text_view_new ();
 
333
        gtk_container_add (GTK_CONTAINER (sw), wid);
 
334
        gtk_text_view_set_left_margin (GTK_TEXT_VIEW (wid), 5);
 
335
        gtk_text_view_set_right_margin (GTK_TEXT_VIEW (wid), 5);
 
336
        gtk_text_view_set_editable (GTK_TEXT_VIEW (wid), FALSE);
 
337
        ws->priv->textbuffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (wid));
 
338
        gtk_text_buffer_set_text (ws->priv->textbuffer, "", -1);
 
339
        gtk_widget_show (wid);
 
340
        gtk_text_buffer_create_tag (ws->priv->textbuffer, "funcname",
 
341
                                    "weight", PANGO_WEIGHT_BOLD,
 
342
                                    "foreground", "blue", NULL);
 
343
        
 
344
        gtk_text_buffer_create_tag (ws->priv->textbuffer, "descr",
 
345
                                    "style", PANGO_STYLE_ITALIC, NULL);
 
346
        
 
347
        g_signal_connect (G_OBJECT (ws->priv->dict), "object_updated",
 
348
                          G_CALLBACK (dtype_updated_cb), ws);
 
349
}
 
350
 
 
351
static void dtype_info_display_update (GdaDictType *dtype, WsDatatypes *ws);
 
352
static void
 
353
selector_selection_changed_cb (GnomeDbSelector *mgsel, GObject *sel_object, WsDatatypes *ws)
 
354
{
 
355
        if (sel_object && !GDA_IS_DICT_TYPE (sel_object))
 
356
                return;
 
357
        
 
358
        ws->priv->sel_obj = sel_object;
 
359
        gtk_notebook_set_current_page (GTK_NOTEBOOK (ws->priv->notebook), sel_object ? 1 : 0);
 
360
        dtype_info_display_update ((GdaDictType*) sel_object, ws);
 
361
}
 
362
 
 
363
static void 
 
364
dtypes_filter_mode_changed_cb (GtkWidget *wid, WsDatatypes *ws)
 
365
{
 
366
        if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wid))) {
 
367
                GObject *sel_obj;
 
368
                
 
369
                ws->priv->filter_mode = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (wid), "mode"));
 
370
                sel_obj = gnome_db_selector_get_selected_object (GNOME_DB_SELECTOR (ws->priv->selector));
 
371
                selector_selection_changed_cb (GNOME_DB_SELECTOR (ws->priv->selector), sel_obj, ws);
 
372
        }
 
373
 
 
374
}
 
375
 
 
376
static void
 
377
dtype_updated_cb (GdaConnection *srv, GdaDictType *dtype, WsDatatypes *ws)
 
378
{
 
379
        if (GDA_IS_DICT_TYPE (dtype) && ((GObject *)dtype == ws->priv->sel_obj))
 
380
                dtype_info_display_update (dtype, ws);
 
381
}
 
382
 
 
383
static gchar *function_get_args (GdaDictFunction *func);
 
384
static void
 
385
dtype_info_display_update (GdaDictType *dtype, WsDatatypes *ws)
 
386
{
 
387
        GtkTextIter start, end;
 
388
        gchar *str = NULL;
 
389
        gchar *title = NULL;
 
390
 
 
391
        /* description */
 
392
        if (dtype)
 
393
                str = (gchar *) gda_object_get_description (GDA_OBJECT (dtype));
 
394
        
 
395
        if (str && *str) 
 
396
                gtk_label_set_text (GTK_LABEL (ws->priv->description), str);
 
397
        else
 
398
                gtk_label_set_text (GTK_LABEL (ws->priv->description), "---");
 
399
 
 
400
        /* synonyms */
 
401
        str = NULL;
 
402
        if (dtype) {
 
403
                const GSList *synlist = gda_dict_type_get_synonyms (dtype);
 
404
                if (synlist) {
 
405
                        GString *string;
 
406
 
 
407
                        string = g_string_new ((gchar *) synlist->data);
 
408
                        synlist = g_slist_next (synlist);
 
409
                        while (synlist) {
 
410
                                g_string_append (string, ", ");
 
411
                                g_string_append (string, (gchar *) synlist->data);
 
412
                                synlist = g_slist_next (synlist);
 
413
                        }
 
414
                        str = string->str;
 
415
                        g_string_free (string, FALSE);
 
416
                }
 
417
        }
 
418
        if (str) {
 
419
                gtk_label_set_text (GTK_LABEL (ws->priv->synonyms), str);
 
420
                g_free (str);
 
421
        }
 
422
        else
 
423
                gtk_label_set_text (GTK_LABEL (ws->priv->synonyms), "---");
 
424
 
 
425
        /* global title update */
 
426
        title = ws_datatypes_get_description (WORKSPACE_PAGE (ws));
 
427
        g_signal_emit_by_name (G_OBJECT (ws), "description_changed", title);
 
428
        g_free (title);
 
429
 
 
430
        /* apply filter */
 
431
        gtk_text_buffer_get_start_iter (ws->priv->textbuffer, &start);
 
432
        gtk_text_buffer_get_end_iter (ws->priv->textbuffer, &end);
 
433
        gtk_text_buffer_delete (ws->priv->textbuffer, &start, &end);
 
434
        if (dtype) {
 
435
                GSList *list, *funcs, *args, *aggs;
 
436
                gboolean getfunc;
 
437
                GdaDictType *ldt;
 
438
                
 
439
                funcs = gda_dict_get_functions (ws->priv->dict);
 
440
                aggs = gda_dict_get_aggregates (ws->priv->dict);
 
441
                list = g_slist_concat (funcs, aggs);
 
442
                funcs = list;
 
443
                while (list) {
 
444
                        getfunc = FALSE;
 
445
                        switch (ws->priv->filter_mode) {
 
446
                        case 0:
 
447
                                if (GDA_IS_DICT_FUNCTION (list->data)) {
 
448
                                        ldt = gda_dict_function_get_ret_dict_type (GDA_DICT_FUNCTION (list->data));
 
449
                                        getfunc = (ldt == dtype) ? TRUE : FALSE;
 
450
                                }
 
451
                                break;
 
452
                        case 1:
 
453
                                if (GDA_IS_DICT_FUNCTION (list->data)) {
 
454
                                        args = (GSList *) gda_dict_function_get_arg_dict_types (GDA_DICT_FUNCTION (list->data));
 
455
                                        while (args && !getfunc) {
 
456
                                                if ((args->data == (gpointer) dtype) || !args->data)
 
457
                                                        getfunc = TRUE;
 
458
                                                args = g_slist_next (args);
 
459
                                        }
 
460
                                }
 
461
                                break;
 
462
                        case 2:
 
463
                                if (GDA_IS_DICT_AGGREGATE (list->data)) {
 
464
                                        ldt = gda_dict_aggregate_get_arg_dict_type (GDA_DICT_AGGREGATE (list->data));
 
465
                                        getfunc = !ldt || (ldt == dtype) ? TRUE : FALSE;
 
466
                                }
 
467
                                break;
 
468
                        }
 
469
 
 
470
                        if (getfunc) {
 
471
                                gchar *str;
 
472
 
 
473
                                str = (gchar *) gda_object_get_name (GDA_OBJECT (list->data));
 
474
                                gtk_text_buffer_get_end_iter (ws->priv->textbuffer, &end);
 
475
                                gtk_text_buffer_insert_with_tags_by_name (ws->priv->textbuffer, 
 
476
                                                                          &end, str, -1, 
 
477
                                                                          "funcname", NULL);
 
478
 
 
479
                                if (GDA_IS_DICT_FUNCTION (list->data))
 
480
                                        str = function_get_args (GDA_DICT_FUNCTION (list->data));
 
481
                                else {
 
482
                                        if ((ldt = gda_dict_aggregate_get_arg_dict_type (GDA_DICT_AGGREGATE (list->data)))) {
 
483
                                                str = g_strdup_printf (" (%s)", gda_object_get_name (GDA_OBJECT (ldt)));
 
484
                                        }
 
485
                                        else
 
486
                                                str = g_strdup (" (*)");
 
487
                                }
 
488
                                gtk_text_buffer_get_end_iter (ws->priv->textbuffer, &end);
 
489
                                gtk_text_buffer_insert (ws->priv->textbuffer, &end, str, -1);
 
490
                                g_free (str);
 
491
 
 
492
                                str = (gchar *) gda_object_get_description (GDA_OBJECT (list->data));
 
493
                                if (str && *str) {
 
494
                                        gchar *str2 = g_strdup_printf (" -- %s\n", str);
 
495
                                        gtk_text_buffer_get_end_iter (ws->priv->textbuffer, &end);
 
496
                                        gtk_text_buffer_insert_with_tags_by_name (ws->priv->textbuffer, &end, str2, -1, 
 
497
                                                                                  "descr", NULL);
 
498
                                        g_free (str2);
 
499
                                }
 
500
                                else {
 
501
                                        gtk_text_buffer_get_end_iter (ws->priv->textbuffer, &end);
 
502
                                        gtk_text_buffer_insert (ws->priv->textbuffer, &end, "\n", -1);
 
503
                                }
 
504
                        }
 
505
                        list = g_slist_next (list);
 
506
                }
 
507
                g_slist_free (funcs);
 
508
        }
 
509
}
 
510
 
 
511
static gchar *
 
512
function_get_args (GdaDictFunction *func)
 
513
{
 
514
        GString *string;
 
515
        const GSList *args;
 
516
        gchar *retval;
 
517
        gboolean firstarg = TRUE;
 
518
 
 
519
        string = g_string_new ("");
 
520
        args = gda_dict_function_get_arg_dict_types (func);
 
521
        g_string_append (string, " (");
 
522
        while (args) {
 
523
                if (firstarg)
 
524
                        firstarg = FALSE;
 
525
                else
 
526
                        g_string_append (string, ", ");
 
527
                if (args->data) 
 
528
                        g_string_append (string,
 
529
                                         gda_dict_type_get_sqlname (GDA_DICT_TYPE (args->data)));
 
530
                else
 
531
                        g_string_append (string, "*");
 
532
                args = g_slist_next (args);
 
533
        }
 
534
        g_string_append (string, ")");
 
535
        retval = string->str;
 
536
        g_string_free (string, FALSE);
 
537
 
 
538
        return retval;
 
539
}
 
540
 
 
541
 
 
542
/* 
 
543
 * WorkspacePage interface implementation
 
544
 */
 
545
static gchar *
 
546
ws_datatypes_get_name (WorkspacePage *iface)
 
547
{
 
548
        g_return_val_if_fail (iface && IS_WS_DATATYPES (iface), NULL);
 
549
        g_return_val_if_fail (WS_DATATYPES (iface)->priv, NULL);
 
550
 
 
551
        return g_strdup_printf (_("Data types"));
 
552
}
 
553
 
 
554
static gchar *
 
555
ws_datatypes_get_description (WorkspacePage *iface)
 
556
{
 
557
        gchar *str = NULL;
 
558
        WsDatatypes *ws;
 
559
 
 
560
        g_return_val_if_fail (iface && IS_WS_DATATYPES (iface), NULL);
 
561
        g_return_val_if_fail (WS_DATATYPES (iface)->priv, NULL);
 
562
 
 
563
        ws = WS_DATATYPES (iface);
 
564
        if (ws->priv->sel_obj) {
 
565
                const gchar *cstr;
 
566
                 cstr =  gda_object_get_name (GDA_OBJECT (ws->priv->sel_obj));
 
567
                 str = g_strdup_printf ("Data type: <b>%s</b>", (cstr && *cstr) ? cstr : "---");
 
568
        }
 
569
        else
 
570
                str = g_strdup_printf ("<b>%s</b>", _("No data type selected"));
 
571
 
 
572
        return str;
 
573
}
 
574
 
 
575
static GtkWidget *
 
576
ws_datatypes_get_sel_button (WorkspacePage *iface)
 
577
{
 
578
        GdkPixbuf *pixbuf;
 
579
        GtkWidget *button, *wid, *hbox;
 
580
 
 
581
        g_return_val_if_fail (iface && IS_WS_DATATYPES (iface), NULL);
 
582
        g_return_val_if_fail (WS_DATATYPES (iface)->priv, NULL);
 
583
 
 
584
        hbox = gtk_hbox_new (FALSE, 0);
 
585
 
 
586
        pixbuf = gnome_db_stock_get_icon_pixbuf (GNOME_DB_STOCK_TYPES);
 
587
        wid = gtk_image_new_from_pixbuf (pixbuf);
 
588
        g_object_unref (pixbuf);
 
589
        gtk_box_pack_start (GTK_BOX (hbox), wid, FALSE, FALSE, 0);
 
590
        gtk_widget_show (wid);
 
591
 
 
592
        wid = gtk_label_new (_("Types"));
 
593
        gtk_box_pack_start (GTK_BOX (hbox), wid, FALSE, FALSE, 5);
 
594
        gtk_widget_show (wid);
 
595
 
 
596
        button = gtk_toggle_button_new ();
 
597
        gtk_container_add (GTK_CONTAINER (button), hbox);
 
598
        gtk_widget_show (hbox);
 
599
 
 
600
        return button;
 
601
}
 
602
 
 
603
static GtkWidget *
 
604
ws_datatypes_get_selector (WorkspacePage *iface)
 
605
{
 
606
        g_return_val_if_fail (iface && IS_WS_DATATYPES (iface), NULL);
 
607
        g_return_val_if_fail (WS_DATATYPES (iface)->priv, NULL);
 
608
 
 
609
        return WS_DATATYPES (iface)->priv->selector;
 
610
}
 
611
 
 
612
static GtkWidget *
 
613
ws_datatypes_get_work_area (WorkspacePage *iface)
 
614
{
 
615
        g_return_val_if_fail (iface && IS_WS_DATATYPES (iface), NULL);
 
616
        g_return_val_if_fail (WS_DATATYPES (iface)->priv, NULL);
 
617
 
 
618
        return WS_DATATYPES (iface)->priv->work_area;
 
619
}