source: appstream-generator/build/girepo/glib/BookmarkFile.d @ 4841

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

Initial release

File size: 28.5 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// generated automatically - do not change
19
20
21module glib.BookmarkFile;
22
23private import gi.glib;
24public  import gi.glibtypes;
25private import glib.ConstructionException;
26private import glib.ErrorG;
27private import glib.GException;
28private import glib.Str;
29
30
31/**
32 * The `GBookmarkFile` structure contains only
33 * private data and should not be directly accessed.
34 */
35public class BookmarkFile
36{
37        /** the main Gtk struct */
38        protected GBookmarkFile* gBookmarkFile;
39        protected bool ownedRef;
40
41        /** Get the main Gtk struct */
42        public GBookmarkFile* getBookmarkFileStruct()
43        {
44                return gBookmarkFile;
45        }
46
47        /** the main Gtk struct as a void* */
48        protected void* getStruct()
49        {
50                return cast(void*)gBookmarkFile;
51        }
52
53        /**
54         * Sets our main struct and passes it to the parent class.
55         */
56        public this (GBookmarkFile* gBookmarkFile, bool ownedRef = false)
57        {
58                this.gBookmarkFile = gBookmarkFile;
59                this.ownedRef = ownedRef;
60        }
61
62
63        /**
64         * Adds the application with @name and @exec to the list of
65         * applications that have registered a bookmark for @uri into
66         * @bookmark.
67         *
68         * Every bookmark inside a #GBookmarkFile must have at least an
69         * application registered.  Each application must provide a name, a
70         * command line useful for launching the bookmark, the number of times
71         * the bookmark has been registered by the application and the last
72         * time the application registered this bookmark.
73         *
74         * If @name is %NULL, the name of the application will be the
75         * same returned by g_get_application_name(); if @exec is %NULL, the
76         * command line will be a composition of the program name as
77         * returned by g_get_prgname() and the "\%u" modifier, which will be
78         * expanded to the bookmark's URI.
79         *
80         * This function will automatically take care of updating the
81         * registrations count and timestamping in case an application
82         * with the same @name had already registered a bookmark for
83         * @uri inside @bookmark.
84         *
85         * If no bookmark for @uri is found, one is created.
86         *
87         * Params:
88         *     uri = a valid URI
89         *     name = the name of the application registering the bookmark
90         *         or %NULL
91         *     exec = command line to be used to launch the bookmark or %NULL
92         *
93         * Since: 2.12
94         */
95        public void addApplication(string uri, string name, string exec)
96        {
97                g_bookmark_file_add_application(gBookmarkFile, Str.toStringz(uri), Str.toStringz(name), Str.toStringz(exec));
98        }
99
100        /**
101         * Adds @group to the list of groups to which the bookmark for @uri
102         * belongs to.
103         *
104         * If no bookmark for @uri is found then it is created.
105         *
106         * Params:
107         *     uri = a valid URI
108         *     group = the group name to be added
109         *
110         * Since: 2.12
111         */
112        public void addGroup(string uri, string group)
113        {
114                g_bookmark_file_add_group(gBookmarkFile, Str.toStringz(uri), Str.toStringz(group));
115        }
116
117        /**
118         * Frees a #GBookmarkFile.
119         *
120         * Since: 2.12
121         */
122        public void free()
123        {
124                g_bookmark_file_free(gBookmarkFile);
125        }
126
127        /**
128         * Gets the time the bookmark for @uri was added to @bookmark
129         *
130         * In the event the URI cannot be found, -1 is returned and
131         * @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
132         *
133         * Params:
134         *     uri = a valid URI
135         *
136         * Returns: a timestamp
137         *
138         * Since: 2.12
139         *
140         * Throws: GException on failure.
141         */
142        public uint getAdded(string uri)
143        {
144                GError* err = null;
145               
146                auto p = g_bookmark_file_get_added(gBookmarkFile, Str.toStringz(uri), &err);
147               
148                if (err !is null)
149                {
150                        throw new GException( new ErrorG(err) );
151                }
152               
153                return p;
154        }
155
156        /**
157         * Gets the registration informations of @app_name for the bookmark for
158         * @uri.  See g_bookmark_file_set_app_info() for more informations about
159         * the returned data.
160         *
161         * The string returned in @app_exec must be freed.
162         *
163         * In the event the URI cannot be found, %FALSE is returned and
164         * @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.  In the
165         * event that no application with name @app_name has registered a bookmark
166         * for @uri,  %FALSE is returned and error is set to
167         * #G_BOOKMARK_FILE_ERROR_APP_NOT_REGISTERED. In the event that unquoting
168         * the command line fails, an error of the #G_SHELL_ERROR domain is
169         * set and %FALSE is returned.
170         *
171         * Params:
172         *     uri = a valid URI
173         *     name = an application's name
174         *     exec = return location for the command line of the application, or %NULL
175         *     count = return location for the registration count, or %NULL
176         *     stamp = return location for the last registration time, or %NULL
177         *
178         * Returns: %TRUE on success.
179         *
180         * Since: 2.12
181         *
182         * Throws: GException on failure.
183         */
184        public bool getAppInfo(string uri, string name, out string exec, out uint count, out uint stamp)
185        {
186                char* outexec = null;
187                GError* err = null;
188               
189                auto p = g_bookmark_file_get_app_info(gBookmarkFile, Str.toStringz(uri), Str.toStringz(name), &outexec, &count, &stamp, &err) != 0;
190               
191                if (err !is null)
192                {
193                        throw new GException( new ErrorG(err) );
194                }
195               
196                exec = Str.toString(outexec);
197               
198                return p;
199        }
200
201        /**
202         * Retrieves the names of the applications that have registered the
203         * bookmark for @uri.
204         *
205         * In the event the URI cannot be found, %NULL is returned and
206         * @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
207         *
208         * Params:
209         *     uri = a valid URI
210         *
211         * Returns: a newly allocated %NULL-terminated array of strings.
212         *     Use g_strfreev() to free it.
213         *
214         * Since: 2.12
215         *
216         * Throws: GException on failure.
217         */
218        public string[] getApplications(string uri)
219        {
220                size_t length;
221                GError* err = null;
222               
223                auto retStr = g_bookmark_file_get_applications(gBookmarkFile, Str.toStringz(uri), &length, &err);
224               
225                if (err !is null)
226                {
227                        throw new GException( new ErrorG(err) );
228                }
229               
230                scope(exit) Str.freeStringArray(retStr);
231                return Str.toStringArray(retStr, length);
232        }
233
234        /**
235         * Retrieves the description of the bookmark for @uri.
236         *
237         * In the event the URI cannot be found, %NULL is returned and
238         * @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
239         *
240         * Params:
241         *     uri = a valid URI
242         *
243         * Returns: a newly allocated string or %NULL if the specified
244         *     URI cannot be found.
245         *
246         * Since: 2.12
247         *
248         * Throws: GException on failure.
249         */
250        public string getDescription(string uri)
251        {
252                GError* err = null;
253               
254                auto retStr = g_bookmark_file_get_description(gBookmarkFile, Str.toStringz(uri), &err);
255               
256                if (err !is null)
257                {
258                        throw new GException( new ErrorG(err) );
259                }
260               
261                scope(exit) Str.freeString(retStr);
262                return Str.toString(retStr);
263        }
264
265        /**
266         * Retrieves the list of group names of the bookmark for @uri.
267         *
268         * In the event the URI cannot be found, %NULL is returned and
269         * @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
270         *
271         * The returned array is %NULL terminated, so @length may optionally
272         * be %NULL.
273         *
274         * Params:
275         *     uri = a valid URI
276         *
277         * Returns: a newly allocated %NULL-terminated array of group names.
278         *     Use g_strfreev() to free it.
279         *
280         * Since: 2.12
281         *
282         * Throws: GException on failure.
283         */
284        public string[] getGroups(string uri)
285        {
286                size_t length;
287                GError* err = null;
288               
289                auto retStr = g_bookmark_file_get_groups(gBookmarkFile, Str.toStringz(uri), &length, &err);
290               
291                if (err !is null)
292                {
293                        throw new GException( new ErrorG(err) );
294                }
295               
296                scope(exit) Str.freeStringArray(retStr);
297                return Str.toStringArray(retStr, length);
298        }
299
300        /**
301         * Gets the icon of the bookmark for @uri.
302         *
303         * In the event the URI cannot be found, %FALSE is returned and
304         * @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
305         *
306         * Params:
307         *     uri = a valid URI
308         *     href = return location for the icon's location or %NULL
309         *     mimeType = return location for the icon's MIME type or %NULL
310         *
311         * Returns: %TRUE if the icon for the bookmark for the URI was found.
312         *     You should free the returned strings.
313         *
314         * Since: 2.12
315         *
316         * Throws: GException on failure.
317         */
318        public bool getIcon(string uri, out string href, out string mimeType)
319        {
320                char* outhref = null;
321                char* outmimeType = null;
322                GError* err = null;
323               
324                auto p = g_bookmark_file_get_icon(gBookmarkFile, Str.toStringz(uri), &outhref, &outmimeType, &err) != 0;
325               
326                if (err !is null)
327                {
328                        throw new GException( new ErrorG(err) );
329                }
330               
331                href = Str.toString(outhref);
332                mimeType = Str.toString(outmimeType);
333               
334                return p;
335        }
336
337        /**
338         * Gets whether the private flag of the bookmark for @uri is set.
339         *
340         * In the event the URI cannot be found, %FALSE is returned and
341         * @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.  In the
342         * event that the private flag cannot be found, %FALSE is returned and
343         * @error is set to #G_BOOKMARK_FILE_ERROR_INVALID_VALUE.
344         *
345         * Params:
346         *     uri = a valid URI
347         *
348         * Returns: %TRUE if the private flag is set, %FALSE otherwise.
349         *
350         * Since: 2.12
351         *
352         * Throws: GException on failure.
353         */
354        public bool getIsPrivate(string uri)
355        {
356                GError* err = null;
357               
358                auto p = g_bookmark_file_get_is_private(gBookmarkFile, Str.toStringz(uri), &err) != 0;
359               
360                if (err !is null)
361                {
362                        throw new GException( new ErrorG(err) );
363                }
364               
365                return p;
366        }
367
368        /**
369         * Retrieves the MIME type of the resource pointed by @uri.
370         *
371         * In the event the URI cannot be found, %NULL is returned and
372         * @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.  In the
373         * event that the MIME type cannot be found, %NULL is returned and
374         * @error is set to #G_BOOKMARK_FILE_ERROR_INVALID_VALUE.
375         *
376         * Params:
377         *     uri = a valid URI
378         *
379         * Returns: a newly allocated string or %NULL if the specified
380         *     URI cannot be found.
381         *
382         * Since: 2.12
383         *
384         * Throws: GException on failure.
385         */
386        public string getMimeType(string uri)
387        {
388                GError* err = null;
389               
390                auto retStr = g_bookmark_file_get_mime_type(gBookmarkFile, Str.toStringz(uri), &err);
391               
392                if (err !is null)
393                {
394                        throw new GException( new ErrorG(err) );
395                }
396               
397                scope(exit) Str.freeString(retStr);
398                return Str.toString(retStr);
399        }
400
401        /**
402         * Gets the time when the bookmark for @uri was last modified.
403         *
404         * In the event the URI cannot be found, -1 is returned and
405         * @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
406         *
407         * Params:
408         *     uri = a valid URI
409         *
410         * Returns: a timestamp
411         *
412         * Since: 2.12
413         *
414         * Throws: GException on failure.
415         */
416        public uint getModified(string uri)
417        {
418                GError* err = null;
419               
420                auto p = g_bookmark_file_get_modified(gBookmarkFile, Str.toStringz(uri), &err);
421               
422                if (err !is null)
423                {
424                        throw new GException( new ErrorG(err) );
425                }
426               
427                return p;
428        }
429
430        /**
431         * Gets the number of bookmarks inside @bookmark.
432         *
433         * Returns: the number of bookmarks
434         *
435         * Since: 2.12
436         */
437        public int getSize()
438        {
439                return g_bookmark_file_get_size(gBookmarkFile);
440        }
441
442        /**
443         * Returns the title of the bookmark for @uri.
444         *
445         * If @uri is %NULL, the title of @bookmark is returned.
446         *
447         * In the event the URI cannot be found, %NULL is returned and
448         * @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
449         *
450         * Params:
451         *     uri = a valid URI or %NULL
452         *
453         * Returns: a newly allocated string or %NULL if the specified
454         *     URI cannot be found.
455         *
456         * Since: 2.12
457         *
458         * Throws: GException on failure.
459         */
460        public string getTitle(string uri)
461        {
462                GError* err = null;
463               
464                auto retStr = g_bookmark_file_get_title(gBookmarkFile, Str.toStringz(uri), &err);
465               
466                if (err !is null)
467                {
468                        throw new GException( new ErrorG(err) );
469                }
470               
471                scope(exit) Str.freeString(retStr);
472                return Str.toString(retStr);
473        }
474
475        /**
476         * Returns all URIs of the bookmarks in the bookmark file @bookmark.
477         * The array of returned URIs will be %NULL-terminated, so @length may
478         * optionally be %NULL.
479         *
480         * Returns: a newly allocated %NULL-terminated array of strings.
481         *     Use g_strfreev() to free it.
482         *
483         * Since: 2.12
484         */
485        public string[] getUris()
486        {
487                size_t length;
488               
489                auto retStr = g_bookmark_file_get_uris(gBookmarkFile, &length);
490               
491                scope(exit) Str.freeStringArray(retStr);
492                return Str.toStringArray(retStr, length);
493        }
494
495        /**
496         * Gets the time the bookmark for @uri was last visited.
497         *
498         * In the event the URI cannot be found, -1 is returned and
499         * @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
500         *
501         * Params:
502         *     uri = a valid URI
503         *
504         * Returns: a timestamp.
505         *
506         * Since: 2.12
507         *
508         * Throws: GException on failure.
509         */
510        public uint getVisited(string uri)
511        {
512                GError* err = null;
513               
514                auto p = g_bookmark_file_get_visited(gBookmarkFile, Str.toStringz(uri), &err);
515               
516                if (err !is null)
517                {
518                        throw new GException( new ErrorG(err) );
519                }
520               
521                return p;
522        }
523
524        /**
525         * Checks whether the bookmark for @uri inside @bookmark has been
526         * registered by application @name.
527         *
528         * In the event the URI cannot be found, %FALSE is returned and
529         * @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
530         *
531         * Params:
532         *     uri = a valid URI
533         *     name = the name of the application
534         *
535         * Returns: %TRUE if the application @name was found
536         *
537         * Since: 2.12
538         *
539         * Throws: GException on failure.
540         */
541        public bool hasApplication(string uri, string name)
542        {
543                GError* err = null;
544               
545                auto p = g_bookmark_file_has_application(gBookmarkFile, Str.toStringz(uri), Str.toStringz(name), &err) != 0;
546               
547                if (err !is null)
548                {
549                        throw new GException( new ErrorG(err) );
550                }
551               
552                return p;
553        }
554
555        /**
556         * Checks whether @group appears in the list of groups to which
557         * the bookmark for @uri belongs to.
558         *
559         * In the event the URI cannot be found, %FALSE is returned and
560         * @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
561         *
562         * Params:
563         *     uri = a valid URI
564         *     group = the group name to be searched
565         *
566         * Returns: %TRUE if @group was found.
567         *
568         * Since: 2.12
569         *
570         * Throws: GException on failure.
571         */
572        public bool hasGroup(string uri, string group)
573        {
574                GError* err = null;
575               
576                auto p = g_bookmark_file_has_group(gBookmarkFile, Str.toStringz(uri), Str.toStringz(group), &err) != 0;
577               
578                if (err !is null)
579                {
580                        throw new GException( new ErrorG(err) );
581                }
582               
583                return p;
584        }
585
586        /**
587         * Looks whether the desktop bookmark has an item with its URI set to @uri.
588         *
589         * Params:
590         *     uri = a valid URI
591         *
592         * Returns: %TRUE if @uri is inside @bookmark, %FALSE otherwise
593         *
594         * Since: 2.12
595         */
596        public bool hasItem(string uri)
597        {
598                return g_bookmark_file_has_item(gBookmarkFile, Str.toStringz(uri)) != 0;
599        }
600
601        /**
602         * Loads a bookmark file from memory into an empty #GBookmarkFile
603         * structure.  If the object cannot be created then @error is set to a
604         * #GBookmarkFileError.
605         *
606         * Params:
607         *     data = desktop bookmarks loaded in memory
608         *     length = the length of @data in bytes
609         *
610         * Returns: %TRUE if a desktop bookmark could be loaded.
611         *
612         * Since: 2.12
613         *
614         * Throws: GException on failure.
615         */
616        public bool loadFromData(string data, size_t length)
617        {
618                GError* err = null;
619               
620                auto p = g_bookmark_file_load_from_data(gBookmarkFile, Str.toStringz(data), length, &err) != 0;
621               
622                if (err !is null)
623                {
624                        throw new GException( new ErrorG(err) );
625                }
626               
627                return p;
628        }
629
630        /**
631         * This function looks for a desktop bookmark file named @file in the
632         * paths returned from g_get_user_data_dir() and g_get_system_data_dirs(),
633         * loads the file into @bookmark and returns the file's full path in
634         * @full_path.  If the file could not be loaded then an %error is
635         * set to either a #GFileError or #GBookmarkFileError.
636         *
637         * Params:
638         *     file = a relative path to a filename to open and parse
639         *     fullPath = return location for a string containing the full path
640         *         of the file, or %NULL
641         *
642         * Returns: %TRUE if a key file could be loaded, %FALSE otherwise
643         *
644         * Since: 2.12
645         *
646         * Throws: GException on failure.
647         */
648        public bool loadFromDataDirs(string file, out string fullPath)
649        {
650                char* outfullPath = null;
651                GError* err = null;
652               
653                auto p = g_bookmark_file_load_from_data_dirs(gBookmarkFile, Str.toStringz(file), &outfullPath, &err) != 0;
654               
655                if (err !is null)
656                {
657                        throw new GException( new ErrorG(err) );
658                }
659               
660                fullPath = Str.toString(outfullPath);
661               
662                return p;
663        }
664
665        /**
666         * Loads a desktop bookmark file into an empty #GBookmarkFile structure.
667         * If the file could not be loaded then @error is set to either a #GFileError
668         * or #GBookmarkFileError.
669         *
670         * Params:
671         *     filename = the path of a filename to load, in the GLib file name encoding
672         *
673         * Returns: %TRUE if a desktop bookmark file could be loaded
674         *
675         * Since: 2.12
676         *
677         * Throws: GException on failure.
678         */
679        public bool loadFromFile(string filename)
680        {
681                GError* err = null;
682               
683                auto p = g_bookmark_file_load_from_file(gBookmarkFile, Str.toStringz(filename), &err) != 0;
684               
685                if (err !is null)
686                {
687                        throw new GException( new ErrorG(err) );
688                }
689               
690                return p;
691        }
692
693        /**
694         * Changes the URI of a bookmark item from @old_uri to @new_uri.  Any
695         * existing bookmark for @new_uri will be overwritten.  If @new_uri is
696         * %NULL, then the bookmark is removed.
697         *
698         * In the event the URI cannot be found, %FALSE is returned and
699         * @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
700         *
701         * Params:
702         *     oldUri = a valid URI
703         *     newUri = a valid URI, or %NULL
704         *
705         * Returns: %TRUE if the URI was successfully changed
706         *
707         * Since: 2.12
708         *
709         * Throws: GException on failure.
710         */
711        public bool moveItem(string oldUri, string newUri)
712        {
713                GError* err = null;
714               
715                auto p = g_bookmark_file_move_item(gBookmarkFile, Str.toStringz(oldUri), Str.toStringz(newUri), &err) != 0;
716               
717                if (err !is null)
718                {
719                        throw new GException( new ErrorG(err) );
720                }
721               
722                return p;
723        }
724
725        /**
726         * Removes application registered with @name from the list of applications
727         * that have registered a bookmark for @uri inside @bookmark.
728         *
729         * In the event the URI cannot be found, %FALSE is returned and
730         * @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
731         * In the event that no application with name @app_name has registered
732         * a bookmark for @uri,  %FALSE is returned and error is set to
733         * #G_BOOKMARK_FILE_ERROR_APP_NOT_REGISTERED.
734         *
735         * Params:
736         *     uri = a valid URI
737         *     name = the name of the application
738         *
739         * Returns: %TRUE if the application was successfully removed.
740         *
741         * Since: 2.12
742         *
743         * Throws: GException on failure.
744         */
745        public bool removeApplication(string uri, string name)
746        {
747                GError* err = null;
748               
749                auto p = g_bookmark_file_remove_application(gBookmarkFile, Str.toStringz(uri), Str.toStringz(name), &err) != 0;
750               
751                if (err !is null)
752                {
753                        throw new GException( new ErrorG(err) );
754                }
755               
756                return p;
757        }
758
759        /**
760         * Removes @group from the list of groups to which the bookmark
761         * for @uri belongs to.
762         *
763         * In the event the URI cannot be found, %FALSE is returned and
764         * @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
765         * In the event no group was defined, %FALSE is returned and
766         * @error is set to #G_BOOKMARK_FILE_ERROR_INVALID_VALUE.
767         *
768         * Params:
769         *     uri = a valid URI
770         *     group = the group name to be removed
771         *
772         * Returns: %TRUE if @group was successfully removed.
773         *
774         * Since: 2.12
775         *
776         * Throws: GException on failure.
777         */
778        public bool removeGroup(string uri, string group)
779        {
780                GError* err = null;
781               
782                auto p = g_bookmark_file_remove_group(gBookmarkFile, Str.toStringz(uri), Str.toStringz(group), &err) != 0;
783               
784                if (err !is null)
785                {
786                        throw new GException( new ErrorG(err) );
787                }
788               
789                return p;
790        }
791
792        /**
793         * Removes the bookmark for @uri from the bookmark file @bookmark.
794         *
795         * Params:
796         *     uri = a valid URI
797         *
798         * Returns: %TRUE if the bookmark was removed successfully.
799         *
800         * Since: 2.12
801         *
802         * Throws: GException on failure.
803         */
804        public bool removeItem(string uri)
805        {
806                GError* err = null;
807               
808                auto p = g_bookmark_file_remove_item(gBookmarkFile, Str.toStringz(uri), &err) != 0;
809               
810                if (err !is null)
811                {
812                        throw new GException( new ErrorG(err) );
813                }
814               
815                return p;
816        }
817
818        /**
819         * Sets the time the bookmark for @uri was added into @bookmark.
820         *
821         * If no bookmark for @uri is found then it is created.
822         *
823         * Params:
824         *     uri = a valid URI
825         *     added = a timestamp or -1 to use the current time
826         *
827         * Since: 2.12
828         */
829        public void setAdded(string uri, uint added)
830        {
831                g_bookmark_file_set_added(gBookmarkFile, Str.toStringz(uri), added);
832        }
833
834        /**
835         * Sets the meta-data of application @name inside the list of
836         * applications that have registered a bookmark for @uri inside
837         * @bookmark.
838         *
839         * You should rarely use this function; use g_bookmark_file_add_application()
840         * and g_bookmark_file_remove_application() instead.
841         *
842         * @name can be any UTF-8 encoded string used to identify an
843         * application.
844         * @exec can have one of these two modifiers: "\%f", which will
845         * be expanded as the local file name retrieved from the bookmark's
846         * URI; "\%u", which will be expanded as the bookmark's URI.
847         * The expansion is done automatically when retrieving the stored
848         * command line using the g_bookmark_file_get_app_info() function.
849         * @count is the number of times the application has registered the
850         * bookmark; if is < 0, the current registration count will be increased
851         * by one, if is 0, the application with @name will be removed from
852         * the list of registered applications.
853         * @stamp is the Unix time of the last registration; if it is -1, the
854         * current time will be used.
855         *
856         * If you try to remove an application by setting its registration count to
857         * zero, and no bookmark for @uri is found, %FALSE is returned and
858         * @error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND; similarly,
859         * in the event that no application @name has registered a bookmark
860         * for @uri,  %FALSE is returned and error is set to
861         * #G_BOOKMARK_FILE_ERROR_APP_NOT_REGISTERED.  Otherwise, if no bookmark
862         * for @uri is found, one is created.
863         *
864         * Params:
865         *     uri = a valid URI
866         *     name = an application's name
867         *     exec = an application's command line
868         *     count = the number of registrations done for this application
869         *     stamp = the time of the last registration for this application
870         *
871         * Returns: %TRUE if the application's meta-data was successfully
872         *     changed.
873         *
874         * Since: 2.12
875         *
876         * Throws: GException on failure.
877         */
878        public bool setAppInfo(string uri, string name, string exec, int count, uint stamp)
879        {
880                GError* err = null;
881               
882                auto p = g_bookmark_file_set_app_info(gBookmarkFile, Str.toStringz(uri), Str.toStringz(name), Str.toStringz(exec), count, stamp, &err) != 0;
883               
884                if (err !is null)
885                {
886                        throw new GException( new ErrorG(err) );
887                }
888               
889                return p;
890        }
891
892        /**
893         * Sets @description as the description of the bookmark for @uri.
894         *
895         * If @uri is %NULL, the description of @bookmark is set.
896         *
897         * If a bookmark for @uri cannot be found then it is created.
898         *
899         * Params:
900         *     uri = a valid URI or %NULL
901         *     description = a string
902         *
903         * Since: 2.12
904         */
905        public void setDescription(string uri, string description)
906        {
907                g_bookmark_file_set_description(gBookmarkFile, Str.toStringz(uri), Str.toStringz(description));
908        }
909
910        /**
911         * Sets a list of group names for the item with URI @uri.  Each previously
912         * set group name list is removed.
913         *
914         * If @uri cannot be found then an item for it is created.
915         *
916         * Params:
917         *     uri = an item's URI
918         *     groups = an array of group names, or %NULL to remove all groups
919         *     length = number of group name values in @groups
920         *
921         * Since: 2.12
922         */
923        public void setGroups(string uri, string[] groups)
924        {
925                g_bookmark_file_set_groups(gBookmarkFile, Str.toStringz(uri), Str.toStringzArray(groups), cast(size_t)groups.length);
926        }
927
928        /**
929         * Sets the icon for the bookmark for @uri. If @href is %NULL, unsets
930         * the currently set icon. @href can either be a full URL for the icon
931         * file or the icon name following the Icon Naming specification.
932         *
933         * If no bookmark for @uri is found one is created.
934         *
935         * Params:
936         *     uri = a valid URI
937         *     href = the URI of the icon for the bookmark, or %NULL
938         *     mimeType = the MIME type of the icon for the bookmark
939         *
940         * Since: 2.12
941         */
942        public void setIcon(string uri, string href, string mimeType)
943        {
944                g_bookmark_file_set_icon(gBookmarkFile, Str.toStringz(uri), Str.toStringz(href), Str.toStringz(mimeType));
945        }
946
947        /**
948         * Sets the private flag of the bookmark for @uri.
949         *
950         * If a bookmark for @uri cannot be found then it is created.
951         *
952         * Params:
953         *     uri = a valid URI
954         *     isPrivate = %TRUE if the bookmark should be marked as private
955         *
956         * Since: 2.12
957         */
958        public void setIsPrivate(string uri, bool isPrivate)
959        {
960                g_bookmark_file_set_is_private(gBookmarkFile, Str.toStringz(uri), isPrivate);
961        }
962
963        /**
964         * Sets @mime_type as the MIME type of the bookmark for @uri.
965         *
966         * If a bookmark for @uri cannot be found then it is created.
967         *
968         * Params:
969         *     uri = a valid URI
970         *     mimeType = a MIME type
971         *
972         * Since: 2.12
973         */
974        public void setMimeType(string uri, string mimeType)
975        {
976                g_bookmark_file_set_mime_type(gBookmarkFile, Str.toStringz(uri), Str.toStringz(mimeType));
977        }
978
979        /**
980         * Sets the last time the bookmark for @uri was last modified.
981         *
982         * If no bookmark for @uri is found then it is created.
983         *
984         * The "modified" time should only be set when the bookmark's meta-data
985         * was actually changed.  Every function of #GBookmarkFile that
986         * modifies a bookmark also changes the modification time, except for
987         * g_bookmark_file_set_visited().
988         *
989         * Params:
990         *     uri = a valid URI
991         *     modified = a timestamp or -1 to use the current time
992         *
993         * Since: 2.12
994         */
995        public void setModified(string uri, uint modified)
996        {
997                g_bookmark_file_set_modified(gBookmarkFile, Str.toStringz(uri), modified);
998        }
999
1000        /**
1001         * Sets @title as the title of the bookmark for @uri inside the
1002         * bookmark file @bookmark.
1003         *
1004         * If @uri is %NULL, the title of @bookmark is set.
1005         *
1006         * If a bookmark for @uri cannot be found then it is created.
1007         *
1008         * Params:
1009         *     uri = a valid URI or %NULL
1010         *     title = a UTF-8 encoded string
1011         *
1012         * Since: 2.12
1013         */
1014        public void setTitle(string uri, string title)
1015        {
1016                g_bookmark_file_set_title(gBookmarkFile, Str.toStringz(uri), Str.toStringz(title));
1017        }
1018
1019        /**
1020         * Sets the time the bookmark for @uri was last visited.
1021         *
1022         * If no bookmark for @uri is found then it is created.
1023         *
1024         * The "visited" time should only be set if the bookmark was launched,
1025         * either using the command line retrieved by g_bookmark_file_get_app_info()
1026         * or by the default application for the bookmark's MIME type, retrieved
1027         * using g_bookmark_file_get_mime_type().  Changing the "visited" time
1028         * does not affect the "modified" time.
1029         *
1030         * Params:
1031         *     uri = a valid URI
1032         *     visited = a timestamp or -1 to use the current time
1033         *
1034         * Since: 2.12
1035         */
1036        public void setVisited(string uri, uint visited)
1037        {
1038                g_bookmark_file_set_visited(gBookmarkFile, Str.toStringz(uri), visited);
1039        }
1040
1041        /**
1042         * This function outputs @bookmark as a string.
1043         *
1044         * Params:
1045         *     length = return location for the length of the returned string, or %NULL
1046         *
1047         * Returns: a newly allocated string holding
1048         *     the contents of the #GBookmarkFile
1049         *
1050         * Since: 2.12
1051         *
1052         * Throws: GException on failure.
1053         */
1054        public string toData(out size_t length)
1055        {
1056                GError* err = null;
1057               
1058                auto retStr = g_bookmark_file_to_data(gBookmarkFile, &length, &err);
1059               
1060                if (err !is null)
1061                {
1062                        throw new GException( new ErrorG(err) );
1063                }
1064               
1065                scope(exit) Str.freeString(retStr);
1066                return Str.toString(retStr);
1067        }
1068
1069        /**
1070         * This function outputs @bookmark into a file.  The write process is
1071         * guaranteed to be atomic by using g_file_set_contents() internally.
1072         *
1073         * Params:
1074         *     filename = path of the output file
1075         *
1076         * Returns: %TRUE if the file was successfully written.
1077         *
1078         * Since: 2.12
1079         *
1080         * Throws: GException on failure.
1081         */
1082        public bool toFile(string filename)
1083        {
1084                GError* err = null;
1085               
1086                auto p = g_bookmark_file_to_file(gBookmarkFile, Str.toStringz(filename), &err) != 0;
1087               
1088                if (err !is null)
1089                {
1090                        throw new GException( new ErrorG(err) );
1091                }
1092               
1093                return p;
1094        }
1095
1096        /** */
1097        public static GQuark errorQuark()
1098        {
1099                return g_bookmark_file_error_quark();
1100        }
1101
1102        /**
1103         * Creates a new empty #GBookmarkFile object.
1104         *
1105         * Use g_bookmark_file_load_from_file(), g_bookmark_file_load_from_data()
1106         * or g_bookmark_file_load_from_data_dirs() to read an existing bookmark
1107         * file.
1108         *
1109         * Returns: an empty #GBookmarkFile
1110         *
1111         * Since: 2.12
1112         *
1113         * Throws: ConstructionException GTK+ fails to create the object.
1114         */
1115        public this()
1116        {
1117                auto p = g_bookmark_file_new();
1118               
1119                if(p is null)
1120                {
1121                        throw new ConstructionException("null returned by new");
1122                }
1123               
1124                this(cast(GBookmarkFile*) p);
1125        }
1126}
Note: See TracBrowser for help on using the repository browser.