← Back to branch summary

~ubuntu-branches/debian/stretch/glade/stretch

« back to all changes in this revision

Viewing changes to gladeui/glade-widget.c

  • Committer: Package Import Robot
  • Author(s): Andreas Henriksson, Emilio Pozuelo Monfort, Andreas Henriksson
  • Date: 2014-05-23 13:00:17 UTC
  • mfrom: (1.3.2)
  • Revision ID: package-import@ubuntu.com-20140523130017-7sp231ghdz55szde
Tags: 3.18.3-1
[ Emilio Pozuelo Monfort ]
* debian/rules:
  + Pass -c4 to dpkg-gensymbols so we know when new symbols are added.
* debian/libgladeui-2-6.symbols:
  + Add missing symbols.

[ Andreas Henriksson ]
* New upstream release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
gladeui/glade-widget.c
59
59
#include "glade-object-stub.h"
60
60
#include "glade-dnd.h"
61
61
 
62
 
static void glade_widget_set_adaptor (GladeWidget * widget,
63
 
                                      GladeWidgetAdaptor * adaptor);
64
 
static void glade_widget_set_properties (GladeWidget * widget,
65
 
                                         GList * properties);
66
 
static void glade_widget_set_object (GladeWidget * gwidget,
67
 
                                     GObject * new_object);
 
62
static void glade_widget_set_adaptor    (GladeWidget        *widget,
 
63
                                         GladeWidgetAdaptor *adaptor);
 
64
static void glade_widget_set_properties (GladeWidget        *widget,
 
65
                                         GList              *properties);
 
66
static void glade_widget_set_object     (GladeWidget        *gwidget,
 
67
                                         GObject            *new_object);
68
68
 
69
69
 
70
70
struct _GladeWidgetPrivate {
207
207
static void glade_widget_drag_init (_GladeDragInterface *iface);
208
208
 
209
209
G_DEFINE_TYPE_WITH_CODE (GladeWidget, glade_widget, G_TYPE_INITIALLY_UNOWNED,
 
210
                         G_ADD_PRIVATE (GladeWidget)
210
211
                         G_IMPLEMENT_INTERFACE (GLADE_TYPE_DRAG, 
211
212
                                                glade_widget_drag_init))
212
213
 
214
215
                           GladeWidget class methods
215
216
 *******************************************************************************/
216
217
static void
217
 
glade_widget_set_packing_actions (GladeWidget * widget,
218
 
                                  GladeWidget * parent)
 
218
glade_widget_set_packing_actions (GladeWidget *widget,
 
219
                                  GladeWidget *parent)
219
220
{
220
221
  if (widget->priv->packing_actions)
221
222
    {
229
230
}
230
231
 
231
232
static void
232
 
glade_widget_add_child_impl (GladeWidget * widget,
233
 
                             GladeWidget * child, gboolean at_mouse)
 
233
glade_widget_add_child_impl (GladeWidget *widget,
 
234
                             GladeWidget *child, gboolean at_mouse)
234
235
{
235
236
  g_object_ref (child);
236
237
 
266
267
}
267
268
 
268
269
static void
269
 
glade_widget_remove_child_impl (GladeWidget * widget, GladeWidget * child)
 
270
glade_widget_remove_child_impl (GladeWidget *widget, GladeWidget *child)
270
271
{
271
272
  glade_widget_adaptor_remove (widget->priv->adaptor, widget->priv->object, child->priv->object);
272
273
 
276
277
}
277
278
 
278
279
static void
279
 
glade_widget_replace_child_impl (GladeWidget * widget,
280
 
                                 GObject * old_object, GObject * new_object)
 
280
glade_widget_replace_child_impl (GladeWidget *widget,
 
281
                                 GObject     *old_object,
 
282
                                 GObject     *new_object)
281
283
{
282
284
  GladeWidget *gnew_widget = glade_widget_get_from_gobject (new_object);
283
285
  GladeWidget *gold_widget = glade_widget_get_from_gobject (old_object);
319
321
 * Adds a signal handler for @widget 
320
322
 */
321
323
void
322
 
glade_widget_add_signal_handler (GladeWidget *widget, const GladeSignal *signal_handler)
 
324
glade_widget_add_signal_handler (GladeWidget       *widget,
 
325
                                 const GladeSignal *signal_handler)
323
326
{
324
327
  GPtrArray *signals;
325
328
  GladeSignal *new_signal_handler;
355
358
 */
356
359
 
357
360
void
358
 
glade_widget_remove_signal_handler (GladeWidget * widget,
359
 
                                    const GladeSignal * signal_handler)
 
361
glade_widget_remove_signal_handler (GladeWidget       *widget,
 
362
                                    const GladeSignal *signal_handler)
360
363
{
361
364
  GPtrArray *signals;
362
365
  GladeSignal *tmp_signal_handler;
396
399
 * Changes a #GladeSignal on @widget 
397
400
 */
398
401
void
399
 
glade_widget_change_signal_handler (GladeWidget * widget,
400
 
                                    const GladeSignal * old_signal_handler,
401
 
                                    const GladeSignal * new_signal_handler)
 
402
glade_widget_change_signal_handler (GladeWidget       *widget,
 
403
                                    const GladeSignal *old_signal_handler,
 
404
                                    const GladeSignal *new_signal_handler)
402
405
{
403
406
  GPtrArray *signals;
404
407
  GladeSignal *signal_handler_iter;
448
451
}
449
452
 
450
453
static gboolean
451
 
glade_widget_button_press_event_impl (GladeWidget * gwidget,
452
 
                                      GdkEvent * base_event)
 
454
glade_widget_button_press_event_impl (GladeWidget *gwidget,
 
455
                                      GdkEvent    *base_event)
453
456
{
454
457
  GtkWidget *widget;
455
458
  GdkEventButton *event = (GdkEventButton *) base_event;
496
499
}
497
500
 
498
501
static gboolean
499
 
glade_widget_event_impl (GladeWidget * gwidget, GdkEvent * event)
 
502
glade_widget_event_impl (GladeWidget *gwidget, GdkEvent *event)
500
503
{
501
504
  gboolean handled = FALSE;
502
505
 
537
540
 * Returns: whether the event was handled or not.
538
541
 */
539
542
gboolean
540
 
glade_widget_event (GladeWidget * gwidget, GdkEvent * event)
 
543
glade_widget_event (GladeWidget *gwidget, GdkEvent *event)
541
544
{
542
545
  gboolean handled = FALSE;
543
546
 
569
572
 * values currently in use.
570
573
 */
571
574
static GParameter *
572
 
glade_widget_template_params (GladeWidget * widget,
573
 
                              gboolean construct, guint * n_params)
 
575
glade_widget_template_params (GladeWidget *widget,
 
576
                              gboolean     construct,
 
577
                              guint       *n_params)
574
578
{
575
579
  GladeWidgetAdaptor *adaptor;
576
580
  GArray             *params;
653
657
}
654
658
 
655
659
static void
656
 
free_params (GParameter * params, guint n_params)
 
660
free_params (GParameter *params, guint n_params)
657
661
{
658
662
  gint i;
659
663
  for (i = 0; i < n_params; i++)
663
667
}
664
668
 
665
669
static GObject *
666
 
glade_widget_build_object (GladeWidget * widget,
667
 
                           GladeWidget * template, GladeCreateReason reason)
 
670
glade_widget_build_object (GladeWidget      *widget,
 
671
                           GladeWidget      *template,
 
672
                           GladeCreateReason reason)
668
673
{
669
674
  GParameter *params;
670
675
  GObject *object;
721
726
 * Returns: A newly allocated #GList of new #GladeProperty objects.
722
727
 */
723
728
GList *
724
 
glade_widget_dup_properties (GladeWidget * dest_widget, GList * template_props,
725
 
                             gboolean as_load, gboolean copy_parentless,
726
 
                             gboolean exact)
 
729
glade_widget_dup_properties (GladeWidget *dest_widget,
 
730
                             GList       *template_props,
 
731
                             gboolean     as_load,
 
732
                             gboolean     copy_parentless,
 
733
                             gboolean     exact)
727
734
{
728
735
  GList *list, *properties = NULL;
729
736
 
777
784
 * style properties).
778
785
 */
779
786
void
780
 
glade_widget_remove_property (GladeWidget * widget, const gchar * id_property)
 
787
glade_widget_remove_property (GladeWidget *widget, const gchar *id_property)
781
788
{
782
789
  GladeProperty *prop;
783
790
 
800
807
}
801
808
 
802
809
static void
803
 
glade_widget_set_catalog_defaults (GList * list)
 
810
glade_widget_set_catalog_defaults (GList *list)
804
811
{
805
812
  GList *l;
806
813
  for (l = list; l && l->data; l = l->next)
818
825
}
819
826
 
820
827
static void
821
 
glade_widget_sync_custom_props (GladeWidget * widget)
 
828
glade_widget_sync_custom_props (GladeWidget *widget)
822
829
{
823
830
  GList *l;
824
831
  for (l = widget->priv->properties; l && l->data; l = l->next)
833
840
}
834
841
 
835
842
static void
836
 
glade_widget_sync_packing_props (GladeWidget * widget)
 
843
glade_widget_sync_packing_props (GladeWidget *widget)
837
844
{
838
845
  GList *l;
839
846
  for (l = widget->priv->packing_properties; l && l->data; l = l->next)
845
852
 
846
853
 
847
854
static GObject *
848
 
glade_widget_constructor (GType type,
849
 
                          guint n_construct_properties,
850
 
                          GObjectConstructParam * construct_properties)
 
855
glade_widget_constructor (GType                  type,
 
856
                          guint                  n_construct_properties,
 
857
                          GObjectConstructParam *construct_properties)
851
858
{
852
859
  GladeWidget *gwidget;
853
860
  GObject *ret_obj;
963
970
}
964
971
 
965
972
static void
966
 
glade_widget_finalize (GObject * object)
 
973
glade_widget_finalize (GObject *object)
967
974
{
968
975
  GladeWidget *widget = GLADE_WIDGET (object);
969
976
 
987
994
}
988
995
 
989
996
static void
990
 
reset_object_property (GladeProperty * property, GladeProject * project)
 
997
reset_object_property (GladeProperty *property, GladeProject *project)
991
998
{
992
999
  GladePropertyClass *pclass = glade_property_get_class (property);
993
1000
 
996
1003
}
997
1004
 
998
1005
static void
999
 
glade_widget_dispose (GObject * object)
 
1006
glade_widget_dispose (GObject *object)
1000
1007
{
1001
1008
  GladeWidget *widget = GLADE_WIDGET (object);
1002
1009
  GList *children, *l;
1069
1076
}
1070
1077
 
1071
1078
static void
1072
 
glade_widget_set_real_property (GObject * object,
1073
 
                                guint prop_id,
1074
 
                                const GValue * value, GParamSpec * pspec)
 
1079
glade_widget_set_real_property (GObject      *object,
 
1080
                                guint         prop_id,
 
1081
                                const GValue *value,
 
1082
                                GParamSpec   *pspec)
1075
1083
{
1076
1084
  GladeWidget *widget;
1077
1085
 
1137
1145
}
1138
1146
 
1139
1147
static void
1140
 
glade_widget_get_real_property (GObject * object,
1141
 
                                guint prop_id,
1142
 
                                GValue * value, GParamSpec * pspec)
 
1148
glade_widget_get_real_property (GObject    *object,
 
1149
                                guint       prop_id,
 
1150
                                GValue     *value,
 
1151
                                GParamSpec *pspec)
1143
1152
{
1144
1153
  GladeWidget *widget;
1145
1154
 
1203
1212
}
1204
1213
 
1205
1214
static void
1206
 
glade_widget_init (GladeWidget * widget)
 
1215
glade_widget_init (GladeWidget *widget)
1207
1216
{
1208
 
  widget->priv = G_TYPE_INSTANCE_GET_PRIVATE (widget,
1209
 
                                              GLADE_TYPE_WIDGET,
1210
 
                                              GladeWidgetPrivate);
 
1217
  widget->priv = glade_widget_get_instance_private (widget);
1211
1218
 
1212
1219
  widget->priv->adaptor = NULL;
1213
1220
  widget->priv->project = NULL;
1321
1328
}
1322
1329
 
1323
1330
static void
1324
 
glade_widget_class_init (GladeWidgetClass * klass)
 
1331
glade_widget_class_init (GladeWidgetClass *klass)
1325
1332
{
1326
1333
  GObjectClass *object_class;
1327
1334
 
1550
1557
                    G_SIGNAL_RUN_LAST,
1551
1558
                    0, NULL, NULL,
1552
1559
                    g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
1553
 
 
1554
 
  g_type_class_add_private (klass, sizeof (GladeWidgetPrivate));
1555
1560
}
1556
1561
 
1557
1562
/*******************************************************************************
1558
1563
                                Static stuff....
1559
1564
 *******************************************************************************/
1560
1565
static void
1561
 
glade_widget_copy_packing_props (GladeWidget * parent,
1562
 
                                 GladeWidget * child,
1563
 
                                 GladeWidget * template_widget)
 
1566
glade_widget_copy_packing_props (GladeWidget *parent,
 
1567
                                 GladeWidget *child,
 
1568
                                 GladeWidget *template_widget)
1564
1569
{
1565
1570
  GladeProperty *dup_prop, *orig_prop;
1566
1571
  GList *l;
1582
1587
}
1583
1588
 
1584
1589
static void
1585
 
glade_widget_set_default_packing_properties (GladeWidget * container,
1586
 
                                             GladeWidget * child)
 
1590
glade_widget_set_default_packing_properties (GladeWidget *container,
 
1591
                                             GladeWidget *child)
1587
1592
{
1588
1593
  GladePropertyClass *property_class;
1589
1594
  const GList *l;
1635
1640
}
1636
1641
 
1637
1642
static GladeWidget *
1638
 
glade_widget_dup_internal (GladeWidget * main_target,
1639
 
                           GladeWidget * parent,
1640
 
                           GladeWidget * template_widget, gboolean exact)
 
1643
glade_widget_dup_internal (GladeWidget *main_target,
 
1644
                           GladeWidget *parent,
 
1645
                           GladeWidget *template_widget,
 
1646
                           gboolean     exact)
1641
1647
{
1642
1648
  GladeWidget *gwidget = NULL;
1643
1649
  GList *children;
1780
1786
} GladeChildExtract;
1781
1787
 
1782
1788
static GList *
1783
 
glade_widget_extract_children (GladeWidget * gwidget)
 
1789
glade_widget_extract_children (GladeWidget *gwidget)
1784
1790
{
1785
1791
  GladeChildExtract *extract;
1786
1792
  GList *extract_list = NULL;
1843
1849
}
1844
1850
 
1845
1851
static void
1846
 
glade_widget_insert_children (GladeWidget * gwidget, GList * children)
 
1852
glade_widget_insert_children (GladeWidget *gwidget, GList *children)
1847
1853
{
1848
1854
  GladeChildExtract *extract;
1849
1855
  GladeWidget *gchild;
1946
1952
}
1947
1953
 
1948
1954
static void
1949
 
glade_widget_set_properties (GladeWidget * widget, GList * properties)
 
1955
glade_widget_set_properties (GladeWidget *widget, GList *properties)
1950
1956
{
1951
1957
  GladeProperty *property;
1952
1958
  GList *list;
1981
1987
}
1982
1988
 
1983
1989
static void
1984
 
glade_widget_set_adaptor (GladeWidget * widget, GladeWidgetAdaptor * adaptor)
 
1990
glade_widget_set_adaptor (GladeWidget *widget, GladeWidgetAdaptor *adaptor)
1985
1991
{
1986
1992
  GladePropertyClass *property_class;
1987
1993
  GladeProperty      *property;
2023
2029
 * child type for this widget of this container.
2024
2030
 */
2025
2031
static GList *
2026
 
glade_widget_create_packing_properties (GladeWidget * container,
2027
 
                                        GladeWidget * widget)
 
2032
glade_widget_create_packing_properties (GladeWidget *container,
 
2033
                                        GladeWidget *widget)
2028
2034
{
2029
2035
  GladePropertyClass *property_class;
2030
2036
  GladeProperty      *property;
2048
2054
/* Private API */
2049
2055
 
2050
2056
GList *
2051
 
_glade_widget_peek_prop_refs (GladeWidget      *widget)
 
2057
_glade_widget_peek_prop_refs (GladeWidget *widget)
2052
2058
{
2053
2059
  return widget->priv->prop_refs;
2054
2060
}
2135
2141
 *       reffer to this object.
2136
2142
 */
2137
2143
void
2138
 
glade_widget_add_prop_ref (GladeWidget * widget, GladeProperty * property)
 
2144
glade_widget_add_prop_ref (GladeWidget *widget, GladeProperty *property)
2139
2145
{
2140
2146
  GladePropertyClass *pclass;
2141
2147
 
2171
2177
 *       reffer to this object.
2172
2178
 */
2173
2179
void
2174
 
glade_widget_remove_prop_ref (GladeWidget * widget, GladeProperty * property)
 
2180
glade_widget_remove_prop_ref (GladeWidget *widget, GladeProperty *property)
2175
2181
{
2176
2182
  GladePropertyClass *pclass;
2177
2183
 
2191
2197
}
2192
2198
 
2193
2199
GList *
2194
 
glade_widget_list_prop_refs (GladeWidget      *widget)
 
2200
glade_widget_list_prop_refs (GladeWidget *widget)
2195
2201
{
2196
2202
  g_return_val_if_fail (GLADE_IS_WIDGET (widget), NULL);
2197
2203
 
2200
2206
 
2201
2207
 
2202
2208
GladeProperty *
2203
 
glade_widget_get_parentless_widget_ref (GladeWidget * widget)
 
2209
glade_widget_get_parentless_widget_ref (GladeWidget *widget)
2204
2210
{
2205
2211
  GladePropertyClass *pclass;
2206
2212
  GladeProperty      *property;
2222
2228
 
2223
2229
 
2224
2230
GList *
2225
 
glade_widget_get_parentless_reffed_widgets (GladeWidget * widget)
 
2231
glade_widget_get_parentless_reffed_widgets (GladeWidget *widget)
2226
2232
{
2227
2233
  GladeProperty      *property = NULL;
2228
2234
  GladePropertyClass *pclass;
2250
2256
}
2251
2257
 
2252
2258
static void
2253
 
glade_widget_accum_signal_foreach (const gchar * key,
2254
 
                                   GPtrArray * signals, GList ** list)
 
2259
glade_widget_accum_signal_foreach (const gchar *key,
 
2260
                                   GPtrArray   *signals,
 
2261
                                   GList      **list)
2255
2262
{
2256
2263
  GladeSignal *signal;
2257
2264
  gint i;
2273
2280
 * must call g_list_free() to free the list.
2274
2281
 */
2275
2282
GList *
2276
 
glade_widget_get_signal_list (GladeWidget * widget)
 
2283
glade_widget_get_signal_list (GladeWidget *widget)
2277
2284
{
2278
2285
  GList *signals = NULL;
2279
2286
 
2286
2293
}
2287
2294
 
2288
2295
static void
2289
 
glade_widget_copy_signal_foreach (const gchar * key,
2290
 
                                  GPtrArray * signals, GladeWidget * dest)
 
2296
glade_widget_copy_signal_foreach (const gchar *key,
 
2297
                                  GPtrArray   *signals,
 
2298
                                  GladeWidget *dest)
2291
2299
{
2292
2300
  GladeSignal *signal;
2293
2301
  gint i;
2308
2316
 * matching signals in @template_widget
2309
2317
 */
2310
2318
void
2311
 
glade_widget_copy_signals (GladeWidget * widget, GladeWidget * template_widget)
 
2319
glade_widget_copy_signals (GladeWidget *widget, GladeWidget *template_widget)
2312
2320
{
2313
2321
  g_return_if_fail (GLADE_IS_WIDGET (widget));
2314
2322
  g_return_if_fail (GLADE_IS_WIDGET (template_widget));
2328
2336
 * matching properties in @template_widget
2329
2337
 */
2330
2338
void
2331
 
glade_widget_copy_properties (GladeWidget * widget,
2332
 
                              GladeWidget * template_widget,
2333
 
                              gboolean copy_parentless, gboolean exact)
 
2339
glade_widget_copy_properties (GladeWidget *widget,
 
2340
                              GladeWidget *template_widget,
 
2341
                              gboolean     copy_parentless,
 
2342
                              gboolean     exact)
2334
2343
{
2335
2344
  GList *l;
2336
2345
 
2398
2407
 * Returns: whether @child can be added to @widget.
2399
2408
 */
2400
2409
gboolean
2401
 
glade_widget_add_verify (GladeWidget      *widget,
2402
 
                         GladeWidget      *child,
2403
 
                         gboolean          user_feedback)
 
2410
glade_widget_add_verify (GladeWidget *widget,
 
2411
                         GladeWidget *child,
 
2412
                         gboolean     user_feedback)
2404
2413
{
2405
2414
  g_return_val_if_fail (GLADE_IS_WIDGET (widget), FALSE);
2406
2415
  g_return_val_if_fail (GLADE_IS_WIDGET (child), FALSE);
2421
2430
 * Adds @child to @parent in a generic way for this #GladeWidget parent.
2422
2431
 */
2423
2432
void
2424
 
glade_widget_add_child (GladeWidget * parent,
2425
 
                        GladeWidget * child, gboolean at_mouse)
 
2433
glade_widget_add_child (GladeWidget *parent,
 
2434
                        GladeWidget *child,
 
2435
                        gboolean     at_mouse)
2426
2436
{
2427
2437
  g_return_if_fail (GLADE_IS_WIDGET (parent));
2428
2438
  g_return_if_fail (GLADE_IS_WIDGET (child));
2438
2448
 * Removes @child from @parent in a generic way for this #GladeWidget parent.
2439
2449
 */
2440
2450
void
2441
 
glade_widget_remove_child (GladeWidget * parent, GladeWidget * child)
 
2451
glade_widget_remove_child (GladeWidget *parent, GladeWidget *child)
2442
2452
{
2443
2453
  g_return_if_fail (GLADE_IS_WIDGET (parent));
2444
2454
  g_return_if_fail (GLADE_IS_WIDGET (child));
2459
2469
 * Returns: The newly created #GladeWidget
2460
2470
 */
2461
2471
GladeWidget *
2462
 
glade_widget_dup (GladeWidget * template_widget, gboolean exact)
 
2472
glade_widget_dup (GladeWidget *template_widget, gboolean exact)
2463
2473
{
2464
2474
  GladeWidget *widget;
2465
2475
 
2489
2499
 *
2490
2500
 */
2491
2501
void
2492
 
glade_widget_rebuild (GladeWidget * gwidget)
 
2502
glade_widget_rebuild (GladeWidget *gwidget)
2493
2503
{
2494
2504
  GObject *new_object, *old_object;
2495
2505
  GladeWidgetAdaptor *adaptor;
2676
2686
 * Returns: A #GPtrArray of #GladeSignal for @signal_name
2677
2687
 */
2678
2688
GPtrArray *
2679
 
glade_widget_list_signal_handlers (GladeWidget * widget, const gchar * signal_name)     /* array of GladeSignal* */
 
2689
glade_widget_list_signal_handlers (GladeWidget *widget, const gchar *signal_name)     /* array of GladeSignal* */
2680
2690
{
2681
2691
  g_return_val_if_fail (GLADE_IS_WIDGET (widget), NULL);
2682
2692
  return g_hash_table_lookup (widget->priv->signals, signal_name);
2690
2700
 * Sets @widget's name to @name.
2691
2701
 */
2692
2702
void
2693
 
glade_widget_set_name (GladeWidget * widget, const gchar * name)
 
2703
glade_widget_set_name (GladeWidget *widget, const gchar *name)
2694
2704
{
2695
2705
  g_return_if_fail (GLADE_IS_WIDGET (widget));
2696
2706
  if (widget->priv->name != name)
2710
2720
 * Returns: a pointer to @widget's name
2711
2721
 */
2712
2722
const gchar *
2713
 
glade_widget_get_name (GladeWidget * widget)
 
2723
glade_widget_get_name (GladeWidget *widget)
2714
2724
{
2715
2725
  g_return_val_if_fail (GLADE_IS_WIDGET (widget), NULL);
2716
2726
  return widget->priv->name;
2727
2737
 * Only one widget in a project should be composite.
2728
2738
 */
2729
2739
void
2730
 
glade_widget_set_is_composite (GladeWidget      *widget,
2731
 
                               gboolean          composite)
 
2740
glade_widget_set_is_composite (GladeWidget *widget, gboolean composite)
2732
2741
{
2733
2742
  g_return_if_fail (GLADE_IS_WIDGET (widget));
2734
2743
 
2775
2784
 * Sets the internal name of @widget to @internal
2776
2785
 */
2777
2786
void
2778
 
glade_widget_set_internal (GladeWidget * widget, const gchar * internal)
 
2787
glade_widget_set_internal (GladeWidget *widget, const gchar *internal)
2779
2788
{
2780
2789
  g_return_if_fail (GLADE_IS_WIDGET (widget));
2781
2790
  if (widget->priv->internal != internal)
2793
2802
 * Returns: the internal name of @widget
2794
2803
 */
2795
2804
G_CONST_RETURN gchar *
2796
 
glade_widget_get_internal (GladeWidget * widget)
 
2805
glade_widget_get_internal (GladeWidget *widget)
2797
2806
{
2798
2807
  g_return_val_if_fail (GLADE_IS_WIDGET (widget), NULL);
2799
2808
  return widget->priv->internal;
2806
2815
 * Returns: the #GladeWidgetAdaptor of @widget
2807
2816
 */
2808
2817
GladeWidgetAdaptor *
2809
 
glade_widget_get_adaptor (GladeWidget * widget)
 
2818
glade_widget_get_adaptor (GladeWidget *widget)
2810
2819
{
2811
2820
  g_return_val_if_fail (GLADE_IS_WIDGET (widget), NULL);
2812
2821
  return widget->priv->adaptor;
2820
2829
 * Makes @widget belong to @project.
2821
2830
 */
2822
2831
void
2823
 
glade_widget_set_project (GladeWidget * widget, GladeProject * project)
 
2832
glade_widget_set_project (GladeWidget *widget, GladeProject *project)
2824
2833
{
2825
2834
  if (widget->priv->project != project)
2826
2835
    {
2836
2845
 * Returns: the #GladeProject that @widget belongs to
2837
2846
 */
2838
2847
GladeProject *
2839
 
glade_widget_get_project (GladeWidget * widget)
 
2848
glade_widget_get_project (GladeWidget *widget)
2840
2849
{
2841
2850
  g_return_val_if_fail (GLADE_IS_WIDGET (widget), NULL);
2842
2851
  return widget->priv->project;
2843
2852
}
2844
2853
 
2845
2854
void
2846
 
glade_widget_set_in_project (GladeWidget      *widget,
2847
 
                             gboolean          in_project)
 
2855
glade_widget_set_in_project (GladeWidget *widget, gboolean in_project)
2848
2856
{
2849
2857
  g_return_if_fail (GLADE_IS_WIDGET (widget));
2850
2858
 
2852
2860
}
2853
2861
 
2854
2862
gboolean
2855
 
glade_widget_in_project (GladeWidget      *widget)
 
2863
glade_widget_in_project (GladeWidget *widget)
2856
2864
{
2857
2865
  g_return_val_if_fail (GLADE_IS_WIDGET (widget), FALSE);
2858
2866
 
2867
2875
 * Returns: the #GladeProperty in @widget named @id_property
2868
2876
 */
2869
2877
GladeProperty *
2870
 
glade_widget_get_property (GladeWidget * widget, const gchar * id_property)
 
2878
glade_widget_get_property (GladeWidget *widget, const gchar *id_property)
2871
2879
{
2872
2880
  GladeProperty *property;
2873
2881
 
2889
2897
 * Returns: the #GladeProperty in @widget named @id_property
2890
2898
 */
2891
2899
GladeProperty *
2892
 
glade_widget_get_pack_property (GladeWidget * widget, const gchar * id_property)
 
2900
glade_widget_get_pack_property (GladeWidget *widget, const gchar *id_property)
2893
2901
{
2894
2902
  GladeProperty *property;
2895
2903
 
2916
2924
 *
2917
2925
 */
2918
2926
gboolean
2919
 
glade_widget_property_get (GladeWidget * widget, const gchar * id_property, ...)
 
2927
glade_widget_property_get (GladeWidget *widget, const gchar *id_property, ...)
2920
2928
{
2921
2929
  GladeProperty *property;
2922
2930
  va_list vl;
2945
2953
 * Returns: whether @id_property was found or not.
2946
2954
 */
2947
2955
gboolean
2948
 
glade_widget_property_set (GladeWidget * widget, const gchar * id_property, ...)
 
2956
glade_widget_property_set (GladeWidget *widget, const gchar *id_property, ...)
2949
2957
{
2950
2958
  GladeProperty *property;
2951
2959
  va_list vl;
2974
2982
 * Returns: whether @id_property was found or not.
2975
2983
 */
2976
2984
gboolean
2977
 
glade_widget_pack_property_get (GladeWidget * widget,
2978
 
                                const gchar * id_property, ...)
 
2985
glade_widget_pack_property_get (GladeWidget *widget, 
 
2986
                                const gchar *id_property,
 
2987
                                ...)
2979
2988
{
2980
2989
  GladeProperty *property;
2981
2990
  va_list vl;
3004
3013
 * Returns: whether @id_property was found or not.
3005
3014
 */
3006
3015
gboolean
3007
 
glade_widget_pack_property_set (GladeWidget * widget,
3008
 
                                const gchar * id_property, ...)
 
3016
glade_widget_pack_property_set (GladeWidget *widget,
 
3017
                                const gchar *id_property,
 
3018
                                ...)
3009
3019
{
3010
3020
  GladeProperty *property;
3011
3021
  va_list vl;
3036
3046
 * Returns: whether @id_property was found or not.
3037
3047
 */
3038
3048
gboolean
3039
 
glade_widget_property_set_sensitive (GladeWidget * widget,
3040
 
                                     const gchar * id_property,
3041
 
                                     gboolean sensitive, const gchar * reason)
 
3049
glade_widget_property_set_sensitive (GladeWidget *widget,
 
3050
                                     const gchar *id_property,
 
3051
                                     gboolean     sensitive,
 
3052
                                     const gchar *reason)
3042
3053
{
3043
3054
  GladeProperty *property;
3044
3055
 
3066
3077
 * Returns: whether @id_property was found or not.
3067
3078
 */
3068
3079
gboolean
3069
 
glade_widget_pack_property_set_sensitive (GladeWidget * widget,
3070
 
                                          const gchar * id_property,
3071
 
                                          gboolean sensitive,
3072
 
                                          const gchar * reason)
 
3080
glade_widget_pack_property_set_sensitive (GladeWidget *widget,
 
3081
                                          const gchar *id_property,
 
3082
                                          gboolean     sensitive,
 
3083
                                          const gchar *reason)
3073
3084
{
3074
3085
  GladeProperty *property;
3075
3086
 
3096
3107
 * Returns: whether @id_property was found or not.
3097
3108
 */
3098
3109
gboolean
3099
 
glade_widget_property_set_enabled (GladeWidget * widget,
3100
 
                                   const gchar * id_property, gboolean enabled)
 
3110
glade_widget_property_set_enabled (GladeWidget *widget,
 
3111
                                   const gchar *id_property, 
 
3112
                                   gboolean     enabled)
3101
3113
{
3102
3114
  GladeProperty *property;
3103
3115
 
3124
3136
 * Returns: whether @id_property was found or not.
3125
3137
 */
3126
3138
gboolean
3127
 
glade_widget_pack_property_set_enabled (GladeWidget * widget,
3128
 
                                        const gchar * id_property,
3129
 
                                        gboolean enabled)
 
3139
glade_widget_pack_property_set_enabled (GladeWidget *widget,
 
3140
                                        const gchar *id_property,
 
3141
                                        gboolean     enabled)
3130
3142
{
3131
3143
  GladeProperty *property;
3132
3144
 
3156
3168
 * Returns: whether @id_property was found or not.
3157
3169
 */
3158
3170
gboolean
3159
 
glade_widget_property_set_save_always (GladeWidget * widget,
3160
 
                                       const gchar * id_property,
3161
 
                                       gboolean setting)
 
3171
glade_widget_property_set_save_always (GladeWidget *widget,
 
3172
                                       const gchar *id_property,
 
3173
                                       gboolean     setting)
3162
3174
{
3163
3175
  GladeProperty *property;
3164
3176
 
3188
3200
 * Returns: whether @id_property was found or not.
3189
3201
 */
3190
3202
gboolean
3191
 
glade_widget_pack_property_set_save_always (GladeWidget * widget,
3192
 
                                            const gchar * id_property,
3193
 
                                            gboolean setting)
 
3203
glade_widget_pack_property_set_save_always (GladeWidget *widget,
 
3204
                                            const gchar *id_property,
 
3205
                                            gboolean     setting)
3194
3206
{
3195
3207
  GladeProperty *property;
3196
3208
 
3254
3266
 * Returns: A newly allocated string representing @id_property
3255
3267
 */
3256
3268
gchar *
3257
 
glade_widget_pack_property_string (GladeWidget * widget,
3258
 
                                   const gchar * id_property,
3259
 
                                   const GValue * value)
 
3269
glade_widget_pack_property_string (GladeWidget  *widget,
 
3270
                                   const gchar  *id_property,
 
3271
                                   const GValue *value)
3260
3272
{
3261
3273
  GladeProperty      *property;
3262
3274
  GladePropertyClass *pclass;
3287
3299
 * Returns: whether @id_property was found or not.
3288
3300
 */
3289
3301
gboolean
3290
 
glade_widget_property_reset (GladeWidget * widget, const gchar * id_property)
 
3302
glade_widget_property_reset (GladeWidget *widget, const gchar *id_property)
3291
3303
{
3292
3304
  GladeProperty *property;
3293
3305
 
3311
3323
 * Returns: whether @id_property was found or not.
3312
3324
 */
3313
3325
gboolean
3314
 
glade_widget_pack_property_reset (GladeWidget * widget,
3315
 
                                  const gchar * id_property)
 
3326
glade_widget_pack_property_reset (GladeWidget *widget,
 
3327
                                  const gchar *id_property)
3316
3328
{
3317
3329
  GladeProperty *property;
3318
3330
 
3327
3339
}
3328
3340
 
3329
3341
static gboolean
3330
 
glade_widget_property_default_common (GladeWidget * widget,
3331
 
                                      const gchar * id_property,
3332
 
                                      gboolean original)
 
3342
glade_widget_property_default_common (GladeWidget *widget,
 
3343
                                      const gchar *id_property,
 
3344
                                      gboolean     original)
3333
3345
{
3334
3346
  GladeProperty *property;
3335
3347
 
3351
3363
 * currently set to it's default value.
3352
3364
 */
3353
3365
gboolean
3354
 
glade_widget_property_default (GladeWidget * widget, const gchar * id_property)
 
3366
glade_widget_property_default (GladeWidget *widget, const gchar *id_property)
3355
3367
{
3356
3368
  return glade_widget_property_default_common (widget, id_property, FALSE);
3357
3369
}
3365
3377
 * currently set to it's original default value.
3366
3378
 */
3367
3379
gboolean
3368
 
glade_widget_property_original_default (GladeWidget * widget,
3369
 
                                        const gchar * id_property)
 
3380
glade_widget_property_original_default (GladeWidget *widget,
 
3381
                                        const gchar *id_property)
3370
3382
{
3371
3383
  return glade_widget_property_default_common (widget, id_property, TRUE);
3372
3384
}
3380
3392
 * currently set to it's default value.
3381
3393
 */
3382
3394
gboolean
3383
 
glade_widget_pack_property_default (GladeWidget * widget,
3384
 
                                    const gchar * id_property)
 
3395
glade_widget_pack_property_default (GladeWidget *widget,
 
3396
                                    const gchar *id_property)
3385
3397
{
3386
3398
  GladeProperty *property;
3387
3399
 
3404
3416
 * the runtime object of @widget.
3405
3417
 */
3406
3418
void
3407
 
glade_widget_object_set_property (GladeWidget * widget,
3408
 
                                  const gchar * property_name,
3409
 
                                  const GValue * value)
 
3419
glade_widget_object_set_property (GladeWidget  *widget,
 
3420
                                  const gchar  *property_name,
 
3421
                                  const GValue *value)
3410
3422
{
3411
3423
  g_return_if_fail (GLADE_IS_WIDGET (widget));
3412
3424
  g_return_if_fail (property_name != NULL && value != NULL);
3426
3438
 * the runtime object of @widget and sets it in @value.
3427
3439
 */
3428
3440
void
3429
 
glade_widget_object_get_property (GladeWidget * widget,
3430
 
                                  const gchar * property_name, GValue * value)
 
3441
glade_widget_object_get_property (GladeWidget *widget,
 
3442
                                  const gchar *property_name,
 
3443
                                  GValue      *value)
3431
3444
{
3432
3445
  g_return_if_fail (GLADE_IS_WIDGET (widget));
3433
3446
  g_return_if_fail (property_name != NULL && value != NULL);
3491
3504
 * Gets @child's packing property identified by @property_name.
3492
3505
 */
3493
3506
void
3494
 
glade_widget_child_get_property (GladeWidget * widget,
3495
 
                                 GladeWidget * child,
3496
 
                                 const gchar * property_name, GValue * value)
 
3507
glade_widget_child_get_property (GladeWidget *widget,
 
3508
                                 GladeWidget *child,
 
3509
                                 const gchar *property_name,
 
3510
                                 GValue      *value)
3497
3511
{
3498
3512
  g_return_if_fail (GLADE_IS_WIDGET (widget));
3499
3513
  g_return_if_fail (GLADE_IS_WIDGET (child));
3506
3520
}
3507
3521
 
3508
3522
static void
3509
 
glade_widget_add_events (GtkWidget * widget)
 
3523
glade_widget_add_events (GtkWidget *widget)
3510
3524
{
3511
3525
  GList *children, *list;
3512
3526
 
3531
3545
}
3532
3546
 
3533
3547
static void
3534
 
glade_widget_set_object (GladeWidget * gwidget, GObject * new_object)
 
3548
glade_widget_set_object (GladeWidget *gwidget, GObject *new_object)
3535
3549
{
3536
3550
  GObject *old_object;
3537
3551
 
3605
3619
 * Returns: the #GObject associated with @widget
3606
3620
 */
3607
3621
GObject *
3608
 
glade_widget_get_object (GladeWidget * widget)
 
3622
glade_widget_get_object (GladeWidget *widget)
3609
3623
{
3610
3624
  g_return_val_if_fail (GLADE_IS_WIDGET (widget), NULL);
3611
3625
  return widget->priv->object;
3618
3632
 * Returns: The parenting #GladeWidget
3619
3633
 */
3620
3634
GladeWidget *
3621
 
glade_widget_get_parent (GladeWidget * widget)
 
3635
glade_widget_get_parent (GladeWidget *widget)
3622
3636
{
3623
3637
  g_return_val_if_fail (GLADE_IS_WIDGET (widget), NULL);
3624
3638
  return widget->priv->parent;
3632
3646
 * sets the parenting #GladeWidget
3633
3647
 */
3634
3648
void
3635
 
glade_widget_set_parent (GladeWidget * widget, GladeWidget * parent)
 
3649
glade_widget_set_parent (GladeWidget *widget, GladeWidget *parent)
3636
3650
{
3637
3651
  GladeWidget *old_parent;
3638
3652
 
3671
3685
 * Returns: The child of widget or NULL if it was not found.
3672
3686
 */
3673
3687
GladeWidget *
3674
 
glade_widget_find_child (GladeWidget *widget, 
3675
 
                         const gchar *name)
 
3688
glade_widget_find_child (GladeWidget *widget, const gchar *name)
3676
3689
{
3677
3690
  GList *adapter_children;
3678
3691
  GladeWidget *real_child = NULL;
3715
3728
 * exposed for Glade configuration</para></note>
3716
3729
 */
3717
3730
GList *
3718
 
glade_widget_get_children (GladeWidget * widget)
 
3731
glade_widget_get_children (GladeWidget *widget)
3719
3732
{
3720
3733
  GList *adapter_children;
3721
3734
  GList *real_children = NULL;
3747
3760
 * Returns: The toplevel #GladeWidget in the hierarchy (or @widget)
3748
3761
 */
3749
3762
GladeWidget *
3750
 
glade_widget_get_toplevel (GladeWidget * widget)
 
3763
glade_widget_get_toplevel (GladeWidget *widget)
3751
3764
{
3752
3765
  GladeWidget *toplevel = widget;
3753
3766
  g_return_val_if_fail (GLADE_IS_WIDGET (widget), NULL);
3769
3782
 * has changed, the current list is freed and replaced.
3770
3783
 */
3771
3784
void
3772
 
glade_widget_set_packing_properties (GladeWidget * widget,
3773
 
                                     GladeWidget * container)
 
3785
glade_widget_set_packing_properties (GladeWidget *widget, 
 
3786
                                     GladeWidget *container)
3774
3787
{
3775
3788
  GList *list;
3776
3789
 
3848
3861
 *          or any decendants that implement the @type interface
3849
3862
 */
3850
3863
gboolean
3851
 
glade_widget_has_decendant (GladeWidget * widget, GType type)
 
3864
glade_widget_has_decendant (GladeWidget *widget, GType type)
3852
3865
{
3853
3866
  GladeWidget *child;
3854
3867
  GList *children, *l;
3881
3894
 * Note that both GObjects must be owned by a GladeWidget.
3882
3895
 */
3883
3896
void
3884
 
glade_widget_replace (GladeWidget * parent, GObject * old_object,
3885
 
                      GObject * new_object)
 
3897
glade_widget_replace (GladeWidget *parent,
 
3898
                      GObject     *old_object, 
 
3899
                      GObject     *new_object)
3886
3900
{
3887
3901
  g_return_if_fail (G_IS_OBJECT (old_object));
3888
3902
  g_return_if_fail (G_IS_OBJECT (new_object));
3896
3910
 *******************************************************************************/
3897
3911
/* XXX Doc me !*/
3898
3912
void
3899
 
glade_widget_write_special_child_prop (GladeWidget * parent,
3900
 
                                       GObject * object,
3901
 
                                       GladeXmlContext * context,
3902
 
                                       GladeXmlNode * node)
 
3913
glade_widget_write_special_child_prop (GladeWidget     *parent,
 
3914
                                       GObject         *object,
 
3915
                                       GladeXmlContext *context,
 
3916
                                       GladeXmlNode    *node)
3903
3917
{
3904
3918
  gchar *buff, *special_child_type;
3905
3919
 
3916
3930
 
3917
3931
/* XXX Doc me ! */
3918
3932
void
3919
 
glade_widget_set_child_type_from_node (GladeWidget * parent,
3920
 
                                       GObject * child, GladeXmlNode * node)
 
3933
glade_widget_set_child_type_from_node (GladeWidget  *parent,
 
3934
                                       GObject      *child,
 
3935
                                       GladeXmlNode *node)
3921
3936
{
3922
3937
  gchar *special_child_type, *value;
3923
3938
 
3947
3962
 * Reads in a child widget from the xml (handles 'child' tag)
3948
3963
 */
3949
3964
void
3950
 
glade_widget_read_child (GladeWidget * widget, GladeXmlNode * node)
 
3965
glade_widget_read_child (GladeWidget *widget, GladeXmlNode *node)
3951
3966
{
3952
3967
  if (glade_project_load_cancelled (widget->priv->project))
3953
3968
    return;
3964
3979
 * Returns: a new #GladeWidget for @project, based on @node
3965
3980
 */
3966
3981
GladeWidget *
3967
 
glade_widget_read (GladeProject * project,
3968
 
                   GladeWidget * parent,
3969
 
                   GladeXmlNode * node, const gchar * internal)
 
3982
glade_widget_read (GladeProject *project,
 
3983
                   GladeWidget  *parent,
 
3984
                   GladeXmlNode *node,
 
3985
                   const gchar  *internal)
3970
3986
{
3971
3987
  GladeWidgetAdaptor *adaptor;
3972
3988
  GladeWidget *widget = NULL;
4088
4104
 * of packing properties and special child types.
4089
4105
 */
4090
4106
void
4091
 
glade_widget_write_child (GladeWidget * widget,
4092
 
                          GladeWidget * child,
4093
 
                          GladeXmlContext * context, GladeXmlNode * node)
 
4107
glade_widget_write_child (GladeWidget     *widget,
 
4108
                          GladeWidget     *child,
 
4109
                          GladeXmlContext *context,
 
4110
                          GladeXmlNode    *node)
4094
4111
{
4095
4112
  g_return_if_fail (GLADE_IS_WIDGET (widget));
4096
4113
  g_return_if_fail (GLADE_IS_WIDGET (child));
4110
4127
 * Writes out a placeholder to the xml
4111
4128
 */
4112
4129
void
4113
 
glade_widget_write_placeholder (GladeWidget * parent,
4114
 
                                GObject * object,
4115
 
                                GladeXmlContext * context, GladeXmlNode * node)
 
4130
glade_widget_write_placeholder (GladeWidget     *parent,
 
4131
                                GObject         *object,
 
4132
                                GladeXmlContext *context,
 
4133
                                GladeXmlNode    *node)
4116
4134
{
4117
4135
  GladeXmlNode *child_node, *packing_node, *placeholder_node;
4118
4136
 
4136
4154
}
4137
4155
 
4138
4156
static gint
4139
 
signal_compare (GladeSignal *signal_a,
4140
 
                GladeSignal *signal_b)
 
4157
signal_compare (GladeSignal *signal_a, GladeSignal *signal_b)
4141
4158
{
4142
4159
  const gchar *handler_a;
4143
4160
  const gchar *handler_b;
4198
4215
}
4199
4216
 
4200
4217
void
4201
 
glade_widget_write_signals (GladeWidget * widget,
4202
 
                            GladeXmlContext * context, GladeXmlNode * node)
 
4218
glade_widget_write_signals (GladeWidget     *widget,
 
4219
                            GladeXmlContext *context,
 
4220
                            GladeXmlNode    *node)
4203
4221
{
4204
4222
  GHashTableIter iter;
4205
4223
  gpointer key, value;
4246
4264
 * and appends the created #GladeXmlNode to @node.
4247
4265
 */
4248
4266
void
4249
 
glade_widget_write (GladeWidget * widget,
4250
 
                    GladeXmlContext * context, GladeXmlNode * node)
 
4267
glade_widget_write (GladeWidget     *widget,
 
4268
                    GladeXmlContext *context,
 
4269
                    GladeXmlNode    *node)
4251
4270
{
4252
4271
  GObject *object = glade_widget_get_object (widget);
4253
4272
  GladeXmlNode *widget_node;
4328
4347
 *    grandchild, great grandchild, etc.
4329
4348
 **/
4330
4349
gboolean
4331
 
glade_widget_is_ancestor (GladeWidget * widget, GladeWidget * ancestor)
 
4350
glade_widget_is_ancestor (GladeWidget *widget, GladeWidget *ancestor)
4332
4351
{
4333
4352
  g_return_val_if_fail (GLADE_IS_WIDGET (widget), FALSE);
4334
4353
  g_return_val_if_fail (GLADE_IS_WIDGET (ancestor), FALSE);
4359
4378
 * Deprecated: 3.18 
4360
4379
 **/
4361
4380
gboolean
4362
 
glade_widget_depends (GladeWidget      *widget,
4363
 
                      GladeWidget      *other)
 
4381
glade_widget_depends (GladeWidget *widget, GladeWidget *other)
4364
4382
{
4365
4383
  return FALSE;
4366
4384
}
4448
4466
 * Returns: whether to use placeholders for this relationship.
4449
4467
 */
4450
4468
gboolean
4451
 
glade_widget_placeholder_relation (GladeWidget * parent, GladeWidget * widget)
 
4469
glade_widget_placeholder_relation (GladeWidget *parent, GladeWidget *widget)
4452
4470
{
4453
4471
  g_return_val_if_fail (GLADE_IS_WIDGET (parent), FALSE);
4454
4472
  g_return_val_if_fail (GLADE_IS_WIDGET (widget), FALSE);
4459
4477
}
4460
4478
 
4461
4479
static GladeWidgetAction *
4462
 
glade_widget_action_lookup (GList *actions, const gchar * path)
 
4480
glade_widget_action_lookup (GList *actions, const gchar *path)
4463
4481
{
4464
4482
  GList *l;
4465
4483
 
4491
4509
 * Returns: the action or NULL if not found.
4492
4510
 */
4493
4511
GladeWidgetAction *
4494
 
glade_widget_get_action (GladeWidget * widget, const gchar * action_path)
 
4512
glade_widget_get_action (GladeWidget *widget, const gchar *action_path)
4495
4513
{
4496
4514
  g_return_val_if_fail (GLADE_IS_WIDGET (widget), NULL);
4497
4515
  g_return_val_if_fail (action_path != NULL, NULL);
4509
4527
 * Returns: the action or NULL if not found.
4510
4528
 */
4511
4529
GladeWidgetAction *
4512
 
glade_widget_get_pack_action (GladeWidget * widget, const gchar * action_path)
 
4530
glade_widget_get_pack_action (GladeWidget *widget, const gchar *action_path)
4513
4531
{
4514
4532
  g_return_val_if_fail (GLADE_IS_WIDGET (widget), NULL);
4515
4533
  g_return_val_if_fail (action_path != NULL, NULL);
4546
4564
 * Returns: whether @action_path was found or not.
4547
4565
 */
4548
4566
gboolean
4549
 
glade_widget_set_action_sensitive (GladeWidget * widget,
4550
 
                                   const gchar * action_path,
4551
 
                                   gboolean sensitive)
 
4567
glade_widget_set_action_sensitive (GladeWidget *widget,
 
4568
                                   const gchar *action_path,
 
4569
                                   gboolean     sensitive)
4552
4570
{
4553
4571
  GladeWidgetAction *action;
4554
4572
 
4573
4591
 * Returns: whether @action_path was found or not.
4574
4592
 */
4575
4593
gboolean
4576
 
glade_widget_set_pack_action_sensitive (GladeWidget * widget,
4577
 
                                        const gchar * action_path,
4578
 
                                        gboolean sensitive)
 
4594
glade_widget_set_pack_action_sensitive (GladeWidget *widget,
 
4595
                                        const gchar *action_path,
 
4596
                                        gboolean     sensitive)
4579
4597
{
4580
4598
  GladeWidgetAction *action;
4581
4599
 
4658
4676
 * Returns: A newly created and connected GladeEditorProperty
4659
4677
 */
4660
4678
GladeEditorProperty *
4661
 
glade_widget_create_editor_property (GladeWidget * widget,
4662
 
                                     const gchar * property,
4663
 
                                     gboolean packing, gboolean use_command)
 
4679
glade_widget_create_editor_property (GladeWidget *widget,
 
4680
                                     const gchar *property,
 
4681
                                     gboolean     packing,
 
4682
                                     gboolean     use_command)
4664
4683
{
4665
4684
  GladeEditorProperty *eprop;
4666
4685
  GladeProperty       *prop;
4690
4709
 * Returns: A newly allocated string
4691
4710
 */
4692
4711
gchar *
4693
 
glade_widget_generate_path_name (GladeWidget * widget)
 
4712
glade_widget_generate_path_name (GladeWidget *widget)
4694
4713
{
4695
4714
  GString *string;
4696
4715
  GladeWidget *iter;
4718
4737
 * This function will update the widget's support warning.
4719
4738
 */
4720
4739
void
4721
 
glade_widget_verify (GladeWidget      *widget)
 
4740
glade_widget_verify (GladeWidget *widget)
4722
4741
{
4723
4742
  gchar *warning = NULL;
4724
4743
  GList *warn_properties = NULL;
4839
4858
}
4840
4859
 
4841
4860
void
4842
 
glade_widget_set_support_warning (GladeWidget * widget, const gchar * warning)
 
4861
glade_widget_set_support_warning (GladeWidget *widget, const gchar *warning)
4843
4862
{
4844
4863
  g_return_if_fail (GLADE_IS_WIDGET (widget));
4845
4864
 
4873
4892
 *
4874
4893
 */
4875
4894
void
4876
 
glade_widget_lock (GladeWidget * widget, GladeWidget * locked)
 
4895
glade_widget_lock (GladeWidget *widget, GladeWidget *locked)
4877
4896
{
4878
4897
  g_return_if_fail (GLADE_IS_WIDGET (widget));
4879
4898
  g_return_if_fail (GLADE_IS_WIDGET (locked));
4892
4911
 *
4893
4912
 */
4894
4913
void
4895
 
glade_widget_unlock (GladeWidget * widget)
 
4914
glade_widget_unlock (GladeWidget *widget)
4896
4915
{
4897
4916
  GladeWidget *lock;
4898
4917
 
4933
4952
 *
4934
4953
 */
4935
4954
void
4936
 
glade_widget_support_changed (GladeWidget * widget)
 
4955
glade_widget_support_changed (GladeWidget *widget)
4937
4956
{
4938
4957
  g_return_if_fail (GLADE_IS_WIDGET (widget));
4939
4958