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

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

Initial release

File size: 19.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.DriveT;
22
23public  import gi.gio;
24public  import gi.giotypes;
25public  import gio.AsyncResultIF;
26public  import gio.Cancellable;
27public  import gio.Icon;
28public  import gio.IconIF;
29public  import gio.MountOperation;
30public  import glib.ErrorG;
31public  import glib.GException;
32public  import glib.ListG;
33public  import glib.Str;
34public  import gobject.ObjectG;
35public  import gobject.Signals;
36public  import std.algorithm;
37
38
39/**
40 * #GDrive - this represent a piece of hardware connected to the machine.
41 * It's generally only created for removable hardware or hardware with
42 * removable media.
43 *
44 * #GDrive is a container class for #GVolume objects that stem from
45 * the same piece of media. As such, #GDrive abstracts a drive with
46 * (or without) removable media and provides operations for querying
47 * whether media is available, determining whether media change is
48 * automatically detected and ejecting the media.
49 *
50 * If the #GDrive reports that media isn't automatically detected, one
51 * can poll for media; typically one should not do this periodically
52 * as a poll for media operation is potententially expensive and may
53 * spin up the drive creating noise.
54 *
55 * #GDrive supports starting and stopping drives with authentication
56 * support for the former. This can be used to support a diverse set
57 * of use cases including connecting/disconnecting iSCSI devices,
58 * powering down external disk enclosures and starting/stopping
59 * multi-disk devices such as RAID devices. Note that the actual
60 * semantics and side-effects of starting/stopping a #GDrive may vary
61 * according to implementation. To choose the correct verbs in e.g. a
62 * file manager, use g_drive_get_start_stop_type().
63 *
64 * For porting from GnomeVFS note that there is no equivalent of
65 * #GDrive in that API.
66 */
67public template DriveT(TStruct)
68{
69        /** Get the main Gtk struct */
70        public GDrive* getDriveStruct()
71        {
72                return cast(GDrive*)getStruct();
73        }
74
75
76        /**
77         * Checks if a drive can be ejected.
78         *
79         * Returns: %TRUE if the @drive can be ejected, %FALSE otherwise.
80         */
81        public bool canEject()
82        {
83                return g_drive_can_eject(getDriveStruct()) != 0;
84        }
85
86        /**
87         * Checks if a drive can be polled for media changes.
88         *
89         * Returns: %TRUE if the @drive can be polled for media changes,
90         *     %FALSE otherwise.
91         */
92        public bool canPollForMedia()
93        {
94                return g_drive_can_poll_for_media(getDriveStruct()) != 0;
95        }
96
97        /**
98         * Checks if a drive can be started.
99         *
100         * Returns: %TRUE if the @drive can be started, %FALSE otherwise.
101         *
102         * Since: 2.22
103         */
104        public bool canStart()
105        {
106                return g_drive_can_start(getDriveStruct()) != 0;
107        }
108
109        /**
110         * Checks if a drive can be started degraded.
111         *
112         * Returns: %TRUE if the @drive can be started degraded, %FALSE otherwise.
113         *
114         * Since: 2.22
115         */
116        public bool canStartDegraded()
117        {
118                return g_drive_can_start_degraded(getDriveStruct()) != 0;
119        }
120
121        /**
122         * Checks if a drive can be stopped.
123         *
124         * Returns: %TRUE if the @drive can be stopped, %FALSE otherwise.
125         *
126         * Since: 2.22
127         */
128        public bool canStop()
129        {
130                return g_drive_can_stop(getDriveStruct()) != 0;
131        }
132
133        /**
134         * Asynchronously ejects a drive.
135         *
136         * When the operation is finished, @callback will be called.
137         * You can then call g_drive_eject_finish() to obtain the
138         * result of the operation.
139         *
140         * Deprecated: Use g_drive_eject_with_operation() instead.
141         *
142         * Params:
143         *     flags = flags affecting the unmount if required for eject
144         *     cancellable = optional #GCancellable object, %NULL to ignore.
145         *     callback = a #GAsyncReadyCallback, or %NULL.
146         *     userData = user data to pass to @callback
147         */
148        public void eject(GMountUnmountFlags flags, Cancellable cancellable, GAsyncReadyCallback callback, void* userData)
149        {
150                g_drive_eject(getDriveStruct(), flags, (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData);
151        }
152
153        /**
154         * Finishes ejecting a drive.
155         *
156         * Deprecated: Use g_drive_eject_with_operation_finish() instead.
157         *
158         * Params:
159         *     result = a #GAsyncResult.
160         *
161         * Returns: %TRUE if the drive has been ejected successfully,
162         *     %FALSE otherwise.
163         *
164         * Throws: GException on failure.
165         */
166        public bool ejectFinish(AsyncResultIF result)
167        {
168                GError* err = null;
169               
170                auto p = g_drive_eject_finish(getDriveStruct(), (result is null) ? null : result.getAsyncResultStruct(), &err) != 0;
171               
172                if (err !is null)
173                {
174                        throw new GException( new ErrorG(err) );
175                }
176               
177                return p;
178        }
179
180        /**
181         * Ejects a drive. This is an asynchronous operation, and is
182         * finished by calling g_drive_eject_with_operation_finish() with the @drive
183         * and #GAsyncResult data returned in the @callback.
184         *
185         * Params:
186         *     flags = flags affecting the unmount if required for eject
187         *     mountOperation = a #GMountOperation or %NULL to avoid
188         *         user interaction.
189         *     cancellable = optional #GCancellable object, %NULL to ignore.
190         *     callback = a #GAsyncReadyCallback, or %NULL.
191         *     userData = user data passed to @callback.
192         *
193         * Since: 2.22
194         */
195        public void ejectWithOperation(GMountUnmountFlags flags, MountOperation mountOperation, Cancellable cancellable, GAsyncReadyCallback callback, void* userData)
196        {
197                g_drive_eject_with_operation(getDriveStruct(), flags, (mountOperation is null) ? null : mountOperation.getMountOperationStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData);
198        }
199
200        /**
201         * Finishes ejecting a drive. If any errors occurred during the operation,
202         * @error will be set to contain the errors and %FALSE will be returned.
203         *
204         * Params:
205         *     result = a #GAsyncResult.
206         *
207         * Returns: %TRUE if the drive was successfully ejected. %FALSE otherwise.
208         *
209         * Since: 2.22
210         *
211         * Throws: GException on failure.
212         */
213        public bool ejectWithOperationFinish(AsyncResultIF result)
214        {
215                GError* err = null;
216               
217                auto p = g_drive_eject_with_operation_finish(getDriveStruct(), (result is null) ? null : result.getAsyncResultStruct(), &err) != 0;
218               
219                if (err !is null)
220                {
221                        throw new GException( new ErrorG(err) );
222                }
223               
224                return p;
225        }
226
227        /**
228         * Gets the kinds of identifiers that @drive has.
229         * Use g_drive_get_identifier() to obtain the identifiers
230         * themselves.
231         *
232         * Returns: a %NULL-terminated
233         *     array of strings containing kinds of identifiers. Use g_strfreev()
234         *     to free.
235         */
236        public string[] enumerateIdentifiers()
237        {
238                auto retStr = g_drive_enumerate_identifiers(getDriveStruct());
239               
240                scope(exit) Str.freeStringArray(retStr);
241                return Str.toStringArray(retStr);
242        }
243
244        /**
245         * Gets the icon for @drive.
246         *
247         * Returns: #GIcon for the @drive.
248         *     Free the returned object with g_object_unref().
249         */
250        public IconIF getIcon()
251        {
252                auto p = g_drive_get_icon(getDriveStruct());
253               
254                if(p is null)
255                {
256                        return null;
257                }
258               
259                return ObjectG.getDObject!(Icon, IconIF)(cast(GIcon*) p, true);
260        }
261
262        /**
263         * Gets the identifier of the given kind for @drive.
264         *
265         * Params:
266         *     kind = the kind of identifier to return
267         *
268         * Returns: a newly allocated string containing the
269         *     requested identfier, or %NULL if the #GDrive
270         *     doesn't have this kind of identifier.
271         */
272        public string getIdentifier(string kind)
273        {
274                auto retStr = g_drive_get_identifier(getDriveStruct(), Str.toStringz(kind));
275               
276                scope(exit) Str.freeString(retStr);
277                return Str.toString(retStr);
278        }
279
280        /**
281         * Gets the name of @drive.
282         *
283         * Returns: a string containing @drive's name. The returned
284         *     string should be freed when no longer needed.
285         */
286        public string getName()
287        {
288                auto retStr = g_drive_get_name(getDriveStruct());
289               
290                scope(exit) Str.freeString(retStr);
291                return Str.toString(retStr);
292        }
293
294        /**
295         * Gets the sort key for @drive, if any.
296         *
297         * Returns: Sorting key for @drive or %NULL if no such key is available.
298         *
299         * Since: 2.32
300         */
301        public string getSortKey()
302        {
303                return Str.toString(g_drive_get_sort_key(getDriveStruct()));
304        }
305
306        /**
307         * Gets a hint about how a drive can be started/stopped.
308         *
309         * Returns: A value from the #GDriveStartStopType enumeration.
310         *
311         * Since: 2.22
312         */
313        public GDriveStartStopType getStartStopType()
314        {
315                return g_drive_get_start_stop_type(getDriveStruct());
316        }
317
318        /**
319         * Gets the icon for @drive.
320         *
321         * Returns: symbolic #GIcon for the @drive.
322         *     Free the returned object with g_object_unref().
323         *
324         * Since: 2.34
325         */
326        public IconIF getSymbolicIcon()
327        {
328                auto p = g_drive_get_symbolic_icon(getDriveStruct());
329               
330                if(p is null)
331                {
332                        return null;
333                }
334               
335                return ObjectG.getDObject!(Icon, IconIF)(cast(GIcon*) p, true);
336        }
337
338        /**
339         * Get a list of mountable volumes for @drive.
340         *
341         * The returned list should be freed with g_list_free(), after
342         * its elements have been unreffed with g_object_unref().
343         *
344         * Returns: #GList containing any #GVolume objects on the given @drive.
345         */
346        public ListG getVolumes()
347        {
348                auto p = g_drive_get_volumes(getDriveStruct());
349               
350                if(p is null)
351                {
352                        return null;
353                }
354               
355                return new ListG(cast(GList*) p, true);
356        }
357
358        /**
359         * Checks if the @drive has media. Note that the OS may not be polling
360         * the drive for media changes; see g_drive_is_media_check_automatic()
361         * for more details.
362         *
363         * Returns: %TRUE if @drive has media, %FALSE otherwise.
364         */
365        public bool hasMedia()
366        {
367                return g_drive_has_media(getDriveStruct()) != 0;
368        }
369
370        /**
371         * Check if @drive has any mountable volumes.
372         *
373         * Returns: %TRUE if the @drive contains volumes, %FALSE otherwise.
374         */
375        public bool hasVolumes()
376        {
377                return g_drive_has_volumes(getDriveStruct()) != 0;
378        }
379
380        /**
381         * Checks if @drive is capabable of automatically detecting media changes.
382         *
383         * Returns: %TRUE if the @drive is capabable of automatically detecting
384         *     media changes, %FALSE otherwise.
385         */
386        public bool isMediaCheckAutomatic()
387        {
388                return g_drive_is_media_check_automatic(getDriveStruct()) != 0;
389        }
390
391        /**
392         * Checks if the @drive supports removable media.
393         *
394         * Returns: %TRUE if @drive supports removable media, %FALSE otherwise.
395         */
396        public bool isMediaRemovable()
397        {
398                return g_drive_is_media_removable(getDriveStruct()) != 0;
399        }
400
401        /**
402         * Asynchronously polls @drive to see if media has been inserted or removed.
403         *
404         * When the operation is finished, @callback will be called.
405         * You can then call g_drive_poll_for_media_finish() to obtain the
406         * result of the operation.
407         *
408         * Params:
409         *     cancellable = optional #GCancellable object, %NULL to ignore.
410         *     callback = a #GAsyncReadyCallback, or %NULL.
411         *     userData = user data to pass to @callback
412         */
413        public void pollForMedia(Cancellable cancellable, GAsyncReadyCallback callback, void* userData)
414        {
415                g_drive_poll_for_media(getDriveStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData);
416        }
417
418        /**
419         * Finishes an operation started with g_drive_poll_for_media() on a drive.
420         *
421         * Params:
422         *     result = a #GAsyncResult.
423         *
424         * Returns: %TRUE if the drive has been poll_for_mediaed successfully,
425         *     %FALSE otherwise.
426         *
427         * Throws: GException on failure.
428         */
429        public bool pollForMediaFinish(AsyncResultIF result)
430        {
431                GError* err = null;
432               
433                auto p = g_drive_poll_for_media_finish(getDriveStruct(), (result is null) ? null : result.getAsyncResultStruct(), &err) != 0;
434               
435                if (err !is null)
436                {
437                        throw new GException( new ErrorG(err) );
438                }
439               
440                return p;
441        }
442
443        /**
444         * Asynchronously starts a drive.
445         *
446         * When the operation is finished, @callback will be called.
447         * You can then call g_drive_start_finish() to obtain the
448         * result of the operation.
449         *
450         * Params:
451         *     flags = flags affecting the start operation.
452         *     mountOperation = a #GMountOperation or %NULL to avoid
453         *         user interaction.
454         *     cancellable = optional #GCancellable object, %NULL to ignore.
455         *     callback = a #GAsyncReadyCallback, or %NULL.
456         *     userData = user data to pass to @callback
457         *
458         * Since: 2.22
459         */
460        public void start(GDriveStartFlags flags, MountOperation mountOperation, Cancellable cancellable, GAsyncReadyCallback callback, void* userData)
461        {
462                g_drive_start(getDriveStruct(), flags, (mountOperation is null) ? null : mountOperation.getMountOperationStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData);
463        }
464
465        /**
466         * Finishes starting a drive.
467         *
468         * Params:
469         *     result = a #GAsyncResult.
470         *
471         * Returns: %TRUE if the drive has been started successfully,
472         *     %FALSE otherwise.
473         *
474         * Since: 2.22
475         *
476         * Throws: GException on failure.
477         */
478        public bool startFinish(AsyncResultIF result)
479        {
480                GError* err = null;
481               
482                auto p = g_drive_start_finish(getDriveStruct(), (result is null) ? null : result.getAsyncResultStruct(), &err) != 0;
483               
484                if (err !is null)
485                {
486                        throw new GException( new ErrorG(err) );
487                }
488               
489                return p;
490        }
491
492        /**
493         * Asynchronously stops a drive.
494         *
495         * When the operation is finished, @callback will be called.
496         * You can then call g_drive_stop_finish() to obtain the
497         * result of the operation.
498         *
499         * Params:
500         *     flags = flags affecting the unmount if required for stopping.
501         *     mountOperation = a #GMountOperation or %NULL to avoid
502         *         user interaction.
503         *     cancellable = optional #GCancellable object, %NULL to ignore.
504         *     callback = a #GAsyncReadyCallback, or %NULL.
505         *     userData = user data to pass to @callback
506         *
507         * Since: 2.22
508         */
509        public void stop(GMountUnmountFlags flags, MountOperation mountOperation, Cancellable cancellable, GAsyncReadyCallback callback, void* userData)
510        {
511                g_drive_stop(getDriveStruct(), flags, (mountOperation is null) ? null : mountOperation.getMountOperationStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData);
512        }
513
514        /**
515         * Finishes stopping a drive.
516         *
517         * Params:
518         *     result = a #GAsyncResult.
519         *
520         * Returns: %TRUE if the drive has been stopped successfully,
521         *     %FALSE otherwise.
522         *
523         * Since: 2.22
524         *
525         * Throws: GException on failure.
526         */
527        public bool stopFinish(AsyncResultIF result)
528        {
529                GError* err = null;
530               
531                auto p = g_drive_stop_finish(getDriveStruct(), (result is null) ? null : result.getAsyncResultStruct(), &err) != 0;
532               
533                if (err !is null)
534                {
535                        throw new GException( new ErrorG(err) );
536                }
537               
538                return p;
539        }
540
541        protected class OnChangedDelegateWrapper
542        {
543                static OnChangedDelegateWrapper[] listeners;
544                void delegate(DriveIF) dlg;
545                gulong handlerId;
546               
547                this(void delegate(DriveIF) dlg)
548                {
549                        this.dlg = dlg;
550                        this.listeners ~= this;
551                }
552               
553                void remove(OnChangedDelegateWrapper source)
554                {
555                        foreach(index, wrapper; listeners)
556                        {
557                                if (wrapper.handlerId == source.handlerId)
558                                {
559                                        listeners[index] = null;
560                                        listeners = std.algorithm.remove(listeners, index);
561                                        break;
562                                }
563                        }
564                }
565        }
566
567        /**
568         * Emitted when the drive's state has changed.
569         */
570        gulong addOnChanged(void delegate(DriveIF) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
571        {
572                auto wrapper = new OnChangedDelegateWrapper(dlg);
573                wrapper.handlerId = Signals.connectData(
574                        this,
575                        "changed",
576                        cast(GCallback)&callBackChanged,
577                        cast(void*)wrapper,
578                        cast(GClosureNotify)&callBackChangedDestroy,
579                        connectFlags);
580                return wrapper.handlerId;
581        }
582       
583        extern(C) static void callBackChanged(GDrive* driveStruct, OnChangedDelegateWrapper wrapper)
584        {
585                wrapper.dlg(wrapper.outer);
586        }
587       
588        extern(C) static void callBackChangedDestroy(OnChangedDelegateWrapper wrapper, GClosure* closure)
589        {
590                wrapper.remove(wrapper);
591        }
592
593        protected class OnDisconnectedDelegateWrapper
594        {
595                static OnDisconnectedDelegateWrapper[] listeners;
596                void delegate(DriveIF) dlg;
597                gulong handlerId;
598               
599                this(void delegate(DriveIF) dlg)
600                {
601                        this.dlg = dlg;
602                        this.listeners ~= this;
603                }
604               
605                void remove(OnDisconnectedDelegateWrapper source)
606                {
607                        foreach(index, wrapper; listeners)
608                        {
609                                if (wrapper.handlerId == source.handlerId)
610                                {
611                                        listeners[index] = null;
612                                        listeners = std.algorithm.remove(listeners, index);
613                                        break;
614                                }
615                        }
616                }
617        }
618
619        /**
620         * This signal is emitted when the #GDrive have been
621         * disconnected. If the recipient is holding references to the
622         * object they should release them so the object can be
623         * finalized.
624         */
625        gulong addOnDisconnected(void delegate(DriveIF) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
626        {
627                auto wrapper = new OnDisconnectedDelegateWrapper(dlg);
628                wrapper.handlerId = Signals.connectData(
629                        this,
630                        "disconnected",
631                        cast(GCallback)&callBackDisconnected,
632                        cast(void*)wrapper,
633                        cast(GClosureNotify)&callBackDisconnectedDestroy,
634                        connectFlags);
635                return wrapper.handlerId;
636        }
637       
638        extern(C) static void callBackDisconnected(GDrive* driveStruct, OnDisconnectedDelegateWrapper wrapper)
639        {
640                wrapper.dlg(wrapper.outer);
641        }
642       
643        extern(C) static void callBackDisconnectedDestroy(OnDisconnectedDelegateWrapper wrapper, GClosure* closure)
644        {
645                wrapper.remove(wrapper);
646        }
647
648        protected class OnEjectButtonDelegateWrapper
649        {
650                static OnEjectButtonDelegateWrapper[] listeners;
651                void delegate(DriveIF) dlg;
652                gulong handlerId;
653               
654                this(void delegate(DriveIF) dlg)
655                {
656                        this.dlg = dlg;
657                        this.listeners ~= this;
658                }
659               
660                void remove(OnEjectButtonDelegateWrapper source)
661                {
662                        foreach(index, wrapper; listeners)
663                        {
664                                if (wrapper.handlerId == source.handlerId)
665                                {
666                                        listeners[index] = null;
667                                        listeners = std.algorithm.remove(listeners, index);
668                                        break;
669                                }
670                        }
671                }
672        }
673
674        /**
675         * Emitted when the physical eject button (if any) of a drive has
676         * been pressed.
677         */
678        gulong addOnEjectButton(void delegate(DriveIF) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
679        {
680                auto wrapper = new OnEjectButtonDelegateWrapper(dlg);
681                wrapper.handlerId = Signals.connectData(
682                        this,
683                        "eject-button",
684                        cast(GCallback)&callBackEjectButton,
685                        cast(void*)wrapper,
686                        cast(GClosureNotify)&callBackEjectButtonDestroy,
687                        connectFlags);
688                return wrapper.handlerId;
689        }
690       
691        extern(C) static void callBackEjectButton(GDrive* driveStruct, OnEjectButtonDelegateWrapper wrapper)
692        {
693                wrapper.dlg(wrapper.outer);
694        }
695       
696        extern(C) static void callBackEjectButtonDestroy(OnEjectButtonDelegateWrapper wrapper, GClosure* closure)
697        {
698                wrapper.remove(wrapper);
699        }
700
701        protected class OnStopButtonDelegateWrapper
702        {
703                static OnStopButtonDelegateWrapper[] listeners;
704                void delegate(DriveIF) dlg;
705                gulong handlerId;
706               
707                this(void delegate(DriveIF) dlg)
708                {
709                        this.dlg = dlg;
710                        this.listeners ~= this;
711                }
712               
713                void remove(OnStopButtonDelegateWrapper source)
714                {
715                        foreach(index, wrapper; listeners)
716                        {
717                                if (wrapper.handlerId == source.handlerId)
718                                {
719                                        listeners[index] = null;
720                                        listeners = std.algorithm.remove(listeners, index);
721                                        break;
722                                }
723                        }
724                }
725        }
726
727        /**
728         * Emitted when the physical stop button (if any) of a drive has
729         * been pressed.
730         *
731         * Since: 2.22
732         */
733        gulong addOnStopButton(void delegate(DriveIF) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
734        {
735                auto wrapper = new OnStopButtonDelegateWrapper(dlg);
736                wrapper.handlerId = Signals.connectData(
737                        this,
738                        "stop-button",
739                        cast(GCallback)&callBackStopButton,
740                        cast(void*)wrapper,
741                        cast(GClosureNotify)&callBackStopButtonDestroy,
742                        connectFlags);
743                return wrapper.handlerId;
744        }
745       
746        extern(C) static void callBackStopButton(GDrive* driveStruct, OnStopButtonDelegateWrapper wrapper)
747        {
748                wrapper.dlg(wrapper.outer);
749        }
750       
751        extern(C) static void callBackStopButtonDestroy(OnStopButtonDelegateWrapper wrapper, GClosure* closure)
752        {
753                wrapper.remove(wrapper);
754        }
755}
Note: See TracBrowser for help on using the repository browser.