← Back to branch summary

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

« back to all changes in this revision

Viewing changes to libmergeant/handlers/mg-entry-wrapper.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:
libmergeant/handlers/mg-entry-wrapper.c
1
 
/* mg-entry-wrapper.c
2
 
 *
3
 
 * Copyright (C) 2003 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 "mg-entry-wrapper.h"
22
 
#include <libmergeant/mg-data-handler.h>
23
 
 
24
 
static void mg_entry_wrapper_class_init (MgEntryWrapperClass *class);
25
 
static void mg_entry_wrapper_init (MgEntryWrapper *wid);
26
 
static void mg_entry_wrapper_dispose (GObject *object);
27
 
 
28
 
static void mg_entry_wrapper_set_property (GObject              *object,
29
 
                                           guint                 param_id,
30
 
                                           const GValue         *value,
31
 
                                           GParamSpec           *pspec);
32
 
static void mg_entry_wrapper_get_property (GObject              *object,
33
 
                                           guint                 param_id,
34
 
                                           GValue               *value,
35
 
                                           GParamSpec           *pspec);
36
 
 
37
 
static void contents_changed_cb (GtkWidget *entry, MgEntryWrapper *mgwrap);
38
 
static void check_correct_init (MgEntryWrapper *wid);
39
 
static void block_signals (MgEntryWrapper *wid);
40
 
static void unblock_signals (MgEntryWrapper *wid);
41
 
 
42
 
/* MgDataEntry interface */
43
 
static void            mg_entry_wrapper_data_entry_init   (MgDataEntryIface *iface);
44
 
static void            mg_entry_wrapper_set_value_type    (MgDataEntry *de, GdaValueType type);
45
 
static GdaValueType    mg_entry_wrapper_get_value_type    (MgDataEntry *de);
46
 
static void            mg_entry_wrapper_set_value         (MgDataEntry *de, const GdaValue *value);
47
 
static GdaValue       *mg_entry_wrapper_get_value         (MgDataEntry *de);
48
 
static void            mg_entry_wrapper_set_value_orig    (MgDataEntry *de, const GdaValue *value);
49
 
static const GdaValue *mg_entry_wrapper_get_value_orig    (MgDataEntry *de);
50
 
static void            mg_entry_wrapper_set_value_default (MgDataEntry *de, const GdaValue *value);
51
 
static void            mg_entry_wrapper_set_attributes    (MgDataEntry *de, guint attrs, guint mask);
52
 
static guint           mg_entry_wrapper_get_attributes    (MgDataEntry *de);
53
 
static MgDataHandler  *mg_entry_wrapper_get_handler       (MgDataEntry *de);
54
 
static gboolean        mg_entry_wrapper_expand_in_layout  (MgDataEntry *de);
55
 
 
56
 
 
57
 
/* properties */
58
 
enum
59
 
{
60
 
        PROP_0,
61
 
        PROP_SET_DEFAULT_IF_INVALID
62
 
};
63
 
 
64
 
/* signals */
65
 
enum
66
 
{
67
 
        LAST_SIGNAL
68
 
};
69
 
 
70
 
static gint mg_entry_wrapper_signals[LAST_SIGNAL] = { };
71
 
 
72
 
 
73
 
struct  _MgEntryWrapperPriv {
74
 
        gboolean            impl_is_correct;
75
 
        GtkWidget          *entry;
76
 
        MgEntryWrapperClass *real_class;
77
 
        guint               signals_blocked;
78
 
 
79
 
        GdaValueType        type;
80
 
        GdaValue           *value_orig;
81
 
        GdaValue           *value_default; /* Can be of any type, not just 'type' */
82
 
 
83
 
        gboolean            null_forced;
84
 
        gboolean            default_forced;
85
 
 
86
 
        gboolean            null_possible;
87
 
        gboolean            default_possible;
88
 
        gboolean            show_actions;
89
 
 
90
 
        /* property */
91
 
        gboolean            set_default_if_invalid;
92
 
};
93
 
 
94
 
/* get a pointer to the parents to be able to call their destructor */
95
 
static GObjectClass *parent_class = NULL;
96
 
 
97
 
guint
98
 
mg_entry_wrapper_get_type (void)
99
 
{
100
 
        static GType type = 0;
101
 
 
102
 
        if (!type) {
103
 
                static const GTypeInfo info = {
104
 
                        sizeof (MgEntryWrapperClass),
105
 
                        (GBaseInitFunc) NULL,
106
 
                        (GBaseFinalizeFunc) NULL,
107
 
                        (GClassInitFunc) mg_entry_wrapper_class_init,
108
 
                        NULL,
109
 
                        NULL,
110
 
                        sizeof (MgEntryWrapper),
111
 
                        0,
112
 
                        (GInstanceInitFunc) mg_entry_wrapper_init
113
 
                };              
114
 
 
115
 
                static const GInterfaceInfo data_entry_info = {
116
 
                        (GInterfaceInitFunc) mg_entry_wrapper_data_entry_init,
117
 
                        NULL,
118
 
                        NULL
119
 
                };
120
 
 
121
 
                type = g_type_register_static (MG_ENTRY_SHELL_TYPE, "MgEntryWrapper", &info, 0);
122
 
                g_type_add_interface_static (type, MG_DATA_ENTRY_TYPE, &data_entry_info);
123
 
        }
124
 
        return type;
125
 
}
126
 
 
127
 
static void
128
 
mg_entry_wrapper_data_entry_init (MgDataEntryIface *iface)
129
 
{
130
 
        iface->set_value_type = mg_entry_wrapper_set_value_type;
131
 
        iface->get_value_type = mg_entry_wrapper_get_value_type;
132
 
        iface->set_value = mg_entry_wrapper_set_value;
133
 
        iface->get_value = mg_entry_wrapper_get_value;
134
 
        iface->set_value_orig = mg_entry_wrapper_set_value_orig;
135
 
        iface->get_value_orig = mg_entry_wrapper_get_value_orig;
136
 
        iface->set_value_default = mg_entry_wrapper_set_value_default;
137
 
        iface->set_attributes = mg_entry_wrapper_set_attributes;
138
 
        iface->get_attributes = mg_entry_wrapper_get_attributes;
139
 
        iface->get_handler = mg_entry_wrapper_get_handler;
140
 
        iface->expand_in_layout = mg_entry_wrapper_expand_in_layout;
141
 
}
142
 
 
143
 
 
144
 
static void
145
 
mg_entry_wrapper_class_init (MgEntryWrapperClass *class)
146
 
{
147
 
        GObjectClass   *object_class = G_OBJECT_CLASS (class);
148
 
        
149
 
        parent_class = g_type_class_peek_parent (class);
150
 
 
151
 
        /* virtual functions */
152
 
        class->create_entry = NULL;
153
 
        class->real_set_value = NULL;
154
 
        class->real_get_value = NULL;
155
 
 
156
 
        /* Properties */
157
 
        object_class->set_property = mg_entry_wrapper_set_property;
158
 
        object_class->get_property = mg_entry_wrapper_get_property;
159
 
        g_object_class_install_property (object_class, PROP_SET_DEFAULT_IF_INVALID,
160
 
                                         g_param_spec_boolean ("set_default_if_invalid", NULL, NULL, FALSE,
161
 
                                                               (G_PARAM_READABLE | G_PARAM_WRITABLE)));
162
 
 
163
 
        object_class->dispose = mg_entry_wrapper_dispose;
164
 
}
165
 
 
166
 
static void
167
 
check_correct_init (MgEntryWrapper *mgwrap)
168
 
{
169
 
        if (!mgwrap->priv->impl_is_correct) {
170
 
                GtkWidget *entry = NULL;
171
 
                MgEntryWrapperClass *class;
172
 
                gboolean class_impl_error = FALSE;;
173
 
                
174
 
                class = MG_ENTRY_WRAPPER_CLASS (G_OBJECT_GET_CLASS (mgwrap));
175
 
                if (! class->create_entry) {
176
 
                        g_warning ("create_entry () virtual function not implemented for object class %s\n",
177
 
                                   G_OBJECT_TYPE_NAME (mgwrap));
178
 
                        class_impl_error = TRUE;
179
 
                }
180
 
                if (! class->real_set_value) {
181
 
                        g_warning ("real_set_value () virtual function not implemented for object class %s\n",
182
 
                                   G_OBJECT_TYPE_NAME (mgwrap));
183
 
                        class_impl_error = TRUE;
184
 
                }
185
 
                if (! class->real_get_value) {
186
 
                        g_warning ("real_get_value () virtual function not implemented for object class %s\n",
187
 
                                   G_OBJECT_TYPE_NAME (mgwrap));
188
 
                        class_impl_error = TRUE;
189
 
                }
190
 
                if (! class->connect_signals) {
191
 
                        g_warning ("connect_signals () virtual function not implemented for object class %s\n",
192
 
                                   G_OBJECT_TYPE_NAME (mgwrap));
193
 
                        class_impl_error = TRUE;
194
 
                }
195
 
                if (! class->expand_in_layout) {
196
 
                        g_warning ("expand_in_layout () virtual function not implemented for object class %s\n",
197
 
                                   G_OBJECT_TYPE_NAME (mgwrap));
198
 
                        class_impl_error = TRUE;
199
 
                }
200
 
 
201
 
                if (!class_impl_error) {
202
 
                        mgwrap->priv->real_class = class;
203
 
                        mgwrap->priv->impl_is_correct = TRUE;
204
 
                        entry = (*mgwrap->priv->real_class->create_entry) (mgwrap);
205
 
                        
206
 
                        mg_entry_shell_pack_entry (MG_ENTRY_SHELL (mgwrap), entry);
207
 
                        gtk_widget_show (entry);
208
 
                        mgwrap->priv->entry = entry;
209
 
                        
210
 
                        (*mgwrap->priv->real_class->connect_signals) (mgwrap, G_CALLBACK (contents_changed_cb));
211
 
                }
212
 
                else {
213
 
                        /* we need to exit because the program WILL BE unstable and WILL crash */
214
 
                        g_assert_not_reached ();
215
 
                }       
216
 
        }
217
 
}
218
 
 
219
 
static void
220
 
block_signals (MgEntryWrapper *mgwrap)
221
 
{
222
 
        mgwrap->priv->signals_blocked ++;
223
 
}
224
 
 
225
 
static void
226
 
unblock_signals (MgEntryWrapper *mgwrap)
227
 
{
228
 
        mgwrap->priv->signals_blocked --;
229
 
}
230
 
 
231
 
 
232
 
static void
233
 
mg_entry_wrapper_init (MgEntryWrapper *mgwrap)
234
 
{
235
 
        /* Private structure */
236
 
        mgwrap->priv = g_new0 (MgEntryWrapperPriv, 1);
237
 
        mgwrap->priv->impl_is_correct = FALSE;
238
 
        mgwrap->priv->entry = NULL;
239
 
        mgwrap->priv->real_class = NULL;
240
 
        mgwrap->priv->signals_blocked = 0;
241
 
 
242
 
        mgwrap->priv->type = GDA_VALUE_TYPE_UNKNOWN;
243
 
        mgwrap->priv->value_orig = NULL;
244
 
        mgwrap->priv->value_default = NULL;
245
 
 
246
 
        mgwrap->priv->null_forced = FALSE;
247
 
        mgwrap->priv->default_forced = FALSE;
248
 
 
249
 
        mgwrap->priv->null_possible = TRUE;
250
 
        mgwrap->priv->default_possible = FALSE;
251
 
        mgwrap->priv->show_actions = TRUE;
252
 
 
253
 
        mgwrap->priv->set_default_if_invalid = FALSE;
254
 
}
255
 
 
256
 
static void
257
 
mg_entry_wrapper_dispose (GObject   *object)
258
 
{
259
 
        MgEntryWrapper *mgwrap;
260
 
 
261
 
        g_return_if_fail (object != NULL);
262
 
        g_return_if_fail (IS_MG_ENTRY_WRAPPER (object));
263
 
 
264
 
        mgwrap = MG_ENTRY_WRAPPER (object);
265
 
 
266
 
        if (mgwrap->priv) {
267
 
                if (mgwrap->priv->value_orig)
268
 
                        gda_value_free (mgwrap->priv->value_orig);
269
 
                if (mgwrap->priv->value_default)
270
 
                        gda_value_free (mgwrap->priv->value_default);
271
 
 
272
 
                g_free (mgwrap->priv);
273
 
                mgwrap->priv = NULL;
274
 
        }
275
 
 
276
 
        /* for the parent class */
277
 
        parent_class->dispose (object);
278
 
}
279
 
 
280
 
 
281
 
static void 
282
 
mg_entry_wrapper_set_property (GObject              *object,
283
 
                            guint                 param_id,
284
 
                            const GValue         *value,
285
 
                            GParamSpec           *pspec)
286
 
{
287
 
        MgEntryWrapper *mgwrap = MG_ENTRY_WRAPPER (object);
288
 
        if (mgwrap->priv) {
289
 
                switch (param_id) {
290
 
                case PROP_SET_DEFAULT_IF_INVALID:
291
 
                        if (mgwrap->priv->set_default_if_invalid != g_value_get_boolean (value)) {
292
 
                                guint attrs;
293
 
 
294
 
                                mgwrap->priv->set_default_if_invalid = g_value_get_boolean (value);
295
 
                                attrs = mg_data_entry_get_attributes (MG_DATA_ENTRY (mgwrap));
296
 
 
297
 
                                if (mgwrap->priv->set_default_if_invalid && (attrs & MG_DATA_ENTRY_DATA_NON_VALID)) {
298
 
                                        GdaValue *sane_value;
299
 
                                        MgDataHandler *dh;
300
 
                                        GdaValueType type;
301
 
 
302
 
                                        check_correct_init (mgwrap);
303
 
                                        dh = mg_data_entry_get_handler (MG_DATA_ENTRY (mgwrap));
304
 
                                        type = mg_data_entry_get_value_type (MG_DATA_ENTRY (mgwrap));
305
 
                                        sane_value = mg_data_handler_get_sane_init_value (dh, type);
306
 
                                        (*mgwrap->priv->real_class->real_set_value) (mgwrap, sane_value);
307
 
                                        gda_value_free (sane_value);
308
 
                                }
309
 
                        }
310
 
                        break;
311
 
                }
312
 
        }
313
 
}
314
 
 
315
 
static void
316
 
mg_entry_wrapper_get_property (GObject              *object,
317
 
                             guint                 param_id,
318
 
                             GValue               *value,
319
 
                             GParamSpec           *pspec)
320
 
{
321
 
        MgEntryWrapper *mgwrap = MG_ENTRY_WRAPPER (object);
322
 
        if (mgwrap->priv) {
323
 
                switch (param_id) {
324
 
                case PROP_SET_DEFAULT_IF_INVALID:
325
 
                        g_value_set_boolean (value, mgwrap->priv->set_default_if_invalid);
326
 
                        break;
327
 
                }
328
 
        }
329
 
}
330
 
 
331
 
 
332
 
static void mg_entry_wrapper_emit_signal (MgEntryWrapper *mgwrap);
333
 
static void
334
 
contents_changed_cb (GtkWidget *entry, MgEntryWrapper *mgwrap)
335
 
{
336
 
        if (! mgwrap->priv->signals_blocked) {
337
 
                mgwrap->priv->null_forced = FALSE;
338
 
                mgwrap->priv->default_forced = FALSE;
339
 
                mg_entry_wrapper_emit_signal (mgwrap);
340
 
        }
341
 
}
342
 
 
343
 
static void
344
 
mg_entry_wrapper_emit_signal (MgEntryWrapper *mgwrap)
345
 
{
346
 
        if (! mgwrap->priv->signals_blocked) {
347
 
#ifdef debug_signal
348
 
                g_print (">> 'CONTENTS_MODIFIED' from %s\n", __FUNCTION__);
349
 
#endif
350
 
                g_signal_emit_by_name (G_OBJECT (mgwrap), "contents_modified");
351
 
#ifdef debug_signal
352
 
                g_print ("<< 'CONTENTS_MODIFIED' from %s\n", __FUNCTION__);
353
 
#endif
354
 
        }
355
 
}
356
 
 
357
 
 
358
 
 
359
 
/* Interface implementation */
360
 
static void
361
 
mg_entry_wrapper_set_value_type (MgDataEntry *iface, GdaValueType type)
362
 
{
363
 
        MgEntryWrapper *mgwrap;
364
 
 
365
 
        g_return_if_fail (iface && IS_MG_ENTRY_WRAPPER (iface));
366
 
        mgwrap = MG_ENTRY_WRAPPER (iface);
367
 
        g_return_if_fail (mgwrap->priv);
368
 
        
369
 
        if (mgwrap->priv->type != type) {
370
 
                GdaValue *value;
371
 
                MgDataHandler *dh;
372
 
 
373
 
                if (mgwrap->priv->value_orig) {
374
 
                        gda_value_free (mgwrap->priv->value_orig);
375
 
                        mgwrap->priv->value_orig = NULL;
376
 
                }
377
 
                if (mgwrap->priv->value_default) {
378
 
                        gda_value_free (mgwrap->priv->value_default);
379
 
                        mgwrap->priv->value_default = NULL;
380
 
                }
381
 
 
382
 
                mgwrap->priv->type = type;
383
 
                mgwrap->priv->value_default = gda_value_new_null ();
384
 
 
385
 
                /* Set original value */
386
 
                dh = mg_data_entry_get_handler (MG_DATA_ENTRY (mgwrap));
387
 
                value = gda_value_new_null ();
388
 
                mg_entry_wrapper_set_value_orig (MG_DATA_ENTRY (mgwrap), value);
389
 
                gda_value_free (value);
390
 
        }
391
 
}
392
 
 
393
 
static GdaValueType
394
 
mg_entry_wrapper_get_value_type (MgDataEntry *iface)
395
 
{
396
 
        MgEntryWrapper *mgwrap;
397
 
 
398
 
        g_return_val_if_fail (iface && IS_MG_ENTRY_WRAPPER (iface), GDA_VALUE_TYPE_UNKNOWN);
399
 
        mgwrap = MG_ENTRY_WRAPPER (iface);
400
 
        g_return_val_if_fail (mgwrap->priv, GDA_VALUE_TYPE_UNKNOWN);
401
 
 
402
 
        return mgwrap->priv->type;
403
 
}
404
 
 
405
 
 
406
 
static void
407
 
mg_entry_wrapper_set_value (MgDataEntry *iface, const GdaValue *value)
408
 
{
409
 
        MgEntryWrapper *mgwrap;
410
 
 
411
 
        g_return_if_fail (iface && IS_MG_ENTRY_WRAPPER (iface));
412
 
        mgwrap = MG_ENTRY_WRAPPER (iface);
413
 
        g_return_if_fail (mgwrap->priv);
414
 
        check_correct_init (mgwrap);
415
 
        
416
 
        block_signals (mgwrap);
417
 
        if (value) {
418
 
                g_return_if_fail ((gda_value_get_type (value) == mgwrap->priv->type) || 
419
 
                                  (gda_value_get_type (value) == GDA_VALUE_TYPE_NULL));
420
 
                (*mgwrap->priv->real_class->real_set_value) (mgwrap, value);
421
 
                if (gda_value_is_null (value))
422
 
                        mgwrap->priv->null_forced = TRUE;
423
 
                else 
424
 
                        mgwrap->priv->null_forced = FALSE;
425
 
        }
426
 
        else {
427
 
                (*mgwrap->priv->real_class->real_set_value) (mgwrap, NULL);
428
 
                mgwrap->priv->null_forced = TRUE;
429
 
        }
430
 
        unblock_signals (mgwrap);
431
 
        mgwrap->priv->default_forced = FALSE;
432
 
 
433
 
        mg_entry_wrapper_emit_signal (mgwrap);
434
 
}
435
 
 
436
 
static GdaValue *
437
 
mg_entry_wrapper_get_value (MgDataEntry *iface)
438
 
{
439
 
        GdaValue *value = NULL;
440
 
        MgEntryWrapper *mgwrap;
441
 
        MgDataHandler *dh;
442
 
 
443
 
        g_return_val_if_fail (iface && IS_MG_ENTRY_WRAPPER (iface), NULL);
444
 
        mgwrap = MG_ENTRY_WRAPPER (iface);
445
 
        g_return_val_if_fail (mgwrap->priv, NULL);
446
 
 
447
 
        dh = mg_entry_wrapper_get_handler (MG_DATA_ENTRY (mgwrap));
448
 
 
449
 
        if (mgwrap->priv->null_forced)
450
 
                value = gda_value_new_null ();
451
 
        else {
452
 
                if (mgwrap->priv->default_forced) {
453
 
                        if (gda_value_get_type (mgwrap->priv->value_default) == mgwrap->priv->type)
454
 
                                value = gda_value_copy (mgwrap->priv->value_default);
455
 
                        else
456
 
                                value = gda_value_new_null ();
457
 
                }
458
 
                else {
459
 
                        check_correct_init (mgwrap);
460
 
                        value = (*mgwrap->priv->real_class->real_get_value) (mgwrap);
461
 
                }
462
 
        }
463
 
 
464
 
        return value;
465
 
}
466
 
 
467
 
static void
468
 
mg_entry_wrapper_set_value_orig (MgDataEntry *iface, const GdaValue *value)
469
 
{
470
 
        MgEntryWrapper *mgwrap;
471
 
        gboolean changed = TRUE;
472
 
        GdaValue *evalue;
473
 
        
474
 
        g_return_if_fail (iface && IS_MG_ENTRY_WRAPPER (iface));
475
 
        mgwrap = MG_ENTRY_WRAPPER (iface);
476
 
        g_return_if_fail (mgwrap->priv);
477
 
        check_correct_init (mgwrap);
478
 
 
479
 
        /* compare existing value and the one provided as argument */
480
 
        evalue = mg_entry_wrapper_get_value (iface);
481
 
        if ((!value && !evalue) ||
482
 
            (!value && gda_value_is_null (evalue)) ||
483
 
            (!evalue && gda_value_is_null (value)) ||
484
 
            ((gda_value_get_type (value) == gda_value_get_type (evalue)) &&
485
 
             !gda_value_compare (value, evalue)))
486
 
                changed = FALSE;
487
 
 
488
 
        /* get rid on any existing orig value */
489
 
        if (mgwrap->priv->value_orig) { 
490
 
                gda_value_free (mgwrap->priv->value_orig);
491
 
                mgwrap->priv->value_orig = NULL;
492
 
        }
493
 
 
494
 
        /* apply changes */
495
 
        if (changed) {
496
 
                block_signals (mgwrap);
497
 
                mg_entry_wrapper_set_value (iface, value);
498
 
                unblock_signals (mgwrap);
499
 
                
500
 
                if (value) {
501
 
                        g_return_if_fail ((gda_value_get_type (value) == mgwrap->priv->type) || 
502
 
                                          (gda_value_get_type (value) == GDA_VALUE_TYPE_NULL));
503
 
                        mgwrap->priv->value_orig = gda_value_copy (value);
504
 
                }
505
 
                else
506
 
                        mgwrap->priv->value_orig = gda_value_new_null ();
507
 
                mg_entry_wrapper_emit_signal (mgwrap);
508
 
                if (evalue)
509
 
                        gda_value_free (evalue);
510
 
        }
511
 
        else {
512
 
                if (evalue)
513
 
                        mgwrap->priv->value_orig = evalue;
514
 
                else
515
 
                        mgwrap->priv->value_orig = gda_value_new_null ();
516
 
        }
517
 
}
518
 
 
519
 
static const GdaValue *
520
 
mg_entry_wrapper_get_value_orig (MgDataEntry *iface)
521
 
{
522
 
        g_return_val_if_fail (iface && IS_MG_ENTRY_WRAPPER (iface), NULL);
523
 
        g_return_val_if_fail (MG_ENTRY_WRAPPER (iface)->priv, NULL);
524
 
 
525
 
        return MG_ENTRY_WRAPPER (iface)->priv->value_orig;
526
 
}
527
 
 
528
 
static void
529
 
mg_entry_wrapper_set_value_default (MgDataEntry *iface, const GdaValue *value)
530
 
{
531
 
        MgEntryWrapper *mgwrap;
532
 
 
533
 
        g_return_if_fail (iface && IS_MG_ENTRY_WRAPPER (iface));
534
 
        mgwrap = MG_ENTRY_WRAPPER (iface);
535
 
        g_return_if_fail (mgwrap->priv);
536
 
 
537
 
        if (mgwrap->priv->value_default)
538
 
                gda_value_free (mgwrap->priv->value_default);
539
 
 
540
 
        if (value) 
541
 
                mgwrap->priv->value_default = gda_value_copy (value);
542
 
        else 
543
 
                mgwrap->priv->value_default = gda_value_new_null ();
544
 
 
545
 
        if (mgwrap->priv->default_forced) {
546
 
                if (gda_value_get_type (mgwrap->priv->value_default) == mgwrap->priv->type) {
547
 
                        check_correct_init (mgwrap);
548
 
                        block_signals (mgwrap);
549
 
                        mg_entry_wrapper_set_value (iface, mgwrap->priv->value_default);
550
 
                        unblock_signals (mgwrap);
551
 
                        mgwrap->priv->default_forced = TRUE;
552
 
                        mg_entry_wrapper_emit_signal (mgwrap);
553
 
                }
554
 
                else {
555
 
                        check_correct_init (mgwrap);
556
 
                        (*mgwrap->priv->real_class->real_set_value) (mgwrap, NULL);
557
 
                        mg_entry_wrapper_emit_signal (mgwrap);
558
 
                }
559
 
        }
560
 
}
561
 
 
562
 
static void
563
 
mg_entry_wrapper_set_attributes (MgDataEntry *iface, guint attrs, guint mask)
564
 
{
565
 
        MgEntryWrapper *mgwrap;
566
 
 
567
 
        g_return_if_fail (iface && IS_MG_ENTRY_WRAPPER (iface));
568
 
        mgwrap = MG_ENTRY_WRAPPER (iface);
569
 
        g_return_if_fail (mgwrap->priv);
570
 
        check_correct_init (mgwrap);
571
 
 
572
 
        /* Setting to NULL */
573
 
        if (mask & MG_DATA_ENTRY_IS_NULL) {
574
 
                if ((mask & MG_DATA_ENTRY_CAN_BE_NULL) &&
575
 
                    !(attrs & MG_DATA_ENTRY_CAN_BE_NULL))
576
 
                        g_return_if_reached ();
577
 
                if (attrs & MG_DATA_ENTRY_IS_NULL) {
578
 
                        block_signals (mgwrap);
579
 
                        mg_entry_wrapper_set_value (iface, NULL);
580
 
                        unblock_signals (mgwrap);
581
 
                        mgwrap->priv->null_forced = TRUE;
582
 
                        
583
 
                        /* if default is set, see if we can keep it that way */
584
 
                        if (mgwrap->priv->default_forced) {
585
 
                                if (gda_value_get_type (mgwrap->priv->value_default) != 
586
 
                                    GDA_VALUE_TYPE_NULL)
587
 
                                        mgwrap->priv->default_forced = FALSE;
588
 
                        }
589
 
 
590
 
                        mg_entry_wrapper_emit_signal (mgwrap);
591
 
                        return;
592
 
                }
593
 
                else {
594
 
                        mgwrap->priv->null_forced = FALSE;
595
 
                        mg_entry_wrapper_emit_signal (mgwrap);
596
 
                }
597
 
        }
598
 
 
599
 
        /* Can be NULL ? */
600
 
        if (mask & MG_DATA_ENTRY_CAN_BE_NULL)
601
 
                mgwrap->priv->null_possible = (attrs & MG_DATA_ENTRY_CAN_BE_NULL) ? TRUE : FALSE;
602
 
 
603
 
        /* Setting to DEFAULT */
604
 
        if (mask & MG_DATA_ENTRY_IS_DEFAULT) {
605
 
                if ((mask & MG_DATA_ENTRY_CAN_BE_DEFAULT) &&
606
 
                    !(attrs & MG_DATA_ENTRY_CAN_BE_DEFAULT))
607
 
                        g_return_if_reached ();
608
 
                if (attrs & MG_DATA_ENTRY_IS_DEFAULT) {
609
 
                        block_signals (mgwrap);
610
 
                        if (mgwrap->priv->value_default) {
611
 
                                if (gda_value_get_type (mgwrap->priv->value_default) == mgwrap->priv->type)
612
 
                                        mg_entry_wrapper_set_value (iface, mgwrap->priv->value_default);
613
 
                                else 
614
 
                                        (*mgwrap->priv->real_class->real_set_value) (mgwrap, NULL);
615
 
                        }
616
 
                        else
617
 
                                mg_entry_wrapper_set_value (iface, NULL);
618
 
                        unblock_signals (mgwrap);
619
 
 
620
 
                        /* if NULL is set, see if we can keep it that way */
621
 
                        if (mgwrap->priv->null_forced) {
622
 
                                if (gda_value_get_type (mgwrap->priv->value_default) != 
623
 
                                    GDA_VALUE_TYPE_NULL)
624
 
                                        mgwrap->priv->null_forced = FALSE;
625
 
                        }
626
 
 
627
 
                        mgwrap->priv->default_forced = TRUE;
628
 
                        mg_entry_wrapper_emit_signal (mgwrap);
629
 
                        return;
630
 
                }
631
 
                else {
632
 
                        mgwrap->priv->default_forced = FALSE;
633
 
                        mg_entry_wrapper_emit_signal (mgwrap);
634
 
                }
635
 
        }
636
 
 
637
 
        /* Can be DEFAULT ? */
638
 
        if (mask & MG_DATA_ENTRY_CAN_BE_DEFAULT)
639
 
                mgwrap->priv->default_possible = (attrs & MG_DATA_ENTRY_CAN_BE_DEFAULT) ? TRUE : FALSE;
640
 
        
641
 
        /* Modified ? */
642
 
        if (mask & MG_DATA_ENTRY_IS_UNCHANGED) {
643
 
                if (attrs & MG_DATA_ENTRY_IS_UNCHANGED) {
644
 
                        mgwrap->priv->default_forced = FALSE;
645
 
                        block_signals (mgwrap);
646
 
                        mg_entry_wrapper_set_value (iface, mgwrap->priv->value_orig);
647
 
                        unblock_signals (mgwrap);
648
 
                        mg_entry_wrapper_emit_signal (mgwrap);
649
 
                }
650
 
        }
651
 
 
652
 
        /* Actions buttons ? */
653
 
        if (mask & MG_DATA_ENTRY_ACTIONS_SHOWN) {
654
 
                GValue *gval;
655
 
                mgwrap->priv->show_actions = (attrs & MG_DATA_ENTRY_ACTIONS_SHOWN) ? TRUE : FALSE;
656
 
                
657
 
                gval = g_new0 (GValue, 1);
658
 
                g_value_init (gval, G_TYPE_BOOLEAN);
659
 
                g_value_set_boolean (gval, mgwrap->priv->show_actions);
660
 
                g_object_set_property (G_OBJECT (mgwrap), "actions", gval);
661
 
                g_free (gval);
662
 
        }
663
 
 
664
 
        /* NON WRITABLE attributes */
665
 
        if (mask & MG_DATA_ENTRY_DATA_NON_VALID) 
666
 
                g_warning ("Can't force a MgDataEntry to be invalid!");
667
 
 
668
 
        if (mask & MG_DATA_ENTRY_HAS_VALUE_ORIG)
669
 
                g_warning ("Having an original value is not a write attribute on MgDataEntry!");
670
 
 
671
 
        g_signal_emit_by_name (G_OBJECT (mgwrap), "status_changed");
672
 
}
673
 
 
674
 
static guint
675
 
mg_entry_wrapper_get_attributes (MgDataEntry *iface)
676
 
{
677
 
        guint retval = 0;
678
 
        MgEntryWrapper *mgwrap;
679
 
        GdaValue *value;
680
 
 
681
 
        g_return_val_if_fail (iface && IS_MG_ENTRY_WRAPPER (iface), 0);
682
 
        mgwrap = MG_ENTRY_WRAPPER (iface);
683
 
        g_return_val_if_fail (mgwrap->priv, 0);
684
 
 
685
 
        value = mg_entry_wrapper_get_value (iface);
686
 
 
687
 
        /* NULL? */
688
 
        if (gda_value_get_type (value) == GDA_VALUE_TYPE_NULL) {
689
 
                if (mgwrap->priv->default_forced) {
690
 
                        if (mgwrap->priv->null_forced)
691
 
                                retval = retval | MG_DATA_ENTRY_IS_NULL;
692
 
                }
693
 
                else
694
 
                        retval = retval | MG_DATA_ENTRY_IS_NULL;
695
 
        }
696
 
 
697
 
        /* can be NULL? */
698
 
        if (mgwrap->priv->null_possible) 
699
 
                retval = retval | MG_DATA_ENTRY_CAN_BE_NULL;
700
 
        
701
 
        /* is default */
702
 
        if (mgwrap->priv->default_forced) 
703
 
                retval = retval | MG_DATA_ENTRY_IS_DEFAULT;
704
 
        
705
 
        /* can be default? */
706
 
        if (mgwrap->priv->default_possible)
707
 
                retval = retval | MG_DATA_ENTRY_CAN_BE_DEFAULT;
708
 
        
709
 
        /* is unchanged */
710
 
        if (mgwrap->priv->value_orig && 
711
 
            (gda_value_get_type (value) == gda_value_get_type (mgwrap->priv->value_orig))) {
712
 
                if (gda_value_is_null (value)) 
713
 
                        retval = retval | MG_DATA_ENTRY_IS_UNCHANGED;
714
 
                else {
715
 
                        if (! gda_value_compare (value, mgwrap->priv->value_orig))
716
 
                                retval = retval | MG_DATA_ENTRY_IS_UNCHANGED;
717
 
                }
718
 
        }
719
 
 
720
 
        /* actions shown */
721
 
        if (mgwrap->priv->show_actions)
722
 
                retval = retval | MG_DATA_ENTRY_ACTIONS_SHOWN;
723
 
 
724
 
        /* data valid? */
725
 
        if (! (mgwrap->priv->default_forced && mgwrap->priv->default_possible)) {
726
 
                if (/*(gda_value_is_null (value) && !mgwrap->priv->null_forced) ||*/
727
 
                    (gda_value_is_null (value) && !mgwrap->priv->null_possible))
728
 
                        retval = retval | MG_DATA_ENTRY_DATA_NON_VALID;
729
 
        }
730
 
 
731
 
        /* has original value? */
732
 
        if (mgwrap->priv->value_orig) {
733
 
                retval = retval | MG_DATA_ENTRY_HAS_VALUE_ORIG;
734
 
        }
735
 
        
736
 
        gda_value_free (value);
737
 
 
738
 
        return retval;
739
 
}
740
 
 
741
 
 
742
 
static MgDataHandler *
743
 
mg_entry_wrapper_get_handler (MgDataEntry *iface)
744
 
{
745
 
        GValue val = { 0, };
746
 
        MgDataHandler *dh;
747
 
 
748
 
        g_return_val_if_fail (iface && IS_MG_ENTRY_WRAPPER (iface), NULL);
749
 
        g_return_val_if_fail (MG_ENTRY_WRAPPER (iface)->priv, NULL);
750
 
 
751
 
        g_value_init (&val, G_TYPE_POINTER);
752
 
        g_object_get_property (G_OBJECT (iface), "handler", &val);
753
 
        dh = g_value_get_pointer (&val);
754
 
        g_value_unset (&val);
755
 
 
756
 
        return dh;
757
 
}
758
 
 
759
 
static gboolean
760
 
mg_entry_wrapper_expand_in_layout (MgDataEntry *iface)
761
 
{
762
 
        MgEntryWrapper *mgwrap;
763
 
 
764
 
        g_return_val_if_fail (iface && IS_MG_ENTRY_WRAPPER (iface), FALSE);
765
 
        mgwrap = MG_ENTRY_WRAPPER (iface);
766
 
        g_return_val_if_fail (mgwrap->priv, FALSE);
767
 
        check_correct_init (mgwrap);
768
 
 
769
 
        return (*mgwrap->priv->real_class->expand_in_layout) (mgwrap);
770
 
}