1 { GLIB - Library of useful routines for C programming
2
3 Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
4
5 This library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2 of the License, or (at your option) any later version.
9
10 This library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public
16 License along with this library; if not, write to the
17 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18 Boston, MA 02110-1301, USA.
19 }
20 {
21 Modified by the GLib Team and others 1997-2000. See the AUTHORS
22 file for a list of people on the GLib Team. See the ChangeLog
23 files for a list of changes. These files are distributed with
24 GLib at ftp://ftp.gtk.org/pub/gtk/.
25 }
26 unit glib2; // keep unit name lowercase for kylix
27
28 {$IFDEF FPC}
29 {$mode objfpc}
30 {$ENDIF}
31 {$IFDEF VER140}
32 {$DEFINE KYLIX}
33 {$ENDIF}
34
35 interface
36
37 uses
38 ctypes,SysUtils;
39
40 const
41 {$ifdef windows}
42 {$define gtkwin}
43 gliblib = 'libglib-2.0-0.dll';
44 gthreadlib = 'libgthread-2.0-0.dll';
45 gmodulelib = 'libgmodule-2.0-0.dll';
46 gobjectlib = 'libgobject-2.0-0.dll';
47 {$IFDEF FPC}
48 {$ifndef NO_SMART_LINK}
49 {$smartlink on}
50 {$endif}
51 {$ENDIF}
52 {$else}
53 {$ifdef UseCustomLibs}
54 gliblib = '';
55 gthreadlib = '';
56 gmodulelib = '';
57 gobjectlib = '';
58 {$else}
59 gliblib = 'libglib-2.0.so';
60 gthreadlib = 'libgthread-2.0.so';
61 gmodulelib = 'libgmodule-2.0.so';
62 gobjectlib = 'libgobject-2.0.so';
63 {$endif}
64 {$endif}
65
66 {$ifdef FREEBSD}
67 {$linklib c}
68 {$linklib pthread}
69 {$endif}
70
71 {$IFNDEF KYLIX}
72 {$PACKRECORDS C}
73 {$ELSE}
74 {$ALIGN 4}
75 {$WEAKPACKAGEUNIT}
76 {$WARNINGS OFF}
77 {$ENDIF}
78
79 // {$define HasGLIB2_10}
80
81 {$DEFINE read_forward_definitions}
82 type
83 // internal types
84 PGTypePlugin = pointer;
85 PGParamSpecPool = pointer;
86
87 {$include gincludes.inc}
88 {$UNDEF read_forward_definitions}
89
90 {$DEFINE read_interface_types}
91 {$include gincludes.inc}
92 {$UNDEF read_interface_types}
93
94 {$DEFINE read_interface_rest}
95 {$include gincludes.inc}
96 {$UNDEF read_interface_rest}
97
98 implementation
99
100 {$DEFINE read_implementation}
101 {$include gincludes.inc}
102 {$UNDEF read_implementation}
103
104
105 {$IFNDEF KYLIX}
106 { There is a bug in the compiler. If an external variable is not used, it will
107 create code, that can't be relocated by the linker.
108 So, use them in this hidden dummy procedure.
109 }
110 procedure CheckUnusedVariable; [Public];
111 begin
112 if glib_mem_profiler_table=nil then ;
113 if (glib_interface_age=0) or (glib_binary_age=0)
114 or (g_thread_use_default_impl) then ;
115 end;
116 {$ENDIF}
117
118
119 {************************************
120 * macro functions
121 *
122 ************************************}
123
124 {*
125 * gtypes.inc
126 *}
GUINT16_SWAP_LE_BE_CONSTANTnull127 function GUINT16_SWAP_LE_BE_CONSTANT(val: guint16): guint16;
128 begin
129 Result:=((val and $ff) shl 8) or ((val and $ff00) shr 8);
130 end;
131
GUINT32_SWAP_LE_BE_CONSTANTnull132 function GUINT32_SWAP_LE_BE_CONSTANT(val: guint32): guint32;
133 begin
134 Result:=
135 ((val and $000000ff) shl 24) or
136 ((val and $0000ff00) shl 8) or
137 ((val and $00ff0000) shr 8) or
138 ((val and $ff000000) shr 24);
139 end;
140
141 {*
142 * glibconfig.inc
143 *}
GUINT_TO_POINTERnull144 function GUINT_TO_POINTER(i: guint): pointer;
145 begin
146 Result:=Pointer(PtrInt(i));
147 end;
148
149 {*
150 * garray.inc
151 *}
152
g_array_append_valnull153 function g_array_append_val(a: PGArray; v : gpointer) : PGArray;
154 begin
155 g_array_append_val := g_array_append_vals(a,@(v),1);
156 end;
157
g_array_prepend_valnull158 function g_array_prepend_val(a: PGArray; v : gpointer) : PGArray;
159 begin
160 g_array_prepend_val := g_array_prepend_vals(a,@(v),1);
161 end;
162
g_array_insert_valnull163 function g_array_insert_val(a: PGArray; i: guint; v : gpointer) : PGArray;
164 begin
165 g_array_insert_val := g_array_insert_vals(a,i,@(v),1);
166 end;
167
g_ptr_array_indexnull168 function g_ptr_array_index (parray: PGPtrArray; index: guint): gpointer;
169 begin
170 {$IFDEF FPC}
171 g_ptr_array_index := parray^.pdata[index];
172 {$ELSE}
173 g_ptr_array_index := PGPointer(integer(parray^.pdata) + index*SizeOf(GPointer))^;
174 {$ENDIF}
175 end;
176
177 {*
178 * gthread.inc
179 *}
180
G_THREAD_ERRORnull181 function G_THREAD_ERROR: TGQuark;
182 begin
183 G_THREAD_ERROR:=g_thread_error_quark;
184 end;
185
186 procedure g_mutex_lock (mutex: PGMutex);
187 begin
188 {$IFNDEF KYLIX}
189 if g_threads_got_initialized then
190 g_thread_functions_for_glib_use.mutex_lock (mutex);
191 {$ENDIF}
192 end;
193
g_mutex_trylocknull194 function g_mutex_trylock (mutex: PGMutex):gboolean;
195 begin
196 {$IFNDEF KYLIX}
197 if g_threads_got_initialized then
198 g_mutex_trylock := g_thread_functions_for_glib_use.mutex_trylock (mutex)
199 else
200 g_mutex_trylock := true;
201 {$ENDIF}
202 end;
203
204 procedure g_mutex_unlock (mutex: PGMutex);
205 begin
206 {$IFNDEF KYLIX}
207 if g_threads_got_initialized then
208 g_thread_functions_for_glib_use.mutex_unlock (mutex);
209 {$ENDIF}
210 end;
211
212 procedure g_mutex_free (mutex: PGMutex);
213 begin
214 {$IFNDEF KYLIX}
215 if g_threads_got_initialized then
216 g_thread_functions_for_glib_use.mutex_free (mutex);
217 {$ENDIF}
218 end;
219
220 procedure g_cond_wait (cond: PGCond; mutex: PGMutex);
221 begin
222 {$IFNDEF KYLIX}
223 if g_threads_got_initialized then
224 g_thread_functions_for_glib_use.cond_wait (cond, mutex);
225 {$ENDIF}
226 end;
227
g_cond_timed_waitnull228 function g_cond_timed_wait (cond : PGCond;
229 mutex : PGMutex;
230 end_time : PGTimeVal):gboolean;
231 begin
232 {$IFNDEF KYLIX}
233 if g_threads_got_initialized then
234 g_cond_timed_wait := g_thread_functions_for_glib_use.cond_timed_wait (cond,
235 mutex,
236 end_time)
237 else
238 g_cond_timed_wait := true;
239 {$ENDIF}
240 end;
241
242
g_thread_supportednull243 function g_thread_supported: gboolean;
244 begin
245 {$IFNDEF KYLIX}
246 g_thread_supported := g_threads_got_initialized;
247 {$ENDIF}
248 end;
249
g_mutex_newnull250 function g_mutex_new : PGMutex;
251 begin
252 {$IFNDEF KYLIX}
253 g_mutex_new := g_thread_functions_for_glib_use.mutex_new;
254 {$ENDIF}
255 end;
256
g_cond_newnull257 function g_cond_new : PGCond;
258 begin
259 {$IFNDEF KYLIX}
260 g_cond_new := g_thread_functions_for_glib_use.cond_new;
261 {$ENDIF}
262 end;
263
264 procedure g_cond_signal (cond: PGCond);
265 begin
266 {$IFNDEF KYLIX}
267 if g_threads_got_initialized then
268 g_thread_functions_for_glib_use.cond_signal (cond);
269 {$ENDIF}
270 end;
271
272 procedure g_cond_broadcast (cond: PGCond);
273 begin
274 {$IFNDEF KYLIX}
275 if g_threads_got_initialized then
276 g_thread_functions_for_glib_use.cond_broadcast (cond);
277 {$ENDIF}
278 end;
279
280 procedure g_cond_free (cond: PGCond);
281 begin
282 {$IFNDEF KYLIX}
283 if g_threads_got_initialized then
284 g_thread_functions_for_glib_use.cond_free (cond);
285 {$ENDIF}
286 end;
287
g_private_newnull288 function g_private_new (dest: TGDestroyNotify): PGPrivate;
289 begin
290 {$IFNDEF KYLIX}
291 g_private_new := g_thread_functions_for_glib_use.private_new (dest);
292 {$ENDIF}
293 end;
294
g_private_getnull295 function g_private_get (private_key: PGPrivate): gpointer;
296 begin
297 {$IFNDEF KYLIX}
298 // convert result to gpointer
299 if g_threads_got_initialized then
300 g_private_get := g_thread_functions_for_glib_use.private_get (private_key)
301 else
302 g_private_get := private_key;
303 {$ENDIF}
304 end;
305
306
307 procedure g_private_set (var private_key: PGPrivate; data: gpointer);
308 begin
309 {$IFNDEF KYLIX}
310 if g_threads_got_initialized then
311 // g_private_set := g_thread_functions_for_glib_use.private_set (private_key, data)
312 else
313 private_key := data; // data casted to GPrivate
314 {$ENDIF}
315 end;
316
317
318 procedure g_thread_yield;
319 begin
320 {$IFNDEF KYLIX}
321 if g_threads_got_initialized then
322 g_thread_functions_for_glib_use.thread_yield;
323 {$ENDIF}
324 end;
325
g_thread_createnull326 function g_thread_create (func: TGThreadFunc;
327 data: gpointer;
328 joinable: gboolean;
329 error: PPGError): PGThread;
330 begin
331 g_thread_create := g_thread_create_full (func, data, 0, joinable, false,
332 G_THREAD_PRIORITY_NORMAL, error);
333 end;
334
g_static_mutex_get_mutexnull335 function g_static_mutex_get_mutex(mutex: PPGMutex):PGMutex;
336 begin
337 g_static_mutex_get_mutex := g_static_mutex_get_mutex_impl (mutex);
338 end;
339
340 procedure g_static_mutex_lock (mutex: PGStaticMutex);
341 begin
342 g_mutex_lock (g_static_mutex_get_mutex_impl (PPGMutex(mutex)));
343 end;
344
g_static_mutex_trylocknull345 function g_static_mutex_trylock (mutex: PGStaticMutex): gboolean;
346 begin
347 g_static_mutex_trylock := g_mutex_trylock (g_static_mutex_get_mutex (PPGMutex(mutex)));
348 end;
349
350 procedure g_static_mutex_unlock (mutex: PGStaticMutex);
351 begin
352 g_mutex_unlock (g_static_mutex_get_mutex_impl (PPGMutex(mutex)));
353 end;
354
355 {*
356 * gmain.inc
357 *}
358
g_main_newnull359 function g_main_new(is_running: gboolean): PGMainLoop;
360 begin
361 g_main_new := g_main_loop_new (nil, is_running);
362 end;
363
g_main_iterationnull364 function g_main_iteration (may_block: gboolean): gboolean;
365 begin
366 g_main_iteration := g_main_context_iteration (nil, may_block);
367 end;
368
g_main_pendingnull369 function g_main_pending: gboolean;
370 begin
371 g_main_pending := g_main_context_pending (nil);
372 end;
373
374 procedure g_main_set_poll_func(func: TGPollFunc);
375 begin
376 g_main_context_set_poll_func (nil, func);
377 end;
378
379 {*
380 * gslist.inc
381 *}
382
g_slist_nextnull383 function g_slist_next(slist : PGSList) : PGSList;
384 begin
385 if slist <> nil then
386 g_slist_next := slist^.next
387 else
388 g_slist_next := nil;
389 end;
390
391 {*
392 * gmem.inc
393 *}
394
g_newnull395 function g_new(bytes_per_struct, n_structs: gsize): gpointer;
396 begin
397 g_new:=g_malloc(n_structs*bytes_per_struct);
398 end;
399
g_new0null400 function g_new0(bytes_per_struct, n_structs: gsize): gpointer;
401 begin
402 g_new0:=g_malloc0(n_structs*bytes_per_struct);
403 end;
404
g_renewnull405 function g_renew(struct_size: gsize; OldMem: gpointer; n_structs : gsize) : gpointer;
406 begin
407 g_renew:=g_realloc(OldMem,struct_size*n_structs);
408 end;
409
g_chunk_newnull410 function g_chunk_new(chunk : Pointer) : Pointer;
411 begin
412 g_chunk_new:=g_mem_chunk_alloc(chunk);
413 end;
414
g_chunk_new0null415 function g_chunk_new0(chunk : Pointer) : Pointer;
416 begin
417 g_chunk_new0:=g_mem_chunk_alloc0(chunk);
418 end;
419
420 procedure g_chunk_free(mem_chunk:PGMemChunk; mem:gpointer);
421 begin
422 g_mem_chunk_free(mem_chunk,mem);
423 end;
424
425
426 {*
427 * glist.inc
428 *}
g_list_previousnull429 function g_list_previous (list : PGList) : PGList;
430 begin
431 if list <> nil then
432 g_list_previous:=(PGList(list))^.prev
433 else
434 g_list_previous:=nil;
435 end;
436
g_list_nextnull437 function g_list_next (list : PGList) : PGList;
438 begin
439 if list <> nil then
440 g_list_next:=(PGList(list))^.next
441 else
442 g_list_next:=NULL;
443 end;
444
445 {*
446 * gconvert,inc
447 *}
G_CONVERT_ERRORnull448 function G_CONVERT_ERROR : TGQuark;
449 begin
450 G_CONVERT_ERROR:=g_convert_error_quark;
451 end;
452
453 {*
454 * gdataset.inc
455 *}
456
457 procedure g_datalist_id_set_data (datalist: PPGData; key_id:TGQuark; data: gpointer);
458 begin
459 g_datalist_id_set_data_full (datalist, key_id, data, nil);
460 end;
461
462 procedure g_datalist_id_remove_data (datalist: PPGData; key_id:TGQuark);
463 begin
464 g_datalist_id_set_data (datalist, key_id, NULL);
465 end;
466
g_datalist_get_datanull467 function g_datalist_get_data(datalist: PPGData; key_str:PGChar):PPGData;
468 begin
469 g_datalist_get_data := g_datalist_id_get_data (datalist, g_quark_try_string (key_str));
470 end;
471
472 procedure g_datalist_set_data_full(datalist: PPGData; key_str:PGChar; data:gpointer; destroy_func:TGDestroyNotify);
473 begin
474 g_datalist_id_set_data_full (datalist, g_quark_from_string (key_str), data, destroy_func);
475 end;
476
477 procedure g_datalist_set_data (datalist: PPGData; key_str:PGChar; data:gpointer);
478 begin
479 g_datalist_set_data_full (datalist, key_str, data, nil);
480 end;
481
482 procedure g_datalist_remove_no_notify(datalist: PPGData; key_str:PGChar);
483 begin
484 g_datalist_id_remove_no_notify (datalist, g_quark_try_string (key_str) );
485 end;
486
487 procedure g_datalist_remove_data(datalist:PPGData; key_str:PGChar);
488 begin
489 g_datalist_id_set_data (datalist, g_quark_try_string (key_str), nil);
490 end;
491
492 procedure g_dataset_id_set_data(location: gconstpointer; key_id:TGQuark; data:gpointer);
493 begin
494 g_dataset_id_set_data_full (location, key_id, data, nil);
495 end;
496
497 procedure g_dataset_id_remove_data(location: gconstpointer; key_id:TGQuark);
498 begin
499 g_dataset_id_set_data (location, key_id, nil);
500 end;
501
g_dataset_get_datanull502 function g_dataset_get_data(location: gconstpointer; key_str:PGChar): gpointer;
503 begin
504 g_dataset_get_data:= g_dataset_id_get_data (location, g_quark_try_string (key_str));
505 end;
506
507 procedure g_dataset_set_data_full(location: gconstpointer; key_str:PGChar; data:gpointer; destroy_func:TGDestroyNotify);
508 begin
509 g_dataset_id_set_data_full (location, g_quark_from_string (key_str), data, destroy_func);
510 end;
511
512 procedure g_dataset_remove_no_notify(location: gconstpointer; key_str:PGChar);
513 begin
514 g_dataset_id_remove_no_notify (location, g_quark_try_string (key_str));
515 end;
516
517 procedure g_dataset_set_data(location: gconstpointer; key_str:PGChar; data:gpointer);
518 begin
519 g_dataset_set_data_full (location, key_str, data, nil);
520 end;
521
522 procedure g_dataset_remove_data(location:gconstpointer; key_str: PGChar);
523 begin
524 g_dataset_id_set_data (location, g_quark_try_string (key_str), nil);
525 end;
526 {*
527 * gfileutils.inc
528 *}
G_FILE_ERRORnull529 function G_FILE_ERROR: TGQuark;
530 begin
531 G_FILE_ERROR:=g_file_error_quark;
532 end;
533
534 {*
535 * ghook.inc
536 *}
TGHookList_hook_sizenull537 function TGHookList_hook_size (var a : TGHookList) : guint;
538 begin
539 TGHookList_hook_size:=(a.flag0 and bm_TGHookList_hook_size) shr bp_TGHookList_hook_size;
540 end;
541
542 procedure TGHookList_set_hook_size (var a : TGHookList; __hook_size : guint);
543 begin
544 a.flag0:=a.flag0 or ((__hook_size shl bp_TGHookList_hook_size) and bm_TGHookList_hook_size);
545 end;
546
TGHookList_is_setupnull547 function TGHookList_is_setup (var a : TGHookList) : guint;
548 begin
549 TGHookList_is_setup:=(a.flag0 and bm_TGHookList_is_setup) shr bp_TGHookList_is_setup;
550 end;
551
552 procedure TGHookList_set_is_setup (var a : TGHookList; __is_setup : guint);
553 begin
554 a.flag0:=a.flag0 or ((__is_setup shl bp_TGHookList_is_setup) and bm_TGHookList_is_setup);
555 end;
556
G_HOOKnull557 function G_HOOK(hook : pointer) : PGHook;
558 begin
559 G_HOOK := PGHook(hook);
560 end;
561
G_HOOK_FLAGSnull562 function G_HOOK_FLAGS(hook : PGHook) : guint;
563 begin
564 G_HOOK_FLAGS := hook^.flags;
565 end;
566 { from the old glib}
G_HOOK_ACTIVEnull567 function G_HOOK_ACTIVE(hook : PGHook) : boolean;
568 begin
569 G_HOOK_ACTIVE:=(((PGHook(hook))^.flags) and cardinal(G_HOOK_FLAG_ACTIVE)) <> 0;
570 end;
571
G_HOOK_IN_CALLnull572 function G_HOOK_IN_CALL(hook : PGHook) : boolean;
573 begin
574 G_HOOK_IN_CALL:=(((PGHook(hook))^.flags) and cardinal(G_HOOK_FLAG_IN_CALL)) <> 0;
575 end;
576
G_HOOK_IS_VALIDnull577 function G_HOOK_IS_VALID(hook : PGHook) : boolean;
578 begin
579 G_HOOK_IS_VALID:=(hook^.hook_id<>0) and G_HOOK_ACTIVE(hook);
580 end;
581
G_HOOK_IS_UNLINKEDnull582 function G_HOOK_IS_UNLINKED(hook : PGHook) : boolean;
583 begin
584 G_HOOK_IS_UNLINKED:=(hook^.next=NULL) and (hook^.prev=NULL) and (hook^.hook_id=0) and (hook^.ref_count = 0);
585 end;
586 { end of old glib}
587
588 procedure g_hook_append (hook_list: PGHookList; hook:PGHook);
589 begin
590 g_hook_insert_before (hook_list, nil, hook);
591 end;
592
593 {*
594 * giochannel.inc
595 *}
G_IO_CHANNEL_ERRORnull596 function G_IO_CHANNEL_ERROR : TGQuark;
597 begin
598 G_IO_CHANNEL_ERROR:=g_io_channel_error_quark;
599 end;
600
TGIOChannel_use_buffernull601 function TGIOChannel_use_buffer(var a : TGIOChannel) : guint;
602 begin
603 TGIOChannel_use_buffer:=(a.flag0 and bm_TGIOChannel_use_buffer) shr bp_TGIOChannel_use_buffer;
604 end;
605
606 procedure TGIOChannel_set_use_buffer(var a : TGIOChannel; __use_buffer : guint);
607 begin
608 a.flag0:=a.flag0 or ((__use_buffer shl bp_TGIOChannel_use_buffer) and bm_TGIOChannel_use_buffer);
609 end;
610
TGIOChannel_do_encodenull611 function TGIOChannel_do_encode(var a : TGIOChannel) : guint;
612 begin
613 TGIOChannel_do_encode:=(a.flag0 and bm_TGIOChannel_do_encode) shr bp_TGIOChannel_do_encode;
614 end;
615
616 procedure TGIOChannel_set_do_encode(var a : TGIOChannel; __do_encode : guint);
617 begin
618 a.flag0:=a.flag0 or ((__do_encode shl bp_TGIOChannel_do_encode) and bm_TGIOChannel_do_encode);
619 end;
620
TGIOChannel_close_on_unrefnull621 function TGIOChannel_close_on_unref(var a : TGIOChannel) : guint;
622 begin
623 TGIOChannel_close_on_unref:=(a.flag0 and bm_TGIOChannel_close_on_unref) shr bp_TGIOChannel_close_on_unref;
624 end;
625
626 procedure TGIOChannel_set_close_on_unref(var a : TGIOChannel; __close_on_unref : guint);
627 begin
628 a.flag0:=a.flag0 or ((__close_on_unref shl bp_TGIOChannel_close_on_unref) and bm_TGIOChannel_close_on_unref);
629 end;
630
TGIOChannel_is_readablenull631 function TGIOChannel_is_readable(var a : TGIOChannel) : guint;
632 begin
633 TGIOChannel_is_readable:=(a.flag0 and bm_TGIOChannel_is_readable) shr bp_TGIOChannel_is_readable;
634 end;
635
636 procedure TGIOChannel_set_is_readable(var a : TGIOChannel; __is_readable : guint);
637 begin
638 a.flag0:=a.flag0 or ((__is_readable shl bp_TGIOChannel_is_readable) and bm_TGIOChannel_is_readable);
639 end;
640
TGIOChannel_is_writeablenull641 function TGIOChannel_is_writeable(var a : TGIOChannel) : guint;
642 begin
643 TGIOChannel_is_writeable:=(a.flag0 and bm_TGIOChannel_is_writeable) shr bp_TGIOChannel_is_writeable;
644 end;
645
646 procedure TGIOChannel_set_is_writeable(var a : TGIOChannel; __is_writeable : guint);
647 begin
648 a.flag0:=a.flag0 or ((__is_writeable shl bp_TGIOChannel_is_writeable) and bm_TGIOChannel_is_writeable);
649 end;
650
TGIOChannel_is_seekablenull651 function TGIOChannel_is_seekable(var a : TGIOChannel) : guint;
652 begin
653 TGIOChannel_is_seekable:=(a.flag0 and bm_TGIOChannel_is_seekable) shr bp_TGIOChannel_is_seekable;
654 end;
655
656 procedure TGIOChannel_set_is_seekable(var a : TGIOChannel; __is_seekable : guint);
657 begin
658 a.flag0:=a.flag0 or ((__is_seekable shl bp_TGIOChannel_is_seekable) and bm_TGIOChannel_is_seekable);
659 end;
660 {*
661 * gunicode.inc
662 *}
g_utf8_next_charnull663 function g_utf8_next_char (p: pguchar):pguchar;
664 begin
665 {$IFNDEF KYLIX}
666 g_utf8_next_char := p + ord ((g_utf8_skip + p^ )^); // needs to be tested
667 {$ENDIF}
668 end;
669
670 {*
671 * gutils.inc
672 *}
GLIB_CHECK_VERSIONnull673 function GLIB_CHECK_VERSION (major, minor, micro: guint):boolean;
674 begin
675 {$IFNDEF KYLIX}
676 GLIB_CHECK_VERSION := ( (GLIB_MAJOR_VERSION > major) or
677 ((GLIB_MAJOR_VERSION = major) and (GLIB_MINOR_VERSION > minor)) or
678 ((GLIB_MAJOR_VERSION = major) and (GLIB_MINOR_VERSION = minor) and (GLIB_MICRO_VERSION >= micro)));
679 {$ENDIF}
680 end;
681 {*
682 * gmessages.inc
683 *}
684 procedure g_error (format:Pgchar; args: array of const);
685 begin
686 g_log (G_LOG_DOMAIN, G_LOG_LEVEL_ERROR, Pgchar(SysUtils.Format(string(format), args)));
687 end;
688
689 procedure g_error (format:Pgchar);
690 begin
691 g_log (G_LOG_DOMAIN, G_LOG_LEVEL_ERROR, format);
692 end;
693
694 procedure g_message (format:Pgchar; args: array of const);
695 begin
696 g_log (G_LOG_DOMAIN, G_LOG_LEVEL_MESSAGE, Pgchar(SysUtils.Format(string(format), args)));
697 end;
698
699 procedure g_message (format:Pgchar);
700 begin
701 g_log (G_LOG_DOMAIN, G_LOG_LEVEL_MESSAGE, format);
702 end;
703
704 procedure g_critical (format:Pgchar; args: array of const);
705 begin
706 g_log (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, Pgchar(SysUtils.Format(string(format), args)));
707 end;
708
709 procedure g_critical (format:Pgchar);
710 begin
711 g_log (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, format);
712 end;
713
714 procedure g_warning (format:Pgchar; args: array of const);
715 begin
716 g_log (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING, Pgchar(SysUtils.Format(string(format), args)));
717 end;
718
719 procedure g_warning (format:Pgchar);
720 begin
721 g_log (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING, format);
722 end;
723
724 {*
725 * gmarkup.inc
726 *}
G_MARKUP_ERRORnull727 function G_MARKUP_ERROR : TGQuark;
728 begin
729 G_MARKUP_ERROR:=g_markup_error_quark;
730 end;
731
732 {*
733 * gnode.inc
734 *}
G_NODE_IS_ROOTnull735 function G_NODE_IS_ROOT (node: PGNode): boolean;
736 begin
737 G_NODE_IS_ROOT := (node^.parent = nil) and (node^.next = nil) and (node^.prev = nil);
738 end;
739
G_NODE_IS_LEAFnull740 function G_NODE_IS_LEAF (node: PGNode): boolean;
741 begin
742 G_NODE_IS_LEAF := node^.children = nil;
743 end;
744
g_node_appendnull745 function g_node_append (parent: PGNode; node: PGNode): PGNode;
746 begin
747 g_node_append := g_node_insert_before (parent, nil, node);
748 end;
749
g_node_insert_datanull750 function g_node_insert_data (parent: PGNode; position: gint; data: gpointer): PGNode;
751 begin
752 g_node_insert_data := g_node_insert (parent, position, g_node_new(data));
753 end;
754
g_node_insert_data_beforenull755 function g_node_insert_data_before (parent: PGNode; sibling: PGNode; data: gpointer): PGNode;
756 begin
757 g_node_insert_data_before := g_node_insert_before (parent, sibling, g_node_new(data));
758 end;
759
g_node_prepend_datanull760 function g_node_prepend_data (parent: PGNode; data: gpointer): PGNode;
761 begin
762 g_node_prepend_data := g_node_prepend (parent, g_node_new(data));
763 end;
764
g_node_append_datanull765 function g_node_append_data (parent: PGNode; data: gpointer): PGNode;
766 begin
767 g_node_append_data := g_node_insert_before (parent, nil, g_node_new(data));
768 end;
769
g_node_prev_siblingnull770 function g_node_prev_sibling (node : PGNode): PGNode;
771 begin
772 if node <> nil then
773 g_node_prev_sibling := node^.prev
774 else
775 g_node_prev_sibling := nil;
776 end;
777
g_node_next_siblingnull778 function g_node_next_sibling (node : PGNode): PGNode;
779 begin
780 if node <> nil then
781 g_node_next_sibling := node^.next
782 else
783 g_node_next_sibling := nil;
784 end;
785
g_node_first_childnull786 function g_node_first_child (node : PGNode): PGNode;
787 begin
788 if node <> nil then
789 g_node_first_child := node^.children
790 else
791 g_node_first_child := nil;
792 end;
793
794 {*
795 * grand.inc
796 *}
797
g_rand_booleannull798 function g_rand_boolean(rand : PGRand) : gboolean;
799 begin
800 g_rand_boolean:=((g_rand_int(rand)) and (1 shl 15)) <> 0;
801 end;
802 {
803 function g_rand_boolean(rand : PGRand) :gboolean;
804 begin
805 if ((g_rand_int(rand)) and (1 shl 15)) <> 0 then
806 g_rand_boolean := 1
807 else
808 g_rand_boolean := 0;
809 end;
810 }
g_random_booleannull811 function g_random_boolean : gboolean;
812 begin
813 g_random_boolean:=((g_random_int) and (1 shl 15)) <> 0;
814 end;
815 {
816 function g_random_boolean : gboolean;
817 begin
818 if (((g_random_int) and (1 shl 15))) <> 0 then
819 g_random_boolean := 1
820 else
821 g_random_boolean := 0;
822 end;
823 }
824
825 {*
826 * gscanner.inc
827 *}
TGScannerConfig_case_sensitivenull828 function TGScannerConfig_case_sensitive(var a : TGScannerConfig) : guint;
829 begin
830 TGScannerConfig_case_sensitive:=(a.flag0 and bm_TGScannerConfig_case_sensitive) shr bp_TGScannerConfig_case_sensitive;
831 end;
832
833 procedure TGScannerConfig_set_case_sensitive(var a : TGScannerConfig; __case_sensitive : guint);
834 begin
835 a.flag0:=a.flag0 or ((__case_sensitive shl bp_TGScannerConfig_case_sensitive) and bm_TGScannerConfig_case_sensitive);
836 end;
837
TGScannerConfig_skip_comment_multinull838 function TGScannerConfig_skip_comment_multi(var a : TGScannerConfig) : guint;
839 begin
840 TGScannerConfig_skip_comment_multi:=(a.flag0 and bm_TGScannerConfig_skip_comment_multi) shr bp_TGScannerConfig_skip_comment_multi;
841 end;
842
843 procedure TGScannerConfig_set_skip_comment_multi(var a : TGScannerConfig; __skip_comment_multi : guint);
844 begin
845 a.flag0:=a.flag0 or ((__skip_comment_multi shl bp_TGScannerConfig_skip_comment_multi) and bm_TGScannerConfig_skip_comment_multi);
846 end;
847
TGScannerConfig_skip_comment_singlenull848 function TGScannerConfig_skip_comment_single(var a : TGScannerConfig) : guint;
849 begin
850 TGScannerConfig_skip_comment_single:=(a.flag0 and bm_TGScannerConfig_skip_comment_single) shr bp_TGScannerConfig_skip_comment_single;
851 end;
852
853 procedure TGScannerConfig_set_skip_comment_single(var a : TGScannerConfig; __skip_comment_single : guint);
854 begin
855 a.flag0:=a.flag0 or ((__skip_comment_single shl bp_TGScannerConfig_skip_comment_single) and bm_TGScannerConfig_skip_comment_single);
856 end;
857
TGScannerConfig_scan_comment_multinull858 function TGScannerConfig_scan_comment_multi(var a : TGScannerConfig) : guint;
859 begin
860 TGScannerConfig_scan_comment_multi:=(a.flag0 and bm_TGScannerConfig_scan_comment_multi) shr bp_TGScannerConfig_scan_comment_multi;
861 end;
862
863 procedure TGScannerConfig_set_scan_comment_multi(var a : TGScannerConfig; __scan_comment_multi : guint);
864 begin
865 a.flag0:=a.flag0 or ((__scan_comment_multi shl bp_TGScannerConfig_scan_comment_multi) and bm_TGScannerConfig_scan_comment_multi);
866 end;
867
TGScannerConfig_scan_identifiernull868 function TGScannerConfig_scan_identifier(var a : TGScannerConfig) : guint;
869 begin
870 TGScannerConfig_scan_identifier:=(a.flag0 and bm_TGScannerConfig_scan_identifier) shr bp_TGScannerConfig_scan_identifier;
871 end;
872
873 procedure TGScannerConfig_set_scan_identifier(var a : TGScannerConfig; __scan_identifier : guint);
874 begin
875 a.flag0:=a.flag0 or ((__scan_identifier shl bp_TGScannerConfig_scan_identifier) and bm_TGScannerConfig_scan_identifier);
876 end;
877
TGScannerConfig_scan_identifier_1charnull878 function TGScannerConfig_scan_identifier_1char(var a : TGScannerConfig) : guint;
879 begin
880 TGScannerConfig_scan_identifier_1char:=(a.flag0 and bm_TGScannerConfig_scan_identifier_1char) shr bp_TGScannerConfig_scan_identifier_1char;
881 end;
882
883 procedure TGScannerConfig_set_scan_identifier_1char(var a : TGScannerConfig; __scan_identifier_1char : guint);
884 begin
885 a.flag0:=a.flag0 or ((__scan_identifier_1char shl bp_TGScannerConfig_scan_identifier_1char) and bm_TGScannerConfig_scan_identifier_1char);
886 end;
887
TGScannerConfig_scan_identifier_NULLnull888 function TGScannerConfig_scan_identifier_NULL(var a : TGScannerConfig) : guint;
889 begin
890 TGScannerConfig_scan_identifier_NULL:=(a.flag0 and bm_TGScannerConfig_scan_identifier_NULL) shr bp_TGScannerConfig_scan_identifier_NULL;
891 end;
892
893 procedure TGScannerConfig_set_scan_identifier_NULL(var a : TGScannerConfig; __scan_identifier_NULL : guint);
894 begin
895 a.flag0:=a.flag0 or ((__scan_identifier_NULL shl bp_TGScannerConfig_scan_identifier_NULL) and bm_TGScannerConfig_scan_identifier_NULL);
896 end;
897
TGScannerConfig_scan_symbolsnull898 function TGScannerConfig_scan_symbols(var a : TGScannerConfig) : guint;
899 begin
900 TGScannerConfig_scan_symbols:=(a.flag0 and bm_TGScannerConfig_scan_symbols) shr bp_TGScannerConfig_scan_symbols;
901 end;
902
903 procedure TGScannerConfig_set_scan_symbols(var a : TGScannerConfig; __scan_symbols : guint);
904 begin
905 a.flag0:=a.flag0 or ((__scan_symbols shl bp_TGScannerConfig_scan_symbols) and bm_TGScannerConfig_scan_symbols);
906 end;
907
TGScannerConfig_scan_binarynull908 function TGScannerConfig_scan_binary(var a : TGScannerConfig) : guint;
909 begin
910 TGScannerConfig_scan_binary:=(a.flag0 and bm_TGScannerConfig_scan_binary) shr bp_TGScannerConfig_scan_binary;
911 end;
912
913 procedure TGScannerConfig_set_scan_binary(var a : TGScannerConfig; __scan_binary : guint);
914 begin
915 a.flag0:=a.flag0 or ((__scan_binary shl bp_TGScannerConfig_scan_binary) and bm_TGScannerConfig_scan_binary);
916 end;
917
TGScannerConfig_scan_octalnull918 function TGScannerConfig_scan_octal(var a : TGScannerConfig) : guint;
919 begin
920 TGScannerConfig_scan_octal:=(a.flag0 and bm_TGScannerConfig_scan_octal) shr bp_TGScannerConfig_scan_octal;
921 end;
922
923 procedure TGScannerConfig_set_scan_octal(var a : TGScannerConfig; __scan_octal : guint);
924 begin
925 a.flag0:=a.flag0 or ((__scan_octal shl bp_TGScannerConfig_scan_octal) and bm_TGScannerConfig_scan_octal);
926 end;
927
TGScannerConfig_scan_floatnull928 function TGScannerConfig_scan_float(var a : TGScannerConfig) : guint;
929 begin
930 TGScannerConfig_scan_float:=(a.flag0 and bm_TGScannerConfig_scan_float) shr bp_TGScannerConfig_scan_float;
931 end;
932
933 procedure TGScannerConfig_set_scan_float(var a : TGScannerConfig; __scan_float : guint);
934 begin
935 a.flag0:=a.flag0 or ((__scan_float shl bp_TGScannerConfig_scan_float) and bm_TGScannerConfig_scan_float);
936 end;
937
TGScannerConfig_scan_hexnull938 function TGScannerConfig_scan_hex(var a : TGScannerConfig) : guint;
939 begin
940 TGScannerConfig_scan_hex:=(a.flag0 and bm_TGScannerConfig_scan_hex) shr bp_TGScannerConfig_scan_hex;
941 end;
942
943 procedure TGScannerConfig_set_scan_hex(var a : TGScannerConfig; __scan_hex : guint);
944 begin
945 a.flag0:=a.flag0 or ((__scan_hex shl bp_TGScannerConfig_scan_hex) and bm_TGScannerConfig_scan_hex);
946 end;
947
TGScannerConfig_scan_hex_dollarnull948 function TGScannerConfig_scan_hex_dollar(var a : TGScannerConfig) : guint;
949 begin
950 TGScannerConfig_scan_hex_dollar:=(a.flag0 and bm_TGScannerConfig_scan_hex_dollar) shr bp_TGScannerConfig_scan_hex_dollar;
951 end;
952
953 procedure TGScannerConfig_set_scan_hex_dollar(var a : TGScannerConfig; __scan_hex_dollar : guint);
954 begin
955 a.flag0:=a.flag0 or ((__scan_hex_dollar shl bp_TGScannerConfig_scan_hex_dollar) and bm_TGScannerConfig_scan_hex_dollar);
956 end;
957
TGScannerConfig_scan_string_sqnull958 function TGScannerConfig_scan_string_sq(var a : TGScannerConfig) : guint;
959 begin
960 TGScannerConfig_scan_string_sq:=(a.flag0 and bm_TGScannerConfig_scan_string_sq) shr bp_TGScannerConfig_scan_string_sq;
961 end;
962
963 procedure TGScannerConfig_set_scan_string_sq(var a : TGScannerConfig; __scan_string_sq : guint);
964 begin
965 a.flag0:=a.flag0 or ((__scan_string_sq shl bp_TGScannerConfig_scan_string_sq) and bm_TGScannerConfig_scan_string_sq);
966 end;
967
TGScannerConfig_scan_string_dqnull968 function TGScannerConfig_scan_string_dq(var a : TGScannerConfig) : guint;
969 begin
970 TGScannerConfig_scan_string_dq:=(a.flag0 and bm_TGScannerConfig_scan_string_dq) shr bp_TGScannerConfig_scan_string_dq;
971 end;
972
973 procedure TGScannerConfig_set_scan_string_dq(var a : TGScannerConfig; __scan_string_dq : guint);
974 begin
975 a.flag0:=a.flag0 or ((__scan_string_dq shl bp_TGScannerConfig_scan_string_dq) and bm_TGScannerConfig_scan_string_dq);
976 end;
977
TGScannerConfig_numbers_2_intnull978 function TGScannerConfig_numbers_2_int(var a : TGScannerConfig) : guint;
979 begin
980 TGScannerConfig_numbers_2_int:=(a.flag0 and bm_TGScannerConfig_numbers_2_int) shr bp_TGScannerConfig_numbers_2_int;
981 end;
982
983 procedure TGScannerConfig_set_numbers_2_int(var a : TGScannerConfig; __numbers_2_int : guint);
984 begin
985 a.flag0:=a.flag0 or ((__numbers_2_int shl bp_TGScannerConfig_numbers_2_int) and bm_TGScannerConfig_numbers_2_int);
986 end;
987
TGScannerConfig_int_2_floatnull988 function TGScannerConfig_int_2_float(var a : TGScannerConfig) : guint;
989 begin
990 TGScannerConfig_int_2_float:=(a.flag0 and bm_TGScannerConfig_int_2_float) shr bp_TGScannerConfig_int_2_float;
991 end;
992
993 procedure TGScannerConfig_set_int_2_float(var a : TGScannerConfig; __int_2_float : guint);
994 begin
995 a.flag0:=a.flag0 or ((__int_2_float shl bp_TGScannerConfig_int_2_float) and bm_TGScannerConfig_int_2_float);
996 end;
997
TGScannerConfig_identifier_2_stringnull998 function TGScannerConfig_identifier_2_string(var a : TGScannerConfig) : guint;
999 begin
1000 TGScannerConfig_identifier_2_string:=(a.flag0 and bm_TGScannerConfig_identifier_2_string) shr bp_TGScannerConfig_identifier_2_string;
1001 end;
1002
1003 procedure TGScannerConfig_set_identifier_2_string(var a : TGScannerConfig; __identifier_2_string : guint);
1004 begin
1005 a.flag0:=a.flag0 or ((__identifier_2_string shl bp_TGScannerConfig_identifier_2_string) and bm_TGScannerConfig_identifier_2_string);
1006 end;
1007
TGScannerConfig_char_2_tokennull1008 function TGScannerConfig_char_2_token(var a : TGScannerConfig) : guint;
1009 begin
1010 TGScannerConfig_char_2_token:=(a.flag0 and bm_TGScannerConfig_char_2_token) shr bp_TGScannerConfig_char_2_token;
1011 end;
1012
1013 procedure TGScannerConfig_set_char_2_token(var a : TGScannerConfig; __char_2_token : guint);
1014 begin
1015 a.flag0:=a.flag0 or ((__char_2_token shl bp_TGScannerConfig_char_2_token) and bm_TGScannerConfig_char_2_token);
1016 end;
1017
TGScannerConfig_symbol_2_tokennull1018 function TGScannerConfig_symbol_2_token(var a : TGScannerConfig) : guint;
1019 begin
1020 TGScannerConfig_symbol_2_token:=(a.flag0 and bm_TGScannerConfig_symbol_2_token) shr bp_TGScannerConfig_symbol_2_token;
1021 end;
1022
1023 procedure TGScannerConfig_set_symbol_2_token(var a : TGScannerConfig; __symbol_2_token : guint);
1024 begin
1025 a.flag0:=a.flag0 or ((__symbol_2_token shl bp_TGScannerConfig_symbol_2_token) and bm_TGScannerConfig_symbol_2_token);
1026 end;
1027
TGScannerConfig_scope_0_fallbacknull1028 function TGScannerConfig_scope_0_fallback(var a : TGScannerConfig) : guint;
1029 begin
1030 TGScannerConfig_scope_0_fallback:=(a.flag0 and bm_TGScannerConfig_scope_0_fallback) shr bp_TGScannerConfig_scope_0_fallback;
1031 end;
1032
1033 procedure TGScannerConfig_set_scope_0_fallback(var a : TGScannerConfig; __scope_0_fallback : guint);
1034 begin
1035 a.flag0:=a.flag0 or ((__scope_0_fallback shl bp_TGScannerConfig_scope_0_fallback) and bm_TGScannerConfig_scope_0_fallback);
1036 end;
1037
1038 procedure g_scanner_freeze_symbol_table(scanner : PGScanner);
1039 begin
1040 { do nothing }
1041 if Scanner=nil then ;
1042 end;
1043
1044 procedure g_scanner_thaw_symbol_table(scanner : PGScanner);
1045 begin
1046 { do nothing }
1047 if Scanner=nil then ;
1048 end;
1049 {*
1050 * gshell.inc
1051 *}
G_SHELL_ERRORnull1052 function G_SHELL_ERROR : TGQuark;
1053 begin
1054 G_SHELL_ERROR:=g_shell_error_quark;
1055 end;
1056
1057 {*
1058 * gspawn.inc
1059 *}
G_SPAWN_ERRORnull1060 function G_SPAWN_ERROR : TGQuark;
1061 begin
1062 G_SPAWN_ERROR:=g_spawn_error_quark;
1063 end;
1064
1065
1066 // from gstrfuncs.inc ----------------------------------------------------------
1067
g_ascii_isalnumnull1068 function g_ascii_isalnum(c : gchar) : boolean;
1069 begin
1070 {$IFNDEF KYLIX}
1071 g_ascii_isalnum:=((g_ascii_table[guchar(c)]) and G_ASCII_ALNUM) <> 0;
1072 {$ENDIF}
1073 end;
1074
g_ascii_isalphanull1075 function g_ascii_isalpha(c : gchar) : boolean;
1076 begin
1077 {$IFNDEF KYLIX}
1078 g_ascii_isalpha:=((g_ascii_table[guchar(c)]) and G_ASCII_ALPHA) <> 0;
1079 {$ENDIF}
1080 end;
1081
g_ascii_iscntrlnull1082 function g_ascii_iscntrl(c : gchar) : boolean;
1083 begin
1084 {$IFNDEF KYLIX}
1085 g_ascii_iscntrl:=((g_ascii_table[guchar(c)]) and G_ASCII_CNTRL) <> 0;
1086 {$ENDIF}
1087 end;
1088
g_ascii_isdigitnull1089 function g_ascii_isdigit(c : gchar) : boolean;
1090 begin
1091 {$IFNDEF KYLIX}
1092 g_ascii_isdigit:=((g_ascii_table[guchar(c)]) and G_ASCII_DIGIT) <> 0;
1093 {$ENDIF}
1094 end;
1095
g_ascii_isgraphnull1096 function g_ascii_isgraph(c : gchar) : boolean;
1097 begin
1098 {$IFNDEF KYLIX}
1099 g_ascii_isgraph:=((g_ascii_table[guchar(c)]) and G_ASCII_GRAPH) <> 0;
1100 {$ENDIF}
1101 end;
1102
g_ascii_islowernull1103 function g_ascii_islower(c : gchar) : boolean;
1104 begin
1105 {$IFNDEF KYLIX}
1106 g_ascii_islower:=((g_ascii_table[guchar(c)]) and G_ASCII_LOWER) <> 0;
1107 {$ENDIF}
1108 end;
1109
g_ascii_isprintnull1110 function g_ascii_isprint(c : gchar) : boolean;
1111 begin
1112 {$IFNDEF KYLIX}
1113 g_ascii_isprint:=((g_ascii_table[guchar(c)]) and G_ASCII_PRINT) <> 0;
1114 {$ENDIF}
1115 end;
1116
g_ascii_ispunctnull1117 function g_ascii_ispunct(c : gchar) : boolean;
1118 begin
1119 {$IFNDEF KYLIX}
1120 g_ascii_ispunct:=((g_ascii_table[guchar(c)]) and G_ASCII_PUNCT) <> 0;
1121 {$ENDIF}
1122 end;
1123
g_ascii_isspacenull1124 function g_ascii_isspace(c : gchar) : boolean;
1125 begin
1126 {$IFNDEF KYLIX}
1127 g_ascii_isspace:=((g_ascii_table[guchar(c)]) and G_ASCII_SPACE) <> 0;
1128 {$ENDIF}
1129 end;
1130
g_ascii_isuppernull1131 function g_ascii_isupper(c : gchar) : boolean;
1132 begin
1133 {$IFNDEF KYLIX}
1134 g_ascii_isupper:=((g_ascii_table[guchar(c)]) and G_ASCII_UPPER) <> 0;
1135 {$ENDIF}
1136 end;
1137
g_ascii_isxdigitnull1138 function g_ascii_isxdigit(c : gchar) : boolean;
1139 begin
1140 {$IFNDEF KYLIX}
1141 g_ascii_isxdigit:=((g_ascii_table[guchar(c)]) and G_ASCII_XDIGIT) <> 0;
1142 {$ENDIF}
1143 end;
1144
g_strstripnull1145 function g_strstrip(_string : PGChar) : PGChar;
1146 begin
1147 g_strstrip:=g_strchomp(g_strchug(_string));
1148 end;
1149
1150 // gtype.inc -------------------------------------------------------------------
1151
G_TYPE_MAKE_FUNDAMENTALnull1152 function G_TYPE_MAKE_FUNDAMENTAL(x : longint) : GType;
1153 begin
1154 G_TYPE_MAKE_FUNDAMENTAL:=GType(x shl G_TYPE_FUNDAMENTAL_SHIFT);
1155 end;
1156
G_TYPE_IS_FUNDAMENTALnull1157 function G_TYPE_IS_FUNDAMENTAL(_type : GType) : boolean;
1158 begin
1159 G_TYPE_IS_FUNDAMENTAL:=_type <= G_TYPE_FUNDAMENTAL_MAX;
1160 end;
1161
G_TYPE_IS_DERIVEDnull1162 function G_TYPE_IS_DERIVED(_type : GType) : boolean;
1163 begin
1164 G_TYPE_IS_DERIVED:=_type > G_TYPE_FUNDAMENTAL_MAX;
1165 end;
1166
G_TYPE_IS_INTERFACEnull1167 function G_TYPE_IS_INTERFACE(_type : GType) : boolean;
1168 begin
1169 G_TYPE_IS_INTERFACE:=(G_TYPE_FUNDAMENTAL(_type)) = G_TYPE_INTERFACE;
1170 end;
1171
G_TYPE_IS_CLASSEDnull1172 function G_TYPE_IS_CLASSED(_type : GType) : gboolean;
1173 begin
1174 G_TYPE_IS_CLASSED:=private_g_type_test_flags(_type,G_TYPE_FLAG_CLASSED);
1175 end;
1176
G_TYPE_IS_INSTANTIATABLEnull1177 function G_TYPE_IS_INSTANTIATABLE(_type : GType) : boolean;
1178 begin
1179 G_TYPE_IS_INSTANTIATABLE:=private_g_type_test_flags(_type,
1180 G_TYPE_FLAG_INSTANTIATABLE);
1181 end;
1182
G_TYPE_IS_DERIVABLEnull1183 function G_TYPE_IS_DERIVABLE(_type : GType) : boolean;
1184 begin
1185 G_TYPE_IS_DERIVABLE:=private_g_type_test_flags(_type,G_TYPE_FLAG_DERIVABLE);
1186 end;
1187
G_TYPE_IS_DEEP_DERIVABLEnull1188 function G_TYPE_IS_DEEP_DERIVABLE(_type : GType) : boolean;
1189 begin
1190 G_TYPE_IS_DEEP_DERIVABLE:=private_g_type_test_flags(_type,G_TYPE_FLAG_DEEP_DERIVABLE);
1191 end;
1192
G_TYPE_IS_ABSTRACTnull1193 function G_TYPE_IS_ABSTRACT(_type : GType) : boolean;
1194 begin
1195 G_TYPE_IS_ABSTRACT:=private_g_type_test_flags(_type,G_TYPE_FLAG_ABSTRACT);
1196 end;
1197
G_TYPE_IS_VALUE_ABSTRACTnull1198 function G_TYPE_IS_VALUE_ABSTRACT(_type : GType) : boolean;
1199 begin
1200 G_TYPE_IS_VALUE_ABSTRACT:=private_g_type_test_flags(_type,G_TYPE_FLAG_VALUE_ABSTRACT);
1201 end;
1202
G_TYPE_IS_VALUE_TYPEnull1203 function G_TYPE_IS_VALUE_TYPE(_type : GType) : boolean;
1204 begin
1205 G_TYPE_IS_VALUE_TYPE:=private_g_type_check_is_value_type(_type);
1206 end;
1207
G_TYPE_HAS_VALUE_TABLEnull1208 function G_TYPE_HAS_VALUE_TABLE(_type : GType) : boolean;
1209 begin
1210 G_TYPE_HAS_VALUE_TABLE:=(g_type_value_table_peek(_type)) <> NULL;
1211 end;
1212
G_TYPE_CHECK_INSTANCEnull1213 function G_TYPE_CHECK_INSTANCE(instance : Pointer) : gboolean;
1214 begin
1215 G_TYPE_CHECK_INSTANCE:=private_g_type_check_instance(PGTypeInstance(instance));
1216 end;
1217
G_TYPE_CHECK_INSTANCE_CASTnull1218 function G_TYPE_CHECK_INSTANCE_CAST(instance: Pointer; g_type: GType) : PGTypeInstance;
1219 begin
1220 G_TYPE_CHECK_INSTANCE_CAST:=private_g_type_check_instance_cast(instance,g_type);
1221 end;
1222
G_TYPE_CHECK_INSTANCE_TYPEnull1223 function G_TYPE_CHECK_INSTANCE_TYPE(instance: Pointer; g_type: GType) : boolean;
1224 begin
1225 G_TYPE_CHECK_INSTANCE_TYPE:=private_g_type_check_instance_is_a(instance,g_type);
1226 end;
1227
G_TYPE_INSTANCE_GET_CLASSnull1228 function G_TYPE_INSTANCE_GET_CLASS(instance: Pointer; g_type: GType) : PGTypeClass;
1229 // #define G_TYPE_INSTANCE_GET_CLASS(instance, g_type, c_type) (_G_TYPE_IGC ((instance), (g_type), c_type))
1230 // #define _G_TYPE_IGC(ip, gt, ct) ((ct*) (((GTypeInstance*) ip)->g_class))
1231 begin
1232 Result:=PGTypeInstance(Instance)^.g_class;
1233 Result:=private_g_type_check_class_cast(Result,g_type);
1234 end;
1235
G_TYPE_INSTANCE_GET_INTERFACEnull1236 function G_TYPE_INSTANCE_GET_INTERFACE(instance: Pointer; g_type: GType) : Pointer;
1237 begin
1238 G_TYPE_INSTANCE_GET_INTERFACE:=
1239 g_type_interface_peek((PGTypeInstance(instance))^.g_class,g_type);
1240 end;
1241
G_TYPE_CHECK_CLASS_CASTnull1242 function G_TYPE_CHECK_CLASS_CAST(g_class: pointer; g_type: GType) : Pointer;
1243 begin
1244 G_TYPE_CHECK_CLASS_CAST:=
1245 private_g_type_check_class_cast(PGTypeClass(g_class),g_type);
1246 end;
1247
G_TYPE_CHECK_CLASS_TYPEnull1248 function G_TYPE_CHECK_CLASS_TYPE(g_class: pointer; g_type : GType) : boolean;
1249 begin
1250 G_TYPE_CHECK_CLASS_TYPE:=private_g_type_check_class_is_a(PGTypeClass(g_class),g_type);
1251 end;
1252
G_TYPE_CHECK_VALUEnull1253 function G_TYPE_CHECK_VALUE(value : Pointer) : boolean;
1254 begin
1255 G_TYPE_CHECK_VALUE:=private_g_type_check_value(PGValue(Value));
1256 end;
1257
G_TYPE_CHECK_VALUE_TYPEnull1258 function G_TYPE_CHECK_VALUE_TYPE(value: pointer; g_type : GType) : boolean;
1259 begin
1260 G_TYPE_CHECK_VALUE_TYPE:=private_g_type_check_value_holds(PGValue(value),g_type);
1261 end;
1262
G_TYPE_FROM_INSTANCEnull1263 function G_TYPE_FROM_INSTANCE(instance : Pointer) : GType;
1264 begin
1265 G_TYPE_FROM_INSTANCE:=G_TYPE_FROM_CLASS((PGTypeInstance(instance))^.g_class);
1266 end;
1267
G_TYPE_FROM_CLASSnull1268 function G_TYPE_FROM_CLASS(g_class : Pointer) : GType;
1269 begin
1270 G_TYPE_FROM_CLASS:=(PGTypeClass(g_class))^.g_type;
1271 end;
1272
G_TYPE_FROM_INTERFACEnull1273 function G_TYPE_FROM_INTERFACE(g_iface : Pointer) : GType;
1274 begin
1275 G_TYPE_FROM_INTERFACE:=(PGTypeInterface(g_iface))^.g_type;
1276 end;
1277
1278 // gvalue.inc ------------------------------------------------------------------
1279
G_TYPE_IS_VALUEnull1280 function G_TYPE_IS_VALUE(_type : GType) : boolean;
1281 begin
1282 G_TYPE_IS_VALUE:=private_g_type_check_is_value_type(_type);
1283 end;
1284
G_IS_VALUEnull1285 function G_IS_VALUE(value : Pointer) : boolean;
1286 begin
1287 G_IS_VALUE:=G_TYPE_CHECK_VALUE(value);
1288 end;
1289
G_VALUE_TYPEnull1290 function G_VALUE_TYPE(value : Pointer) : GType;
1291 begin
1292 G_VALUE_TYPE:=(PGValue(value))^.g_type;
1293 end;
1294
G_VALUE_TYPE_NAMEnull1295 function G_VALUE_TYPE_NAME(value : Pointer) : PGChar;
1296 begin
1297 G_VALUE_TYPE_NAME:=g_type_name(G_VALUE_TYPE(value));
1298 end;
1299
G_VALUE_HOLDSnull1300 function G_VALUE_HOLDS(value: pointer; g_type : GType) : boolean;
1301 begin
1302 G_VALUE_HOLDS:=G_TYPE_CHECK_VALUE_TYPE(value,g_type);
1303 end;
1304
1305 // gparam.inc ------------------------------------------------------------------
1306
G_TYPE_IS_PARAMnull1307 function G_TYPE_IS_PARAM(_type : GType) : boolean;
1308 begin
1309 G_TYPE_IS_PARAM:=(G_TYPE_FUNDAMENTAL(_type)) = G_TYPE_PARAM;
1310 end;
1311
G_PARAM_SPECnull1312 function G_PARAM_SPEC(pspec : Pointer) : PGParamSpec;
1313 begin
1314 G_PARAM_SPEC:=PGParamSpec(G_TYPE_CHECK_INSTANCE_CAST(pspec,G_TYPE_PARAM));
1315 end;
1316
G_IS_PARAM_SPECnull1317 function G_IS_PARAM_SPEC(pspec : Pointer) : boolean;
1318 begin
1319 G_IS_PARAM_SPEC:=G_TYPE_CHECK_INSTANCE_TYPE(pspec,G_TYPE_PARAM);
1320 end;
1321
G_PARAM_SPEC_CLASSnull1322 function G_PARAM_SPEC_CLASS(pclass : Pointer) : PGParamSpecClass;
1323 begin
1324 G_PARAM_SPEC_CLASS:=PGParamSpecClass(G_TYPE_CHECK_CLASS_CAST(pclass,G_TYPE_PARAM));
1325 end;
1326
G_IS_PARAM_SPEC_CLASSnull1327 function G_IS_PARAM_SPEC_CLASS(pclass : Pointer) : boolean;
1328 begin
1329 G_IS_PARAM_SPEC_CLASS:=G_TYPE_CHECK_CLASS_TYPE(pclass,G_TYPE_PARAM);
1330 end;
1331
G_PARAM_SPEC_GET_CLASSnull1332 function G_PARAM_SPEC_GET_CLASS(pspec : Pointer) : PGParamSpecClass;
1333 begin
1334 G_PARAM_SPEC_GET_CLASS:=PGParamSpecClass(G_TYPE_INSTANCE_GET_CLASS(pspec,G_TYPE_PARAM));
1335 end;
1336
G_PARAM_SPEC_TYPEnull1337 function G_PARAM_SPEC_TYPE(pspec : Pointer) : GType;
1338 begin
1339 G_PARAM_SPEC_TYPE:=G_TYPE_FROM_INSTANCE(pspec);
1340 end;
1341
G_PARAM_SPEC_TYPE_NAMEnull1342 function G_PARAM_SPEC_TYPE_NAME(pspec : Pointer) : PGChar;
1343 begin
1344 G_PARAM_SPEC_TYPE_NAME:=g_type_name(G_PARAM_SPEC_TYPE(pspec));
1345 end;
1346
G_PARAM_SPEC_VALUE_TYPEnull1347 function G_PARAM_SPEC_VALUE_TYPE(pspec : Pointer) : GType;
1348 begin
1349 G_PARAM_SPEC_VALUE_TYPE:=(G_PARAM_SPEC(pspec))^.value_type;
1350 end;
1351
G_VALUE_HOLDS_PARAMnull1352 function G_VALUE_HOLDS_PARAM(value : Pointer) : boolean;
1353 begin
1354 G_VALUE_HOLDS_PARAM:=G_TYPE_CHECK_VALUE_TYPE(value,G_TYPE_PARAM);
1355 end;
1356
1357 // gclosure.inc ----------------------------------------------------------------
1358
G_CLOSURE_NEEDS_MARSHALnull1359 function G_CLOSURE_NEEDS_MARSHAL(closure : Pointer) : boolean;
1360 begin
1361 G_CLOSURE_NEEDS_MARSHAL := not Assigned((PGClosure(closure))^.marshal);
1362 end;
1363
G_CLOSURE_N_NOTIFIERSnull1364 function G_CLOSURE_N_NOTIFIERS(cl : PGClosure) : longint;
1365 begin
1366 G_CLOSURE_N_NOTIFIERS:=((meta_marshal(cl) + ((n_guards(cl)) shl 1))
1367 + (n_fnotifiers(cl))) + (n_inotifiers(cl));
1368 end;
1369
G_CCLOSURE_SWAP_DATAnull1370 function G_CCLOSURE_SWAP_DATA(cclosure : PGClosure) : longint;
1371 begin
1372 G_CCLOSURE_SWAP_DATA:=derivative_flag(cclosure);
1373 end;
1374
G_CALLBACKnull1375 function G_CALLBACK(f : pointer) : TGCallback;
1376 begin
1377 G_CALLBACK:=TGCallback(f);
1378 end;
1379
ref_countnull1380 function ref_count(var a : TGClosure) : guint;
1381 begin
1382 ref_count:=(a.flag0 and bm_TGClosure_ref_count) shr bp_TGClosure_ref_count;
1383 end;
1384
1385 procedure set_ref_count(var a : TGClosure; __ref_count : guint);
1386 begin
1387 a.flag0:=a.flag0 or ((__ref_count shl bp_TGClosure_ref_count) and bm_TGClosure_ref_count);
1388 end;
1389
meta_marshalnull1390 function meta_marshal(a : PGClosure) : guint;
1391 begin
1392 meta_marshal:=(a^.flag0 and bm_TGClosure_meta_marshal) shr bp_TGClosure_meta_marshal;
1393 end;
1394
1395 procedure set_meta_marshal(var a : TGClosure; __meta_marshal : guint);
1396 begin
1397 a.flag0:=a.flag0 or ((__meta_marshal shl bp_TGClosure_meta_marshal) and bm_TGClosure_meta_marshal);
1398 end;
1399
n_guardsnull1400 function n_guards(a : PGClosure) : guint;
1401 begin
1402 n_guards:=(a^.flag0 and bm_TGClosure_n_guards) shr bp_TGClosure_n_guards;
1403 end;
1404
1405 procedure set_n_guards(var a : TGClosure; __n_guards : guint);
1406 begin
1407 a.flag0:=a.flag0 or ((__n_guards shl bp_TGClosure_n_guards) and bm_TGClosure_n_guards);
1408 end;
1409
n_fnotifiersnull1410 function n_fnotifiers(a : PGClosure) : guint;
1411 begin
1412 n_fnotifiers:=(a^.flag0 and bm_TGClosure_n_fnotifiers) shr bp_TGClosure_n_fnotifiers;
1413 end;
1414
1415 procedure set_n_fnotifiers(var a : TGClosure; __n_fnotifiers : guint);
1416 begin
1417 a.flag0:=a.flag0 or ((__n_fnotifiers shl bp_TGClosure_n_fnotifiers) and bm_TGClosure_n_fnotifiers);
1418 end;
1419
n_inotifiersnull1420 function n_inotifiers(a : PGClosure) : guint;
1421 begin
1422 n_inotifiers:=(a^.flag0 and bm_TGClosure_n_inotifiers) shr bp_TGClosure_n_inotifiers;
1423 end;
1424
1425 procedure set_n_inotifiers(var a : TGClosure; __n_inotifiers : guint);
1426 begin
1427 a.flag0:=a.flag0 or ((__n_inotifiers shl bp_TGClosure_n_inotifiers) and bm_TGClosure_n_inotifiers);
1428 end;
1429
in_inotifynull1430 function in_inotify(var a : TGClosure) : guint;
1431 begin
1432 in_inotify:=(a.flag0 and bm_TGClosure_in_inotify) shr bp_TGClosure_in_inotify;
1433 end;
1434
1435 procedure set_in_inotify(var a : TGClosure; __in_inotify : guint);
1436 begin
1437 a.flag0:=a.flag0 or ((__in_inotify shl bp_TGClosure_in_inotify) and bm_TGClosure_in_inotify);
1438 end;
1439
floatingnull1440 function floating(var a : TGClosure) : guint;
1441 begin
1442 floating:=(a.flag0 and bm_TGClosure_floating) shr bp_TGClosure_floating;
1443 end;
1444
1445 procedure set_floating(var a : TGClosure; __floating : guint);
1446 begin
1447 a.flag0:=a.flag0 or ((__floating shl bp_TGClosure_floating) and bm_TGClosure_floating);
1448 end;
1449
derivative_flagnull1450 function derivative_flag(a : PGClosure) : guint;
1451 begin
1452 derivative_flag:=(a^.flag0 and bm_TGClosure_derivative_flag) shr bp_TGClosure_derivative_flag;
1453 end;
1454
1455 procedure set_derivative_flag(var a : TGClosure; __derivative_flag : guint);
1456 begin
1457 a.flag0:=a.flag0 or ((__derivative_flag shl bp_TGClosure_derivative_flag) and bm_TGClosure_derivative_flag);
1458 end;
1459
in_marshalnull1460 function in_marshal(var a : TGClosure) : guint;
1461 begin
1462 in_marshal:=(a.flag0 and bm_TGClosure_in_marshal) shr bp_TGClosure_in_marshal;
1463 end;
1464
1465 procedure set_in_marshal(var a : TGClosure; __in_marshal : guint);
1466 begin
1467 a.flag0:=a.flag0 or ((__in_marshal shl bp_TGClosure_in_marshal) and bm_TGClosure_in_marshal);
1468 end;
1469
is_invalidnull1470 function is_invalid(var a : TGClosure) : guint;
1471 begin
1472 is_invalid:=(a.flag0 and bm_TGClosure_is_invalid) shr bp_TGClosure_is_invalid;
1473 end;
1474
1475 procedure set_is_invalid(var a : TGClosure; __is_invalid : guint);
1476 begin
1477 a.flag0:=a.flag0 or ((__is_invalid shl bp_TGClosure_is_invalid) and bm_TGClosure_is_invalid);
1478 end;
1479
1480 // gsignal.inc -----------------------------------------------------------------
1481
g_signal_connectnull1482 function g_signal_connect(instance:gpointer; detailed_signal:Pgchar;
1483 c_handler:TGCallback; data:gpointer) : gulong;
1484 begin
1485 g_signal_connect:=g_signal_connect_data(instance,detailed_signal,c_handler,
1486 data,NULL,TGConnectFlags(0));
1487 end;
1488
g_signal_connect_afternull1489 function g_signal_connect_after(instance:gpointer; detailed_signal:Pgchar;
1490 c_handler:TGCallback; data:gpointer) : gulong;
1491 begin
1492 g_signal_connect_after:=g_signal_connect_data(instance,detailed_signal,
1493 c_handler,data,NULL,G_CONNECT_AFTER);
1494 end;
1495
g_signal_connect_swappednull1496 function g_signal_connect_swapped(instance:gpointer; detailed_signal:Pgchar;
1497 c_handler:TGCallback; data:gpointer) : gulong;
1498 begin
1499 g_signal_connect_swapped:=g_signal_connect_data(instance,detailed_signal,
1500 c_handler,data,NULL,G_CONNECT_SWAPPED);
1501 end;
1502
g_signal_handlers_disconnect_by_funcnull1503 function g_signal_handlers_disconnect_by_func(instance:gpointer;
1504 func, data: gpointer) : guint;
1505 begin
1506 g_signal_handlers_disconnect_by_func:=g_signal_handlers_disconnect_matched(
1507 instance,TGSignalMatchType(G_SIGNAL_MATCH_FUNC or G_SIGNAL_MATCH_DATA),0,0,
1508 NULL,func,data);
1509 end;
1510
1511 procedure g_signal_handlers_block_by_func(instance: gpointer; func, data: gpointer);
1512 begin
1513 g_signal_handlers_block_matched(instance,
1514 TGSignalMatchType(G_SIGNAL_MATCH_FUNC or G_SIGNAL_MATCH_DATA),
1515 0, 0, nil, func, data);
1516 end;
1517
1518 procedure g_signal_handlers_unblock_by_func(instance: gpointer; func, data: gpointer);
1519 begin
1520 g_signal_handlers_unblock_matched(instance,
1521 TGSignalMatchType(G_SIGNAL_MATCH_FUNC or G_SIGNAL_MATCH_DATA),
1522 0, 0, nil, func, data);
1523 end;
1524
1525
1526 // gobject.inc -----------------------------------------------------------------
1527
G_TYPE_IS_OBJECTnull1528 function G_TYPE_IS_OBJECT(_type : GType) : boolean;
1529 begin
1530 G_TYPE_IS_OBJECT:=(G_TYPE_FUNDAMENTAL(_type)) = G_TYPE_OBJECT;
1531 end;
1532
G_OBJECTnull1533 function G_OBJECT(anObject: pointer) : PGObject;
1534 begin
1535 G_OBJECT:=PGObject(G_TYPE_CHECK_INSTANCE_CAST(anObject,G_TYPE_OBJECT));
1536 end;
1537
G_OBJECT_CLASSnull1538 function G_OBJECT_CLASS(_class : Pointer) : PGObjectClass;
1539 begin
1540 G_OBJECT_CLASS:=PGObjectClass(G_TYPE_CHECK_CLASS_CAST(_class,G_TYPE_OBJECT));
1541 end;
1542
G_IS_OBJECTnull1543 function G_IS_OBJECT(anObject: pointer) : boolean;
1544 begin
1545 G_IS_OBJECT:=G_TYPE_CHECK_INSTANCE_TYPE(anObject,G_TYPE_OBJECT);
1546 end;
1547
G_IS_OBJECT_CLASSnull1548 function G_IS_OBJECT_CLASS(_class : Pointer) : boolean;
1549 begin
1550 G_IS_OBJECT_CLASS:=G_TYPE_CHECK_CLASS_TYPE(_class,G_TYPE_OBJECT);
1551 end;
1552
G_OBJECT_GET_CLASSnull1553 function G_OBJECT_GET_CLASS(anObject: pointer) : PGObjectClass;
1554 begin
1555 G_OBJECT_GET_CLASS:=PGObjectClass(G_TYPE_INSTANCE_GET_CLASS(anObject,G_TYPE_OBJECT));
1556 end;
1557
G_OBJECT_TYPEnull1558 function G_OBJECT_TYPE(anObject: pointer) : GType;
1559 begin
1560 G_OBJECT_TYPE:=G_TYPE_FROM_INSTANCE(anObject);
1561 end;
1562
G_OBJECT_TYPE_NAMEnull1563 function G_OBJECT_TYPE_NAME(anObject: pointer) : Pgchar;
1564 begin
1565 G_OBJECT_TYPE_NAME:=g_type_name(G_OBJECT_TYPE(anObject));
1566 end;
1567
G_OBJECT_CLASS_TYPEnull1568 function G_OBJECT_CLASS_TYPE(_class : Pointer) : GType;
1569 begin
1570 G_OBJECT_CLASS_TYPE:=G_TYPE_FROM_CLASS(_class);
1571 end;
1572
G_OBJECT_CLASS_NAMEnull1573 function G_OBJECT_CLASS_NAME(_class : Pointer) : Pgchar;
1574 begin
1575 G_OBJECT_CLASS_NAME:=g_type_name(G_OBJECT_CLASS_TYPE(_class));
1576 end;
1577
G_VALUE_HOLDS_OBJECTnull1578 function G_VALUE_HOLDS_OBJECT(value : Pointer) : boolean;
1579 begin
1580 G_VALUE_HOLDS_OBJECT:=G_TYPE_CHECK_VALUE_TYPE(value,G_TYPE_OBJECT);
1581 end;
1582
1583 procedure G_OBJECT_WARN_INVALID_PROPERTY_ID(anObject: gpointer;
1584 property_id: gint; pspec : gpointer);
1585 begin
1586 G_OBJECT_WARN_INVALID_PSPEC(anObject,'property',property_id,pspec);
1587 end;
1588
1589 procedure G_OBJECT_WARN_INVALID_PSPEC(anObject: gpointer; pname: PGChar;
1590 property_id: gint; pspec: gpointer);
1591 var
1592 _object: PGObject;
1593 _pspec: PGParamSpec;
1594 _property_id: guint;
1595 begin
1596 _object := PGObject (anObject);
1597 _pspec := PGParamSpec (pspec);
1598 _property_id := (property_id);
1599 g_warning ('%s: invalid %s id %u for "%s" of type `%s'' in `%s''',
1600 ['',
1601 pname,
1602 _property_id,
1603 _pspec^.name,
1604 g_type_name (G_PARAM_SPEC_TYPE (_pspec)),
1605 G_OBJECT_TYPE_NAME (_object)]);
1606 end;
1607
1608 // gtypeplugin.inc -------------------------------------------------------------
1609
1610
1611
G_TYPE_TYPE_PLUGINnull1612 function G_TYPE_TYPE_PLUGIN : GType;
1613 begin
1614 G_TYPE_TYPE_PLUGIN:=g_type_plugin_get_type;
1615 end;
1616
G_TYPE_PLUGINnull1617 function G_TYPE_PLUGIN(inst : Pointer) : PGTypePlugin;
1618 begin
1619 G_TYPE_PLUGIN:=PGTypePlugin(G_TYPE_CHECK_INSTANCE_CAST(inst,G_TYPE_TYPE_PLUGIN));
1620 end;
1621
G_TYPE_PLUGIN_CLASSnull1622 function G_TYPE_PLUGIN_CLASS(vtable : Pointer) : PGTypePluginClass;
1623 begin
1624 G_TYPE_PLUGIN_CLASS:=PGTypePluginClass(G_TYPE_CHECK_CLASS_CAST(vtable,G_TYPE_TYPE_PLUGIN));
1625 end;
1626
G_IS_TYPE_PLUGINnull1627 function G_IS_TYPE_PLUGIN(inst : Pointer) : boolean;
1628 begin
1629 G_IS_TYPE_PLUGIN:=G_TYPE_CHECK_INSTANCE_TYPE(inst,G_TYPE_TYPE_PLUGIN);
1630 end;
1631
G_IS_TYPE_PLUGIN_CLASSnull1632 function G_IS_TYPE_PLUGIN_CLASS(vtable : Pointer) : boolean;
1633 begin
1634 G_IS_TYPE_PLUGIN_CLASS:=G_TYPE_CHECK_CLASS_TYPE(vtable,G_TYPE_TYPE_PLUGIN);
1635 end;
1636
G_TYPE_PLUGIN_GET_CLASSnull1637 function G_TYPE_PLUGIN_GET_CLASS(inst : Pointer) : PGTypePluginClass;
1638 begin
1639 G_TYPE_PLUGIN_GET_CLASS:=PGTypePluginClass(G_TYPE_INSTANCE_GET_INTERFACE(inst,G_TYPE_TYPE_PLUGIN));
1640 end;
1641
1642 // genums.inc ------------------------------------------------------------------
1643
1644
G_TYPE_IS_ENUMnull1645 function G_TYPE_IS_ENUM(_type : GType) : gboolean;
1646 begin
1647 G_TYPE_IS_ENUM:=(G_TYPE_FUNDAMENTAL(_type) = G_TYPE_ENUM);
1648 end;
1649
G_ENUM_CLASSnull1650 function G_ENUM_CLASS(_class : pointer) : PGEnumClass;
1651 begin
1652 G_ENUM_CLASS:=PGEnumClass(G_TYPE_CHECK_CLASS_CAST(_class,G_TYPE_ENUM));
1653 end;
1654
G_IS_ENUM_CLASSnull1655 function G_IS_ENUM_CLASS(_class : pointer) : gboolean;
1656 begin
1657 G_IS_ENUM_CLASS:=G_TYPE_CHECK_CLASS_TYPE(_class,G_TYPE_ENUM);
1658 end;
1659
G_ENUM_CLASS_TYPEnull1660 function G_ENUM_CLASS_TYPE(_class : pointer) : GType;
1661 begin
1662 G_ENUM_CLASS_TYPE:=G_TYPE_FROM_CLASS(_class);
1663 end;
1664
G_ENUM_CLASS_TYPE_NAMEnull1665 function G_ENUM_CLASS_TYPE_NAME(_class : pointer) : PGChar;
1666 begin
1667 G_ENUM_CLASS_TYPE_NAME:=g_type_name(G_ENUM_CLASS_TYPE(_class));
1668 end;
1669
G_TYPE_IS_FLAGSnull1670 function G_TYPE_IS_FLAGS(_type : GType) : gboolean;
1671 begin
1672 G_TYPE_IS_FLAGS:=(G_TYPE_FUNDAMENTAL(_type)) = G_TYPE_FLAGS;
1673 end;
1674
G_FLAGS_CLASSnull1675 function G_FLAGS_CLASS(_class : pointer) : PGFlagsClass;
1676 begin
1677 G_FLAGS_CLASS:=PGFlagsClass(G_TYPE_CHECK_CLASS_CAST(_class,G_TYPE_FLAGS));
1678 end;
1679
G_IS_FLAGS_CLASSnull1680 function G_IS_FLAGS_CLASS(_class : pointer) : gboolean;
1681 begin
1682 G_IS_FLAGS_CLASS:=G_TYPE_CHECK_CLASS_TYPE(_class,G_TYPE_FLAGS);
1683 end;
1684
G_FLAGS_CLASS_TYPEnull1685 function G_FLAGS_CLASS_TYPE(_class : pointer) : GType;
1686 begin
1687 G_FLAGS_CLASS_TYPE:=G_TYPE_FROM_CLASS(_class);
1688 end;
1689
G_FLAGS_CLASS_TYPE_NAMEnull1690 function G_FLAGS_CLASS_TYPE_NAME(_class : pointer) : PGChar;
1691 begin
1692 G_FLAGS_CLASS_TYPE_NAME:=g_type_name(G_FLAGS_TYPE(PtrInt(_class)));
1693 end;
1694
G_VALUE_HOLDS_ENUMnull1695 function G_VALUE_HOLDS_ENUM(value : pointer) : gboolean;
1696 begin
1697 G_VALUE_HOLDS_ENUM:=G_TYPE_CHECK_VALUE_TYPE(value,G_TYPE_ENUM);
1698 end;
1699
G_VALUE_HOLDS_FLAGSnull1700 function G_VALUE_HOLDS_FLAGS(value : pointer) : gboolean;
1701 begin
1702 G_VALUE_HOLDS_FLAGS:=G_TYPE_CHECK_VALUE_TYPE(value,G_TYPE_FLAGS);
1703 end;
1704
1705 // gmacros.inc -----------------------------------------------------------------
1706
CLAMPnull1707 function CLAMP(x, MinX, MaxX: integer): integer;
1708 begin
1709 if x<MinX then
1710 Result:=MinX
1711 else if x>MaxX then
1712 Result:=MaxX
1713 else
1714 Result:=x;
1715 end;
1716
GPOINTER_TO_SIZEnull1717 function GPOINTER_TO_SIZE(p: GPointer): GSize;
1718 begin
1719 Result:=GSize(PtrInt(p));
1720 end;
1721
GSIZE_TO_POINTERnull1722 function GSIZE_TO_POINTER(s: GSize): GPointer;
1723 begin
1724 Result:=GPointer(PtrInt(s));
1725 end;
1726
1727 // gvaluetypes.inc -------------------------------------------------------------
1728
G_VALUE_HOLDS_CHARnull1729 function G_VALUE_HOLDS_CHAR(value : PGValue) : boolean;
1730 begin
1731 G_VALUE_HOLDS_CHAR:=G_TYPE_CHECK_VALUE_TYPE(value,G_TYPE_CHAR);
1732 end;
1733
G_VALUE_HOLDS_UCHARnull1734 function G_VALUE_HOLDS_UCHAR(value : PGValue) : boolean;
1735 begin
1736 G_VALUE_HOLDS_UCHAR:=G_TYPE_CHECK_VALUE_TYPE(value,G_TYPE_UCHAR);
1737 end;
1738
G_VALUE_HOLDS_BOOLEANnull1739 function G_VALUE_HOLDS_BOOLEAN(value : PGValue) : boolean;
1740 begin
1741 G_VALUE_HOLDS_BOOLEAN:=G_TYPE_CHECK_VALUE_TYPE(value,G_TYPE_BOOLEAN);
1742 end;
1743
G_VALUE_HOLDS_INTnull1744 function G_VALUE_HOLDS_INT(value : PGValue) : boolean;
1745 begin
1746 G_VALUE_HOLDS_INT:=G_TYPE_CHECK_VALUE_TYPE(value,G_TYPE_INT);
1747 end;
1748
G_VALUE_HOLDS_UINTnull1749 function G_VALUE_HOLDS_UINT(value : PGValue) : boolean;
1750 begin
1751 G_VALUE_HOLDS_UINT:=G_TYPE_CHECK_VALUE_TYPE(value,G_TYPE_UINT);
1752 end;
1753
G_VALUE_HOLDS_LONGnull1754 function G_VALUE_HOLDS_LONG(value : PGValue) : boolean;
1755 begin
1756 G_VALUE_HOLDS_LONG:=G_TYPE_CHECK_VALUE_TYPE(value,G_TYPE_LONG);
1757 end;
1758
G_VALUE_HOLDS_ULONGnull1759 function G_VALUE_HOLDS_ULONG(value : PGValue) : boolean;
1760 begin
1761 G_VALUE_HOLDS_ULONG:=G_TYPE_CHECK_VALUE_TYPE(value,G_TYPE_ULONG);
1762 end;
1763
G_VALUE_HOLDS_INT64null1764 function G_VALUE_HOLDS_INT64(value : PGValue) : boolean;
1765 begin
1766 G_VALUE_HOLDS_INT64:=G_TYPE_CHECK_VALUE_TYPE(value,G_TYPE_INT64);
1767 end;
1768
G_VALUE_HOLDS_UINT64null1769 function G_VALUE_HOLDS_UINT64(value : PGValue) : boolean;
1770 begin
1771 G_VALUE_HOLDS_UINT64:=G_TYPE_CHECK_VALUE_TYPE(value,G_TYPE_UINT64);
1772 end;
1773
G_VALUE_HOLDS_FLOATnull1774 function G_VALUE_HOLDS_FLOAT(value : PGValue) : boolean;
1775 begin
1776 G_VALUE_HOLDS_FLOAT:=G_TYPE_CHECK_VALUE_TYPE(value,G_TYPE_FLOAT);
1777 end;
1778
G_VALUE_HOLDS_DOUBLEnull1779 function G_VALUE_HOLDS_DOUBLE(value : PGValue) : boolean;
1780 begin
1781 G_VALUE_HOLDS_DOUBLE:=G_TYPE_CHECK_VALUE_TYPE(value,G_TYPE_DOUBLE);
1782 end;
1783
G_VALUE_HOLDS_STRINGnull1784 function G_VALUE_HOLDS_STRING(value : PGValue) : boolean;
1785 begin
1786 G_VALUE_HOLDS_STRING:=G_TYPE_CHECK_VALUE_TYPE(value,G_TYPE_STRING);
1787 end;
1788
G_VALUE_HOLDS_POINTERnull1789 function G_VALUE_HOLDS_POINTER(value : PGValue) : boolean;
1790 begin
1791 G_VALUE_HOLDS_POINTER:=G_TYPE_CHECK_VALUE_TYPE(value,G_TYPE_POINTER);
1792 end;
1793
1794
1795 // gboxed.inc ------------------------------------------------------------------
1796
G_TYPE_IS_BOXEDnull1797 function G_TYPE_IS_BOXED(_type : GType) : gboolean;
1798 begin
1799 G_TYPE_IS_BOXED:=(G_TYPE_FUNDAMENTAL(_type)) = G_TYPE_BOXED;
1800 end;
1801
G_VALUE_HOLDS_BOXEDnull1802 function G_VALUE_HOLDS_BOXED(value : PGValue) : gboolean;
1803 begin
1804 G_VALUE_HOLDS_BOXED:=G_TYPE_CHECK_VALUE_TYPE(value,G_TYPE_BOXED);
1805 end;
1806
G_TYPE_CLOSUREnull1807 function G_TYPE_CLOSURE : GType;
1808 begin
1809 G_TYPE_CLOSURE:=g_closure_get_type;
1810 end;
1811
G_TYPE_VALUEnull1812 function G_TYPE_VALUE : GType;
1813 begin
1814 G_TYPE_VALUE:=g_value_get_type;
1815 end;
1816
G_TYPE_VALUE_ARRAYnull1817 function G_TYPE_VALUE_ARRAY : GType;
1818 begin
1819 G_TYPE_VALUE_ARRAY:=g_value_array_get_type;
1820 end;
1821
G_TYPE_GSTRINGnull1822 function G_TYPE_GSTRING : GType;
1823 begin
1824 G_TYPE_GSTRING:=g_gstring_get_type;
1825 end;
1826
1827
1828 end.
1829