← Back to branch summary

~ubuntu-branches/ubuntu/raring/rygel/raring

« back to all changes in this revision

Viewing changes to doc/reference/librygel-server/gtkdoc/librygel-server-decl.txt

  • Committer: Package Import Robot
  • Author(s): Andreas Henriksson
  • Date: 2012-09-26 22:34:15 UTC
  • mfrom: (11.1.19 experimental)
  • Revision ID: package-import@ubuntu.com-20120926223415-9day2s783n9td4e8
Tags: 0.16.0-1
Imported Upstream version 0.16.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
doc/reference/librygel-server/gtkdoc/librygel-server-decl.txt
 
1
<MACRO>
 
2
<NAME>RYGEL_TYPE_MEDIA_OBJECT</NAME>
 
3
#define RYGEL_TYPE_MEDIA_OBJECT (rygel_media_object_get_type ())
 
4
</MACRO>
 
5
<MACRO>
 
6
<NAME>RYGEL_MEDIA_OBJECT</NAME>
 
7
#define RYGEL_MEDIA_OBJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_MEDIA_OBJECT, RygelMediaObject))
 
8
</MACRO>
 
9
<MACRO>
 
10
<NAME>RYGEL_MEDIA_OBJECT_CLASS</NAME>
 
11
#define RYGEL_MEDIA_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_MEDIA_OBJECT, RygelMediaObjectClass))
 
12
</MACRO>
 
13
<MACRO>
 
14
<NAME>RYGEL_IS_MEDIA_OBJECT</NAME>
 
15
#define RYGEL_IS_MEDIA_OBJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_MEDIA_OBJECT))
 
16
</MACRO>
 
17
<MACRO>
 
18
<NAME>RYGEL_IS_MEDIA_OBJECT_CLASS</NAME>
 
19
#define RYGEL_IS_MEDIA_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_MEDIA_OBJECT))
 
20
</MACRO>
 
21
<MACRO>
 
22
<NAME>RYGEL_MEDIA_OBJECT_GET_CLASS</NAME>
 
23
#define RYGEL_MEDIA_OBJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_MEDIA_OBJECT, RygelMediaObjectClass))
 
24
</MACRO>
 
25
<MACRO>
 
26
<NAME>RYGEL_TYPE_TRANSCODE_MANAGER</NAME>
 
27
#define RYGEL_TYPE_TRANSCODE_MANAGER (rygel_transcode_manager_get_type ())
 
28
</MACRO>
 
29
<MACRO>
 
30
<NAME>RYGEL_TRANSCODE_MANAGER</NAME>
 
31
#define RYGEL_TRANSCODE_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_TRANSCODE_MANAGER, RygelTranscodeManager))
 
32
</MACRO>
 
33
<MACRO>
 
34
<NAME>RYGEL_TRANSCODE_MANAGER_CLASS</NAME>
 
35
#define RYGEL_TRANSCODE_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_TRANSCODE_MANAGER, RygelTranscodeManagerClass))
 
36
</MACRO>
 
37
<MACRO>
 
38
<NAME>RYGEL_IS_TRANSCODE_MANAGER</NAME>
 
39
#define RYGEL_IS_TRANSCODE_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_TRANSCODE_MANAGER))
 
40
</MACRO>
 
41
<MACRO>
 
42
<NAME>RYGEL_IS_TRANSCODE_MANAGER_CLASS</NAME>
 
43
#define RYGEL_IS_TRANSCODE_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_TRANSCODE_MANAGER))
 
44
</MACRO>
 
45
<MACRO>
 
46
<NAME>RYGEL_TRANSCODE_MANAGER_GET_CLASS</NAME>
 
47
#define RYGEL_TRANSCODE_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_TRANSCODE_MANAGER, RygelTranscodeManagerClass))
 
48
</MACRO>
 
49
<MACRO>
 
50
<NAME>RYGEL_TYPE_HTTP_SERVER</NAME>
 
51
#define RYGEL_TYPE_HTTP_SERVER (rygel_http_server_get_type ())
 
52
</MACRO>
 
53
<MACRO>
 
54
<NAME>RYGEL_HTTP_SERVER</NAME>
 
55
#define RYGEL_HTTP_SERVER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_HTTP_SERVER, RygelHTTPServer))
 
56
</MACRO>
 
57
<MACRO>
 
58
<NAME>RYGEL_HTTP_SERVER_CLASS</NAME>
 
59
#define RYGEL_HTTP_SERVER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_HTTP_SERVER, RygelHTTPServerClass))
 
60
</MACRO>
 
61
<MACRO>
 
62
<NAME>RYGEL_IS_HTTP_SERVER</NAME>
 
63
#define RYGEL_IS_HTTP_SERVER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_HTTP_SERVER))
 
64
</MACRO>
 
65
<MACRO>
 
66
<NAME>RYGEL_IS_HTTP_SERVER_CLASS</NAME>
 
67
#define RYGEL_IS_HTTP_SERVER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_HTTP_SERVER))
 
68
</MACRO>
 
69
<MACRO>
 
70
<NAME>RYGEL_HTTP_SERVER_GET_CLASS</NAME>
 
71
#define RYGEL_HTTP_SERVER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_HTTP_SERVER, RygelHTTPServerClass))
 
72
</MACRO>
 
73
<MACRO>
 
74
<NAME>RYGEL_TYPE_MEDIA_CONTAINER</NAME>
 
75
#define RYGEL_TYPE_MEDIA_CONTAINER (rygel_media_container_get_type ())
 
76
</MACRO>
 
77
<MACRO>
 
78
<NAME>RYGEL_MEDIA_CONTAINER</NAME>
 
79
#define RYGEL_MEDIA_CONTAINER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_MEDIA_CONTAINER, RygelMediaContainer))
 
80
</MACRO>
 
81
<MACRO>
 
82
<NAME>RYGEL_MEDIA_CONTAINER_CLASS</NAME>
 
83
#define RYGEL_MEDIA_CONTAINER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_MEDIA_CONTAINER, RygelMediaContainerClass))
 
84
</MACRO>
 
85
<MACRO>
 
86
<NAME>RYGEL_IS_MEDIA_CONTAINER</NAME>
 
87
#define RYGEL_IS_MEDIA_CONTAINER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_MEDIA_CONTAINER))
 
88
</MACRO>
 
89
<MACRO>
 
90
<NAME>RYGEL_IS_MEDIA_CONTAINER_CLASS</NAME>
 
91
#define RYGEL_IS_MEDIA_CONTAINER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_MEDIA_CONTAINER))
 
92
</MACRO>
 
93
<MACRO>
 
94
<NAME>RYGEL_MEDIA_CONTAINER_GET_CLASS</NAME>
 
95
#define RYGEL_MEDIA_CONTAINER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_MEDIA_CONTAINER, RygelMediaContainerClass))
 
96
</MACRO>
 
97
<MACRO>
 
98
<NAME>RYGEL_TYPE_MEDIA_ITEM</NAME>
 
99
#define RYGEL_TYPE_MEDIA_ITEM (rygel_media_item_get_type ())
 
100
</MACRO>
 
101
<MACRO>
 
102
<NAME>RYGEL_MEDIA_ITEM</NAME>
 
103
#define RYGEL_MEDIA_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_MEDIA_ITEM, RygelMediaItem))
 
104
</MACRO>
 
105
<MACRO>
 
106
<NAME>RYGEL_MEDIA_ITEM_CLASS</NAME>
 
107
#define RYGEL_MEDIA_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_MEDIA_ITEM, RygelMediaItemClass))
 
108
</MACRO>
 
109
<MACRO>
 
110
<NAME>RYGEL_IS_MEDIA_ITEM</NAME>
 
111
#define RYGEL_IS_MEDIA_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_MEDIA_ITEM))
 
112
</MACRO>
 
113
<MACRO>
 
114
<NAME>RYGEL_IS_MEDIA_ITEM_CLASS</NAME>
 
115
#define RYGEL_IS_MEDIA_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_MEDIA_ITEM))
 
116
</MACRO>
 
117
<MACRO>
 
118
<NAME>RYGEL_MEDIA_ITEM_GET_CLASS</NAME>
 
119
#define RYGEL_MEDIA_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_MEDIA_ITEM, RygelMediaItemClass))
 
120
</MACRO>
 
121
<MACRO>
 
122
<NAME>RYGEL_TYPE_AUDIO_ITEM</NAME>
 
123
#define RYGEL_TYPE_AUDIO_ITEM (rygel_audio_item_get_type ())
 
124
</MACRO>
 
125
<MACRO>
 
126
<NAME>RYGEL_AUDIO_ITEM</NAME>
 
127
#define RYGEL_AUDIO_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_AUDIO_ITEM, RygelAudioItem))
 
128
</MACRO>
 
129
<MACRO>
 
130
<NAME>RYGEL_AUDIO_ITEM_CLASS</NAME>
 
131
#define RYGEL_AUDIO_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_AUDIO_ITEM, RygelAudioItemClass))
 
132
</MACRO>
 
133
<MACRO>
 
134
<NAME>RYGEL_IS_AUDIO_ITEM</NAME>
 
135
#define RYGEL_IS_AUDIO_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_AUDIO_ITEM))
 
136
</MACRO>
 
137
<MACRO>
 
138
<NAME>RYGEL_IS_AUDIO_ITEM_CLASS</NAME>
 
139
#define RYGEL_IS_AUDIO_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_AUDIO_ITEM))
 
140
</MACRO>
 
141
<MACRO>
 
142
<NAME>RYGEL_AUDIO_ITEM_GET_CLASS</NAME>
 
143
#define RYGEL_AUDIO_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_AUDIO_ITEM, RygelAudioItemClass))
 
144
</MACRO>
 
145
<MACRO>
 
146
<NAME>RYGEL_TYPE_VISUAL_ITEM</NAME>
 
147
#define RYGEL_TYPE_VISUAL_ITEM (rygel_visual_item_get_type ())
 
148
</MACRO>
 
149
<MACRO>
 
150
<NAME>RYGEL_VISUAL_ITEM</NAME>
 
151
#define RYGEL_VISUAL_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_VISUAL_ITEM, RygelVisualItem))
 
152
</MACRO>
 
153
<MACRO>
 
154
<NAME>RYGEL_IS_VISUAL_ITEM</NAME>
 
155
#define RYGEL_IS_VISUAL_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_VISUAL_ITEM))
 
156
</MACRO>
 
157
<MACRO>
 
158
<NAME>RYGEL_VISUAL_ITEM_GET_INTERFACE</NAME>
 
159
#define RYGEL_VISUAL_ITEM_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), RYGEL_TYPE_VISUAL_ITEM, RygelVisualItemIface))
 
160
</MACRO>
 
161
<MACRO>
 
162
<NAME>RYGEL_TYPE_THUMBNAIL</NAME>
 
163
#define RYGEL_TYPE_THUMBNAIL (rygel_thumbnail_get_type ())
 
164
</MACRO>
 
165
<MACRO>
 
166
<NAME>RYGEL_THUMBNAIL</NAME>
 
167
#define RYGEL_THUMBNAIL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_THUMBNAIL, RygelThumbnail))
 
168
</MACRO>
 
169
<MACRO>
 
170
<NAME>RYGEL_THUMBNAIL_CLASS</NAME>
 
171
#define RYGEL_THUMBNAIL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_THUMBNAIL, RygelThumbnailClass))
 
172
</MACRO>
 
173
<MACRO>
 
174
<NAME>RYGEL_IS_THUMBNAIL</NAME>
 
175
#define RYGEL_IS_THUMBNAIL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_THUMBNAIL))
 
176
</MACRO>
 
177
<MACRO>
 
178
<NAME>RYGEL_IS_THUMBNAIL_CLASS</NAME>
 
179
#define RYGEL_IS_THUMBNAIL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_THUMBNAIL))
 
180
</MACRO>
 
181
<MACRO>
 
182
<NAME>RYGEL_THUMBNAIL_GET_CLASS</NAME>
 
183
#define RYGEL_THUMBNAIL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_THUMBNAIL, RygelThumbnailClass))
 
184
</MACRO>
 
185
<MACRO>
 
186
<NAME>RYGEL_TYPE_IMAGE_ITEM</NAME>
 
187
#define RYGEL_TYPE_IMAGE_ITEM (rygel_image_item_get_type ())
 
188
</MACRO>
 
189
<MACRO>
 
190
<NAME>RYGEL_IMAGE_ITEM</NAME>
 
191
#define RYGEL_IMAGE_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_IMAGE_ITEM, RygelImageItem))
 
192
</MACRO>
 
193
<MACRO>
 
194
<NAME>RYGEL_IMAGE_ITEM_CLASS</NAME>
 
195
#define RYGEL_IMAGE_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_IMAGE_ITEM, RygelImageItemClass))
 
196
</MACRO>
 
197
<MACRO>
 
198
<NAME>RYGEL_IS_IMAGE_ITEM</NAME>
 
199
#define RYGEL_IS_IMAGE_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_IMAGE_ITEM))
 
200
</MACRO>
 
201
<MACRO>
 
202
<NAME>RYGEL_IS_IMAGE_ITEM_CLASS</NAME>
 
203
#define RYGEL_IS_IMAGE_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_IMAGE_ITEM))
 
204
</MACRO>
 
205
<MACRO>
 
206
<NAME>RYGEL_IMAGE_ITEM_GET_CLASS</NAME>
 
207
#define RYGEL_IMAGE_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_IMAGE_ITEM, RygelImageItemClass))
 
208
</MACRO>
 
209
<MACRO>
 
210
<NAME>RYGEL_TYPE_LOGICAL_OPERATOR</NAME>
 
211
#define RYGEL_TYPE_LOGICAL_OPERATOR (rygel_logical_operator_get_type ())
 
212
</MACRO>
 
213
<MACRO>
 
214
<NAME>RYGEL_TYPE_SEARCH_EXPRESSION</NAME>
 
215
#define RYGEL_TYPE_SEARCH_EXPRESSION (rygel_search_expression_get_type ())
 
216
</MACRO>
 
217
<MACRO>
 
218
<NAME>RYGEL_SEARCH_EXPRESSION</NAME>
 
219
#define RYGEL_SEARCH_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_SEARCH_EXPRESSION, RygelSearchExpression))
 
220
</MACRO>
 
221
<MACRO>
 
222
<NAME>RYGEL_SEARCH_EXPRESSION_CLASS</NAME>
 
223
#define RYGEL_SEARCH_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_SEARCH_EXPRESSION, RygelSearchExpressionClass))
 
224
</MACRO>
 
225
<MACRO>
 
226
<NAME>RYGEL_IS_SEARCH_EXPRESSION</NAME>
 
227
#define RYGEL_IS_SEARCH_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_SEARCH_EXPRESSION))
 
228
</MACRO>
 
229
<MACRO>
 
230
<NAME>RYGEL_IS_SEARCH_EXPRESSION_CLASS</NAME>
 
231
#define RYGEL_IS_SEARCH_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_SEARCH_EXPRESSION))
 
232
</MACRO>
 
233
<MACRO>
 
234
<NAME>RYGEL_SEARCH_EXPRESSION_GET_CLASS</NAME>
 
235
#define RYGEL_SEARCH_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_SEARCH_EXPRESSION, RygelSearchExpressionClass))
 
236
</MACRO>
 
237
<MACRO>
 
238
<NAME>RYGEL_TYPE_LOGICAL_EXPRESSION</NAME>
 
239
#define RYGEL_TYPE_LOGICAL_EXPRESSION (rygel_logical_expression_get_type ())
 
240
</MACRO>
 
241
<MACRO>
 
242
<NAME>RYGEL_LOGICAL_EXPRESSION</NAME>
 
243
#define RYGEL_LOGICAL_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_LOGICAL_EXPRESSION, RygelLogicalExpression))
 
244
</MACRO>
 
245
<MACRO>
 
246
<NAME>RYGEL_LOGICAL_EXPRESSION_CLASS</NAME>
 
247
#define RYGEL_LOGICAL_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_LOGICAL_EXPRESSION, RygelLogicalExpressionClass))
 
248
</MACRO>
 
249
<MACRO>
 
250
<NAME>RYGEL_IS_LOGICAL_EXPRESSION</NAME>
 
251
#define RYGEL_IS_LOGICAL_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_LOGICAL_EXPRESSION))
 
252
</MACRO>
 
253
<MACRO>
 
254
<NAME>RYGEL_IS_LOGICAL_EXPRESSION_CLASS</NAME>
 
255
#define RYGEL_IS_LOGICAL_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_LOGICAL_EXPRESSION))
 
256
</MACRO>
 
257
<MACRO>
 
258
<NAME>RYGEL_LOGICAL_EXPRESSION_GET_CLASS</NAME>
 
259
#define RYGEL_LOGICAL_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_LOGICAL_EXPRESSION, RygelLogicalExpressionClass))
 
260
</MACRO>
 
261
<MACRO>
 
262
<NAME>RYGEL_TYPE_MEDIA_ART_STORE</NAME>
 
263
#define RYGEL_TYPE_MEDIA_ART_STORE (rygel_media_art_store_get_type ())
 
264
</MACRO>
 
265
<MACRO>
 
266
<NAME>RYGEL_MEDIA_ART_STORE</NAME>
 
267
#define RYGEL_MEDIA_ART_STORE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_MEDIA_ART_STORE, RygelMediaArtStore))
 
268
</MACRO>
 
269
<MACRO>
 
270
<NAME>RYGEL_MEDIA_ART_STORE_CLASS</NAME>
 
271
#define RYGEL_MEDIA_ART_STORE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_MEDIA_ART_STORE, RygelMediaArtStoreClass))
 
272
</MACRO>
 
273
<MACRO>
 
274
<NAME>RYGEL_IS_MEDIA_ART_STORE</NAME>
 
275
#define RYGEL_IS_MEDIA_ART_STORE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_MEDIA_ART_STORE))
 
276
</MACRO>
 
277
<MACRO>
 
278
<NAME>RYGEL_IS_MEDIA_ART_STORE_CLASS</NAME>
 
279
#define RYGEL_IS_MEDIA_ART_STORE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_MEDIA_ART_STORE))
 
280
</MACRO>
 
281
<MACRO>
 
282
<NAME>RYGEL_MEDIA_ART_STORE_GET_CLASS</NAME>
 
283
#define RYGEL_MEDIA_ART_STORE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_MEDIA_ART_STORE, RygelMediaArtStoreClass))
 
284
</MACRO>
 
285
<MACRO>
 
286
<NAME>RYGEL_TYPE_MUSIC_ITEM</NAME>
 
287
#define RYGEL_TYPE_MUSIC_ITEM (rygel_music_item_get_type ())
 
288
</MACRO>
 
289
<MACRO>
 
290
<NAME>RYGEL_MUSIC_ITEM</NAME>
 
291
#define RYGEL_MUSIC_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_MUSIC_ITEM, RygelMusicItem))
 
292
</MACRO>
 
293
<MACRO>
 
294
<NAME>RYGEL_MUSIC_ITEM_CLASS</NAME>
 
295
#define RYGEL_MUSIC_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_MUSIC_ITEM, RygelMusicItemClass))
 
296
</MACRO>
 
297
<MACRO>
 
298
<NAME>RYGEL_IS_MUSIC_ITEM</NAME>
 
299
#define RYGEL_IS_MUSIC_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_MUSIC_ITEM))
 
300
</MACRO>
 
301
<MACRO>
 
302
<NAME>RYGEL_IS_MUSIC_ITEM_CLASS</NAME>
 
303
#define RYGEL_IS_MUSIC_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_MUSIC_ITEM))
 
304
</MACRO>
 
305
<MACRO>
 
306
<NAME>RYGEL_MUSIC_ITEM_GET_CLASS</NAME>
 
307
#define RYGEL_MUSIC_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_MUSIC_ITEM, RygelMusicItemClass))
 
308
</MACRO>
 
309
<MACRO>
 
310
<NAME>RYGEL_TYPE_MEDIA_OBJECTS</NAME>
 
311
#define RYGEL_TYPE_MEDIA_OBJECTS (rygel_media_objects_get_type ())
 
312
</MACRO>
 
313
<MACRO>
 
314
<NAME>RYGEL_MEDIA_OBJECTS</NAME>
 
315
#define RYGEL_MEDIA_OBJECTS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_MEDIA_OBJECTS, RygelMediaObjects))
 
316
</MACRO>
 
317
<MACRO>
 
318
<NAME>RYGEL_MEDIA_OBJECTS_CLASS</NAME>
 
319
#define RYGEL_MEDIA_OBJECTS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_MEDIA_OBJECTS, RygelMediaObjectsClass))
 
320
</MACRO>
 
321
<MACRO>
 
322
<NAME>RYGEL_IS_MEDIA_OBJECTS</NAME>
 
323
#define RYGEL_IS_MEDIA_OBJECTS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_MEDIA_OBJECTS))
 
324
</MACRO>
 
325
<MACRO>
 
326
<NAME>RYGEL_IS_MEDIA_OBJECTS_CLASS</NAME>
 
327
#define RYGEL_IS_MEDIA_OBJECTS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_MEDIA_OBJECTS))
 
328
</MACRO>
 
329
<MACRO>
 
330
<NAME>RYGEL_MEDIA_OBJECTS_GET_CLASS</NAME>
 
331
#define RYGEL_MEDIA_OBJECTS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_MEDIA_OBJECTS, RygelMediaObjectsClass))
 
332
</MACRO>
 
333
<MACRO>
 
334
<NAME>RYGEL_TYPE_PHOTO_ITEM</NAME>
 
335
#define RYGEL_TYPE_PHOTO_ITEM (rygel_photo_item_get_type ())
 
336
</MACRO>
 
337
<MACRO>
 
338
<NAME>RYGEL_PHOTO_ITEM</NAME>
 
339
#define RYGEL_PHOTO_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_PHOTO_ITEM, RygelPhotoItem))
 
340
</MACRO>
 
341
<MACRO>
 
342
<NAME>RYGEL_PHOTO_ITEM_CLASS</NAME>
 
343
#define RYGEL_PHOTO_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_PHOTO_ITEM, RygelPhotoItemClass))
 
344
</MACRO>
 
345
<MACRO>
 
346
<NAME>RYGEL_IS_PHOTO_ITEM</NAME>
 
347
#define RYGEL_IS_PHOTO_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_PHOTO_ITEM))
 
348
</MACRO>
 
349
<MACRO>
 
350
<NAME>RYGEL_IS_PHOTO_ITEM_CLASS</NAME>
 
351
#define RYGEL_IS_PHOTO_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_PHOTO_ITEM))
 
352
</MACRO>
 
353
<MACRO>
 
354
<NAME>RYGEL_PHOTO_ITEM_GET_CLASS</NAME>
 
355
#define RYGEL_PHOTO_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_PHOTO_ITEM, RygelPhotoItemClass))
 
356
</MACRO>
 
357
<MACRO>
 
358
<NAME>RYGEL_TYPE_RELATIONAL_EXPRESSION</NAME>
 
359
#define RYGEL_TYPE_RELATIONAL_EXPRESSION (rygel_relational_expression_get_type ())
 
360
</MACRO>
 
361
<MACRO>
 
362
<NAME>RYGEL_RELATIONAL_EXPRESSION</NAME>
 
363
#define RYGEL_RELATIONAL_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_RELATIONAL_EXPRESSION, RygelRelationalExpression))
 
364
</MACRO>
 
365
<MACRO>
 
366
<NAME>RYGEL_RELATIONAL_EXPRESSION_CLASS</NAME>
 
367
#define RYGEL_RELATIONAL_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_RELATIONAL_EXPRESSION, RygelRelationalExpressionClass))
 
368
</MACRO>
 
369
<MACRO>
 
370
<NAME>RYGEL_IS_RELATIONAL_EXPRESSION</NAME>
 
371
#define RYGEL_IS_RELATIONAL_EXPRESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_RELATIONAL_EXPRESSION))
 
372
</MACRO>
 
373
<MACRO>
 
374
<NAME>RYGEL_IS_RELATIONAL_EXPRESSION_CLASS</NAME>
 
375
#define RYGEL_IS_RELATIONAL_EXPRESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_RELATIONAL_EXPRESSION))
 
376
</MACRO>
 
377
<MACRO>
 
378
<NAME>RYGEL_RELATIONAL_EXPRESSION_GET_CLASS</NAME>
 
379
#define RYGEL_RELATIONAL_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_RELATIONAL_EXPRESSION, RygelRelationalExpressionClass))
 
380
</MACRO>
 
381
<MACRO>
 
382
<NAME>RYGEL_TYPE_SEARCHABLE_CONTAINER</NAME>
 
383
#define RYGEL_TYPE_SEARCHABLE_CONTAINER (rygel_searchable_container_get_type ())
 
384
</MACRO>
 
385
<MACRO>
 
386
<NAME>RYGEL_SEARCHABLE_CONTAINER</NAME>
 
387
#define RYGEL_SEARCHABLE_CONTAINER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_SEARCHABLE_CONTAINER, RygelSearchableContainer))
 
388
</MACRO>
 
389
<MACRO>
 
390
<NAME>RYGEL_IS_SEARCHABLE_CONTAINER</NAME>
 
391
#define RYGEL_IS_SEARCHABLE_CONTAINER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_SEARCHABLE_CONTAINER))
 
392
</MACRO>
 
393
<MACRO>
 
394
<NAME>RYGEL_SEARCHABLE_CONTAINER_GET_INTERFACE</NAME>
 
395
#define RYGEL_SEARCHABLE_CONTAINER_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), RYGEL_TYPE_SEARCHABLE_CONTAINER, RygelSearchableContainerIface))
 
396
</MACRO>
 
397
<MACRO>
 
398
<NAME>RYGEL_TYPE_SIMPLE_CONTAINER</NAME>
 
399
#define RYGEL_TYPE_SIMPLE_CONTAINER (rygel_simple_container_get_type ())
 
400
</MACRO>
 
401
<MACRO>
 
402
<NAME>RYGEL_SIMPLE_CONTAINER</NAME>
 
403
#define RYGEL_SIMPLE_CONTAINER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_SIMPLE_CONTAINER, RygelSimpleContainer))
 
404
</MACRO>
 
405
<MACRO>
 
406
<NAME>RYGEL_SIMPLE_CONTAINER_CLASS</NAME>
 
407
#define RYGEL_SIMPLE_CONTAINER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_SIMPLE_CONTAINER, RygelSimpleContainerClass))
 
408
</MACRO>
 
409
<MACRO>
 
410
<NAME>RYGEL_IS_SIMPLE_CONTAINER</NAME>
 
411
#define RYGEL_IS_SIMPLE_CONTAINER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_SIMPLE_CONTAINER))
 
412
</MACRO>
 
413
<MACRO>
 
414
<NAME>RYGEL_IS_SIMPLE_CONTAINER_CLASS</NAME>
 
415
#define RYGEL_IS_SIMPLE_CONTAINER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_SIMPLE_CONTAINER))
 
416
</MACRO>
 
417
<MACRO>
 
418
<NAME>RYGEL_SIMPLE_CONTAINER_GET_CLASS</NAME>
 
419
#define RYGEL_SIMPLE_CONTAINER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_SIMPLE_CONTAINER, RygelSimpleContainerClass))
 
420
</MACRO>
 
421
<MACRO>
 
422
<NAME>RYGEL_TYPE_SUBTITLE</NAME>
 
423
#define RYGEL_TYPE_SUBTITLE (rygel_subtitle_get_type ())
 
424
</MACRO>
 
425
<MACRO>
 
426
<NAME>RYGEL_SUBTITLE</NAME>
 
427
#define RYGEL_SUBTITLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_SUBTITLE, RygelSubtitle))
 
428
</MACRO>
 
429
<MACRO>
 
430
<NAME>RYGEL_SUBTITLE_CLASS</NAME>
 
431
#define RYGEL_SUBTITLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_SUBTITLE, RygelSubtitleClass))
 
432
</MACRO>
 
433
<MACRO>
 
434
<NAME>RYGEL_IS_SUBTITLE</NAME>
 
435
#define RYGEL_IS_SUBTITLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_SUBTITLE))
 
436
</MACRO>
 
437
<MACRO>
 
438
<NAME>RYGEL_IS_SUBTITLE_CLASS</NAME>
 
439
#define RYGEL_IS_SUBTITLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_SUBTITLE))
 
440
</MACRO>
 
441
<MACRO>
 
442
<NAME>RYGEL_SUBTITLE_GET_CLASS</NAME>
 
443
#define RYGEL_SUBTITLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_SUBTITLE, RygelSubtitleClass))
 
444
</MACRO>
 
445
<MACRO>
 
446
<NAME>RYGEL_TYPE_VIDEO_ITEM</NAME>
 
447
#define RYGEL_TYPE_VIDEO_ITEM (rygel_video_item_get_type ())
 
448
</MACRO>
 
449
<MACRO>
 
450
<NAME>RYGEL_VIDEO_ITEM</NAME>
 
451
#define RYGEL_VIDEO_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_VIDEO_ITEM, RygelVideoItem))
 
452
</MACRO>
 
453
<MACRO>
 
454
<NAME>RYGEL_VIDEO_ITEM_CLASS</NAME>
 
455
#define RYGEL_VIDEO_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_VIDEO_ITEM, RygelVideoItemClass))
 
456
</MACRO>
 
457
<MACRO>
 
458
<NAME>RYGEL_IS_VIDEO_ITEM</NAME>
 
459
#define RYGEL_IS_VIDEO_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_VIDEO_ITEM))
 
460
</MACRO>
 
461
<MACRO>
 
462
<NAME>RYGEL_IS_VIDEO_ITEM_CLASS</NAME>
 
463
#define RYGEL_IS_VIDEO_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_VIDEO_ITEM))
 
464
</MACRO>
 
465
<MACRO>
 
466
<NAME>RYGEL_VIDEO_ITEM_GET_CLASS</NAME>
 
467
#define RYGEL_VIDEO_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_VIDEO_ITEM, RygelVideoItemClass))
 
468
</MACRO>
 
469
<MACRO>
 
470
<NAME>RYGEL_TYPE_MEDIA_SERVER_PLUGIN</NAME>
 
471
#define RYGEL_TYPE_MEDIA_SERVER_PLUGIN (rygel_media_server_plugin_get_type ())
 
472
</MACRO>
 
473
<MACRO>
 
474
<NAME>RYGEL_MEDIA_SERVER_PLUGIN</NAME>
 
475
#define RYGEL_MEDIA_SERVER_PLUGIN(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_MEDIA_SERVER_PLUGIN, RygelMediaServerPlugin))
 
476
</MACRO>
 
477
<MACRO>
 
478
<NAME>RYGEL_MEDIA_SERVER_PLUGIN_CLASS</NAME>
 
479
#define RYGEL_MEDIA_SERVER_PLUGIN_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_MEDIA_SERVER_PLUGIN, RygelMediaServerPluginClass))
 
480
</MACRO>
 
481
<MACRO>
 
482
<NAME>RYGEL_IS_MEDIA_SERVER_PLUGIN</NAME>
 
483
#define RYGEL_IS_MEDIA_SERVER_PLUGIN(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_MEDIA_SERVER_PLUGIN))
 
484
</MACRO>
 
485
<MACRO>
 
486
<NAME>RYGEL_IS_MEDIA_SERVER_PLUGIN_CLASS</NAME>
 
487
#define RYGEL_IS_MEDIA_SERVER_PLUGIN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_MEDIA_SERVER_PLUGIN))
 
488
</MACRO>
 
489
<MACRO>
 
490
<NAME>RYGEL_MEDIA_SERVER_PLUGIN_GET_CLASS</NAME>
 
491
#define RYGEL_MEDIA_SERVER_PLUGIN_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_MEDIA_SERVER_PLUGIN, RygelMediaServerPluginClass))
 
492
</MACRO>
 
493
<MACRO>
 
494
<NAME>RYGEL_TYPE_WRITABLE_CONTAINER</NAME>
 
495
#define RYGEL_TYPE_WRITABLE_CONTAINER (rygel_writable_container_get_type ())
 
496
</MACRO>
 
497
<MACRO>
 
498
<NAME>RYGEL_WRITABLE_CONTAINER</NAME>
 
499
#define RYGEL_WRITABLE_CONTAINER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_WRITABLE_CONTAINER, RygelWritableContainer))
 
500
</MACRO>
 
501
<MACRO>
 
502
<NAME>RYGEL_IS_WRITABLE_CONTAINER</NAME>
 
503
#define RYGEL_IS_WRITABLE_CONTAINER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_WRITABLE_CONTAINER))
 
504
</MACRO>
 
505
<MACRO>
 
506
<NAME>RYGEL_WRITABLE_CONTAINER_GET_INTERFACE</NAME>
 
507
#define RYGEL_WRITABLE_CONTAINER_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), RYGEL_TYPE_WRITABLE_CONTAINER, RygelWritableContainerIface))
 
508
</MACRO>
 
509
<MACRO>
 
510
<NAME>RYGEL_TYPE_MEDIA_SERVER</NAME>
 
511
#define RYGEL_TYPE_MEDIA_SERVER (rygel_media_server_get_type ())
 
512
</MACRO>
 
513
<MACRO>
 
514
<NAME>RYGEL_MEDIA_SERVER</NAME>
 
515
#define RYGEL_MEDIA_SERVER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), RYGEL_TYPE_MEDIA_SERVER, RygelMediaServer))
 
516
</MACRO>
 
517
<MACRO>
 
518
<NAME>RYGEL_MEDIA_SERVER_CLASS</NAME>
 
519
#define RYGEL_MEDIA_SERVER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), RYGEL_TYPE_MEDIA_SERVER, RygelMediaServerClass))
 
520
</MACRO>
 
521
<MACRO>
 
522
<NAME>RYGEL_IS_MEDIA_SERVER</NAME>
 
523
#define RYGEL_IS_MEDIA_SERVER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), RYGEL_TYPE_MEDIA_SERVER))
 
524
</MACRO>
 
525
<MACRO>
 
526
<NAME>RYGEL_IS_MEDIA_SERVER_CLASS</NAME>
 
527
#define RYGEL_IS_MEDIA_SERVER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), RYGEL_TYPE_MEDIA_SERVER))
 
528
</MACRO>
 
529
<MACRO>
 
530
<NAME>RYGEL_MEDIA_SERVER_GET_CLASS</NAME>
 
531
#define RYGEL_MEDIA_SERVER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), RYGEL_TYPE_MEDIA_SERVER, RygelMediaServerClass))
 
532
</MACRO>
 
533
<STRUCT>
 
534
<NAME>RygelMediaObject</NAME>
 
535
struct _RygelMediaObject {
 
536
        GObject parent_instance;
 
537
        RygelMediaObjectPrivate * priv;
 
538
        gchar* id;
 
539
        gchar* ref_id;
 
540
        gchar* upnp_class;
 
541
        guint64 modified;
 
542
        GeeArrayList* uris;
 
543
        RygelMediaContainer* parent;
 
544
};
 
545
</STRUCT>
 
546
<STRUCT>
 
547
<NAME>RygelMediaObjectClass</NAME>
 
548
struct _RygelMediaObjectClass {
 
549
        GObjectClass parent_class;
 
550
        GUPnPDIDLLiteObject* (*serialize) (RygelMediaObject* self, GUPnPDIDLLiteWriter* writer, RygelHTTPServer* http_server, GError** error);
 
551
        gint (*compare_by_property) (RygelMediaObject* self, RygelMediaObject* media_object, const gchar* property);
 
552
        GUPnPOCMFlags (*get_ocm_flags) (RygelMediaObject* self);
 
553
};
 
554
</STRUCT>
 
555
<STRUCT>
 
556
<NAME>RygelMediaItem</NAME>
 
557
struct _RygelMediaItem {
 
558
        RygelMediaObject parent_instance;
 
559
        RygelMediaItemPrivate * priv;
 
560
        gchar* date;
 
561
        gchar* mime_type;
 
562
        gchar* dlna_profile;
 
563
        GRegex* address_regex;
 
564
};
 
565
</STRUCT>
 
566
<STRUCT>
 
567
<NAME>RygelMediaItemClass</NAME>
 
568
struct _RygelMediaItemClass {
 
569
        RygelMediaObjectClass parent_class;
 
570
        GstElement* (*create_stream_source) (RygelMediaItem* self, const gchar* host_ip);
 
571
        gboolean (*streamable) (RygelMediaItem* self);
 
572
        void (*add_uri) (RygelMediaItem* self, const gchar* uri);
 
573
        GUPnPDIDLLiteResource* (*add_resource) (RygelMediaItem* self, GUPnPDIDLLiteItem* didl_item, const gchar* uri, const gchar* protocol, const gchar* import_uri, GError** error);
 
574
        void (*add_proxy_resources) (RygelMediaItem* self, RygelHTTPServer* server, GUPnPDIDLLiteItem* didl_item, GError** error);
 
575
        GUPnPProtocolInfo* (*get_protocol_info) (RygelMediaItem* self, const gchar* uri, const gchar* protocol);
 
576
        void (*add_resources) (RygelMediaItem* self, GUPnPDIDLLiteItem* didl_item, gboolean allow_internal, GError** error);
 
577
};
 
578
</STRUCT>
 
579
<STRUCT>
 
580
<NAME>RygelAudioItem</NAME>
 
581
struct _RygelAudioItem {
 
582
        RygelMediaItem parent_instance;
 
583
        RygelAudioItemPrivate * priv;
 
584
        glong duration;
 
585
        gint bitrate;
 
586
        gint sample_freq;
 
587
        gint bits_per_sample;
 
588
        gint channels;
 
589
};
 
590
</STRUCT>
 
591
<STRUCT>
 
592
<NAME>RygelAudioItemClass</NAME>
 
593
struct _RygelAudioItemClass {
 
594
        RygelMediaItemClass parent_class;
 
595
};
 
596
</STRUCT>
 
597
<STRUCT>
 
598
<NAME>RygelVisualItemIface</NAME>
 
599
struct _RygelVisualItemIface {
 
600
        GTypeInterface parent_iface;
 
601
        gint (*get_width) (RygelVisualItem* self);
 
602
        void (*set_width) (RygelVisualItem* self, gint value);
 
603
        gint (*get_height) (RygelVisualItem* self);
 
604
        void (*set_height) (RygelVisualItem* self, gint value);
 
605
        gint (*get_pixel_width) (RygelVisualItem* self);
 
606
        void (*set_pixel_width) (RygelVisualItem* self, gint value);
 
607
        gint (*get_pixel_height) (RygelVisualItem* self);
 
608
        void (*set_pixel_height) (RygelVisualItem* self, gint value);
 
609
        gint (*get_color_depth) (RygelVisualItem* self);
 
610
        void (*set_color_depth) (RygelVisualItem* self, gint value);
 
611
        GeeArrayList* (*get_thumbnails) (RygelVisualItem* self);
 
612
        void (*set_thumbnails) (RygelVisualItem* self, GeeArrayList* value);
 
613
};
 
614
</STRUCT>
 
615
<STRUCT>
 
616
<NAME>RygelImageItem</NAME>
 
617
struct _RygelImageItem {
 
618
        RygelMediaItem parent_instance;
 
619
        RygelImageItemPrivate * priv;
 
620
};
 
621
</STRUCT>
 
622
<STRUCT>
 
623
<NAME>RygelImageItemClass</NAME>
 
624
struct _RygelImageItemClass {
 
625
        RygelMediaItemClass parent_class;
 
626
};
 
627
</STRUCT>
 
628
<ENUM>
 
629
<NAME>RygelLogicalOperator</NAME>
 
630
typedef enum  {
 
631
        RYGEL_LOGICAL_OPERATOR_AND,
 
632
        RYGEL_LOGICAL_OPERATOR_OR
 
633
} RygelLogicalOperator;
 
634
</ENUM>
 
635
<STRUCT>
 
636
<NAME>RygelSearchExpression</NAME>
 
637
struct _RygelSearchExpression {
 
638
        GTypeInstance parent_instance;
 
639
        volatile int ref_count;
 
640
        RygelSearchExpressionPrivate * priv;
 
641
        gpointer op;
 
642
        gpointer operand1;
 
643
        gpointer operand2;
 
644
};
 
645
</STRUCT>
 
646
<STRUCT>
 
647
<NAME>RygelSearchExpressionClass</NAME>
 
648
struct _RygelSearchExpressionClass {
 
649
        GTypeClass parent_class;
 
650
        void (*finalize) (RygelSearchExpression *self);
 
651
        gboolean (*satisfied_by) (RygelSearchExpression* self, RygelMediaObject* media_object);
 
652
        gchar* (*to_string) (RygelSearchExpression* self);
 
653
};
 
654
</STRUCT>
 
655
<STRUCT>
 
656
<NAME>RygelLogicalExpression</NAME>
 
657
struct _RygelLogicalExpression {
 
658
        RygelSearchExpression parent_instance;
 
659
        RygelLogicalExpressionPrivate * priv;
 
660
};
 
661
</STRUCT>
 
662
<STRUCT>
 
663
<NAME>RygelLogicalExpressionClass</NAME>
 
664
struct _RygelLogicalExpressionClass {
 
665
        RygelSearchExpressionClass parent_class;
 
666
};
 
667
</STRUCT>
 
668
<STRUCT>
 
669
<NAME>RygelMediaArtStore</NAME>
 
670
struct _RygelMediaArtStore {
 
671
        GObject parent_instance;
 
672
        RygelMediaArtStorePrivate * priv;
 
673
};
 
674
</STRUCT>
 
675
<STRUCT>
 
676
<NAME>RygelMediaArtStoreClass</NAME>
 
677
struct _RygelMediaArtStoreClass {
 
678
        GObjectClass parent_class;
 
679
};
 
680
</STRUCT>
 
681
<STRUCT>
 
682
<NAME>RygelMediaObjects</NAME>
 
683
struct _RygelMediaObjects {
 
684
        GeeArrayList parent_instance;
 
685
        RygelMediaObjectsPrivate * priv;
 
686
};
 
687
</STRUCT>
 
688
<STRUCT>
 
689
<NAME>RygelMediaObjectsClass</NAME>
 
690
struct _RygelMediaObjectsClass {
 
691
        GeeArrayListClass parent_class;
 
692
};
 
693
</STRUCT>
 
694
<STRUCT>
 
695
<NAME>RygelMusicItem</NAME>
 
696
struct _RygelMusicItem {
 
697
        RygelAudioItem parent_instance;
 
698
        RygelMusicItemPrivate * priv;
 
699
        gchar* artist;
 
700
        gchar* album;
 
701
        gchar* genre;
 
702
        gint track_number;
 
703
        RygelThumbnail* album_art;
 
704
};
 
705
</STRUCT>
 
706
<STRUCT>
 
707
<NAME>RygelMusicItemClass</NAME>
 
708
struct _RygelMusicItemClass {
 
709
        RygelAudioItemClass parent_class;
 
710
};
 
711
</STRUCT>
 
712
<STRUCT>
 
713
<NAME>RygelPhotoItem</NAME>
 
714
struct _RygelPhotoItem {
 
715
        RygelImageItem parent_instance;
 
716
        RygelPhotoItemPrivate * priv;
 
717
        gchar* creator;
 
718
};
 
719
</STRUCT>
 
720
<STRUCT>
 
721
<NAME>RygelPhotoItemClass</NAME>
 
722
struct _RygelPhotoItemClass {
 
723
        RygelImageItemClass parent_class;
 
724
};
 
725
</STRUCT>
 
726
<STRUCT>
 
727
<NAME>RygelRelationalExpression</NAME>
 
728
struct _RygelRelationalExpression {
 
729
        RygelSearchExpression parent_instance;
 
730
        RygelRelationalExpressionPrivate * priv;
 
731
};
 
732
</STRUCT>
 
733
<STRUCT>
 
734
<NAME>RygelRelationalExpressionClass</NAME>
 
735
struct _RygelRelationalExpressionClass {
 
736
        RygelSearchExpressionClass parent_class;
 
737
};
 
738
</STRUCT>
 
739
<STRUCT>
 
740
<NAME>RygelMediaContainer</NAME>
 
741
struct _RygelMediaContainer {
 
742
        RygelMediaObject parent_instance;
 
743
        RygelMediaContainerPrivate * priv;
 
744
        gint child_count;
 
745
        guint32 update_id;
 
746
        gint64 storage_used;
 
747
};
 
748
</STRUCT>
 
749
<STRUCT>
 
750
<NAME>RygelMediaContainerClass</NAME>
 
751
struct _RygelMediaContainerClass {
 
752
        RygelMediaObjectClass parent_class;
 
753
        void (*get_children) (RygelMediaContainer* self, guint offset, guint max_count, const gchar* sort_criteria, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
 
754
        RygelMediaObjects* (*get_children_finish) (RygelMediaContainer* self, GAsyncResult* _res_, GError** error);
 
755
        void (*find_object) (RygelMediaContainer* self, const gchar* id, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
 
756
        RygelMediaObject* (*find_object_finish) (RygelMediaContainer* self, GAsyncResult* _res_, GError** error);
 
757
};
 
758
</STRUCT>
 
759
<STRUCT>
 
760
<NAME>RygelSearchableContainerIface</NAME>
 
761
struct _RygelSearchableContainerIface {
 
762
        GTypeInterface parent_iface;
 
763
        void (*search) (RygelSearchableContainer* self, RygelSearchExpression* expression, guint offset, guint max_count, const gchar* sort_criteria, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
 
764
        RygelMediaObjects* (*search_finish) (RygelSearchableContainer* self, GAsyncResult* _res_, guint* total_matches, GError** error);
 
765
        GeeArrayList* (*get_search_classes) (RygelSearchableContainer* self);
 
766
        void (*set_search_classes) (RygelSearchableContainer* self, GeeArrayList* value);
 
767
};
 
768
</STRUCT>
 
769
<STRUCT>
 
770
<NAME>RygelSimpleContainer</NAME>
 
771
struct _RygelSimpleContainer {
 
772
        RygelMediaContainer parent_instance;
 
773
        RygelSimpleContainerPrivate * priv;
 
774
        RygelMediaObjects* children;
 
775
};
 
776
</STRUCT>
 
777
<STRUCT>
 
778
<NAME>RygelSimpleContainerClass</NAME>
 
779
struct _RygelSimpleContainerClass {
 
780
        RygelMediaContainerClass parent_class;
 
781
};
 
782
</STRUCT>
 
783
<STRUCT>
 
784
<NAME>RygelSubtitle</NAME>
 
785
struct _RygelSubtitle {
 
786
        GTypeInstance parent_instance;
 
787
        volatile int ref_count;
 
788
        RygelSubtitlePrivate * priv;
 
789
        gchar* uri;
 
790
        gchar* mime_type;
 
791
        gchar* caption_type;
 
792
        gint64 size;
 
793
};
 
794
</STRUCT>
 
795
<STRUCT>
 
796
<NAME>RygelSubtitleClass</NAME>
 
797
struct _RygelSubtitleClass {
 
798
        GTypeClass parent_class;
 
799
        void (*finalize) (RygelSubtitle *self);
 
800
};
 
801
</STRUCT>
 
802
<STRUCT>
 
803
<NAME>RygelThumbnail</NAME>
 
804
struct _RygelThumbnail {
 
805
        RygelIconInfo parent_instance;
 
806
        RygelThumbnailPrivate * priv;
 
807
        gchar* dlna_profile;
 
808
};
 
809
</STRUCT>
 
810
<STRUCT>
 
811
<NAME>RygelThumbnailClass</NAME>
 
812
struct _RygelThumbnailClass {
 
813
        RygelIconInfoClass parent_class;
 
814
        GUPnPDIDLLiteResource* (*add_resource) (RygelThumbnail* self, GUPnPDIDLLiteItem* didl_item, const gchar* protocol);
 
815
};
 
816
</STRUCT>
 
817
<STRUCT>
 
818
<NAME>RygelVideoItem</NAME>
 
819
struct _RygelVideoItem {
 
820
        RygelAudioItem parent_instance;
 
821
        RygelVideoItemPrivate * priv;
 
822
        gchar* author;
 
823
        GeeArrayList* subtitles;
 
824
};
 
825
</STRUCT>
 
826
<STRUCT>
 
827
<NAME>RygelVideoItemClass</NAME>
 
828
struct _RygelVideoItemClass {
 
829
        RygelAudioItemClass parent_class;
 
830
};
 
831
</STRUCT>
 
832
<STRUCT>
 
833
<NAME>RygelMediaServerPlugin</NAME>
 
834
struct _RygelMediaServerPlugin {
 
835
        RygelPlugin parent_instance;
 
836
        RygelMediaServerPluginPrivate * priv;
 
837
        RygelMediaContainer* root_container;
 
838
};
 
839
</STRUCT>
 
840
<STRUCT>
 
841
<NAME>RygelMediaServerPluginClass</NAME>
 
842
struct _RygelMediaServerPluginClass {
 
843
        RygelPluginClass parent_class;
 
844
};
 
845
</STRUCT>
 
846
<STRUCT>
 
847
<NAME>RygelWritableContainerIface</NAME>
 
848
struct _RygelWritableContainerIface {
 
849
        GTypeInterface parent_iface;
 
850
        void (*add_item) (RygelWritableContainer* self, RygelMediaItem* item, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
 
851
        void (*add_item_finish) (RygelWritableContainer* self, GAsyncResult* _res_, GError** error);
 
852
        void (*remove_item) (RygelWritableContainer* self, const gchar* id, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
 
853
        void (*remove_item_finish) (RygelWritableContainer* self, GAsyncResult* _res_, GError** error);
 
854
        GeeArrayList* (*get_create_classes) (RygelWritableContainer* self);
 
855
        void (*set_create_classes) (RygelWritableContainer* self, GeeArrayList* value);
 
856
};
 
857
</STRUCT>
 
858
<STRUCT>
 
859
<NAME>RygelMediaServer</NAME>
 
860
struct _RygelMediaServer {
 
861
        RygelMediaDevice parent_instance;
 
862
        RygelMediaServerPrivate * priv;
 
863
};
 
864
</STRUCT>
 
865
<STRUCT>
 
866
<NAME>RygelMediaServerClass</NAME>
 
867
struct _RygelMediaServerClass {
 
868
        RygelMediaDeviceClass parent_class;
 
869
};
 
870
</STRUCT>
 
871
<ENUM>
 
872
<NAME>RygelContentDirectoryError</NAME>
 
873
typedef enum  {
 
874
        RYGEL_CONTENT_DIRECTORY_ERROR_NO_SUCH_OBJECT = 701,
 
875
        RYGEL_CONTENT_DIRECTORY_ERROR_INVALID_SORT_CRITERIA = 709,
 
876
        RYGEL_CONTENT_DIRECTORY_ERROR_RESTRICTED_OBJECT = 711,
 
877
        RYGEL_CONTENT_DIRECTORY_ERROR_BAD_METADATA = 712,
 
878
        RYGEL_CONTENT_DIRECTORY_ERROR_RESTRICTED_PARENT = 713,
 
879
        RYGEL_CONTENT_DIRECTORY_ERROR_NO_SUCH_DESTINATION_RESOURCE = 718,
 
880
        RYGEL_CONTENT_DIRECTORY_ERROR_CANT_PROCESS = 720,
 
881
        RYGEL_CONTENT_DIRECTORY_ERROR_INVALID_ARGS = 402
 
882
} RygelContentDirectoryError;
 
883
</ENUM>
 
884
<MACRO>
 
885
<NAME>RYGEL_CONTENT_DIRECTORY_ERROR</NAME>
 
886
#define RYGEL_CONTENT_DIRECTORY_ERROR rygel_content_directory_error_quark ()
 
887
</MACRO>
 
888
<FUNCTION>
 
889
<NAME>rygel_media_object_get_type</NAME>
 
890
<RETURNS>GType  </RETURNS>
 
891
void 
 
892
</FUNCTION>
 
893
<FUNCTION>
 
894
<NAME>rygel_transcode_manager_get_type</NAME>
 
895
<RETURNS>GType  </RETURNS>
 
896
void 
 
897
</FUNCTION>
 
898
<FUNCTION>
 
899
<NAME>rygel_http_server_get_type</NAME>
 
900
<RETURNS>GType  </RETURNS>
 
901
void 
 
902
</FUNCTION>
 
903
<FUNCTION>
 
904
<NAME>rygel_media_container_get_type</NAME>
 
905
<RETURNS>GType  </RETURNS>
 
906
void 
 
907
</FUNCTION>
 
908
<FUNCTION>
 
909
<NAME>rygel_media_item_get_type</NAME>
 
910
<RETURNS>GType  </RETURNS>
 
911
void 
 
912
</FUNCTION>
 
913
<FUNCTION>
 
914
<NAME>rygel_audio_item_get_type</NAME>
 
915
<RETURNS>GType  </RETURNS>
 
916
void 
 
917
</FUNCTION>
 
918
<MACRO>
 
919
<NAME>RYGEL_AUDIO_ITEM_UPNP_CLASS</NAME>
 
920
#define RYGEL_AUDIO_ITEM_UPNP_CLASS "object.item.audioItem"
 
921
</MACRO>
 
922
<FUNCTION>
 
923
<NAME>rygel_audio_item_new</NAME>
 
924
<RETURNS>RygelAudioItem * </RETURNS>
 
925
const gchar* id, RygelMediaContainer* parent, const gchar* title, const gchar* upnp_class 
 
926
</FUNCTION>
 
927
<FUNCTION>
 
928
<NAME>rygel_audio_item_construct</NAME>
 
929
<RETURNS>RygelAudioItem * </RETURNS>
 
930
GType object_type, const gchar* id, RygelMediaContainer* parent, const gchar* title, const gchar* upnp_class 
 
931
</FUNCTION>
 
932
<FUNCTION>
 
933
<NAME>rygel_thumbnail_get_type</NAME>
 
934
<RETURNS>GType  </RETURNS>
 
935
void 
 
936
</FUNCTION>
 
937
<FUNCTION>
 
938
<NAME>rygel_visual_item_get_type</NAME>
 
939
<RETURNS>GType  </RETURNS>
 
940
void 
 
941
</FUNCTION>
 
942
<FUNCTION>
 
943
<NAME>rygel_image_item_get_type</NAME>
 
944
<RETURNS>GType  </RETURNS>
 
945
void 
 
946
</FUNCTION>
 
947
<MACRO>
 
948
<NAME>RYGEL_IMAGE_ITEM_UPNP_CLASS</NAME>
 
949
#define RYGEL_IMAGE_ITEM_UPNP_CLASS "object.item.imageItem"
 
950
</MACRO>
 
951
<FUNCTION>
 
952
<NAME>rygel_image_item_new</NAME>
 
953
<RETURNS>RygelImageItem * </RETURNS>
 
954
const gchar* id, RygelMediaContainer* parent, const gchar* title, const gchar* upnp_class 
 
955
</FUNCTION>
 
956
<FUNCTION>
 
957
<NAME>rygel_image_item_construct</NAME>
 
958
<RETURNS>RygelImageItem * </RETURNS>
 
959
GType object_type, const gchar* id, RygelMediaContainer* parent, const gchar* title, const gchar* upnp_class 
 
960
</FUNCTION>
 
961
<FUNCTION>
 
962
<NAME>rygel_logical_operator_get_type</NAME>
 
963
<RETURNS>GType  </RETURNS>
 
964
void 
 
965
</FUNCTION>
 
966
<FUNCTION>
 
967
<NAME>rygel_search_expression_ref</NAME>
 
968
<RETURNS>gpointer  </RETURNS>
 
969
gpointer instance 
 
970
</FUNCTION>
 
971
<FUNCTION>
 
972
<NAME>rygel_search_expression_unref</NAME>
 
973
<RETURNS>void  </RETURNS>
 
974
gpointer instance 
 
975
</FUNCTION>
 
976
<FUNCTION>
 
977
<NAME>rygel_param_spec_search_expression</NAME>
 
978
<RETURNS>GParamSpec * </RETURNS>
 
979
const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags 
 
980
</FUNCTION>
 
981
<FUNCTION>
 
982
<NAME>rygel_value_set_search_expression</NAME>
 
983
<RETURNS>void  </RETURNS>
 
984
GValue* value, gpointer v_object 
 
985
</FUNCTION>
 
986
<FUNCTION>
 
987
<NAME>rygel_value_take_search_expression</NAME>
 
988
<RETURNS>void  </RETURNS>
 
989
GValue* value, gpointer v_object 
 
990
</FUNCTION>
 
991
<FUNCTION>
 
992
<NAME>rygel_value_get_search_expression</NAME>
 
993
<RETURNS>gpointer  </RETURNS>
 
994
const GValue* value 
 
995
</FUNCTION>
 
996
<FUNCTION>
 
997
<NAME>rygel_search_expression_get_type</NAME>
 
998
<RETURNS>GType  </RETURNS>
 
999
void 
 
1000
</FUNCTION>
 
1001
<FUNCTION>
 
1002
<NAME>rygel_logical_expression_get_type</NAME>
 
1003
<RETURNS>GType  </RETURNS>
 
1004
void 
 
1005
</FUNCTION>
 
1006
<FUNCTION>
 
1007
<NAME>rygel_logical_expression_new</NAME>
 
1008
<RETURNS>RygelLogicalExpression * </RETURNS>
 
1009
void 
 
1010
</FUNCTION>
 
1011
<FUNCTION>
 
1012
<NAME>rygel_logical_expression_construct</NAME>
 
1013
<RETURNS>RygelLogicalExpression * </RETURNS>
 
1014
GType object_type 
 
1015
</FUNCTION>
 
1016
<FUNCTION>
 
1017
<NAME>rygel_media_art_store_get_type</NAME>
 
1018
<RETURNS>GType  </RETURNS>
 
1019
void 
 
1020
</FUNCTION>
 
1021
<FUNCTION>
 
1022
<NAME>rygel_media_art_store_get_default</NAME>
 
1023
<RETURNS>RygelMediaArtStore * </RETURNS>
 
1024
void 
 
1025
</FUNCTION>
 
1026
<FUNCTION>
 
1027
<NAME>rygel_music_item_get_type</NAME>
 
1028
<RETURNS>GType  </RETURNS>
 
1029
void 
 
1030
</FUNCTION>
 
1031
<FUNCTION>
 
1032
<NAME>rygel_media_art_store_find_media_art</NAME>
 
1033
<RETURNS>RygelThumbnail * </RETURNS>
 
1034
RygelMediaArtStore* self, RygelMusicItem* item, gboolean simple, GError** error 
 
1035
</FUNCTION>
 
1036
<FUNCTION>
 
1037
<NAME>rygel_media_art_store_find_media_art_any</NAME>
 
1038
<RETURNS>RygelThumbnail * </RETURNS>
 
1039
RygelMediaArtStore* self, RygelMusicItem* item, GError** error 
 
1040
</FUNCTION>
 
1041
<FUNCTION>
 
1042
<NAME>rygel_media_art_store_get_media_art_file</NAME>
 
1043
<RETURNS>GFile * </RETURNS>
 
1044
RygelMediaArtStore* self, const gchar* type, RygelMusicItem* item, gboolean simple 
 
1045
</FUNCTION>
 
1046
<FUNCTION>
 
1047
<NAME>rygel_media_objects_get_type</NAME>
 
1048
<RETURNS>GType  </RETURNS>
 
1049
void 
 
1050
</FUNCTION>
 
1051
<MACRO>
 
1052
<NAME>RYGEL_MEDIA_OBJECTS_SORT_CAPS</NAME>
 
1053
#define RYGEL_MEDIA_OBJECTS_SORT_CAPS "@id,@parentID,dc:title,upnp:class," "upnp:artist,upnp:author,upnp:album," "dc:date,upnp:originalTrackNumber"
 
1054
</MACRO>
 
1055
<FUNCTION>
 
1056
<NAME>rygel_media_objects_sort_by_criteria</NAME>
 
1057
<RETURNS>void  </RETURNS>
 
1058
RygelMediaObjects* self, const gchar* sort_criteria 
 
1059
</FUNCTION>
 
1060
<FUNCTION>
 
1061
<NAME>rygel_media_objects_new</NAME>
 
1062
<RETURNS>RygelMediaObjects * </RETURNS>
 
1063
void 
 
1064
</FUNCTION>
 
1065
<FUNCTION>
 
1066
<NAME>rygel_media_objects_construct</NAME>
 
1067
<RETURNS>RygelMediaObjects * </RETURNS>
 
1068
GType object_type 
 
1069
</FUNCTION>
 
1070
<MACRO>
 
1071
<NAME>RYGEL_MUSIC_ITEM_UPNP_CLASS</NAME>
 
1072
#define RYGEL_MUSIC_ITEM_UPNP_CLASS "object.item.audioItem.musicTrack"
 
1073
</MACRO>
 
1074
<FUNCTION>
 
1075
<NAME>rygel_music_item_new</NAME>
 
1076
<RETURNS>RygelMusicItem * </RETURNS>
 
1077
const gchar* id, RygelMediaContainer* parent, const gchar* title, const gchar* upnp_class 
 
1078
</FUNCTION>
 
1079
<FUNCTION>
 
1080
<NAME>rygel_music_item_construct</NAME>
 
1081
<RETURNS>RygelMusicItem * </RETURNS>
 
1082
GType object_type, const gchar* id, RygelMediaContainer* parent, const gchar* title, const gchar* upnp_class 
 
1083
</FUNCTION>
 
1084
<FUNCTION>
 
1085
<NAME>rygel_music_item_lookup_album_art</NAME>
 
1086
<RETURNS>void  </RETURNS>
 
1087
RygelMusicItem* self 
 
1088
</FUNCTION>
 
1089
<FUNCTION>
 
1090
<NAME>rygel_photo_item_get_type</NAME>
 
1091
<RETURNS>GType  </RETURNS>
 
1092
void 
 
1093
</FUNCTION>
 
1094
<MACRO>
 
1095
<NAME>RYGEL_PHOTO_ITEM_UPNP_CLASS</NAME>
 
1096
#define RYGEL_PHOTO_ITEM_UPNP_CLASS "object.item.imageItem.photo"
 
1097
</MACRO>
 
1098
<FUNCTION>
 
1099
<NAME>rygel_photo_item_new</NAME>
 
1100
<RETURNS>RygelPhotoItem * </RETURNS>
 
1101
const gchar* id, RygelMediaContainer* parent, const gchar* title, const gchar* upnp_class 
 
1102
</FUNCTION>
 
1103
<FUNCTION>
 
1104
<NAME>rygel_photo_item_construct</NAME>
 
1105
<RETURNS>RygelPhotoItem * </RETURNS>
 
1106
GType object_type, const gchar* id, RygelMediaContainer* parent, const gchar* title, const gchar* upnp_class 
 
1107
</FUNCTION>
 
1108
<FUNCTION>
 
1109
<NAME>rygel_relational_expression_get_type</NAME>
 
1110
<RETURNS>GType  </RETURNS>
 
1111
void 
 
1112
</FUNCTION>
 
1113
<FUNCTION>
 
1114
<NAME>rygel_relational_expression_compare_string</NAME>
 
1115
<RETURNS>gboolean  </RETURNS>
 
1116
RygelRelationalExpression* self, const gchar* str 
 
1117
</FUNCTION>
 
1118
<FUNCTION>
 
1119
<NAME>rygel_relational_expression_compare_int</NAME>
 
1120
<RETURNS>gboolean  </RETURNS>
 
1121
RygelRelationalExpression* self, gint integer 
 
1122
</FUNCTION>
 
1123
<FUNCTION>
 
1124
<NAME>rygel_relational_expression_new</NAME>
 
1125
<RETURNS>RygelRelationalExpression * </RETURNS>
 
1126
void 
 
1127
</FUNCTION>
 
1128
<FUNCTION>
 
1129
<NAME>rygel_relational_expression_construct</NAME>
 
1130
<RETURNS>RygelRelationalExpression * </RETURNS>
 
1131
GType object_type 
 
1132
</FUNCTION>
 
1133
<FUNCTION>
 
1134
<NAME>rygel_searchable_container_get_type</NAME>
 
1135
<RETURNS>GType  </RETURNS>
 
1136
void 
 
1137
</FUNCTION>
 
1138
<FUNCTION>
 
1139
<NAME>rygel_simple_container_get_type</NAME>
 
1140
<RETURNS>GType  </RETURNS>
 
1141
void 
 
1142
</FUNCTION>
 
1143
<FUNCTION>
 
1144
<NAME>rygel_simple_container_new</NAME>
 
1145
<RETURNS>RygelSimpleContainer * </RETURNS>
 
1146
const gchar* id, RygelMediaContainer* parent, const gchar* title 
 
1147
</FUNCTION>
 
1148
<FUNCTION>
 
1149
<NAME>rygel_simple_container_construct</NAME>
 
1150
<RETURNS>RygelSimpleContainer * </RETURNS>
 
1151
GType object_type, const gchar* id, RygelMediaContainer* parent, const gchar* title 
 
1152
</FUNCTION>
 
1153
<FUNCTION>
 
1154
<NAME>rygel_simple_container_new_root</NAME>
 
1155
<RETURNS>RygelSimpleContainer * </RETURNS>
 
1156
const gchar* title 
 
1157
</FUNCTION>
 
1158
<FUNCTION>
 
1159
<NAME>rygel_simple_container_construct_root</NAME>
 
1160
<RETURNS>RygelSimpleContainer * </RETURNS>
 
1161
GType object_type, const gchar* title 
 
1162
</FUNCTION>
 
1163
<FUNCTION>
 
1164
<NAME>rygel_simple_container_add_child_item</NAME>
 
1165
<RETURNS>void  </RETURNS>
 
1166
RygelSimpleContainer* self, RygelMediaItem* child 
 
1167
</FUNCTION>
 
1168
<FUNCTION>
 
1169
<NAME>rygel_simple_container_get_all_children</NAME>
 
1170
<RETURNS>RygelMediaObjects * </RETURNS>
 
1171
RygelSimpleContainer* self 
 
1172
</FUNCTION>
 
1173
<FUNCTION>
 
1174
<NAME>rygel_simple_container_add_child_container</NAME>
 
1175
<RETURNS>void  </RETURNS>
 
1176
RygelSimpleContainer* self, RygelMediaContainer* child 
 
1177
</FUNCTION>
 
1178
<FUNCTION>
 
1179
<NAME>rygel_simple_container_remove_child</NAME>
 
1180
<RETURNS>void  </RETURNS>
 
1181
RygelSimpleContainer* self, RygelMediaObject* child 
 
1182
</FUNCTION>
 
1183
<FUNCTION>
 
1184
<NAME>rygel_simple_container_clear</NAME>
 
1185
<RETURNS>void  </RETURNS>
 
1186
RygelSimpleContainer* self 
 
1187
</FUNCTION>
 
1188
<FUNCTION>
 
1189
<NAME>rygel_simple_container_is_child_id_unique</NAME>
 
1190
<RETURNS>gboolean  </RETURNS>
 
1191
RygelSimpleContainer* self, const gchar* child_id 
 
1192
</FUNCTION>
 
1193
<FUNCTION>
 
1194
<NAME>rygel_subtitle_ref</NAME>
 
1195
<RETURNS>gpointer  </RETURNS>
 
1196
gpointer instance 
 
1197
</FUNCTION>
 
1198
<FUNCTION>
 
1199
<NAME>rygel_subtitle_unref</NAME>
 
1200
<RETURNS>void  </RETURNS>
 
1201
gpointer instance 
 
1202
</FUNCTION>
 
1203
<FUNCTION>
 
1204
<NAME>rygel_param_spec_subtitle</NAME>
 
1205
<RETURNS>GParamSpec * </RETURNS>
 
1206
const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags 
 
1207
</FUNCTION>
 
1208
<FUNCTION>
 
1209
<NAME>rygel_value_set_subtitle</NAME>
 
1210
<RETURNS>void  </RETURNS>
 
1211
GValue* value, gpointer v_object 
 
1212
</FUNCTION>
 
1213
<FUNCTION>
 
1214
<NAME>rygel_value_take_subtitle</NAME>
 
1215
<RETURNS>void  </RETURNS>
 
1216
GValue* value, gpointer v_object 
 
1217
</FUNCTION>
 
1218
<FUNCTION>
 
1219
<NAME>rygel_value_get_subtitle</NAME>
 
1220
<RETURNS>gpointer  </RETURNS>
 
1221
const GValue* value 
 
1222
</FUNCTION>
 
1223
<FUNCTION>
 
1224
<NAME>rygel_subtitle_get_type</NAME>
 
1225
<RETURNS>GType  </RETURNS>
 
1226
void 
 
1227
</FUNCTION>
 
1228
<FUNCTION>
 
1229
<NAME>rygel_subtitle_new</NAME>
 
1230
<RETURNS>RygelSubtitle * </RETURNS>
 
1231
const gchar* mime_type, const gchar* caption_type 
 
1232
</FUNCTION>
 
1233
<FUNCTION>
 
1234
<NAME>rygel_subtitle_construct</NAME>
 
1235
<RETURNS>RygelSubtitle * </RETURNS>
 
1236
GType object_type, const gchar* mime_type, const gchar* caption_type 
 
1237
</FUNCTION>
 
1238
<FUNCTION>
 
1239
<NAME>rygel_thumbnail_new</NAME>
 
1240
<RETURNS>RygelThumbnail * </RETURNS>
 
1241
const gchar* mime_type, const gchar* dlna_profile, const gchar* file_extension 
 
1242
</FUNCTION>
 
1243
<FUNCTION>
 
1244
<NAME>rygel_thumbnail_construct</NAME>
 
1245
<RETURNS>RygelThumbnail * </RETURNS>
 
1246
GType object_type, const gchar* mime_type, const gchar* dlna_profile, const gchar* file_extension 
 
1247
</FUNCTION>
 
1248
<FUNCTION>
 
1249
<NAME>rygel_video_item_get_type</NAME>
 
1250
<RETURNS>GType  </RETURNS>
 
1251
void 
 
1252
</FUNCTION>
 
1253
<MACRO>
 
1254
<NAME>RYGEL_VIDEO_ITEM_UPNP_CLASS</NAME>
 
1255
#define RYGEL_VIDEO_ITEM_UPNP_CLASS "object.item.videoItem"
 
1256
</MACRO>
 
1257
<FUNCTION>
 
1258
<NAME>rygel_video_item_new</NAME>
 
1259
<RETURNS>RygelVideoItem * </RETURNS>
 
1260
const gchar* id, RygelMediaContainer* parent, const gchar* title, const gchar* upnp_class 
 
1261
</FUNCTION>
 
1262
<FUNCTION>
 
1263
<NAME>rygel_video_item_construct</NAME>
 
1264
<RETURNS>RygelVideoItem * </RETURNS>
 
1265
GType object_type, const gchar* id, RygelMediaContainer* parent, const gchar* title, const gchar* upnp_class 
 
1266
</FUNCTION>
 
1267
<MACRO>
 
1268
<NAME>RYGEL_MEDIA_CONTAINER_UPNP_CLASS</NAME>
 
1269
#define RYGEL_MEDIA_CONTAINER_UPNP_CLASS "object.container"
 
1270
</MACRO>
 
1271
<MACRO>
 
1272
<NAME>RYGEL_MEDIA_CONTAINER_STORAGE_FOLDER</NAME>
 
1273
#define RYGEL_MEDIA_CONTAINER_STORAGE_FOLDER RYGEL_MEDIA_CONTAINER_UPNP_CLASS ".storageFolder"
 
1274
</MACRO>
 
1275
<MACRO>
 
1276
<NAME>RYGEL_MEDIA_CONTAINER_MUSIC_ALBUM</NAME>
 
1277
#define RYGEL_MEDIA_CONTAINER_MUSIC_ALBUM RYGEL_MEDIA_CONTAINER_UPNP_CLASS ".album.musicAlbum"
 
1278
</MACRO>
 
1279
<MACRO>
 
1280
<NAME>RYGEL_MEDIA_CONTAINER_MUSIC_ARTIST</NAME>
 
1281
#define RYGEL_MEDIA_CONTAINER_MUSIC_ARTIST RYGEL_MEDIA_CONTAINER_UPNP_CLASS ".person.musicArtist"
 
1282
</MACRO>
 
1283
<MACRO>
 
1284
<NAME>RYGEL_MEDIA_CONTAINER_MUSIC_GENRE</NAME>
 
1285
#define RYGEL_MEDIA_CONTAINER_MUSIC_GENRE RYGEL_MEDIA_CONTAINER_UPNP_CLASS ".genre.musicGenre"
 
1286
</MACRO>
 
1287
<MACRO>
 
1288
<NAME>RYGEL_MEDIA_CONTAINER_ALBUM_SORT_CRITERIA</NAME>
 
1289
#define RYGEL_MEDIA_CONTAINER_ALBUM_SORT_CRITERIA "+upnp:class," "+rygel:originalVolumeNumber," "+upnp:originalTrackNumber," "+dc:title"
 
1290
</MACRO>
 
1291
<FUNCTION>
 
1292
<NAME>rygel_media_container_construct</NAME>
 
1293
<RETURNS>RygelMediaContainer * </RETURNS>
 
1294
GType object_type, const gchar* id, RygelMediaContainer* parent, const gchar* title, gint child_count 
 
1295
</FUNCTION>
 
1296
<FUNCTION>
 
1297
<NAME>rygel_media_container_construct_root</NAME>
 
1298
<RETURNS>RygelMediaContainer * </RETURNS>
 
1299
GType object_type, const gchar* title, gint child_count 
 
1300
</FUNCTION>
 
1301
<FUNCTION>
 
1302
<NAME>rygel_media_container_get_children</NAME>
 
1303
<RETURNS>void  </RETURNS>
 
1304
RygelMediaContainer* self, guint offset, guint max_count, const gchar* sort_criteria, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_ 
 
1305
</FUNCTION>
 
1306
<FUNCTION>
 
1307
<NAME>rygel_media_container_get_children_finish</NAME>
 
1308
<RETURNS>RygelMediaObjects * </RETURNS>
 
1309
RygelMediaContainer* self, GAsyncResult* _res_, GError** error 
 
1310
</FUNCTION>
 
1311
<FUNCTION>
 
1312
<NAME>rygel_media_container_find_object</NAME>
 
1313
<RETURNS>void  </RETURNS>
 
1314
RygelMediaContainer* self, const gchar* id, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_ 
 
1315
</FUNCTION>
 
1316
<FUNCTION>
 
1317
<NAME>rygel_media_container_find_object_finish</NAME>
 
1318
<RETURNS>RygelMediaObject * </RETURNS>
 
1319
RygelMediaContainer* self, GAsyncResult* _res_, GError** error 
 
1320
</FUNCTION>
 
1321
<FUNCTION>
 
1322
<NAME>rygel_media_container_updated</NAME>
 
1323
<RETURNS>void  </RETURNS>
 
1324
RygelMediaContainer* self 
 
1325
</FUNCTION>
 
1326
<FUNCTION>
 
1327
<NAME>rygel_media_container_get_sort_criteria</NAME>
 
1328
<RETURNS>const gchar * </RETURNS>
 
1329
RygelMediaContainer* self 
 
1330
</FUNCTION>
 
1331
<FUNCTION>
 
1332
<NAME>rygel_media_container_set_sort_criteria</NAME>
 
1333
<RETURNS>void  </RETURNS>
 
1334
RygelMediaContainer* self, const gchar* value 
 
1335
</FUNCTION>
 
1336
<FUNCTION>
 
1337
<NAME>rygel_media_item_construct</NAME>
 
1338
<RETURNS>RygelMediaItem * </RETURNS>
 
1339
GType object_type, const gchar* id, RygelMediaContainer* parent, const gchar* title, const gchar* upnp_class 
 
1340
</FUNCTION>
 
1341
<FUNCTION>
 
1342
<NAME>rygel_media_item_create_stream_source</NAME>
 
1343
<RETURNS>GstElement * </RETURNS>
 
1344
RygelMediaItem* self, const gchar* host_ip 
 
1345
</FUNCTION>
 
1346
<FUNCTION>
 
1347
<NAME>rygel_media_item_is_live_stream</NAME>
 
1348
<RETURNS>gboolean  </RETURNS>
 
1349
RygelMediaItem* self 
 
1350
</FUNCTION>
 
1351
<FUNCTION>
 
1352
<NAME>rygel_media_item_streamable</NAME>
 
1353
<RETURNS>gboolean  </RETURNS>
 
1354
RygelMediaItem* self 
 
1355
</FUNCTION>
 
1356
<FUNCTION>
 
1357
<NAME>rygel_media_item_add_uri</NAME>
 
1358
<RETURNS>void  </RETURNS>
 
1359
RygelMediaItem* self, const gchar* uri 
 
1360
</FUNCTION>
 
1361
<FUNCTION>
 
1362
<NAME>rygel_media_item_get_protocol_info</NAME>
 
1363
<RETURNS>GUPnPProtocolInfo * </RETURNS>
 
1364
RygelMediaItem* self, const gchar* uri, const gchar* protocol 
 
1365
</FUNCTION>
 
1366
<FUNCTION>
 
1367
<NAME>rygel_media_item_add_resources</NAME>
 
1368
<RETURNS>void  </RETURNS>
 
1369
RygelMediaItem* self, GUPnPDIDLLiteItem* didl_item, gboolean allow_internal, GError** error 
 
1370
</FUNCTION>
 
1371
<FUNCTION>
 
1372
<NAME>rygel_media_item_get_size</NAME>
 
1373
<RETURNS>gint64  </RETURNS>
 
1374
RygelMediaItem* self 
 
1375
</FUNCTION>
 
1376
<FUNCTION>
 
1377
<NAME>rygel_media_item_set_size</NAME>
 
1378
<RETURNS>void  </RETURNS>
 
1379
RygelMediaItem* self, gint64 value 
 
1380
</FUNCTION>
 
1381
<FUNCTION>
 
1382
<NAME>rygel_media_item_get_place_holder</NAME>
 
1383
<RETURNS>gboolean  </RETURNS>
 
1384
RygelMediaItem* self 
 
1385
</FUNCTION>
 
1386
<FUNCTION>
 
1387
<NAME>rygel_media_item_set_place_holder</NAME>
 
1388
<RETURNS>void  </RETURNS>
 
1389
RygelMediaItem* self, gboolean value 
 
1390
</FUNCTION>
 
1391
<FUNCTION>
 
1392
<NAME>rygel_media_item_get_description</NAME>
 
1393
<RETURNS>const gchar * </RETURNS>
 
1394
RygelMediaItem* self 
 
1395
</FUNCTION>
 
1396
<FUNCTION>
 
1397
<NAME>rygel_media_item_set_description</NAME>
 
1398
<RETURNS>void  </RETURNS>
 
1399
RygelMediaItem* self, const gchar* value 
 
1400
</FUNCTION>
 
1401
<FUNCTION>
 
1402
<NAME>rygel_media_object_get_writable</NAME>
 
1403
<RETURNS>void  </RETURNS>
 
1404
RygelMediaObject* self, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_ 
 
1405
</FUNCTION>
 
1406
<FUNCTION>
 
1407
<NAME>rygel_media_object_get_writable_finish</NAME>
 
1408
<RETURNS>GFile * </RETURNS>
 
1409
RygelMediaObject* self, GAsyncResult* _res_, GError** error 
 
1410
</FUNCTION>
 
1411
<FUNCTION>
 
1412
<NAME>rygel_media_object_get_writables</NAME>
 
1413
<RETURNS>void  </RETURNS>
 
1414
RygelMediaObject* self, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_ 
 
1415
</FUNCTION>
 
1416
<FUNCTION>
 
1417
<NAME>rygel_media_object_get_writables_finish</NAME>
 
1418
<RETURNS>GeeArrayList * </RETURNS>
 
1419
RygelMediaObject* self, GAsyncResult* _res_, GError** error 
 
1420
</FUNCTION>
 
1421
<FUNCTION>
 
1422
<NAME>rygel_media_object_compare_string_props</NAME>
 
1423
<RETURNS>gint  </RETURNS>
 
1424
RygelMediaObject* self, const gchar* prop1, const gchar* prop2 
 
1425
</FUNCTION>
 
1426
<FUNCTION>
 
1427
<NAME>rygel_media_object_compare_int_props</NAME>
 
1428
<RETURNS>gint  </RETURNS>
 
1429
RygelMediaObject* self, gint prop1, gint prop2 
 
1430
</FUNCTION>
 
1431
<FUNCTION>
 
1432
<NAME>rygel_media_object_construct</NAME>
 
1433
<RETURNS>RygelMediaObject * </RETURNS>
 
1434
GType object_type 
 
1435
</FUNCTION>
 
1436
<FUNCTION>
 
1437
<NAME>rygel_media_object_get_parent_ref</NAME>
 
1438
<RETURNS>RygelMediaContainer * </RETURNS>
 
1439
RygelMediaObject* self 
 
1440
</FUNCTION>
 
1441
<FUNCTION>
 
1442
<NAME>rygel_media_object_set_parent_ref</NAME>
 
1443
<RETURNS>void  </RETURNS>
 
1444
RygelMediaObject* self, RygelMediaContainer* value 
 
1445
</FUNCTION>
 
1446
<FUNCTION>
 
1447
<NAME>rygel_media_object_get_title</NAME>
 
1448
<RETURNS>const gchar * </RETURNS>
 
1449
RygelMediaObject* self 
 
1450
</FUNCTION>
 
1451
<FUNCTION>
 
1452
<NAME>rygel_media_object_set_title</NAME>
 
1453
<RETURNS>void  </RETURNS>
 
1454
RygelMediaObject* self, const gchar* value 
 
1455
</FUNCTION>
 
1456
<FUNCTION>
 
1457
<NAME>rygel_media_server_plugin_get_type</NAME>
 
1458
<RETURNS>GType  </RETURNS>
 
1459
void 
 
1460
</FUNCTION>
 
1461
<FUNCTION>
 
1462
<NAME>rygel_media_server_plugin_construct</NAME>
 
1463
<RETURNS>RygelMediaServerPlugin * </RETURNS>
 
1464
GType object_type, RygelMediaContainer* root_container, const gchar* name, const gchar* description 
 
1465
</FUNCTION>
 
1466
<FUNCTION>
 
1467
<NAME>rygel_search_expression_satisfied_by</NAME>
 
1468
<RETURNS>gboolean  </RETURNS>
 
1469
RygelSearchExpression* self, RygelMediaObject* media_object 
 
1470
</FUNCTION>
 
1471
<FUNCTION>
 
1472
<NAME>rygel_search_expression_to_string</NAME>
 
1473
<RETURNS>gchar * </RETURNS>
 
1474
RygelSearchExpression* self 
 
1475
</FUNCTION>
 
1476
<FUNCTION>
 
1477
<NAME>rygel_search_expression_construct</NAME>
 
1478
<RETURNS>RygelSearchExpression * </RETURNS>
 
1479
GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GType h_type, GBoxedCopyFunc h_dup_func, GDestroyNotify h_destroy_func, GType i_type, GBoxedCopyFunc i_dup_func, GDestroyNotify i_destroy_func 
 
1480
</FUNCTION>
 
1481
<FUNCTION>
 
1482
<NAME>rygel_searchable_container_search</NAME>
 
1483
<RETURNS>void  </RETURNS>
 
1484
RygelSearchableContainer* self, RygelSearchExpression* expression, guint offset, guint max_count, const gchar* sort_criteria, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_ 
 
1485
</FUNCTION>
 
1486
<FUNCTION>
 
1487
<NAME>rygel_searchable_container_search_finish</NAME>
 
1488
<RETURNS>RygelMediaObjects * </RETURNS>
 
1489
RygelSearchableContainer* self, GAsyncResult* _res_, guint* total_matches, GError** error 
 
1490
</FUNCTION>
 
1491
<FUNCTION>
 
1492
<NAME>rygel_searchable_container_simple_search</NAME>
 
1493
<RETURNS>void  </RETURNS>
 
1494
RygelSearchableContainer* self, RygelSearchExpression* expression, guint offset, guint max_count, const gchar* sort_criteria, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_ 
 
1495
</FUNCTION>
 
1496
<FUNCTION>
 
1497
<NAME>rygel_searchable_container_simple_search_finish</NAME>
 
1498
<RETURNS>RygelMediaObjects * </RETURNS>
 
1499
RygelSearchableContainer* self, GAsyncResult* _res_, guint* total_matches, GError** error 
 
1500
</FUNCTION>
 
1501
<FUNCTION>
 
1502
<NAME>rygel_searchable_container_find_object</NAME>
 
1503
<RETURNS>void  </RETURNS>
 
1504
RygelSearchableContainer* self, const gchar* id, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_ 
 
1505
</FUNCTION>
 
1506
<FUNCTION>
 
1507
<NAME>rygel_searchable_container_find_object_finish</NAME>
 
1508
<RETURNS>RygelMediaObject * </RETURNS>
 
1509
RygelSearchableContainer* self, GAsyncResult* _res_, GError** error 
 
1510
</FUNCTION>
 
1511
<FUNCTION>
 
1512
<NAME>rygel_searchable_container_get_search_classes</NAME>
 
1513
<RETURNS>GeeArrayList * </RETURNS>
 
1514
RygelSearchableContainer* self 
 
1515
</FUNCTION>
 
1516
<FUNCTION>
 
1517
<NAME>rygel_searchable_container_set_search_classes</NAME>
 
1518
<RETURNS>void  </RETURNS>
 
1519
RygelSearchableContainer* self, GeeArrayList* value 
 
1520
</FUNCTION>
 
1521
<FUNCTION>
 
1522
<NAME>rygel_visual_item_get_width</NAME>
 
1523
<RETURNS>gint  </RETURNS>
 
1524
RygelVisualItem* self 
 
1525
</FUNCTION>
 
1526
<FUNCTION>
 
1527
<NAME>rygel_visual_item_set_width</NAME>
 
1528
<RETURNS>void  </RETURNS>
 
1529
RygelVisualItem* self, gint value 
 
1530
</FUNCTION>
 
1531
<FUNCTION>
 
1532
<NAME>rygel_visual_item_get_height</NAME>
 
1533
<RETURNS>gint  </RETURNS>
 
1534
RygelVisualItem* self 
 
1535
</FUNCTION>
 
1536
<FUNCTION>
 
1537
<NAME>rygel_visual_item_set_height</NAME>
 
1538
<RETURNS>void  </RETURNS>
 
1539
RygelVisualItem* self, gint value 
 
1540
</FUNCTION>
 
1541
<FUNCTION>
 
1542
<NAME>rygel_visual_item_get_pixel_width</NAME>
 
1543
<RETURNS>gint  </RETURNS>
 
1544
RygelVisualItem* self 
 
1545
</FUNCTION>
 
1546
<FUNCTION>
 
1547
<NAME>rygel_visual_item_set_pixel_width</NAME>
 
1548
<RETURNS>void  </RETURNS>
 
1549
RygelVisualItem* self, gint value 
 
1550
</FUNCTION>
 
1551
<FUNCTION>
 
1552
<NAME>rygel_visual_item_get_pixel_height</NAME>
 
1553
<RETURNS>gint  </RETURNS>
 
1554
RygelVisualItem* self 
 
1555
</FUNCTION>
 
1556
<FUNCTION>
 
1557
<NAME>rygel_visual_item_set_pixel_height</NAME>
 
1558
<RETURNS>void  </RETURNS>
 
1559
RygelVisualItem* self, gint value 
 
1560
</FUNCTION>
 
1561
<FUNCTION>
 
1562
<NAME>rygel_visual_item_get_color_depth</NAME>
 
1563
<RETURNS>gint  </RETURNS>
 
1564
RygelVisualItem* self 
 
1565
</FUNCTION>
 
1566
<FUNCTION>
 
1567
<NAME>rygel_visual_item_set_color_depth</NAME>
 
1568
<RETURNS>void  </RETURNS>
 
1569
RygelVisualItem* self, gint value 
 
1570
</FUNCTION>
 
1571
<FUNCTION>
 
1572
<NAME>rygel_visual_item_get_thumbnails</NAME>
 
1573
<RETURNS>GeeArrayList * </RETURNS>
 
1574
RygelVisualItem* self 
 
1575
</FUNCTION>
 
1576
<FUNCTION>
 
1577
<NAME>rygel_visual_item_set_thumbnails</NAME>
 
1578
<RETURNS>void  </RETURNS>
 
1579
RygelVisualItem* self, GeeArrayList* value 
 
1580
</FUNCTION>
 
1581
<FUNCTION>
 
1582
<NAME>rygel_writable_container_get_type</NAME>
 
1583
<RETURNS>GType  </RETURNS>
 
1584
void 
 
1585
</FUNCTION>
 
1586
<FUNCTION>
 
1587
<NAME>rygel_writable_container_can_create</NAME>
 
1588
<RETURNS>gboolean  </RETURNS>
 
1589
RygelWritableContainer* self, const gchar* upnp_class 
 
1590
</FUNCTION>
 
1591
<FUNCTION>
 
1592
<NAME>rygel_writable_container_add_item</NAME>
 
1593
<RETURNS>void  </RETURNS>
 
1594
RygelWritableContainer* self, RygelMediaItem* item, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_ 
 
1595
</FUNCTION>
 
1596
<FUNCTION>
 
1597
<NAME>rygel_writable_container_add_item_finish</NAME>
 
1598
<RETURNS>void  </RETURNS>
 
1599
RygelWritableContainer* self, GAsyncResult* _res_, GError** error 
 
1600
</FUNCTION>
 
1601
<FUNCTION>
 
1602
<NAME>rygel_writable_container_remove_item</NAME>
 
1603
<RETURNS>void  </RETURNS>
 
1604
RygelWritableContainer* self, const gchar* id, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_ 
 
1605
</FUNCTION>
 
1606
<FUNCTION>
 
1607
<NAME>rygel_writable_container_remove_item_finish</NAME>
 
1608
<RETURNS>void  </RETURNS>
 
1609
RygelWritableContainer* self, GAsyncResult* _res_, GError** error 
 
1610
</FUNCTION>
 
1611
<FUNCTION>
 
1612
<NAME>rygel_writable_container_get_create_classes</NAME>
 
1613
<RETURNS>GeeArrayList * </RETURNS>
 
1614
RygelWritableContainer* self 
 
1615
</FUNCTION>
 
1616
<FUNCTION>
 
1617
<NAME>rygel_writable_container_set_create_classes</NAME>
 
1618
<RETURNS>void  </RETURNS>
 
1619
RygelWritableContainer* self, GeeArrayList* value 
 
1620
</FUNCTION>
 
1621
<FUNCTION>
 
1622
<NAME>rygel_media_server_get_type</NAME>
 
1623
<RETURNS>GType  </RETURNS>
 
1624
void 
 
1625
</FUNCTION>
 
1626
<FUNCTION>
 
1627
<NAME>rygel_media_server_new</NAME>
 
1628
<RETURNS>RygelMediaServer * </RETURNS>
 
1629
const gchar* title, RygelMediaContainer* root_container 
 
1630
</FUNCTION>
 
1631
<FUNCTION>
 
1632
<NAME>rygel_media_server_construct</NAME>
 
1633
<RETURNS>RygelMediaServer * </RETURNS>
 
1634
GType object_type, const gchar* title, RygelMediaContainer* root_container 
 
1635
</FUNCTION>
 
1636
<FUNCTION>
 
1637
<NAME>rygel_content_directory_error_quark</NAME>
 
1638
<RETURNS>GQuark  </RETURNS>
 
1639
void 
 
1640
</FUNCTION>
 
1641
<STRUCT>
 
1642
<NAME>RygelLogicalExpressionPrivate</NAME>
 
1643
</STRUCT>
 
1644
<STRUCT>
 
1645
<NAME>RygelMediaItemPrivate</NAME>
 
1646
</STRUCT>
 
1647
<STRUCT>
 
1648
<NAME>RygelMediaObjectPrivate</NAME>
 
1649
</STRUCT>
 
1650
<STRUCT>
 
1651
<NAME>RygelPhotoItemPrivate</NAME>
 
1652
</STRUCT>
 
1653
<STRUCT>
 
1654
<NAME>RygelVideoItemPrivate</NAME>
 
1655
</STRUCT>
 
1656
<STRUCT>
 
1657
<NAME>RygelImageItemPrivate</NAME>
 
1658
</STRUCT>
 
1659
<STRUCT>
 
1660
<NAME>RygelMusicItemPrivate</NAME>
 
1661
</STRUCT>
 
1662
<STRUCT>
 
1663
<NAME>RygelMediaServerPrivate</NAME>
 
1664
</STRUCT>
 
1665
<STRUCT>
 
1666
<NAME>RygelSearchableContainer</NAME>
 
1667
</STRUCT>
 
1668
<STRUCT>
 
1669
<NAME>RygelVisualItem</NAME>
 
1670
</STRUCT>
 
1671
<STRUCT>
 
1672
<NAME>RygelWritableContainer</NAME>
 
1673
</STRUCT>
 
1674
<STRUCT>
 
1675
<NAME>RygelTranscodeManagerClass</NAME>
 
1676
</STRUCT>
 
1677
<STRUCT>
 
1678
<NAME>RygelSubtitlePrivate</NAME>
 
1679
</STRUCT>
 
1680
<STRUCT>
 
1681
<NAME>RygelMediaServerPluginPrivate</NAME>
 
1682
</STRUCT>
 
1683
<STRUCT>
 
1684
<NAME>RygelHTTPServerClass</NAME>
 
1685
</STRUCT>
 
1686
<STRUCT>
 
1687
<NAME>RygelSimpleContainerPrivate</NAME>
 
1688
</STRUCT>
 
1689
<STRUCT>
 
1690
<NAME>RygelThumbnailPrivate</NAME>
 
1691
</STRUCT>
 
1692
<STRUCT>
 
1693
<NAME>RygelTranscodeManager</NAME>
 
1694
</STRUCT>
 
1695
<STRUCT>
 
1696
<NAME>RygelRelationalExpressionPrivate</NAME>
 
1697
</STRUCT>
 
1698
<STRUCT>
 
1699
<NAME>RygelAudioItemPrivate</NAME>
 
1700
</STRUCT>
 
1701
<STRUCT>
 
1702
<NAME>RygelHTTPServer</NAME>
 
1703
</STRUCT>
 
1704
<STRUCT>
 
1705
<NAME>RygelMediaArtStorePrivate</NAME>
 
1706
</STRUCT>
 
1707
<STRUCT>
 
1708
<NAME>RygelMediaObjectsPrivate</NAME>
 
1709
</STRUCT>
 
1710
<STRUCT>
 
1711
<NAME>RygelSearchExpressionPrivate</NAME>
 
1712
</STRUCT>
 
1713
<STRUCT>
 
1714
<NAME>RygelMediaContainerPrivate</NAME>
 
1715
</STRUCT>