source: appstream-generator/contrib/girwrap/APILookupGLib.txt @ 4841

Last change on this file since 4841 was 4841, checked in by Juanma, 2 years ago

Initial release

File size: 43.8 KB
Line 
1#
2# Licensed under the GNU Lesser General Public License Version 3
3#
4# This library is free software: you can redistribute it and/or modify
5# it under the terms of the GNU Lesser General Public License as published by
6# the Free Software Foundation, either version 3 of the license, or
7# (at your option) any later version.
8#
9# This software is distributed in the hope that it will be useful,
10# but WITHOUT ANY WARRANTY; without even the implied warranty of
11# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12# GNU Lesser General Public License for more details.
13#
14# You should have received a copy of the GNU Lesser General Public License
15# along with this library.  If not, see <http://www.gnu.org/licenses/>.
16
17#############################################
18### Definitions for wrapping Gtk+ ###########
19#############################################
20
21# must start with wrap
22wrap: glib
23file: /usr/share/gir-1.0/GLib-2.0.gir
24file: /usr/share/gir-1.0/GModule-2.0.gir
25
26addAliases: start
27        public alias uint uid_t;
28        public alias int pid_t;
29
30        version( Windows )
31        {
32                alias int glong;
33                alias uint gulong;
34        }
35        else version( X86_64 )
36        {
37                alias long glong;
38                alias ulong gulong;
39        }
40        else
41        {
42                alias int glong;
43                alias uint gulong;
44        }
45
46        version( Windows )
47                enum _utfPostfix = "_utf8";
48        else
49                enum _utfPostfix = "";
50
51        version (Windows)
52        {
53                private import core.stdc.stdio;
54
55                static if( !is(typeof(fdopen(0, null))) )
56                {
57                        extern (C) FILE*  fdopen(int, char*);
58                }
59        }
60
61        static if ( __VERSION__ >= 2063 )
62        {
63                public import std.typecons : scoped;
64
65                template Scoped(T)
66                {
67                        alias typeof(scoped!T(cast(typeof(T.tupleof[0]))null)) Scoped;
68                }
69        }
70        else
71        {
72                // I'm getting the following error on the older dmd versions:
73                // this for Scoped_store needs to be type Scoped not type inout(Scoped!(T)).
74                // Unlike the phobos version this does use GC alocated memory for the object.
75                // Within GtkD this is used to make sure destroy is called on the object
76                // so it releases the resources it holds.
77                struct Scoped(T)
78                {
79                        T payload;
80
81                        alias payload this;
82
83                        @disable this();
84                        @disable this(this);
85
86                        ~this()
87                        {
88                                .destroy(payload);
89                        }
90                }
91
92                auto scoped(T, Args...)(auto ref Args args) if (is(T == class))
93                {
94                        Scoped!(T) result = void;
95                        result.payload = new T(args);
96
97                        return result;
98                }
99        }
100
101        /**
102         * Get the length of a zero terminated array.
103         */
104        size_t getArrayLength(T)(T* arr)
105        {
106                size_t len;
107
108                for ( ; arr[len]; len++ ){}
109
110                return len;
111        }
112
113        unittest
114        {
115                assert(getArrayLength("aaaaaaaaa\0".ptr) == 9);
116        }
117
118        Type* gMalloc(Type)()
119        {
120                import gi.glib;
121                return cast(Type*)g_malloc0(Type.sizeof);
122        }
123
124        alias void* GIConv;
125addAliases: end
126
127addEnums: start
128
129        enum GPriority
130        {
131                HIGH = -100,
132                DEFAULT = 0,
133                HIGH_IDLE = 100,
134                DEFAULT_IDLE = 200,
135                LOW = 300
136        }
137
138addEnums: end
139
140struct: Array
141class: ArrayG
142
143struct: Base64
144move: base64_decode_step Base64 decode_step
145move: base64_decode_inplace Base64 decode_inplace
146noCode: decode_step
147array: decode_inplace Return out_len
148code: start
149        /**
150         * Incrementally decode a sequence of binary data from its Base-64 stringified
151         * representation. By calling this function multiple times you can convert
152         * data in chunks to avoid having to have the full encoded data in memory.
153         *
154         * The output buffer must be large enough to fit all the data that will
155         * be written to it. Since base64 encodes 3 bytes in 4 chars you need
156         * at least: (@len / 4) * 3 + 3 bytes (+ 3 may be needed in case of non-zero
157         * state).
158         *
159         * Params:
160         *     inn = binary input data
161         *     len = max length of @in data to decode
162         *     output = output buffer
163         *     state = Saved state between steps, initialize to 0
164         *     save = Saved state between steps, initialize to 0
165         *
166         * Return: The number of bytes of output that was written
167         *
168         * Since: 2.12
169         */
170        public static size_t decodeStep(string inn, ref ubyte[] output, ref int state, ref uint save)
171        {
172                auto p = g_base64_decode_step(Str.toStringz(inn), cast(int)inn.length, cast(char*)output.ptr, &state, &save);
173
174                return p;
175        }
176code: end
177
178struct: BookmarkFile
179out: load_from_data_dirs full_path
180array: set_groups groups length
181
182struct: ByteArray
183class: ByteArray
184
185struct: Bytes
186noCode: new_take
187noCode: new_static
188
189struct: Checksum
190noCode: get_digest
191code: start
192        /**
193         * Gets the digest from checksum as a raw binary vector and places it
194         * into buffer. The size of the digest depends on the type of checksum.
195         *
196         * Once this function has been called, the Checksum is closed and can
197         * no longer be updated with update().
198         *
199         * Params:
200         *     buffer = output buffer
201         *     digestLen = an inout parameter. The caller initializes it to the size of buffer.
202         *         After the call it contains the length of the digest.
203         *
204         * Since: 2.16
205         */
206        public void getDigest(ref ubyte[] buffer)
207        {
208                size_t digestLen = buffer.length;
209
210                g_checksum_get_digest(gChecksum, buffer.ptr, &digestLen);
211
212                buffer = buffer[0 .. digestLen];
213        }
214code: end
215
216struct: ConstructionException
217namespace:
218code: start
219        class ConstructionException : Exception
220        {
221                this(string message)
222                {
223                        super(message);
224                }
225
226                override string toString()
227                {
228                        return "Construction failure, " ~ msg;
229                }
230        }
231code: end
232
233struct: DateTime
234structWrap: gpointer DateTime
235noCode: new_now_utc
236noCode: new_now_local
237noCode: new_from_unix_local
238noCode: new_from_unix_utc
239noCode: new_from_timeval_local
240noCode: new_from_timeval_utc
241noCode: new_local
242noCode: new_utc
243noCode: hash
244code: start
245        /**
246         * Creates a DateTime corresponding to the given Unix time t
247         * Unix time is the number of seconds that have elapsed since 1970-01-01
248         * 00:00:00 UTC, regardless of the local time offset.
249         *
250         * This call can fail (ConstructionException) if t represents a time outside
251         * of the supported range of GDateTime.
252         * You should release the return value by calling unref()
253         * when you are done with it
254         *
255         * Params:
256         *     t   = the Unix time
257         *     utc = If true use utc else use the local timezone.
258         *
259         * Throws: ConstructionException GTK+ fails to create the object.
260         *
261         * Since: 2.26
262         */
263        public this (long t, bool utc = true)
264        {
265                GDateTime* p;
266
267                if ( utc )
268                {
269                        p = g_date_time_new_from_unix_utc(t);
270                }
271                else
272                {
273                        p = g_date_time_new_from_unix_local(t);
274                }
275
276                if(p is null)
277                {
278                        throw new ConstructionException("null returned by g_date_time_new_from_unix_local(t)");
279                }
280                this(cast(GDateTime*) p);
281        }
282
283        /**
284         * Creates a DateTime corresponding to the given TimeVal tv.
285         * The time contained in a TimeVal is always stored in the form of
286         * seconds elapsed since 1970-01-01 00:00:00 UTC, regardless of the
287         * local time offset.
288         *
289         * This call can fail (ConstructionException) if tv represents a time outside
290         * of the supported range of DateTime.
291         * You should release the return value by calling unref()
292         * when you are done with it.
293         *
294         * Params:
295         *     tv  = a GTimeVal
296         *     utc = If true use utc else use the local timezone.
297         *
298         * Throws: ConstructionException GTK+ fails to create the object.
299         *
300         * Since: 2.26
301         */
302        public this (ref GTimeVal tv, bool utc = true)
303        {
304                GDateTime* p;
305
306                if ( utc )
307                {
308                        p = g_date_time_new_from_timeval_utc(&tv);
309                }
310                else
311                {
312                        p = g_date_time_new_from_timeval_local(&tv);
313                }
314
315                if(p is null)
316                {
317                        throw new ConstructionException("null returned by g_date_time_new_from_timeval_local((tv is null) ? null : tv.getTimeValStruct())");
318                }
319                this(cast(GDateTime*) p);
320        }
321
322        /** */
323        override bool opEquals(Object rhs)
324        {
325                DateTime date = cast(DateTime)rhs;
326
327                if ( date is null )
328                        return false;
329
330                return equal(this, date) != 0;
331        }
332
333        /** */
334        override int opCmp(Object rhs)
335        {
336                DateTime date = cast(DateTime)rhs;
337
338                if ( date is null )
339                        return int.min;
340
341                return compare(this, date);
342        }
343
344        /** */
345        override nothrow @trusted hash_t toHash()
346        {
347                return hash();
348        }
349
350        /**
351         * Hashes datetime into a guint, suitable for use within GHashTable.
352         * Since 2.26
353         * Params:
354         * datetime = a GDateTime
355         * Returns: a guint containing the hash
356         */
357        public nothrow @trusted uint hash()
358        {
359                try
360                {
361                        return g_date_time_hash(gDateTime);
362                }
363                catch(Exception e)
364                {
365                        return 0;
366                }
367        }
368code: end
369
370struct: Dir
371class: Directory
372
373struct: Error
374class: ErrorG
375move: propagate_error Error
376move: set_error_literal Error
377out: set_error_literal err
378out: propagate_error dest
379
380struct: GException
381namespace:
382import: glib.ErrorG
383import: glib.Str
384code: start
385        class GException : Exception
386        {
387                ErrorG error;
388
389                this(ErrorG error)
390                {
391                        super( Str.toString(error.getErrorGStruct().message) );
392                        this.error = error;
393                }
394        }
395code: end
396
397struct: GLib
398namespace:
399code: start
400        static import glib.Version;
401        deprecated("moves to the glib.Version module")
402        alias glib.Version.Version Version;
403code: end
404
405struct: HashTable
406class: HashTable
407
408struct: Hmac
409noCode: get_digest
410move: compute_hmac_for_data Hmac
411move: compute_hmac_for_string Hmac
412array: compute_hmac_for_data data length
413array: compute_hmac_for_string str length
414code: start
415        /**
416         * Gets the digest from checksum as a raw binary array and places it
417         * into buffer. The size of the digest depends on the type of checksum.
418         *
419         * Once this function has been called, the Hmac is closed and can
420         * no longer be updated with update().
421         *
422         * Params:
423         *     buffer = output buffer
424         *
425         * Since: 2.30
426         */
427        public void getDigest(ref ubyte[] buffer)
428        {
429                size_t digestLen = buffer.length;
430
431                g_hmac_get_digest(gHmac, buffer.ptr, &digestLen);
432
433                buffer = buffer[0 .. digestLen];
434        }
435code: end
436
437struct: IConv
438namespace:
439noStruct: true
440ref: iconv inbuf
441out: iconv inbytes_left
442array: iconv inbuf inbytes_left
443ref: iconv outbuf
444out: iconv outbytes_left
445array: iconv outbuf outbytes_left
446
447struct: Idle
448class: Idle
449cType:
450code: start
451        /** Holds all idle delegates */
452        bool delegate()[] idleListeners;
453        /** our idle ID */
454        uint idleID;
455
456        /**
457         * Creates a new idle cycle.
458         * Params:
459         *      interval = the idle in milieconds
460         *      dlg = the delegate to be executed
461         *      fireNow = When true the delegate will be executed emmidiatly
462         */
463        this(bool delegate() dlg, bool fireNow=false)
464        {
465                idleListeners ~= dlg;
466                idleID = g_idle_add(cast(GSourceFunc)&idleCallback, cast(void*)this);
467                if ( fireNow )
468                {
469                        if ( !dlg() )
470                        {
471                                idleListeners.length = 0;
472                        }
473                }
474        }
475
476        /**
477         * Creates a new idle cycle.
478         * Params:
479         *      dlg = the delegate to be executed
480         *      priority = Priority for the idle function
481         *      fireNow = When true the delegate will be executed emmidiatly
482         */
483        this(bool delegate() dlg, GPriority priority, bool fireNow=false)
484        {
485                idleListeners ~= dlg;
486                idleID = g_idle_add_full(priority, cast(GSourceFunc)&idleCallback, cast(void*)this, null);
487                if ( fireNow )
488                {
489                        if ( !dlg() )
490                        {
491                                idleListeners.length = 0;
492                        }
493                }
494        }
495
496        /** */
497        public void stop()
498        {
499                if ( idleID > 0 )
500                {
501                        g_source_remove(idleID);
502                }
503                idleListeners.length = 0;
504        }
505
506        /**
507         * Removes the idle from gtk
508         */
509        ~this()
510        {
511                stop();
512        }
513
514        /**
515         * Adds a new delegate to this idle cycle
516         * Params:
517         *      dlg =
518         *      fireNow =
519         */
520        public void addListener(bool delegate() dlg, bool fireNow=false)
521        {
522                idleListeners ~= dlg;
523                if ( fireNow )
524                {
525                        if ( !dlg() )
526                        {
527                                idleListeners.length = idleListeners.length - 1;
528                        }
529                }
530        }
531
532        /**
533         * The callback execution from glib
534         * Params:
535         *      idle =
536         * Returns:
537         */
538        extern(C) static bool idleCallback(Idle idle)
539        {
540                return idle.callAllListeners();
541        }
542
543        /**
544         * Executes all delegates on the execution list
545         * Returns:
546         */
547        private bool callAllListeners()
548        {
549                bool runAgain = false;
550
551                int i = 0;
552
553                while ( i<idleListeners.length )
554                {
555                        if ( !idleListeners[i]() )
556                        {
557                                idleListeners = idleListeners[0..i] ~ idleListeners[i+1..idleListeners.length];
558                        }
559                        else
560                        {
561                                runAgain = true;
562                                ++i;
563                        }
564                }
565
566                // Set idleID to 0 if all delegates are removed
567        if (idleListeners.length == 0)
568                        idleID = 0;
569
570                return runAgain;
571        }
572code: end
573
574struct: IOChannel
575array: read_line str_return length
576out: read_line_string terminator_pos
577array: write_chars buf count
578
579struct: List
580class: ListG
581import: gobject.ObjectG
582code: start
583        /** */
584        @property void* data()
585        {
586                return gList.data;
587        }
588
589        /**
590         * get the next element
591         * Returns: the next element, or NULL if there are no more elements.
592         */
593        @property ListG next()
594        {
595                if ( gList.next is null )
596                {
597                        return null;
598                }
599
600                return new ListG(gList.next);
601        }
602
603        /**
604         * get the previous element
605         * Returns: the previous element, or NULL if there are no more elements.
606         */
607        @property ListG previous()
608        {
609                if ( gList.prev is null )
610                {
611                        return null;
612                }
613
614                return new ListG(gList.prev);
615        }
616
617        /**
618         * Turn the list into a D array of the desiered type.
619         * Type T wraps should match the type of the data.
620         */
621        public T[] toArray(T, TC = typeof(T.tupleof[0]))()
622        {
623                T[] arr = new T[length()];
624                ListG list = this;
625                size_t count;
626
627                while(list !is null && count < arr.length)
628                {
629                        arr[count] = ObjectG.getDObject!(T)(cast(TC)list.data);
630                        list = list.next();
631                        count++;
632                }
633
634                return arr;
635        }
636
637        unittest
638        {
639                import gobject.Value;
640
641                auto list = new ListG(null);
642                list = list.append(new Value(0).getValueStruct());
643                list = list.append(new Value(1).getValueStruct());
644                auto arr = list.toArray!Value();
645
646                assert(arr[0].getInt() == 0);
647                assert(arr[1].getInt() == 1);
648        }
649code: end
650
651struct: MainContext
652in: query fds
653in: query n_fds
654
655struct: MarkupParseContext
656class: SimpleXML
657
658struct: MemorySlice
659code: start
660        T* mewSlice(T)()
661        {
662                return cast(T*)g_slice_alloc(T.sizeof);
663        }
664
665        T* mewSlice0(T)()
666        {
667                return cast(T*)g_slice_alloc0(T.sizeof);
668        }
669
670        T* dup(T)(T* memBlock)
671        {
672                return cast(T*)g_slice_copy(T.sizeof, memBlock);
673        }
674
675        void free(T)(T* memBlock)
676        {
677                 g_slice_free1(T.sizeof, memBlock);
678        }
679code: end
680
681struct: Module
682in: symbol symbol
683
684struct: PatternSpec
685class: Pattern
686
687struct: PtrArray
688class: PtrArray
689code: start
690        /**
691         * Number of pointers in the array
692         */
693        public uint len ()
694        {
695                return gPtrArray.len;
696        }
697
698        /**
699         * Returns the pointer at the given index of the pointer array.
700         *
701         * This does not perform bounds checking on the given index, so
702         * you are responsible for checking it against the array length.
703         */
704        public void* index (uint idx)
705        {
706                return (gPtrArray.pdata)[idx];
707        }
708code: end
709
710struct: Queue
711class: QueueG
712
713struct: Rand
714class: RandG
715alias: double randDouble
716alias: int randInt
717array: new_with_seed_array seed seed_length
718
719struct: Scanner
720class: ScannerG
721
722struct: SList
723class: ListSG
724import: gobject.ObjectG
725code: start
726        /** */
727        @property void* data()
728        {
729                return gSList.data;
730        }
731
732        /**
733         * get the next element
734         * Returns: the next element, or NULL if there are no more elements.
735         */
736        @property ListSG next()
737        {
738                if ( gSList.next is null )
739                {
740                        return null;
741                }
742
743                return new ListSG(gSList.next);
744        }
745
746        /**
747         * Turn the list into a D array of the desiered type.
748         * Type T wraps should match the type of the data.
749         */
750        public T[] toArray(T, TC = typeof(T.tupleof[0]))()
751        {
752                T[] arr = new T[length()];
753                ListSG list = this;
754                size_t count;
755
756                while(list !is null && count < arr.length)
757                {
758                        arr[count] = ObjectG.getDObject!(T)(cast(TC)list.data);
759                        list = list.next();
760                        count++;
761                }
762
763                return arr;
764        }
765
766        unittest
767        {
768                import gobject.Value;
769
770                auto list = new ListSG(null);
771                list = list.append(new Value(0).getValueStruct());
772                list = list.append(new Value(1).getValueStruct());
773                auto arr = list.toArray!Value();
774
775                assert(arr[0].getInt() == 0);
776                assert(arr[1].getInt() == 1);
777        }
778code: end
779
780struct: Spawn
781class: Spawn
782cType:
783import: core.thread
784import: core.stdc.string
785import: core.stdc.stdio
786import: std.string
787#noCode: spawn_async_with_pipes
788code: start
789        //we need fdopen.
790        version(Posix)
791        {
792                private import core.sys.posix.stdio;
793        }
794        //fdopen for Windows is defined in gi.glibtypes.
795
796        string workingDirectory = ".";
797        string[] argv;
798        string[] envp;
799        GSpawnFlags flags = SpawnFlags.SEARCH_PATH;
800        GSpawnChildSetupFunc childSetup;
801        void* userData;
802        GPid childPid;
803        FILE* standardInput;
804        FILE* standardOutput;
805        FILE* standardError;
806        GError* error;
807        int stdIn;
808        int stdOut;
809        int stdErr;
810
811        // for commandLineSync
812        int exitStatus;
813        char* strOutput;
814        char* strError;
815
816        alias bool delegate(Spawn) ChildWatch;
817        ChildWatch externalWatch;
818
819        /**
820         * Creates a Spawn for execution.
821         */
822        public this(string program, string[] envp=null)
823        {
824                argv ~= program;
825                this.envp = envp;
826        }
827
828        /**
829         * Creates a Spawn for execution.
830         */
831        public this(string[] program, string[] envp=null)
832        {
833                argv = program;
834                this.envp = envp;
835        }
836
837        /**
838         * Adds a delegate to be notified on the end of the child process.
839         * Params:
840         *      dlg =
841         */
842        public void addChildWatch(ChildWatch dlg)
843        {
844                externalWatch = dlg;
845        }
846
847        /**
848         * Closes all open streams and child process.
849         */
850        public void close()
851        {
852                if (stdIn != 0 )
853                {
854                        fclose(standardInput);
855                        stdIn = 0;
856                }
857                if (stdOut != 0 )
858                {
859                        fclose(standardOutput);
860                        stdOut = 0;
861                }
862                if (stdErr != 0 )
863                {
864                        fclose(standardError);
865                        stdErr = 0;
866                }
867                if ( childPid != 0 )
868                {
869                        closePid(childPid);
870                        childPid = 0;
871                }
872        }
873
874        /**
875         * Adds a parameter to the execution program
876         */
877        public void addParm(string parm)
878        {
879                argv ~= parm;
880        }
881
882        /**
883         * Gets the last error message
884         */
885        public string getLastError()
886        {
887                if ( error != null )
888                {
889                        return Str.toString(error.message);
890                }
891                return "";
892        }
893
894        /**
895         * Executes the prepared process
896         */
897        public int execAsyncWithPipes(
898                ChildWatch externalWatch = null,
899                bool delegate(string) readOutput = null,
900                bool delegate(string) readError = null )
901        {
902                int result = g_spawn_async_with_pipes(
903                Str.toStringz(workingDirectory),
904                Str.toStringzArray(argv),
905                Str.toStringzArray(envp),
906                flags,
907                childSetup,
908                userData,
909                &childPid,
910                &stdIn,
911                &stdOut,
912                &stdErr,
913                &error
914                );
915
916                if ( result != 0 )
917                {
918                        this.externalWatch = externalWatch;
919                        g_child_watch_add(childPid, cast(GChildWatchFunc)(&childWatchCallback), cast(void*)this);
920                        standardInput = fdopen(stdIn, Str.toStringz("w"));
921                        standardOutput = fdopen(stdOut, Str.toStringz("r"));
922                        standardError = fdopen(stdErr, Str.toStringz("r"));
923
924                        if ( readOutput !is null )
925                        {
926                                (new ReadFile(standardOutput, readOutput)).start();
927                        }
928                        if ( readError !is null )
929                        {
930                                (new ReadFile(standardError, readError)).start();
931                        }
932                }
933
934                return result;
935        }
936
937        class ReadFile : Thread
938        {
939                bool delegate(string) read;
940                FILE* file;
941
942                int lineCount;
943
944                this(FILE* file, bool delegate (string) read )
945                {
946                        this.file = file;
947                        this.read = read;
948
949                        super(&run);
950                }
951
952                public void run()
953                {
954                        string line = readLine(file);
955                        while( line !is null )
956                        {
957                                ++lineCount;
958                                if ( read !is null )
959                                {
960                                        read(line);
961                                }
962                                line = readLine(file);
963                        }
964                }
965        }
966
967        private string readLine(FILE* stream, int max=4096)
968        {
969                if ( feof(stream) )
970                {
971                        if ( externalWatch !is null )
972                        {
973                                externalWatch(this);
974                        }
975                        return null;
976                }
977                string line;
978                line.length = max+1;
979                char* lineP = fgets(Str.toStringz(line), max, stream);
980                if ( lineP is null )
981                {
982                        return "";
983                }
984                size_t l = strlen(line.ptr);
985                if ( l > 0 ) --l;
986
987                return line[0..l];
988        }
989
990        extern(C) static void childWatchCallback(int pid, int status, Spawn spawn)
991        {
992                //writefln("Spawn.childWatchCallback %s %s", pid, status);
993                spawn.exitStatus = status;
994                if ( spawn.externalWatch !is null )
995                {
996                        spawn.externalWatch(spawn);
997                }
998                spawn.close();
999        }
1000
1001
1002        public bool endOfOutput()
1003        {
1004                if ( standardOutput is null ) return true;
1005                return feof(standardOutput) != 0;
1006        }
1007
1008        public bool endOfError()
1009        {
1010                if ( standardError is null ) return true;
1011                return feof(standardError) != 0;
1012        }
1013
1014        string getOutputString()
1015        {
1016                return Str.toString(strOutput);
1017        }
1018
1019        string getErrorString()
1020        {
1021                return Str.toString(strError);
1022        }
1023
1024        int getExitStatus()
1025        {
1026                return exitStatus;
1027        }
1028
1029        /**
1030         * Executes a command synchronasly and
1031         * optionally calls delegates for sysout, syserr and end of job
1032         *
1033         */
1034        public int commandLineSync(
1035                ChildWatch externalWatch = null,
1036                bool delegate(string) readOutput = null,
1037                bool delegate(string) readError = null )
1038        {
1039                string commandLine;
1040                foreach ( int count, string arg; argv)
1041                {
1042                        if ( count > 0 )
1043                        {
1044                                commandLine ~= ' ';
1045                        }
1046                        commandLine ~= arg;
1047                }
1048                int status = g_spawn_command_line_sync(
1049                        Str.toStringz(commandLine),
1050                        &strOutput,
1051                        &strError,
1052                        &exitStatus,
1053                        &error);
1054                if ( readOutput != null )
1055                {
1056                        foreach ( string line ; splitLines(Str.toString(strOutput)) )
1057                        {
1058                                readOutput(line);
1059                        }
1060                }
1061                if ( readError != null )
1062                {
1063                        foreach ( string line ; splitLines(Str.toString(strError)) )
1064                        {
1065                                readError(line);
1066                        }
1067                }
1068                if ( externalWatch != null )
1069                {
1070                        externalWatch(this);
1071                }
1072                return status;
1073        }
1074code: end
1075
1076struct: Str
1077import: core.stdc.stdio
1078import: core.stdc.string
1079import: gi.gobjecttypes
1080code: start
1081        /*
1082         * Convert C-style 0 terminated string s to char[] string.
1083         * copied from phobos
1084         */
1085        public static string toString(const(char)* s, size_t len = 0)
1086        {
1087                if ( s is null )
1088                        return cast(string)null;
1089
1090                if ( len == 0 )
1091                        len = strlen(s);
1092
1093                return s[0 .. len].idup;
1094        }
1095
1096        /*
1097         * Convert array of chars s[] to a C-style 0 terminated string.
1098         * copied from phobos
1099         */
1100        public static char* toStringz(string s)
1101        {
1102                if ( s is null ) return null;
1103                char[] copy;
1104
1105                if (s.length == 0)
1106                {
1107                        copy = "\0".dup;
1108                }
1109                else
1110                {
1111                        // Need to make a copy
1112                        copy = new char[s.length + 1];
1113                        copy[0..s.length] = s[];
1114                        copy[s.length] = 0;
1115                }
1116
1117                return copy.ptr;
1118        }
1119
1120        /** */
1121        public static char** toStringzArray(string[] args)
1122        {
1123                if ( args is null )
1124                {
1125                        return null;
1126                }
1127                char** argv = (new char*[args.length]).ptr;
1128                int argc = 0;
1129                foreach (string p; args)
1130                {
1131                        argv[argc++] = cast(char*)(p.dup~'\0');
1132                }
1133                argv[argc] = null;
1134
1135                return argv;
1136        }
1137
1138        /** */
1139        public static char*** toStringzArray(string[][] args)
1140        {
1141                if ( args is null )
1142                {
1143                        return null;
1144                }
1145                char**[] argv = new char**[args.length];
1146                int argc = 0;
1147                foreach( string[] p; args )
1148                {
1149                        argv[argc++] = toStringzArray(p);
1150                }
1151                argv[argc] = null;
1152
1153                return argv.ptr;
1154        }
1155
1156        /** */
1157        public static string[] toStringArray(const(char*)* args)
1158        {
1159                if ( args is null )
1160                {
1161                        return null;
1162                }
1163                string[] argv;
1164
1165                while ( *args !is null )
1166                {
1167                        argv ~= toString(*args);
1168                        args++;
1169                }
1170
1171                return argv;
1172        }
1173
1174        /** */
1175        public static string[] toStringArray(const(char*)* args, size_t len)
1176        {
1177                string[] argv = new string[len];
1178
1179                for ( int i; i < len; i++ )
1180                {
1181                        argv[i] = toString(args[i]);
1182                }
1183
1184                return argv;
1185        }
1186
1187        /** */
1188        public static string[][] toStringArray(char*** args)
1189        {
1190                string[][] argv;
1191
1192                if ( args is null )
1193                {
1194                        return null;
1195                }
1196
1197                while ( *args !is null )
1198                {
1199                        argv ~= toStringArray(*args);
1200                        args++;
1201                }
1202
1203                return argv;
1204        }
1205
1206        /** */
1207        public static void freeString(char* str)
1208        {
1209                g_free(str);
1210        }
1211
1212        /** */
1213        public static void freeStringArray(char** str)
1214        {
1215                g_strfreev(str);
1216        }
1217
1218        /** */
1219        public static void freeStringArray(char*** str)
1220        {
1221                while ( *str !is null )
1222                {
1223                        g_strfreev(*str);
1224                        str++;
1225                }
1226
1227                g_free(str);
1228        }
1229code: end
1230
1231struct: String
1232class: StringG
1233
1234struct: Thread
1235noCode: new
1236
1237struct: Timeout
1238class: Timeout
1239cType:
1240code: start
1241        /** Holds all timeout delegates */
1242        bool delegate()[] timeoutListeners;
1243        /** our gtk timeout ID */
1244        uint timeoutID;
1245
1246
1247        /**
1248         * Creates a new timeout cycle with the default priority, GPriority.DEFAULT.
1249         *
1250         * Note that timeout functions may be delayed, due to the processing of other
1251         * event sources. Thus they should not be relied on for precise timing.
1252         * After each call to the timeout function, the time of the next timeout is
1253         * recalculated based on the current time and the given interval
1254         * (it does not try to 'catch up' time lost in delays).
1255         * Params:
1256         *      interval =      the timeout in milieconds
1257         *      delegate() =    the delegate to be executed
1258         *      fireNow =       When true the delegate will be executed emmidiatly
1259         */
1260        this(uint interval, bool delegate() dlg, bool fireNow=false)
1261        {
1262                timeoutListeners ~= dlg;
1263                timeoutID = g_timeout_add(interval, cast(GSourceFunc)&timeoutCallback, cast(void*)this);
1264                if ( fireNow )
1265                {
1266                        if ( !dlg() )
1267                        {
1268                                timeoutListeners.length = 0;
1269                        }
1270                }
1271        }
1272
1273        /**
1274         * Creates a new timeout cycle.
1275         * Params:
1276         *      interval =      the timeout in milieconds
1277         *      delegate() =    the delegate to be executed
1278         *      priority = Priority for the timeout function
1279         *      fireNow =       When true the delegate will be executed emmidiatly
1280         */
1281        this(uint interval, bool delegate() dlg, GPriority priority, bool fireNow=false)
1282        {
1283                timeoutListeners ~= dlg;
1284                timeoutID = g_timeout_add_full(priority, interval, cast(GSourceFunc)&timeoutCallback, cast(void*)this, null);
1285                if ( fireNow )
1286                {
1287                        if ( !dlg() )
1288                        {
1289                                timeoutListeners.length = 0;
1290                        }
1291                }
1292        }
1293
1294        /**
1295         * Creates a new timeout cycle with the default priority, GPriority.DEFAULT.
1296         * Params:
1297         *      delegate() =    the delegate to be executed
1298         *      seconds = interval in seconds.
1299         *      fireNow =       When true the delegate will be executed emmidiatly
1300         */
1301        this(bool delegate() dlg, uint seconds, bool fireNow=false)
1302        {
1303                timeoutListeners ~= dlg;
1304                timeoutID = g_timeout_add_seconds(seconds, cast(GSourceFunc)&timeoutCallback, cast(void*)this);
1305                if ( fireNow )
1306                {
1307                        if ( !dlg() )
1308                        {
1309                                timeoutListeners.length = 0;
1310                        }
1311                }
1312        }
1313
1314        /**
1315         * Creates a new timeout cycle.
1316         * Params:
1317         *      delegate() =    the delegate to be executed
1318         *      seconds = interval in seconds.
1319         *      priority = Priority for the timeout function
1320         *      fireNow =       When true the delegate will be executed emmidiatly
1321         */
1322        this(bool delegate() dlg, uint seconds, GPriority priority, bool fireNow=false)
1323        {
1324                timeoutListeners ~= dlg;
1325                timeoutID = g_timeout_add_seconds_full(priority, seconds, cast(GSourceFunc)&timeoutCallback, cast(void*)this, null);
1326                if ( fireNow )
1327                {
1328                        if ( !dlg() )
1329                        {
1330                                timeoutListeners.length = 0;
1331                        }
1332                }
1333        }
1334
1335        /** */
1336        public void stop()
1337        {
1338                if ( timeoutID > 0 )
1339                {
1340                        g_source_remove(timeoutID);
1341                }
1342                timeoutID = 0;
1343                timeoutListeners.length = 0;
1344        }
1345
1346        /**
1347         * Removes the timeout from gtk
1348         */
1349        ~this()
1350        {
1351                stop();
1352        }
1353
1354        /**
1355         * Adds a new delegate to this timeout cycle
1356         * Params:
1357         *      dlg =
1358         *      fireNow =
1359         */
1360        public void addListener(bool delegate() dlg, bool fireNow=false)
1361        {
1362                timeoutListeners ~= dlg;
1363                if ( fireNow )
1364                {
1365                        if ( !dlg() )
1366                        {
1367                                timeoutListeners.length = timeoutListeners.length - 1;
1368                        }
1369                }
1370        }
1371
1372        /**
1373         * The callback execution from glib
1374         * Params:
1375         *      timeout =
1376         * Returns:
1377         */
1378        extern(C) static bool timeoutCallback(Timeout timeout)
1379        {
1380                return timeout.callAllListeners();
1381        }
1382
1383        /**
1384         * Executes all delegates on the execution list
1385         * Returns:
1386         */
1387        private bool callAllListeners()
1388        {
1389                bool runAgain = false;
1390
1391                int i = 0;
1392
1393                while ( i<timeoutListeners.length )
1394                {
1395                        if ( !timeoutListeners[i]() )
1396                        {
1397                                timeoutListeners = timeoutListeners[0..i] ~ timeoutListeners[i+1..timeoutListeners.length];
1398                        }
1399                        else
1400                        {
1401                                runAgain = true;
1402                                ++i;
1403                        }
1404                }
1405
1406                // Set timeoutID to 0 if all delegates are removed
1407        if (timeoutListeners.length == 0)
1408                        timeoutID = 0;
1409
1410                return runAgain;
1411        }
1412code: end
1413
1414struct: TimeZone
1415noCode: new_local
1416noCode: new_utc
1417
1418struct: Tree
1419class: BBTree
1420
1421struct: Util
1422move: build_filenamev Util
1423move: build_pathv Util
1424noCode: build_filenamev
1425noCode: build_pathv
1426code: start
1427        /**
1428         * Behaves exactly like g_build_filename(), but takes the path elements
1429         * as a string array, instead of varargs. This function is mainly
1430         * meant for language bindings.
1431         *
1432         * Params:
1433         *     args = strings containing the path elements.
1434         *
1435         * Return: a newly-allocated string that must be freed with g_free().
1436         *
1437         * Since: 2.8
1438         */
1439        public static string buildFilename(string[] firstElement ... )
1440        {
1441                return Str.toString(g_build_filenamev(Str.toStringzArray(firstElement)));
1442        }
1443
1444        /**
1445         * Behaves exactly like g_build_path(), but takes the path elements
1446         * as a string array, instead of varargs. This function is mainly
1447         * meant for language bindings.
1448         *
1449         * Params:
1450         *     separator = a string used to separator the elements of the path.
1451         *     args = strings containing the path elements.
1452         *
1453         * Return: a newly-allocated string that must be freed with g_free().
1454         *
1455         * Since: 2.8
1456         */
1457        public static string buildPath(string separator, string[] firstElement ... )
1458        {
1459                return Str.toString(g_build_pathv(Str.toStringz(separator), Str.toStringzArray(firstElement)));
1460        }
1461code: end
1462
1463struct: Variant
1464noCode: new_bytestring_array
1465noCode: new_object_path
1466noCode: new_signature
1467noCode: new_objv
1468noCode: new_bytestring
1469noCode: new_handle
1470noCode: new_take_string
1471code: start
1472        /**
1473         * Creates a DBus object path GVariant with the contents of string.
1474         * string must be a valid DBus object path.
1475         * Use Variant.isObjectPath() if you're not sure.
1476         *
1477         * Since: 2.24
1478         *
1479         * Throws: ConstructionException GTK+ fails to create the object.
1480         */
1481        public static Variant fromObjectPath(string path)
1482        {
1483                auto p = g_variant_new_object_path(Str.toStringz(path));
1484                if(p is null)
1485                {
1486                        throw new ConstructionException("null returned by g_variant_new_object_path");
1487                }
1488                return new Variant(cast(GVariant*) p);
1489        }
1490
1491        /**
1492         * Creates a DBus type signature GVariant with the contents of string.
1493         * string must be a valid DBus type signature.
1494         * Use Variant.isSignature() if you're not sure.
1495         *
1496         * Since: 2.24
1497         *
1498         * Throws: ConstructionException GTK+ fails to create the object.
1499         */
1500        public static Variant fromSignature(string signature)
1501        {
1502                auto p = g_variant_new_signature(Str.toStringz(signature));
1503                if(p is null)
1504                {
1505                        throw new ConstructionException("null returned by g_variant_new_signature");
1506                }
1507                return new Variant(cast(GVariant*) p);
1508        }
1509
1510        /**
1511         * Creates an array-of-bytes GVariant with the contents of string.
1512         * This function is just like new Variant(string) except that the string
1513         * need not be valid utf8.
1514         *
1515         * The nul terminator character at the end of the string is stored in
1516         * the array.
1517         *
1518         * Throws: ConstructionException GTK+ fails to create the object.
1519         */
1520        public static Variant fromByteString(string byteString)
1521        {
1522                auto p = g_variant_new_bytestring(Str.toStringz(byteString));
1523                if(p is null)
1524                {
1525                        throw new ConstructionException("null returned by g_variant_new_bytestring");
1526                }
1527                return new Variant(cast(GVariant*) p);
1528        }
1529
1530        /**
1531         * Constructs an array of object paths Variant from the given array
1532         * of strings.
1533         *
1534         * Each string must be a valid Variant object path.
1535         *
1536         * Since: 2.30
1537         *
1538         * Params:
1539         *     strv   = an array of strings.
1540         *
1541         * Throws: ConstructionException GTK+ fails to create the object.
1542         */
1543        public static Variant fromObjv(string[] strv)
1544        {
1545                // GVariant * g_variant_new_objv (const gchar * const *strv,  gssize length);
1546                auto p = g_variant_new_objv(Str.toStringzArray(strv), strv.length);
1547                if(p is null)
1548                {
1549                        throw new ConstructionException("null returned by g_variant_new_objv(strv, length)");
1550                }
1551                return new Variant(cast(GVariant*) p);
1552        }
1553
1554        /**
1555         * Constructs an array of bytestring GVariant from the given array of
1556         * strings. If length is -1 then strv is null-terminated.
1557         *
1558         * Since: 2.26
1559         *
1560         * Params:
1561         *     strv   = an array of strings.
1562         *
1563         * Throws: ConstructionException GTK+ fails to create the object.
1564         */
1565        public static Variant fromByteStringArray(string[] strv)
1566        {
1567                auto p = g_variant_new_bytestring_array(Str.toStringzArray(strv), strv.length);
1568                if(p is null)
1569                {
1570                        throw new ConstructionException("null returned by g_variant_new_bytestring_array(strv, length)");
1571                }
1572                return new Variant(cast(GVariant*) p);
1573        }
1574code: end
1575
1576struct: VariantType
1577noCode: new_maybe
1578code: start
1579        /**
1580         * Constructs the type corresponding to a maybe instance containing
1581         * type type or Nothing.
1582         *
1583         * It is appropriate to call free() on the return value.
1584         *
1585         * Params:
1586         *     element = a VariantType
1587         *
1588         * Return: a new maybe VariantType
1589         *
1590         *     Since 2.24
1591         *
1592         * Throws: ConstructionException GTK+ fails to create the object.
1593         */
1594        public static VariantType newMaybe(VariantType element)
1595        {
1596                auto p = g_variant_type_new_maybe((element is null) ? null : element.getVariantTypeStruct());
1597
1598                if(p is null)
1599                {
1600                        throw new ConstructionException("null returned by new_maybe");
1601                }
1602
1603                return new VariantType(cast(GVariantType*) p);
1604        }
1605code: end
1606
1607struct:
1608
1609move: atomic_int_add Atomic int_add
1610move: atomic_int_and Atomic int_and
1611move: atomic_int_compare_and_exchange Atomic int_compare_and_exchange
1612move: atomic_int_dec_and_test Atomic int_dec_and_test
1613move: atomic_int_exchange_and_add Atomic int_exchange_and_add
1614move: atomic_int_get Atomic int_get
1615move: atomic_int_inc Atomic int_inc
1616move: atomic_int_or Atomic int_or
1617move: atomic_int_set Atomic int_set
1618move: atomic_int_xor Atomic int_xor
1619move: atomic_pointer_add Atomic pointer_add
1620move: atomic_pointer_and Atomic pointer_and
1621move: atomic_pointer_compare_and_exchange Atomic pointer_compare_and_exchange
1622move: atomic_pointer_get Atomic pointer_get
1623move: atomic_pointer_or Atomic pointer_or
1624move: atomic_pointer_set Atomic pointer_set
1625move: atomic_pointer_xor Atomic pointer_xor
1626
1627move: base64_decode Base64 decode
1628move: base64_encode Base64 encode
1629move: base64_encode_close Base64 encode_close
1630move: base64_encode_step Base64 encode_step
1631
1632move: convert CharacterSet
1633move: convert_error_quark CharacterSet
1634move: convert_with_fallback CharacterSet
1635move: convert_with_iconv CharacterSet
1636move: filename_display_basename CharacterSet
1637move: filename_display_name CharacterSet
1638move: filename_from_utf8 CharacterSet
1639move: filename_to_utf8 CharacterSet
1640move: get_charset CharacterSet
1641move: get_codeset CharacterSet
1642move: get_filename_charsets CharacterSet
1643move: locale_from_utf8 CharacterSet
1644move: locale_to_utf8 CharacterSet
1645
1646move: child_watch_add Child
1647move: child_watch_add_full Child
1648move: child_watch_source_new Child
1649
1650move: compute_checksum_for_bytes Checksum
1651move: compute_checksum_for_data Checksum
1652move: compute_checksum_for_string Checksum
1653
1654move: datalist_clear DataList clear
1655move: datalist_foreach DataList foreach
1656move: datalist_get_data DataList get_data
1657move: datalist_get_flags DataList get_flags
1658move: datalist_id_dup_data DataList id_dup_data
1659move: datalist_id_get_data DataList id_get_data
1660move: datalist_id_remove_no_notify DataList id_remove_no_notify
1661move: datalist_id_replace_data DataList id_replace_data
1662move: datalist_id_set_data_full DataList id_set_data_full
1663move: datalist_init DataList init
1664move: datalist_set_flags DataList set_flags
1665move: datalist_unset_flags DataList unset_flags
1666
1667move: dataset_destroy DataSet destroy
1668move: dataset_foreach DataSet foreach
1669move: dataset_id_get_data DataSet id_get_data
1670move: dataset_id_remove_no_notify DataSet id_remove_no_notify
1671move: dataset_id_set_data_full DataSet id_set_data_full
1672
1673#move: clear_error Error
1674move: prefix_error Error
1675move: propagate_prefixed_error Error
1676move: set_error Error
1677
1678move: access FileUtils
1679move: chdir FileUtils
1680move: close FileUtils
1681move: file_error_from_errno FileUtils
1682move: file_error_quark FileUtils
1683move: file_get_contents FileUtils
1684move: file_open_tmp FileUtils
1685move: file_read_link FileUtils
1686move: file_set_contents FileUtils
1687move: file_test FileUtils
1688move: mkdir_with_parents FileUtils
1689move: mkdtemp FileUtils
1690move: mkdtemp_full FileUtils
1691move: mkstemp FileUtils
1692move: mkstemp_full FileUtils
1693move: rmdir FileUtils
1694move: unlink FileUtils
1695
1696move: direct_equal HashTable
1697move: direct_hash HashTable
1698move: double_equal HashTable
1699move: double_hash HashTable
1700move: int64_equal HashTable
1701move: int64_hash HashTable
1702move: int_equal HashTable
1703move: int_hash HashTable
1704move: str_equal HashTable
1705move: str_hash HashTable
1706
1707move: hostname_is_ascii_encoded Hostname is_ascii_encoded
1708move: hostname_is_ip_address Hostname is_ip_address
1709move: hostname_is_non_ascii Hostname is_non_ascii
1710move: hostname_to_ascii Hostname to_ascii
1711move: hostname_to_unicode Hostname to_unicode
1712
1713move: idle_add Idle add
1714move: idle_add_full Idle add_full
1715move: idle_remove_by_data Idle remove_by_data
1716move: idle_source_new Idle source_new
1717
1718move: dcgettext Internationalization
1719move: dgettext Internationalization
1720move: dngettext Internationalization
1721move: dpgettext Internationalization
1722move: dpgettext2 Internationalization
1723move: get_language_names Internationalization
1724move: get_locale_variants Internationalization
1725move: strip_context Internationalization
1726
1727move: io_add_watch IOChannel
1728move: io_add_watch_full IOChannel
1729move: io_create_watch IOChannel
1730
1731move: main_current_source MainLoop
1732move: main_depth MainLoop
1733move: poll MainLoop
1734
1735move: markup_collect_attributes MarkupParseContext
1736move: markup_error_quark MarkupParseContext
1737move: markup_escape_text MarkupParseContext
1738move: markup_printf_escaped MarkupParseContext
1739move: markup_vprintf_escaped MarkupParseContext
1740
1741move: clear_pointer Memory
1742move: free Memory
1743move: malloc Memory
1744move: malloc0 Memory
1745move: malloc0_n Memory
1746move: malloc_n Memory
1747move: mem_is_system_malloc Memory
1748move: mem_profile Memory
1749move: mem_set_vtable Memory
1750move: memdup Memory
1751move: realloc Memory
1752move: realloc_n Memory
1753move: try_malloc Memory
1754move: try_malloc0 Memory
1755move: try_malloc0_n Memory
1756move: try_malloc_n Memory
1757move: try_realloc Memory
1758move: try_realloc_n Memory
1759
1760move: slice_alloc MemorySlice
1761move: slice_alloc0 MemorySlice
1762move: slice_copy MemorySlice
1763move: slice_free1 MemorySlice
1764move: slice_free_chain_with_offset MemorySlice
1765move: slice_get_config MemorySlice
1766move: slice_get_config_state MemorySlice
1767move: slice_set_config MemorySlice
1768
1769move: log MessageLog
1770move: log_default_handler MessageLog
1771move: log_remove_handler MessageLog
1772move: log_set_always_fatal MessageLog
1773move: log_set_default_handler MessageLog
1774move: log_set_fatal_mask MessageLog
1775move: log_set_handler MessageLog
1776move: log_set_handler_full MessageLog
1777move: logv MessageLog
1778
1779move: on_error_query Messages
1780move: on_error_stack_trace Messages
1781move: print Messages
1782move: printerr Messages
1783move: set_print_handler Messages
1784move: set_printerr_handler Messages
1785
1786move: option_error_quark OptionContext
1787
1788move: pattern_match PatternSpec
1789move: pattern_match_simple PatternSpec
1790move: pattern_match_string PatternSpec
1791
1792move: intern_static_string Quark
1793move: intern_string Quark
1794move: quark_from_static_string Quark
1795move: quark_from_string Quark
1796move: quark_to_string Quark
1797move: quark_try_string Quark
1798
1799move: random_double Rand
1800move: random_double_range Rand
1801move: random_int Rand
1802move: random_int_range Rand
1803move: random_set_seed Rand
1804
1805move: shell_error_quark ShellUtils
1806move: shell_parse_argv ShellUtils
1807move: shell_quote ShellUtils
1808move: shell_unquote ShellUtils
1809
1810move: spawn_async Spawn async
1811move: spawn_async_with_pipes Spawn async_with_pipes
1812move: spawn_check_exit_status Spawn check_exit_status
1813move: spawn_close_pid Spawn close_pid
1814move: spawn_command_line_async Spawn command_line_async
1815move: spawn_command_line_sync Spawn command_line_sync
1816move: spawn_error_quark Spawn error_quark
1817move: spawn_exit_error_quark Spawn exit_error_quark
1818move: spawn_sync Spawn sync
1819
1820struct: Spawn
1821noCode: async_with_pipes
1822
1823move: ascii_digit_value Str
1824move: ascii_dtostr Str
1825move: ascii_formatd Str
1826move: ascii_strcasecmp Str
1827move: ascii_strdown Str
1828move: ascii_strncasecmp Str
1829move: ascii_strtod Str
1830move: ascii_strtoll Str
1831move: ascii_strtoull Str
1832move: ascii_strup Str
1833move: ascii_tolower Str
1834move: ascii_toupper Str
1835move: ascii_xdigit_value Str
1836move: fprintf Str
1837move: printf Str
1838move: printf_string_upper_bound Str
1839move: snprintf Str
1840move: sprintf Str
1841move: stpcpy Str
1842move: str_has_prefix Str has_prefix
1843move: str_has_suffix Str has_suffix
1844move: str_is_ascii Str is_ascii
1845move: str_match_string Str match_string
1846move: str_to_ascii Str to_ascii
1847move: str_tokenize_and_fold Str tokenize_and_fold
1848move: strcanon Str
1849move: strcasecmp Str
1850move: strchomp Str
1851move: strchug Str
1852move: strcmp0 Str
1853move: strcompress Str
1854move: strconcat Str
1855move: strdelimit Str
1856move: strdown Str
1857move: strdup Str
1858move: strdup_printf Str
1859move: strdup_vprintf Str
1860move: strdupv Str
1861move: strerror Str
1862move: strescape Str
1863move: strfreev Str
1864move: strjoin Str
1865move: strjoinv Str
1866move: strlcat Str
1867move: strlcpy Str
1868move: strncasecmp Str
1869move: strndup Str
1870move: strnfill Str
1871move: strreverse Str
1872move: strrstr Str
1873move: strrstr_len Str
1874move: strsignal Str
1875move: strsplit Str
1876move: strsplit_set Str
1877move: strstr_len Str
1878move: strtod Str
1879move: strup Str
1880move: strv_get_type Str
1881move: strv_length Str
1882move: strv_contains Str
1883move: vasprintf Str
1884move: vfprintf Str
1885move: vprintf Str
1886move: vsnprintf Str
1887move: vsprintf Str
1888
1889move: string_new String
1890move: string_new_len String
1891move: string_sized_new String
1892
1893move: bit_lock Thread
1894move: bit_trylock Thread
1895move: bit_unlock Thread
1896move: get_num_processors Thread
1897move: pointer_bit_lock Thread
1898move: pointer_bit_trylock Thread
1899move: pointer_bit_unlock Thread
1900
1901move: timeout_add Timeout add
1902move: timeout_add_full Timeout add_full
1903move: timeout_add_seconds Timeout add_seconds
1904move: timeout_add_seconds_full Timeout add_seconds_full
1905move: timeout_source_new Timeout source_new
1906move: timeout_source_new_seconds Timeout source_new_seconds
1907
1908move: get_current_time TimeVal
1909move: get_monotonic_time TimeVal
1910move: get_real_time TimeVal
1911move: usleep TimeVal
1912
1913move: ucs4_to_utf16 Unicode
1914move: ucs4_to_utf8 Unicode
1915move: unichar_break_type Unicode
1916move: unichar_combining_class Unicode
1917move: unichar_compose Unicode
1918move: unichar_decompose Unicode
1919move: unichar_digit_value Unicode
1920move: unichar_fully_decompose Unicode
1921move: unichar_get_mirror_char Unicode
1922move: unichar_get_script Unicode
1923move: unichar_isalnum Unicode
1924move: unichar_isalpha Unicode
1925move: unichar_iscntrl Unicode
1926move: unichar_isdefined Unicode
1927move: unichar_isdigit Unicode
1928move: unichar_isgraph Unicode
1929move: unichar_islower Unicode
1930move: unichar_ismark Unicode
1931move: unichar_isprint Unicode
1932move: unichar_ispunct Unicode
1933move: unichar_isspace Unicode
1934move: unichar_istitle Unicode
1935move: unichar_isupper Unicode
1936move: unichar_iswide Unicode
1937move: unichar_iswide_cjk Unicode
1938move: unichar_isxdigit Unicode
1939move: unichar_iszerowidth Unicode
1940move: unichar_to_utf8 Unicode
1941move: unichar_tolower Unicode
1942move: unichar_totitle Unicode
1943move: unichar_toupper Unicode
1944move: unichar_type Unicode
1945move: unichar_validate Unicode
1946move: unichar_xdigit_value Unicode
1947move: unicode_canonical_decomposition Unicode
1948move: unicode_canonical_ordering Unicode
1949move: unicode_script_from_iso15924 Unicode
1950move: unicode_script_to_iso15924 Unicode
1951move: utf16_to_ucs4 Unicode
1952move: utf16_to_utf8 Unicode
1953move: utf8_casefold Unicode
1954move: utf8_collate Unicode
1955move: utf8_collate_key Unicode
1956move: utf8_collate_key_for_filename Unicode
1957move: utf8_find_next_char Unicode
1958move: utf8_find_prev_char Unicode
1959move: utf8_get_char Unicode
1960move: utf8_get_char_validated Unicode
1961move: utf8_normalize Unicode
1962move: utf8_offset_to_pointer Unicode
1963move: utf8_pointer_to_offset Unicode
1964move: utf8_prev_char Unicode
1965move: utf8_strchr Unicode
1966move: utf8_strdown Unicode
1967move: utf8_strlen Unicode
1968move: utf8_strncpy Unicode
1969move: utf8_strrchr Unicode
1970move: utf8_strreverse Unicode
1971move: utf8_strup Unicode
1972move: utf8_substring Unicode
1973move: utf8_to_ucs4 Unicode
1974move: utf8_to_ucs4_fast Unicode
1975move: utf8_to_utf16 Unicode
1976move: utf8_validate Unicode
1977
1978move: unix_error_quark UnixUtils error_quark
1979move: unix_fd_add UnixUtils fd_add
1980move: unix_fd_add_full UnixUtils fd_add_full
1981move: unix_fd_source_new UnixUtils fd_source_new
1982move: unix_open_pipe UnixUtils open_pipe
1983move: unix_set_fd_nonblocking UnixUtils set_fd_nonblocking
1984move: unix_signal_add UnixUtils signal_add
1985move: unix_signal_add_full UnixUtils signal_add_full
1986move: unix_signal_source_new UnixUtils signal_source_new
1987
1988move: filename_from_uri URI
1989move: filename_to_uri URI
1990move: uri_escape_string URI
1991move: uri_list_extract_uris URI
1992move: uri_parse_scheme URI
1993move: uri_unescape_segment URI
1994move: uri_unescape_string URI
1995
1996move: atexit Util
1997move: basename Util
1998move: bit_nth_lsf Util
1999move: bit_nth_msf Util
2000move: bit_storage Util
2001move: build_path Util
2002move: environ_getenv Util
2003move: environ_setenv Util
2004move: environ_unsetenv Util
2005move: find_program_in_path Util
2006move: format_size Util
2007move: format_size_for_display Util
2008move: format_size_full Util
2009move: get_application_name Util
2010move: get_environ Util
2011move: get_current_dir Util
2012move: get_home_dir Util
2013move: get_host_name Util
2014move: get_prgname Util
2015move: get_real_name Util
2016move: get_system_config_dirs Util
2017move: get_system_data_dirs Util
2018move: get_tmp_dir Util
2019move: get_user_cache_dir Util
2020move: get_user_config_dir Util
2021move: get_user_data_dir Util
2022move: get_user_name Util
2023move: get_user_runtime_dir Util
2024move: get_user_special_dir Util
2025move: getenv Util
2026move: listenv Util
2027move: nullify_pointer Util
2028move: parse_debug_string Util
2029move: path_get_basename Util
2030move: path_get_dirname Util
2031move: path_is_absolute Util
2032move: path_skip_root Util
2033move: qsort_with_data Util
2034move: reload_user_special_dirs_cache Util
2035move: set_application_name Util
2036move: set_prgname Util
2037move: setenv Util
2038move: spaced_primes_closest Util
2039move: unsetenv Util
2040
2041move: check_version Version
Note: See TracBrowser for help on using the repository browser.