1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
|
/* GTK - The GIMP Toolkit
* Copyright (C) 2006-2007 Async Open Source,
* Johan Dahlin <jdahlin@async.com.br>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#if !defined (__GTK_H_INSIDE__) && !defined (GTK_COMPILATION)
#error "Only <gtk/gtk.h> can be included directly."
#endif
#include <gtk/gtkbuilder.h>
G_BEGIN_DECLS
#define GTK_TYPE_BUILDABLE (gtk_buildable_get_type ())
#define GTK_BUILDABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_BUILDABLE, GtkBuildable))
#define GTK_IS_BUILDABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_BUILDABLE))
#define GTK_BUILDABLE_GET_IFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GTK_TYPE_BUILDABLE, GtkBuildableIface))
typedef struct _GtkBuildable GtkBuildable; /* Dummy typedef */
typedef struct _GtkBuildableIface GtkBuildableIface;
typedef struct _GtkBuildableParseContext GtkBuildableParseContext;
typedef struct _GtkBuildableParser GtkBuildableParser;
/**
* GtkBuildableParseContext:
*
* Provides context for parsing GtkBuilder UI files.
*
* `GtkBuildableParseContext` is an opaque struct.
*/
/**
* GtkBuildableParser:
* @start_element: function called for open elements
* @end_element: function called for close elements
* @text: function called for character data
* @error: function called on error
*
* A sub-parser for `GtkBuildable` implementations.
*/
struct _GtkBuildableParser
{
/* Called for open tags <foo bar="baz"> */
void (*start_element) (GtkBuildableParseContext *context,
const char *element_name,
const char **attribute_names,
const char **attribute_values,
gpointer user_data,
GError **error);
/* Called for close tags </foo> */
void (*end_element) (GtkBuildableParseContext *context,
const char *element_name,
gpointer user_data,
GError **error);
/* Called for character data */
/* text is not nul-terminated */
void (*text) (GtkBuildableParseContext *context,
const char *text,
gsize text_len,
gpointer user_data,
GError **error);
/* Called on error, including one set by other
* methods in the vtable. The GError should not be freed.
*/
void (*error) (GtkBuildableParseContext *context,
GError *error,
gpointer user_data);
/*< private >*/
gpointer padding[4];
};
/**
* GtkBuildableIface:
* @g_iface: the parent class
* @set_id: Stores the id attribute given in the `GtkBuilder` UI definition.
* `GtkWidget` stores the name as object data. Implement this method if your
* object has some notion of “ID” and it makes sense to map the XML id
* attribute to it.
* @get_id: The getter corresponding to @set_id. Implement this
* if you implement @set_id.
* @add_child: Adds a child. The @type parameter can be used to
* differentiate the kind of child. `GtkWidget` implements this
* to add event controllers to the widget, `GtkNotebook` uses
* the @type to distinguish between page labels (of type "page-label")
* and normal children.
* @set_buildable_property: Sets a property of a buildable object.
* It is normally not necessary to implement this, g_object_set_property()
* is used by default. `GtkWindow` implements this to delay showing itself
* (i.e. setting the [property@Gtk.Widget:visible] property) until the whole
* interface is created.
* @construct_child: Constructs a child of a buildable that has been
* specified as “constructor” in the UI definition. This can be used to
* reference a widget created in a `<ui>` tag which is outside
* of the normal GtkBuilder UI definition hierarchy. A reference to the
* constructed object is returned and becomes owned by the caller.
* @custom_tag_start: Implement this if the buildable needs to parse
* content below `<child>`. To handle an element, the implementation
* must fill in the @parser and @user_data and return %TRUE.
* `GtkWidget` implements this to parse accessible attributes specified
* in `<accessibility>` elements.
* Note that @user_data must be freed in @custom_tag_end or @custom_finished.
* @custom_tag_end: Called for the end tag of each custom element that is
* handled by the buildable (see @custom_tag_start).
* @custom_finished: Called for each custom tag handled by the buildable
* when the builder finishes parsing (see @custom_tag_start)
* @parser_finished: Called when a builder finishes the parsing
* of a UI definition. It is normally not necessary to implement this,
* unless you need to perform special cleanup actions. `GtkWindow` sets
* the `GtkWidget:visible` property here.
* @get_internal_child: Returns an internal child of a buildable.
* `GtkDialog` implements this to give access to its @vbox, making
* it possible to add children to the vbox in a UI definition.
* Implement this if the buildable has internal children that may
* need to be accessed from a UI definition.
*
* Contains methods to let `GtkBuilder` construct an object from
* a `GtkBuilder` UI definition.
*/
struct _GtkBuildableIface
{
GTypeInterface g_iface;
/* virtual table */
void (* set_id) (GtkBuildable *buildable,
const char *id);
const char * (* get_id) (GtkBuildable *buildable);
/**
* GtkBuildableIface::add_child:
* @buildable: a `GtkBuildable`
* @builder: a `GtkBuilder`
* @child: child to add
* @type: (nullable): kind of child or %NULL
*
* Adds a child to @buildable. @type is an optional string
* describing how the child should be added.
*/
void (* add_child) (GtkBuildable *buildable,
GtkBuilder *builder,
GObject *child,
const char *type);
void (* set_buildable_property) (GtkBuildable *buildable,
GtkBuilder *builder,
const char *name,
const GValue *value);
GObject * (* construct_child) (GtkBuildable *buildable,
GtkBuilder *builder,
const char *name);
/**
* GtkBuildableIface::custom_tag_start:
* @buildable: a `GtkBuildable`
* @builder: a `GtkBuilder` used to construct this object
* @child: (nullable): child object or %NULL for non-child tags
* @tagname: name of tag
* @parser: (out): a `GtkBuildableParser` to fill in
* @data: (out): return location for user data that will be passed in
* to parser functions
*
* Called for each unknown element under `<child>`.
*
* Returns: %TRUE if an object has a custom implementation, %FALSE
* if it doesn't.
*/
gboolean (* custom_tag_start) (GtkBuildable *buildable,
GtkBuilder *builder,
GObject *child,
const char *tagname,
GtkBuildableParser *parser,
gpointer *data);
/**
* GtkBuildableIface::custom_tag_end:
* @buildable: A `GtkBuildable`
* @builder: `GtkBuilder` used to construct this object
* @child: (nullable): child object or %NULL for non-child tags
* @tagname: name of tag
* @data: user data that will be passed in to parser functions
*
* Called at the end of each custom element handled by
* the buildable.
*/
void (* custom_tag_end) (GtkBuildable *buildable,
GtkBuilder *builder,
GObject *child,
const char *tagname,
gpointer data);
/**
* GtkBuildableIface::custom_finished:
* @buildable: a `GtkBuildable`
* @builder: a `GtkBuilder`
* @child: (nullable): child object or %NULL for non-child tags
* @tagname: the name of the tag
* @data: user data created in custom_tag_start
*
* Similar to gtk_buildable_parser_finished() but is
* called once for each custom tag handled by the @buildable.
*/
void (* custom_finished) (GtkBuildable *buildable,
GtkBuilder *builder,
GObject *child,
const char *tagname,
gpointer data);
void (* parser_finished) (GtkBuildable *buildable,
GtkBuilder *builder);
/**
* GtkBuildableIface::get_internal_child:
* @buildable: a `GtkBuildable`
* @builder: a `GtkBuilder`
* @childname: name of child
*
* Retrieves the internal child called @childname of the @buildable object.
*
* Returns: (transfer none): the internal child of the buildable object
*/
GObject * (* get_internal_child) (GtkBuildable *buildable,
GtkBuilder *builder,
const char *childname);
};
GDK_AVAILABLE_IN_ALL
GType gtk_buildable_get_type (void) G_GNUC_CONST;
GDK_AVAILABLE_IN_ALL
const char * gtk_buildable_get_buildable_id (GtkBuildable *buildable);
GDK_AVAILABLE_IN_ALL
void gtk_buildable_parse_context_push (GtkBuildableParseContext *context,
const GtkBuildableParser *parser,
gpointer user_data);
GDK_AVAILABLE_IN_ALL
gpointer gtk_buildable_parse_context_pop (GtkBuildableParseContext *context);
GDK_AVAILABLE_IN_ALL
const char * gtk_buildable_parse_context_get_element (GtkBuildableParseContext *context);
GDK_AVAILABLE_IN_ALL
GPtrArray *gtk_buildable_parse_context_get_element_stack (GtkBuildableParseContext *context);
GDK_AVAILABLE_IN_ALL
void gtk_buildable_parse_context_get_position (GtkBuildableParseContext *context,
int *line_number,
int *char_number);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(GtkBuildable, g_object_unref)
G_END_DECLS
|
