source: appstream-generator/build/girepo/gio/FileInfo.d @ 4841

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

Initial release

File size: 23.7 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 gio.FileInfo;
22
23private import gi.gio;
24public  import gi.giotypes;
25private import gio.FileAttributeMatcher;
26private import gio.Icon;
27private import gio.IconIF;
28private import glib.ConstructionException;
29private import glib.DateTime;
30private import glib.Str;
31private import glib.TimeVal;
32private import gobject.ObjectG;
33
34
35/**
36 * Functionality for manipulating basic metadata for files. #GFileInfo
37 * implements methods for getting information that all files should
38 * contain, and allows for manipulation of extended attributes.
39 *
40 * See [GFileAttribute][gio-GFileAttribute] for more information on how
41 * GIO handles file attributes.
42 *
43 * To obtain a #GFileInfo for a #GFile, use g_file_query_info() (or its
44 * async variant). To obtain a #GFileInfo for a file input or output
45 * stream, use g_file_input_stream_query_info() or
46 * g_file_output_stream_query_info() (or their async variants).
47 *
48 * To change the actual attributes of a file, you should then set the
49 * attribute in the #GFileInfo and call g_file_set_attributes_from_info()
50 * or g_file_set_attributes_async() on a GFile.
51 *
52 * However, not all attributes can be changed in the file. For instance,
53 * the actual size of a file cannot be changed via g_file_info_set_size().
54 * You may call g_file_query_settable_attributes() and
55 * g_file_query_writable_namespaces() to discover the settable attributes
56 * of a particular file at runtime.
57 *
58 * #GFileAttributeMatcher allows for searching through a #GFileInfo for
59 * attributes.
60 */
61public class FileInfo : ObjectG
62{
63        /** the main Gtk struct */
64        protected GFileInfo* gFileInfo;
65
66        /** Get the main Gtk struct */
67        public GFileInfo* getFileInfoStruct()
68        {
69                return gFileInfo;
70        }
71
72        /** the main Gtk struct as a void* */
73        protected override void* getStruct()
74        {
75                return cast(void*)gFileInfo;
76        }
77
78        protected override void setStruct(GObject* obj)
79        {
80                gFileInfo = cast(GFileInfo*)obj;
81                super.setStruct(obj);
82        }
83
84        /**
85         * Sets our main struct and passes it to the parent class.
86         */
87        public this (GFileInfo* gFileInfo, bool ownedRef = false)
88        {
89                this.gFileInfo = gFileInfo;
90                super(cast(GObject*)gFileInfo, ownedRef);
91        }
92
93
94        /** */
95        public static GType getType()
96        {
97                return g_file_info_get_type();
98        }
99
100        /**
101         * Creates a new file info structure.
102         *
103         * Returns: a #GFileInfo.
104         *
105         * Throws: ConstructionException GTK+ fails to create the object.
106         */
107        public this()
108        {
109                auto p = g_file_info_new();
110               
111                if(p is null)
112                {
113                        throw new ConstructionException("null returned by new");
114                }
115               
116                this(cast(GFileInfo*) p, true);
117        }
118
119        /**
120         * Clears the status information from @info.
121         */
122        public void clearStatus()
123        {
124                g_file_info_clear_status(gFileInfo);
125        }
126
127        /**
128         * Copies all of the [GFileAttribute][gio-GFileAttribute]
129         * from @src_info to @dest_info.
130         *
131         * Params:
132         *     destInfo = destination to copy attributes to.
133         */
134        public void copyInto(FileInfo destInfo)
135        {
136                g_file_info_copy_into(gFileInfo, (destInfo is null) ? null : destInfo.getFileInfoStruct());
137        }
138
139        /**
140         * Duplicates a file info structure.
141         *
142         * Returns: a duplicate #GFileInfo of @other.
143         */
144        public FileInfo dup()
145        {
146                auto p = g_file_info_dup(gFileInfo);
147               
148                if(p is null)
149                {
150                        return null;
151                }
152               
153                return ObjectG.getDObject!(FileInfo)(cast(GFileInfo*) p, true);
154        }
155
156        /**
157         * Gets the value of a attribute, formated as a string.
158         * This escapes things as needed to make the string valid
159         * utf8.
160         *
161         * Params:
162         *     attribute = a file attribute key.
163         *
164         * Returns: a UTF-8 string associated with the given @attribute.
165         *     When you're done with the string it must be freed with g_free().
166         */
167        public string getAttributeAsString(string attribute)
168        {
169                auto retStr = g_file_info_get_attribute_as_string(gFileInfo, Str.toStringz(attribute));
170               
171                scope(exit) Str.freeString(retStr);
172                return Str.toString(retStr);
173        }
174
175        /**
176         * Gets the value of a boolean attribute. If the attribute does not
177         * contain a boolean value, %FALSE will be returned.
178         *
179         * Params:
180         *     attribute = a file attribute key.
181         *
182         * Returns: the boolean value contained within the attribute.
183         */
184        public bool getAttributeBoolean(string attribute)
185        {
186                return g_file_info_get_attribute_boolean(gFileInfo, Str.toStringz(attribute)) != 0;
187        }
188
189        /**
190         * Gets the value of a byte string attribute. If the attribute does
191         * not contain a byte string, %NULL will be returned.
192         *
193         * Params:
194         *     attribute = a file attribute key.
195         *
196         * Returns: the contents of the @attribute value as a byte string, or
197         *     %NULL otherwise.
198         */
199        public string getAttributeByteString(string attribute)
200        {
201                return Str.toString(g_file_info_get_attribute_byte_string(gFileInfo, Str.toStringz(attribute)));
202        }
203
204        /**
205         * Gets the attribute type, value and status for an attribute key.
206         *
207         * Params:
208         *     attribute = a file attribute key
209         *     type = return location for the attribute type, or %NULL
210         *     valuePp = return location for the attribute value, or %NULL
211         *     status = return location for the attribute status, or %NULL
212         *
213         * Returns: %TRUE if @info has an attribute named @attribute,
214         *     %FALSE otherwise.
215         */
216        public bool getAttributeData(string attribute, out GFileAttributeType type, out void* valuePp, out GFileAttributeStatus status)
217        {
218                return g_file_info_get_attribute_data(gFileInfo, Str.toStringz(attribute), &type, &valuePp, &status) != 0;
219        }
220
221        /**
222         * Gets a signed 32-bit integer contained within the attribute. If the
223         * attribute does not contain a signed 32-bit integer, or is invalid,
224         * 0 will be returned.
225         *
226         * Params:
227         *     attribute = a file attribute key.
228         *
229         * Returns: a signed 32-bit integer from the attribute.
230         */
231        public int getAttributeInt32(string attribute)
232        {
233                return g_file_info_get_attribute_int32(gFileInfo, Str.toStringz(attribute));
234        }
235
236        /**
237         * Gets a signed 64-bit integer contained within the attribute. If the
238         * attribute does not contain an signed 64-bit integer, or is invalid,
239         * 0 will be returned.
240         *
241         * Params:
242         *     attribute = a file attribute key.
243         *
244         * Returns: a signed 64-bit integer from the attribute.
245         */
246        public long getAttributeInt64(string attribute)
247        {
248                return g_file_info_get_attribute_int64(gFileInfo, Str.toStringz(attribute));
249        }
250
251        /**
252         * Gets the value of a #GObject attribute. If the attribute does
253         * not contain a #GObject, %NULL will be returned.
254         *
255         * Params:
256         *     attribute = a file attribute key.
257         *
258         * Returns: a #GObject associated with the given @attribute, or
259         *     %NULL otherwise.
260         */
261        public ObjectG getAttributeObject(string attribute)
262        {
263                auto p = g_file_info_get_attribute_object(gFileInfo, Str.toStringz(attribute));
264               
265                if(p is null)
266                {
267                        return null;
268                }
269               
270                return ObjectG.getDObject!(ObjectG)(cast(GObject*) p);
271        }
272
273        /**
274         * Gets the attribute status for an attribute key.
275         *
276         * Params:
277         *     attribute = a file attribute key
278         *
279         * Returns: a #GFileAttributeStatus for the given @attribute, or
280         *     %G_FILE_ATTRIBUTE_STATUS_UNSET if the key is invalid.
281         */
282        public GFileAttributeStatus getAttributeStatus(string attribute)
283        {
284                return g_file_info_get_attribute_status(gFileInfo, Str.toStringz(attribute));
285        }
286
287        /**
288         * Gets the value of a string attribute. If the attribute does
289         * not contain a string, %NULL will be returned.
290         *
291         * Params:
292         *     attribute = a file attribute key.
293         *
294         * Returns: the contents of the @attribute value as a UTF-8 string, or
295         *     %NULL otherwise.
296         */
297        public string getAttributeString(string attribute)
298        {
299                return Str.toString(g_file_info_get_attribute_string(gFileInfo, Str.toStringz(attribute)));
300        }
301
302        /**
303         * Gets the value of a stringv attribute. If the attribute does
304         * not contain a stringv, %NULL will be returned.
305         *
306         * Params:
307         *     attribute = a file attribute key.
308         *
309         * Returns: the contents of the @attribute value as a stringv, or
310         *     %NULL otherwise. Do not free. These returned strings are UTF-8.
311         *
312         * Since: 2.22
313         */
314        public string[] getAttributeStringv(string attribute)
315        {
316                return Str.toStringArray(g_file_info_get_attribute_stringv(gFileInfo, Str.toStringz(attribute)));
317        }
318
319        /**
320         * Gets the attribute type for an attribute key.
321         *
322         * Params:
323         *     attribute = a file attribute key.
324         *
325         * Returns: a #GFileAttributeType for the given @attribute, or
326         *     %G_FILE_ATTRIBUTE_TYPE_INVALID if the key is not set.
327         */
328        public GFileAttributeType getAttributeType(string attribute)
329        {
330                return g_file_info_get_attribute_type(gFileInfo, Str.toStringz(attribute));
331        }
332
333        /**
334         * Gets an unsigned 32-bit integer contained within the attribute. If the
335         * attribute does not contain an unsigned 32-bit integer, or is invalid,
336         * 0 will be returned.
337         *
338         * Params:
339         *     attribute = a file attribute key.
340         *
341         * Returns: an unsigned 32-bit integer from the attribute.
342         */
343        public uint getAttributeUint32(string attribute)
344        {
345                return g_file_info_get_attribute_uint32(gFileInfo, Str.toStringz(attribute));
346        }
347
348        /**
349         * Gets a unsigned 64-bit integer contained within the attribute. If the
350         * attribute does not contain an unsigned 64-bit integer, or is invalid,
351         * 0 will be returned.
352         *
353         * Params:
354         *     attribute = a file attribute key.
355         *
356         * Returns: a unsigned 64-bit integer from the attribute.
357         */
358        public ulong getAttributeUint64(string attribute)
359        {
360                return g_file_info_get_attribute_uint64(gFileInfo, Str.toStringz(attribute));
361        }
362
363        /**
364         * Gets the file's content type.
365         *
366         * Returns: a string containing the file's content type.
367         */
368        public string getContentType()
369        {
370                return Str.toString(g_file_info_get_content_type(gFileInfo));
371        }
372
373        /**
374         * Returns the #GDateTime representing the deletion date of the file, as
375         * available in G_FILE_ATTRIBUTE_TRASH_DELETION_DATE. If the
376         * G_FILE_ATTRIBUTE_TRASH_DELETION_DATE attribute is unset, %NULL is returned.
377         *
378         * Returns: a #GDateTime, or %NULL.
379         *
380         * Since: 2.36
381         */
382        public DateTime getDeletionDate()
383        {
384                auto p = g_file_info_get_deletion_date(gFileInfo);
385               
386                if(p is null)
387                {
388                        return null;
389                }
390               
391                return new DateTime(cast(GDateTime*) p, true);
392        }
393
394        /**
395         * Gets a display name for a file.
396         *
397         * Returns: a string containing the display name.
398         */
399        public string getDisplayName()
400        {
401                return Str.toString(g_file_info_get_display_name(gFileInfo));
402        }
403
404        /**
405         * Gets the edit name for a file.
406         *
407         * Returns: a string containing the edit name.
408         */
409        public string getEditName()
410        {
411                return Str.toString(g_file_info_get_edit_name(gFileInfo));
412        }
413
414        /**
415         * Gets the [entity tag][gfile-etag] for a given
416         * #GFileInfo. See %G_FILE_ATTRIBUTE_ETAG_VALUE.
417         *
418         * Returns: a string containing the value of the "etag:value" attribute.
419         */
420        public string getEtag()
421        {
422                return Str.toString(g_file_info_get_etag(gFileInfo));
423        }
424
425        /**
426         * Gets a file's type (whether it is a regular file, symlink, etc).
427         * This is different from the file's content type, see g_file_info_get_content_type().
428         *
429         * Returns: a #GFileType for the given file.
430         */
431        public GFileType getFileType()
432        {
433                return g_file_info_get_file_type(gFileInfo);
434        }
435
436        /**
437         * Gets the icon for a file.
438         *
439         * Returns: #GIcon for the given @info.
440         */
441        public IconIF getIcon()
442        {
443                auto p = g_file_info_get_icon(gFileInfo);
444               
445                if(p is null)
446                {
447                        return null;
448                }
449               
450                return ObjectG.getDObject!(Icon, IconIF)(cast(GIcon*) p);
451        }
452
453        /**
454         * Checks if a file is a backup file.
455         *
456         * Returns: %TRUE if file is a backup file, %FALSE otherwise.
457         */
458        public bool getIsBackup()
459        {
460                return g_file_info_get_is_backup(gFileInfo) != 0;
461        }
462
463        /**
464         * Checks if a file is hidden.
465         *
466         * Returns: %TRUE if the file is a hidden file, %FALSE otherwise.
467         */
468        public bool getIsHidden()
469        {
470                return g_file_info_get_is_hidden(gFileInfo) != 0;
471        }
472
473        /**
474         * Checks if a file is a symlink.
475         *
476         * Returns: %TRUE if the given @info is a symlink.
477         */
478        public bool getIsSymlink()
479        {
480                return g_file_info_get_is_symlink(gFileInfo) != 0;
481        }
482
483        /**
484         * Gets the modification time of the current @info and sets it
485         * in @result.
486         *
487         * Params:
488         *     result = a #GTimeVal.
489         */
490        public void getModificationTime(out TimeVal result)
491        {
492                GTimeVal* outresult = gMalloc!GTimeVal();
493               
494                g_file_info_get_modification_time(gFileInfo, outresult);
495               
496                result = new TimeVal(outresult, true);
497        }
498
499        /**
500         * Gets the name for a file.
501         *
502         * Returns: a string containing the file name.
503         */
504        public string getName()
505        {
506                return Str.toString(g_file_info_get_name(gFileInfo));
507        }
508
509        /**
510         * Gets the file's size.
511         *
512         * Returns: a #goffset containing the file's size.
513         */
514        public long getSize()
515        {
516                return g_file_info_get_size(gFileInfo);
517        }
518
519        /**
520         * Gets the value of the sort_order attribute from the #GFileInfo.
521         * See %G_FILE_ATTRIBUTE_STANDARD_SORT_ORDER.
522         *
523         * Returns: a #gint32 containing the value of the "standard::sort_order" attribute.
524         */
525        public int getSortOrder()
526        {
527                return g_file_info_get_sort_order(gFileInfo);
528        }
529
530        /**
531         * Gets the symbolic icon for a file.
532         *
533         * Returns: #GIcon for the given @info.
534         *
535         * Since: 2.34
536         */
537        public IconIF getSymbolicIcon()
538        {
539                auto p = g_file_info_get_symbolic_icon(gFileInfo);
540               
541                if(p is null)
542                {
543                        return null;
544                }
545               
546                return ObjectG.getDObject!(Icon, IconIF)(cast(GIcon*) p);
547        }
548
549        /**
550         * Gets the symlink target for a given #GFileInfo.
551         *
552         * Returns: a string containing the symlink target.
553         */
554        public string getSymlinkTarget()
555        {
556                return Str.toString(g_file_info_get_symlink_target(gFileInfo));
557        }
558
559        /**
560         * Checks if a file info structure has an attribute named @attribute.
561         *
562         * Params:
563         *     attribute = a file attribute key.
564         *
565         * Returns: %TRUE if @Ginfo has an attribute named @attribute,
566         *     %FALSE otherwise.
567         */
568        public bool hasAttribute(string attribute)
569        {
570                return g_file_info_has_attribute(gFileInfo, Str.toStringz(attribute)) != 0;
571        }
572
573        /**
574         * Checks if a file info structure has an attribute in the
575         * specified @name_space.
576         *
577         * Params:
578         *     nameSpace = a file attribute namespace.
579         *
580         * Returns: %TRUE if @Ginfo has an attribute in @name_space,
581         *     %FALSE otherwise.
582         *
583         * Since: 2.22
584         */
585        public bool hasNamespace(string nameSpace)
586        {
587                return g_file_info_has_namespace(gFileInfo, Str.toStringz(nameSpace)) != 0;
588        }
589
590        /**
591         * Lists the file info structure's attributes.
592         *
593         * Params:
594         *     nameSpace = a file attribute key's namespace.
595         *
596         * Returns: a
597         *     null-terminated array of strings of all of the possible attribute
598         *     types for the given @name_space, or %NULL on error.
599         */
600        public string[] listAttributes(string nameSpace)
601        {
602                auto retStr = g_file_info_list_attributes(gFileInfo, Str.toStringz(nameSpace));
603               
604                scope(exit) Str.freeStringArray(retStr);
605                return Str.toStringArray(retStr);
606        }
607
608        /**
609         * Removes all cases of @attribute from @info if it exists.
610         *
611         * Params:
612         *     attribute = a file attribute key.
613         */
614        public void removeAttribute(string attribute)
615        {
616                g_file_info_remove_attribute(gFileInfo, Str.toStringz(attribute));
617        }
618
619        /**
620         * Sets the @attribute to contain the given value, if possible. To unset the
621         * attribute, use %G_ATTRIBUTE_TYPE_INVALID for @type.
622         *
623         * Params:
624         *     attribute = a file attribute key.
625         *     type = a #GFileAttributeType
626         *     valueP = pointer to the value
627         */
628        public void setAttribute(string attribute, GFileAttributeType type, void* valueP)
629        {
630                g_file_info_set_attribute(gFileInfo, Str.toStringz(attribute), type, valueP);
631        }
632
633        /**
634         * Sets the @attribute to contain the given @attr_value,
635         * if possible.
636         *
637         * Params:
638         *     attribute = a file attribute key.
639         *     attrValue = a boolean value.
640         */
641        public void setAttributeBoolean(string attribute, bool attrValue)
642        {
643                g_file_info_set_attribute_boolean(gFileInfo, Str.toStringz(attribute), attrValue);
644        }
645
646        /**
647         * Sets the @attribute to contain the given @attr_value,
648         * if possible.
649         *
650         * Params:
651         *     attribute = a file attribute key.
652         *     attrValue = a byte string.
653         */
654        public void setAttributeByteString(string attribute, string attrValue)
655        {
656                g_file_info_set_attribute_byte_string(gFileInfo, Str.toStringz(attribute), Str.toStringz(attrValue));
657        }
658
659        /**
660         * Sets the @attribute to contain the given @attr_value,
661         * if possible.
662         *
663         * Params:
664         *     attribute = a file attribute key.
665         *     attrValue = a signed 32-bit integer
666         */
667        public void setAttributeInt32(string attribute, int attrValue)
668        {
669                g_file_info_set_attribute_int32(gFileInfo, Str.toStringz(attribute), attrValue);
670        }
671
672        /**
673         * Sets the @attribute to contain the given @attr_value,
674         * if possible.
675         *
676         * Params:
677         *     attribute = attribute name to set.
678         *     attrValue = int64 value to set attribute to.
679         */
680        public void setAttributeInt64(string attribute, long attrValue)
681        {
682                g_file_info_set_attribute_int64(gFileInfo, Str.toStringz(attribute), attrValue);
683        }
684
685        /**
686         * Sets @mask on @info to match specific attribute types.
687         *
688         * Params:
689         *     mask = a #GFileAttributeMatcher.
690         */
691        public void setAttributeMask(FileAttributeMatcher mask)
692        {
693                g_file_info_set_attribute_mask(gFileInfo, (mask is null) ? null : mask.getFileAttributeMatcherStruct());
694        }
695
696        /**
697         * Sets the @attribute to contain the given @attr_value,
698         * if possible.
699         *
700         * Params:
701         *     attribute = a file attribute key.
702         *     attrValue = a #GObject.
703         */
704        public void setAttributeObject(string attribute, ObjectG attrValue)
705        {
706                g_file_info_set_attribute_object(gFileInfo, Str.toStringz(attribute), (attrValue is null) ? null : attrValue.getObjectGStruct());
707        }
708
709        /**
710         * Sets the attribute status for an attribute key. This is only
711         * needed by external code that implement g_file_set_attributes_from_info()
712         * or similar functions.
713         *
714         * The attribute must exist in @info for this to work. Otherwise %FALSE
715         * is returned and @info is unchanged.
716         *
717         * Params:
718         *     attribute = a file attribute key
719         *     status = a #GFileAttributeStatus
720         *
721         * Returns: %TRUE if the status was changed, %FALSE if the key was not set.
722         *
723         * Since: 2.22
724         */
725        public bool setAttributeStatus(string attribute, GFileAttributeStatus status)
726        {
727                return g_file_info_set_attribute_status(gFileInfo, Str.toStringz(attribute), status) != 0;
728        }
729
730        /**
731         * Sets the @attribute to contain the given @attr_value,
732         * if possible.
733         *
734         * Params:
735         *     attribute = a file attribute key.
736         *     attrValue = a UTF-8 string.
737         */
738        public void setAttributeString(string attribute, string attrValue)
739        {
740                g_file_info_set_attribute_string(gFileInfo, Str.toStringz(attribute), Str.toStringz(attrValue));
741        }
742
743        /**
744         * Sets the @attribute to contain the given @attr_value,
745         * if possible.
746         *
747         * Sinze: 2.22
748         *
749         * Params:
750         *     attribute = a file attribute key
751         *     attrValue = a %NULL terminated array of UTF-8 strings.
752         */
753        public void setAttributeStringv(string attribute, string[] attrValue)
754        {
755                g_file_info_set_attribute_stringv(gFileInfo, Str.toStringz(attribute), Str.toStringzArray(attrValue));
756        }
757
758        /**
759         * Sets the @attribute to contain the given @attr_value,
760         * if possible.
761         *
762         * Params:
763         *     attribute = a file attribute key.
764         *     attrValue = an unsigned 32-bit integer.
765         */
766        public void setAttributeUint32(string attribute, uint attrValue)
767        {
768                g_file_info_set_attribute_uint32(gFileInfo, Str.toStringz(attribute), attrValue);
769        }
770
771        /**
772         * Sets the @attribute to contain the given @attr_value,
773         * if possible.
774         *
775         * Params:
776         *     attribute = a file attribute key.
777         *     attrValue = an unsigned 64-bit integer.
778         */
779        public void setAttributeUint64(string attribute, ulong attrValue)
780        {
781                g_file_info_set_attribute_uint64(gFileInfo, Str.toStringz(attribute), attrValue);
782        }
783
784        /**
785         * Sets the content type attribute for a given #GFileInfo.
786         * See %G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE.
787         *
788         * Params:
789         *     contentType = a content type. See [GContentType][gio-GContentType]
790         */
791        public void setContentType(string contentType)
792        {
793                g_file_info_set_content_type(gFileInfo, Str.toStringz(contentType));
794        }
795
796        /**
797         * Sets the display name for the current #GFileInfo.
798         * See %G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME.
799         *
800         * Params:
801         *     displayName = a string containing a display name.
802         */
803        public void setDisplayName(string displayName)
804        {
805                g_file_info_set_display_name(gFileInfo, Str.toStringz(displayName));
806        }
807
808        /**
809         * Sets the edit name for the current file.
810         * See %G_FILE_ATTRIBUTE_STANDARD_EDIT_NAME.
811         *
812         * Params:
813         *     editName = a string containing an edit name.
814         */
815        public void setEditName(string editName)
816        {
817                g_file_info_set_edit_name(gFileInfo, Str.toStringz(editName));
818        }
819
820        /**
821         * Sets the file type in a #GFileInfo to @type.
822         * See %G_FILE_ATTRIBUTE_STANDARD_TYPE.
823         *
824         * Params:
825         *     type = a #GFileType.
826         */
827        public void setFileType(GFileType type)
828        {
829                g_file_info_set_file_type(gFileInfo, type);
830        }
831
832        /**
833         * Sets the icon for a given #GFileInfo.
834         * See %G_FILE_ATTRIBUTE_STANDARD_ICON.
835         *
836         * Params:
837         *     icon = a #GIcon.
838         */
839        public void setIcon(IconIF icon)
840        {
841                g_file_info_set_icon(gFileInfo, (icon is null) ? null : icon.getIconStruct());
842        }
843
844        /**
845         * Sets the "is_hidden" attribute in a #GFileInfo according to @is_hidden.
846         * See %G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN.
847         *
848         * Params:
849         *     isHidden = a #gboolean.
850         */
851        public void setIsHidden(bool isHidden)
852        {
853                g_file_info_set_is_hidden(gFileInfo, isHidden);
854        }
855
856        /**
857         * Sets the "is_symlink" attribute in a #GFileInfo according to @is_symlink.
858         * See %G_FILE_ATTRIBUTE_STANDARD_IS_SYMLINK.
859         *
860         * Params:
861         *     isSymlink = a #gboolean.
862         */
863        public void setIsSymlink(bool isSymlink)
864        {
865                g_file_info_set_is_symlink(gFileInfo, isSymlink);
866        }
867
868        /**
869         * Sets the %G_FILE_ATTRIBUTE_TIME_MODIFIED attribute in the file
870         * info to the given time value.
871         *
872         * Params:
873         *     mtime = a #GTimeVal.
874         */
875        public void setModificationTime(TimeVal mtime)
876        {
877                g_file_info_set_modification_time(gFileInfo, (mtime is null) ? null : mtime.getTimeValStruct());
878        }
879
880        /**
881         * Sets the name attribute for the current #GFileInfo.
882         * See %G_FILE_ATTRIBUTE_STANDARD_NAME.
883         *
884         * Params:
885         *     name = a string containing a name.
886         */
887        public void setName(string name)
888        {
889                g_file_info_set_name(gFileInfo, Str.toStringz(name));
890        }
891
892        /**
893         * Sets the %G_FILE_ATTRIBUTE_STANDARD_SIZE attribute in the file info
894         * to the given size.
895         *
896         * Params:
897         *     size = a #goffset containing the file's size.
898         */
899        public void setSize(long size)
900        {
901                g_file_info_set_size(gFileInfo, size);
902        }
903
904        /**
905         * Sets the sort order attribute in the file info structure. See
906         * %G_FILE_ATTRIBUTE_STANDARD_SORT_ORDER.
907         *
908         * Params:
909         *     sortOrder = a sort order integer.
910         */
911        public void setSortOrder(int sortOrder)
912        {
913                g_file_info_set_sort_order(gFileInfo, sortOrder);
914        }
915
916        /**
917         * Sets the symbolic icon for a given #GFileInfo.
918         * See %G_FILE_ATTRIBUTE_STANDARD_SYMBOLIC_ICON.
919         *
920         * Params:
921         *     icon = a #GIcon.
922         *
923         * Since: 2.34
924         */
925        public void setSymbolicIcon(IconIF icon)
926        {
927                g_file_info_set_symbolic_icon(gFileInfo, (icon is null) ? null : icon.getIconStruct());
928        }
929
930        /**
931         * Sets the %G_FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET attribute in the file info
932         * to the given symlink target.
933         *
934         * Params:
935         *     symlinkTarget = a static string containing a path to a symlink target.
936         */
937        public void setSymlinkTarget(string symlinkTarget)
938        {
939                g_file_info_set_symlink_target(gFileInfo, Str.toStringz(symlinkTarget));
940        }
941
942        /**
943         * Unsets a mask set by g_file_info_set_attribute_mask(), if one
944         * is set.
945         */
946        public void unsetAttributeMask()
947        {
948                g_file_info_unset_attribute_mask(gFileInfo);
949        }
950}
Note: See TracBrowser for help on using the repository browser.