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

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

Initial release

File size: 24.3 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.VolumeMonitor;
22
23private import gi.gio;
24public  import gi.giotypes;
25private import gio.Drive;
26private import gio.DriveIF;
27private import gio.Mount;
28private import gio.MountIF;
29private import gio.Volume;
30private import gio.VolumeIF;
31private import glib.ConstructionException;
32private import glib.ListG;
33private import glib.Str;
34private import gobject.ObjectG;
35private import gobject.Signals;
36private import std.algorithm;
37
38
39/**
40 * #GVolumeMonitor is for listing the user interesting devices and volumes
41 * on the computer. In other words, what a file selector or file manager
42 * would show in a sidebar.
43 *
44 * #GVolumeMonitor is not
45 * [thread-default-context aware][g-main-context-push-thread-default],
46 * and so should not be used other than from the main thread, with no
47 * thread-default-context active.
48 */
49public class VolumeMonitor : ObjectG
50{
51        /** the main Gtk struct */
52        protected GVolumeMonitor* gVolumeMonitor;
53
54        /** Get the main Gtk struct */
55        public GVolumeMonitor* getVolumeMonitorStruct()
56        {
57                return gVolumeMonitor;
58        }
59
60        /** the main Gtk struct as a void* */
61        protected override void* getStruct()
62        {
63                return cast(void*)gVolumeMonitor;
64        }
65
66        protected override void setStruct(GObject* obj)
67        {
68                gVolumeMonitor = cast(GVolumeMonitor*)obj;
69                super.setStruct(obj);
70        }
71
72        /**
73         * Sets our main struct and passes it to the parent class.
74         */
75        public this (GVolumeMonitor* gVolumeMonitor, bool ownedRef = false)
76        {
77                this.gVolumeMonitor = gVolumeMonitor;
78                super(cast(GObject*)gVolumeMonitor, ownedRef);
79        }
80
81        /**
82         * Gets the volume monitor used by gio.
83         *
84         * Return: a reference to the #GVolumeMonitor used by gio. Call
85         *     g_object_unref() when done with it.
86         */
87        public this()
88        {
89                auto p = g_volume_monitor_get();
90               
91                if(p is null)
92                {
93                        throw new ConstructionException("g_volume_monitor_get()");
94                }
95               
96                this(cast(GVolumeMonitor*) p, true);
97        }
98
99        /**
100         */
101
102        /** */
103        public static GType getType()
104        {
105                return g_volume_monitor_get_type();
106        }
107
108        /**
109         * This function should be called by any #GVolumeMonitor
110         * implementation when a new #GMount object is created that is not
111         * associated with a #GVolume object. It must be called just before
112         * emitting the @mount_added signal.
113         *
114         * If the return value is not %NULL, the caller must associate the
115         * returned #GVolume object with the #GMount. This involves returning
116         * it in its g_mount_get_volume() implementation. The caller must
117         * also listen for the "removed" signal on the returned object
118         * and give up its reference when handling that signal
119         *
120         * Similary, if implementing g_volume_monitor_adopt_orphan_mount(),
121         * the implementor must take a reference to @mount and return it in
122         * its g_volume_get_mount() implemented. Also, the implementor must
123         * listen for the "unmounted" signal on @mount and give up its
124         * reference upon handling that signal.
125         *
126         * There are two main use cases for this function.
127         *
128         * One is when implementing a user space file system driver that reads
129         * blocks of a block device that is already represented by the native
130         * volume monitor (for example a CD Audio file system driver). Such
131         * a driver will generate its own #GMount object that needs to be
132         * associated with the #GVolume object that represents the volume.
133         *
134         * The other is for implementing a #GVolumeMonitor whose sole purpose
135         * is to return #GVolume objects representing entries in the users
136         * "favorite servers" list or similar.
137         *
138         * Deprecated: Instead of using this function, #GVolumeMonitor
139         * implementations should instead create shadow mounts with the URI of
140         * the mount they intend to adopt. See the proxy volume monitor in
141         * gvfs for an example of this. Also see g_mount_is_shadowed(),
142         * g_mount_shadow() and g_mount_unshadow() functions.
143         *
144         * Params:
145         *     mount = a #GMount object to find a parent for
146         *
147         * Returns: the #GVolume object that is the parent for @mount or %NULL
148         *     if no wants to adopt the #GMount.
149         */
150        public static VolumeIF adoptOrphanMount(MountIF mount)
151        {
152                auto p = g_volume_monitor_adopt_orphan_mount((mount is null) ? null : mount.getMountStruct());
153               
154                if(p is null)
155                {
156                        return null;
157                }
158               
159                return ObjectG.getDObject!(Volume, VolumeIF)(cast(GVolume*) p, true);
160        }
161
162        /**
163         * Gets a list of drives connected to the system.
164         *
165         * The returned list should be freed with g_list_free(), after
166         * its elements have been unreffed with g_object_unref().
167         *
168         * Returns: a #GList of connected #GDrive objects.
169         */
170        public ListG getConnectedDrives()
171        {
172                auto p = g_volume_monitor_get_connected_drives(gVolumeMonitor);
173               
174                if(p is null)
175                {
176                        return null;
177                }
178               
179                return new ListG(cast(GList*) p, true);
180        }
181
182        /**
183         * Finds a #GMount object by its UUID (see g_mount_get_uuid())
184         *
185         * Params:
186         *     uuid = the UUID to look for
187         *
188         * Returns: a #GMount or %NULL if no such mount is available.
189         *     Free the returned object with g_object_unref().
190         */
191        public MountIF getMountForUuid(string uuid)
192        {
193                auto p = g_volume_monitor_get_mount_for_uuid(gVolumeMonitor, Str.toStringz(uuid));
194               
195                if(p is null)
196                {
197                        return null;
198                }
199               
200                return ObjectG.getDObject!(Mount, MountIF)(cast(GMount*) p, true);
201        }
202
203        /**
204         * Gets a list of the mounts on the system.
205         *
206         * The returned list should be freed with g_list_free(), after
207         * its elements have been unreffed with g_object_unref().
208         *
209         * Returns: a #GList of #GMount objects.
210         */
211        public ListG getMounts()
212        {
213                auto p = g_volume_monitor_get_mounts(gVolumeMonitor);
214               
215                if(p is null)
216                {
217                        return null;
218                }
219               
220                return new ListG(cast(GList*) p, true);
221        }
222
223        /**
224         * Finds a #GVolume object by its UUID (see g_volume_get_uuid())
225         *
226         * Params:
227         *     uuid = the UUID to look for
228         *
229         * Returns: a #GVolume or %NULL if no such volume is available.
230         *     Free the returned object with g_object_unref().
231         */
232        public VolumeIF getVolumeForUuid(string uuid)
233        {
234                auto p = g_volume_monitor_get_volume_for_uuid(gVolumeMonitor, Str.toStringz(uuid));
235               
236                if(p is null)
237                {
238                        return null;
239                }
240               
241                return ObjectG.getDObject!(Volume, VolumeIF)(cast(GVolume*) p, true);
242        }
243
244        /**
245         * Gets a list of the volumes on the system.
246         *
247         * The returned list should be freed with g_list_free(), after
248         * its elements have been unreffed with g_object_unref().
249         *
250         * Returns: a #GList of #GVolume objects.
251         */
252        public ListG getVolumes()
253        {
254                auto p = g_volume_monitor_get_volumes(gVolumeMonitor);
255               
256                if(p is null)
257                {
258                        return null;
259                }
260               
261                return new ListG(cast(GList*) p, true);
262        }
263
264        protected class OnDriveChangedDelegateWrapper
265        {
266                static OnDriveChangedDelegateWrapper[] listeners;
267                void delegate(DriveIF, VolumeMonitor) dlg;
268                gulong handlerId;
269               
270                this(void delegate(DriveIF, VolumeMonitor) dlg)
271                {
272                        this.dlg = dlg;
273                        this.listeners ~= this;
274                }
275               
276                void remove(OnDriveChangedDelegateWrapper source)
277                {
278                        foreach(index, wrapper; listeners)
279                        {
280                                if (wrapper.handlerId == source.handlerId)
281                                {
282                                        listeners[index] = null;
283                                        listeners = std.algorithm.remove(listeners, index);
284                                        break;
285                                }
286                        }
287                }
288        }
289
290        /**
291         * Emitted when a drive changes.
292         *
293         * Params:
294         *     drive = the drive that changed
295         */
296        gulong addOnDriveChanged(void delegate(DriveIF, VolumeMonitor) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
297        {
298                auto wrapper = new OnDriveChangedDelegateWrapper(dlg);
299                wrapper.handlerId = Signals.connectData(
300                        this,
301                        "drive-changed",
302                        cast(GCallback)&callBackDriveChanged,
303                        cast(void*)wrapper,
304                        cast(GClosureNotify)&callBackDriveChangedDestroy,
305                        connectFlags);
306                return wrapper.handlerId;
307        }
308       
309        extern(C) static void callBackDriveChanged(GVolumeMonitor* volumemonitorStruct, GDrive* drive, OnDriveChangedDelegateWrapper wrapper)
310        {
311                wrapper.dlg(ObjectG.getDObject!(Drive, DriveIF)(drive), wrapper.outer);
312        }
313       
314        extern(C) static void callBackDriveChangedDestroy(OnDriveChangedDelegateWrapper wrapper, GClosure* closure)
315        {
316                wrapper.remove(wrapper);
317        }
318
319        protected class OnDriveConnectedDelegateWrapper
320        {
321                static OnDriveConnectedDelegateWrapper[] listeners;
322                void delegate(DriveIF, VolumeMonitor) dlg;
323                gulong handlerId;
324               
325                this(void delegate(DriveIF, VolumeMonitor) dlg)
326                {
327                        this.dlg = dlg;
328                        this.listeners ~= this;
329                }
330               
331                void remove(OnDriveConnectedDelegateWrapper source)
332                {
333                        foreach(index, wrapper; listeners)
334                        {
335                                if (wrapper.handlerId == source.handlerId)
336                                {
337                                        listeners[index] = null;
338                                        listeners = std.algorithm.remove(listeners, index);
339                                        break;
340                                }
341                        }
342                }
343        }
344
345        /**
346         * Emitted when a drive is connected to the system.
347         *
348         * Params:
349         *     drive = a #GDrive that was connected.
350         */
351        gulong addOnDriveConnected(void delegate(DriveIF, VolumeMonitor) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
352        {
353                auto wrapper = new OnDriveConnectedDelegateWrapper(dlg);
354                wrapper.handlerId = Signals.connectData(
355                        this,
356                        "drive-connected",
357                        cast(GCallback)&callBackDriveConnected,
358                        cast(void*)wrapper,
359                        cast(GClosureNotify)&callBackDriveConnectedDestroy,
360                        connectFlags);
361                return wrapper.handlerId;
362        }
363       
364        extern(C) static void callBackDriveConnected(GVolumeMonitor* volumemonitorStruct, GDrive* drive, OnDriveConnectedDelegateWrapper wrapper)
365        {
366                wrapper.dlg(ObjectG.getDObject!(Drive, DriveIF)(drive), wrapper.outer);
367        }
368       
369        extern(C) static void callBackDriveConnectedDestroy(OnDriveConnectedDelegateWrapper wrapper, GClosure* closure)
370        {
371                wrapper.remove(wrapper);
372        }
373
374        protected class OnDriveDisconnectedDelegateWrapper
375        {
376                static OnDriveDisconnectedDelegateWrapper[] listeners;
377                void delegate(DriveIF, VolumeMonitor) dlg;
378                gulong handlerId;
379               
380                this(void delegate(DriveIF, VolumeMonitor) dlg)
381                {
382                        this.dlg = dlg;
383                        this.listeners ~= this;
384                }
385               
386                void remove(OnDriveDisconnectedDelegateWrapper source)
387                {
388                        foreach(index, wrapper; listeners)
389                        {
390                                if (wrapper.handlerId == source.handlerId)
391                                {
392                                        listeners[index] = null;
393                                        listeners = std.algorithm.remove(listeners, index);
394                                        break;
395                                }
396                        }
397                }
398        }
399
400        /**
401         * Emitted when a drive is disconnected from the system.
402         *
403         * Params:
404         *     drive = a #GDrive that was disconnected.
405         */
406        gulong addOnDriveDisconnected(void delegate(DriveIF, VolumeMonitor) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
407        {
408                auto wrapper = new OnDriveDisconnectedDelegateWrapper(dlg);
409                wrapper.handlerId = Signals.connectData(
410                        this,
411                        "drive-disconnected",
412                        cast(GCallback)&callBackDriveDisconnected,
413                        cast(void*)wrapper,
414                        cast(GClosureNotify)&callBackDriveDisconnectedDestroy,
415                        connectFlags);
416                return wrapper.handlerId;
417        }
418       
419        extern(C) static void callBackDriveDisconnected(GVolumeMonitor* volumemonitorStruct, GDrive* drive, OnDriveDisconnectedDelegateWrapper wrapper)
420        {
421                wrapper.dlg(ObjectG.getDObject!(Drive, DriveIF)(drive), wrapper.outer);
422        }
423       
424        extern(C) static void callBackDriveDisconnectedDestroy(OnDriveDisconnectedDelegateWrapper wrapper, GClosure* closure)
425        {
426                wrapper.remove(wrapper);
427        }
428
429        protected class OnDriveEjectButtonDelegateWrapper
430        {
431                static OnDriveEjectButtonDelegateWrapper[] listeners;
432                void delegate(DriveIF, VolumeMonitor) dlg;
433                gulong handlerId;
434               
435                this(void delegate(DriveIF, VolumeMonitor) dlg)
436                {
437                        this.dlg = dlg;
438                        this.listeners ~= this;
439                }
440               
441                void remove(OnDriveEjectButtonDelegateWrapper source)
442                {
443                        foreach(index, wrapper; listeners)
444                        {
445                                if (wrapper.handlerId == source.handlerId)
446                                {
447                                        listeners[index] = null;
448                                        listeners = std.algorithm.remove(listeners, index);
449                                        break;
450                                }
451                        }
452                }
453        }
454
455        /**
456         * Emitted when the eject button is pressed on @drive.
457         *
458         * Params:
459         *     drive = the drive where the eject button was pressed
460         *
461         * Since: 2.18
462         */
463        gulong addOnDriveEjectButton(void delegate(DriveIF, VolumeMonitor) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
464        {
465                auto wrapper = new OnDriveEjectButtonDelegateWrapper(dlg);
466                wrapper.handlerId = Signals.connectData(
467                        this,
468                        "drive-eject-button",
469                        cast(GCallback)&callBackDriveEjectButton,
470                        cast(void*)wrapper,
471                        cast(GClosureNotify)&callBackDriveEjectButtonDestroy,
472                        connectFlags);
473                return wrapper.handlerId;
474        }
475       
476        extern(C) static void callBackDriveEjectButton(GVolumeMonitor* volumemonitorStruct, GDrive* drive, OnDriveEjectButtonDelegateWrapper wrapper)
477        {
478                wrapper.dlg(ObjectG.getDObject!(Drive, DriveIF)(drive), wrapper.outer);
479        }
480       
481        extern(C) static void callBackDriveEjectButtonDestroy(OnDriveEjectButtonDelegateWrapper wrapper, GClosure* closure)
482        {
483                wrapper.remove(wrapper);
484        }
485
486        protected class OnDriveStopButtonDelegateWrapper
487        {
488                static OnDriveStopButtonDelegateWrapper[] listeners;
489                void delegate(DriveIF, VolumeMonitor) dlg;
490                gulong handlerId;
491               
492                this(void delegate(DriveIF, VolumeMonitor) dlg)
493                {
494                        this.dlg = dlg;
495                        this.listeners ~= this;
496                }
497               
498                void remove(OnDriveStopButtonDelegateWrapper source)
499                {
500                        foreach(index, wrapper; listeners)
501                        {
502                                if (wrapper.handlerId == source.handlerId)
503                                {
504                                        listeners[index] = null;
505                                        listeners = std.algorithm.remove(listeners, index);
506                                        break;
507                                }
508                        }
509                }
510        }
511
512        /**
513         * Emitted when the stop button is pressed on @drive.
514         *
515         * Params:
516         *     drive = the drive where the stop button was pressed
517         *
518         * Since: 2.22
519         */
520        gulong addOnDriveStopButton(void delegate(DriveIF, VolumeMonitor) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
521        {
522                auto wrapper = new OnDriveStopButtonDelegateWrapper(dlg);
523                wrapper.handlerId = Signals.connectData(
524                        this,
525                        "drive-stop-button",
526                        cast(GCallback)&callBackDriveStopButton,
527                        cast(void*)wrapper,
528                        cast(GClosureNotify)&callBackDriveStopButtonDestroy,
529                        connectFlags);
530                return wrapper.handlerId;
531        }
532       
533        extern(C) static void callBackDriveStopButton(GVolumeMonitor* volumemonitorStruct, GDrive* drive, OnDriveStopButtonDelegateWrapper wrapper)
534        {
535                wrapper.dlg(ObjectG.getDObject!(Drive, DriveIF)(drive), wrapper.outer);
536        }
537       
538        extern(C) static void callBackDriveStopButtonDestroy(OnDriveStopButtonDelegateWrapper wrapper, GClosure* closure)
539        {
540                wrapper.remove(wrapper);
541        }
542
543        protected class OnMountAddedDelegateWrapper
544        {
545                static OnMountAddedDelegateWrapper[] listeners;
546                void delegate(MountIF, VolumeMonitor) dlg;
547                gulong handlerId;
548               
549                this(void delegate(MountIF, VolumeMonitor) dlg)
550                {
551                        this.dlg = dlg;
552                        this.listeners ~= this;
553                }
554               
555                void remove(OnMountAddedDelegateWrapper source)
556                {
557                        foreach(index, wrapper; listeners)
558                        {
559                                if (wrapper.handlerId == source.handlerId)
560                                {
561                                        listeners[index] = null;
562                                        listeners = std.algorithm.remove(listeners, index);
563                                        break;
564                                }
565                        }
566                }
567        }
568
569        /**
570         * Emitted when a mount is added.
571         *
572         * Params:
573         *     mount = a #GMount that was added.
574         */
575        gulong addOnMountAdded(void delegate(MountIF, VolumeMonitor) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
576        {
577                auto wrapper = new OnMountAddedDelegateWrapper(dlg);
578                wrapper.handlerId = Signals.connectData(
579                        this,
580                        "mount-added",
581                        cast(GCallback)&callBackMountAdded,
582                        cast(void*)wrapper,
583                        cast(GClosureNotify)&callBackMountAddedDestroy,
584                        connectFlags);
585                return wrapper.handlerId;
586        }
587       
588        extern(C) static void callBackMountAdded(GVolumeMonitor* volumemonitorStruct, GMount* mount, OnMountAddedDelegateWrapper wrapper)
589        {
590                wrapper.dlg(ObjectG.getDObject!(Mount, MountIF)(mount), wrapper.outer);
591        }
592       
593        extern(C) static void callBackMountAddedDestroy(OnMountAddedDelegateWrapper wrapper, GClosure* closure)
594        {
595                wrapper.remove(wrapper);
596        }
597
598        protected class OnMountChangedDelegateWrapper
599        {
600                static OnMountChangedDelegateWrapper[] listeners;
601                void delegate(MountIF, VolumeMonitor) dlg;
602                gulong handlerId;
603               
604                this(void delegate(MountIF, VolumeMonitor) dlg)
605                {
606                        this.dlg = dlg;
607                        this.listeners ~= this;
608                }
609               
610                void remove(OnMountChangedDelegateWrapper source)
611                {
612                        foreach(index, wrapper; listeners)
613                        {
614                                if (wrapper.handlerId == source.handlerId)
615                                {
616                                        listeners[index] = null;
617                                        listeners = std.algorithm.remove(listeners, index);
618                                        break;
619                                }
620                        }
621                }
622        }
623
624        /**
625         * Emitted when a mount changes.
626         *
627         * Params:
628         *     mount = a #GMount that changed.
629         */
630        gulong addOnMountChanged(void delegate(MountIF, VolumeMonitor) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
631        {
632                auto wrapper = new OnMountChangedDelegateWrapper(dlg);
633                wrapper.handlerId = Signals.connectData(
634                        this,
635                        "mount-changed",
636                        cast(GCallback)&callBackMountChanged,
637                        cast(void*)wrapper,
638                        cast(GClosureNotify)&callBackMountChangedDestroy,
639                        connectFlags);
640                return wrapper.handlerId;
641        }
642       
643        extern(C) static void callBackMountChanged(GVolumeMonitor* volumemonitorStruct, GMount* mount, OnMountChangedDelegateWrapper wrapper)
644        {
645                wrapper.dlg(ObjectG.getDObject!(Mount, MountIF)(mount), wrapper.outer);
646        }
647       
648        extern(C) static void callBackMountChangedDestroy(OnMountChangedDelegateWrapper wrapper, GClosure* closure)
649        {
650                wrapper.remove(wrapper);
651        }
652
653        protected class OnMountPreUnmountDelegateWrapper
654        {
655                static OnMountPreUnmountDelegateWrapper[] listeners;
656                void delegate(MountIF, VolumeMonitor) dlg;
657                gulong handlerId;
658               
659                this(void delegate(MountIF, VolumeMonitor) dlg)
660                {
661                        this.dlg = dlg;
662                        this.listeners ~= this;
663                }
664               
665                void remove(OnMountPreUnmountDelegateWrapper source)
666                {
667                        foreach(index, wrapper; listeners)
668                        {
669                                if (wrapper.handlerId == source.handlerId)
670                                {
671                                        listeners[index] = null;
672                                        listeners = std.algorithm.remove(listeners, index);
673                                        break;
674                                }
675                        }
676                }
677        }
678
679        /**
680         * Emitted when a mount is about to be removed.
681         *
682         * Params:
683         *     mount = a #GMount that is being unmounted.
684         */
685        gulong addOnMountPreUnmount(void delegate(MountIF, VolumeMonitor) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
686        {
687                auto wrapper = new OnMountPreUnmountDelegateWrapper(dlg);
688                wrapper.handlerId = Signals.connectData(
689                        this,
690                        "mount-pre-unmount",
691                        cast(GCallback)&callBackMountPreUnmount,
692                        cast(void*)wrapper,
693                        cast(GClosureNotify)&callBackMountPreUnmountDestroy,
694                        connectFlags);
695                return wrapper.handlerId;
696        }
697       
698        extern(C) static void callBackMountPreUnmount(GVolumeMonitor* volumemonitorStruct, GMount* mount, OnMountPreUnmountDelegateWrapper wrapper)
699        {
700                wrapper.dlg(ObjectG.getDObject!(Mount, MountIF)(mount), wrapper.outer);
701        }
702       
703        extern(C) static void callBackMountPreUnmountDestroy(OnMountPreUnmountDelegateWrapper wrapper, GClosure* closure)
704        {
705                wrapper.remove(wrapper);
706        }
707
708        protected class OnMountRemovedDelegateWrapper
709        {
710                static OnMountRemovedDelegateWrapper[] listeners;
711                void delegate(MountIF, VolumeMonitor) dlg;
712                gulong handlerId;
713               
714                this(void delegate(MountIF, VolumeMonitor) dlg)
715                {
716                        this.dlg = dlg;
717                        this.listeners ~= this;
718                }
719               
720                void remove(OnMountRemovedDelegateWrapper source)
721                {
722                        foreach(index, wrapper; listeners)
723                        {
724                                if (wrapper.handlerId == source.handlerId)
725                                {
726                                        listeners[index] = null;
727                                        listeners = std.algorithm.remove(listeners, index);
728                                        break;
729                                }
730                        }
731                }
732        }
733
734        /**
735         * Emitted when a mount is removed.
736         *
737         * Params:
738         *     mount = a #GMount that was removed.
739         */
740        gulong addOnMountRemoved(void delegate(MountIF, VolumeMonitor) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
741        {
742                auto wrapper = new OnMountRemovedDelegateWrapper(dlg);
743                wrapper.handlerId = Signals.connectData(
744                        this,
745                        "mount-removed",
746                        cast(GCallback)&callBackMountRemoved,
747                        cast(void*)wrapper,
748                        cast(GClosureNotify)&callBackMountRemovedDestroy,
749                        connectFlags);
750                return wrapper.handlerId;
751        }
752       
753        extern(C) static void callBackMountRemoved(GVolumeMonitor* volumemonitorStruct, GMount* mount, OnMountRemovedDelegateWrapper wrapper)
754        {
755                wrapper.dlg(ObjectG.getDObject!(Mount, MountIF)(mount), wrapper.outer);
756        }
757       
758        extern(C) static void callBackMountRemovedDestroy(OnMountRemovedDelegateWrapper wrapper, GClosure* closure)
759        {
760                wrapper.remove(wrapper);
761        }
762
763        protected class OnVolumeAddedDelegateWrapper
764        {
765                static OnVolumeAddedDelegateWrapper[] listeners;
766                void delegate(VolumeIF, VolumeMonitor) dlg;
767                gulong handlerId;
768               
769                this(void delegate(VolumeIF, VolumeMonitor) dlg)
770                {
771                        this.dlg = dlg;
772                        this.listeners ~= this;
773                }
774               
775                void remove(OnVolumeAddedDelegateWrapper source)
776                {
777                        foreach(index, wrapper; listeners)
778                        {
779                                if (wrapper.handlerId == source.handlerId)
780                                {
781                                        listeners[index] = null;
782                                        listeners = std.algorithm.remove(listeners, index);
783                                        break;
784                                }
785                        }
786                }
787        }
788
789        /**
790         * Emitted when a mountable volume is added to the system.
791         *
792         * Params:
793         *     volume = a #GVolume that was added.
794         */
795        gulong addOnVolumeAdded(void delegate(VolumeIF, VolumeMonitor) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
796        {
797                auto wrapper = new OnVolumeAddedDelegateWrapper(dlg);
798                wrapper.handlerId = Signals.connectData(
799                        this,
800                        "volume-added",
801                        cast(GCallback)&callBackVolumeAdded,
802                        cast(void*)wrapper,
803                        cast(GClosureNotify)&callBackVolumeAddedDestroy,
804                        connectFlags);
805                return wrapper.handlerId;
806        }
807       
808        extern(C) static void callBackVolumeAdded(GVolumeMonitor* volumemonitorStruct, GVolume* volume, OnVolumeAddedDelegateWrapper wrapper)
809        {
810                wrapper.dlg(ObjectG.getDObject!(Volume, VolumeIF)(volume), wrapper.outer);
811        }
812       
813        extern(C) static void callBackVolumeAddedDestroy(OnVolumeAddedDelegateWrapper wrapper, GClosure* closure)
814        {
815                wrapper.remove(wrapper);
816        }
817
818        protected class OnVolumeChangedDelegateWrapper
819        {
820                static OnVolumeChangedDelegateWrapper[] listeners;
821                void delegate(VolumeIF, VolumeMonitor) dlg;
822                gulong handlerId;
823               
824                this(void delegate(VolumeIF, VolumeMonitor) dlg)
825                {
826                        this.dlg = dlg;
827                        this.listeners ~= this;
828                }
829               
830                void remove(OnVolumeChangedDelegateWrapper source)
831                {
832                        foreach(index, wrapper; listeners)
833                        {
834                                if (wrapper.handlerId == source.handlerId)
835                                {
836                                        listeners[index] = null;
837                                        listeners = std.algorithm.remove(listeners, index);
838                                        break;
839                                }
840                        }
841                }
842        }
843
844        /**
845         * Emitted when mountable volume is changed.
846         *
847         * Params:
848         *     volume = a #GVolume that changed.
849         */
850        gulong addOnVolumeChanged(void delegate(VolumeIF, VolumeMonitor) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
851        {
852                auto wrapper = new OnVolumeChangedDelegateWrapper(dlg);
853                wrapper.handlerId = Signals.connectData(
854                        this,
855                        "volume-changed",
856                        cast(GCallback)&callBackVolumeChanged,
857                        cast(void*)wrapper,
858                        cast(GClosureNotify)&callBackVolumeChangedDestroy,
859                        connectFlags);
860                return wrapper.handlerId;
861        }
862       
863        extern(C) static void callBackVolumeChanged(GVolumeMonitor* volumemonitorStruct, GVolume* volume, OnVolumeChangedDelegateWrapper wrapper)
864        {
865                wrapper.dlg(ObjectG.getDObject!(Volume, VolumeIF)(volume), wrapper.outer);
866        }
867       
868        extern(C) static void callBackVolumeChangedDestroy(OnVolumeChangedDelegateWrapper wrapper, GClosure* closure)
869        {
870                wrapper.remove(wrapper);
871        }
872
873        protected class OnVolumeRemovedDelegateWrapper
874        {
875                static OnVolumeRemovedDelegateWrapper[] listeners;
876                void delegate(VolumeIF, VolumeMonitor) dlg;
877                gulong handlerId;
878               
879                this(void delegate(VolumeIF, VolumeMonitor) dlg)
880                {
881                        this.dlg = dlg;
882                        this.listeners ~= this;
883                }
884               
885                void remove(OnVolumeRemovedDelegateWrapper source)
886                {
887                        foreach(index, wrapper; listeners)
888                        {
889                                if (wrapper.handlerId == source.handlerId)
890                                {
891                                        listeners[index] = null;
892                                        listeners = std.algorithm.remove(listeners, index);
893                                        break;
894                                }
895                        }
896                }
897        }
898
899        /**
900         * Emitted when a mountable volume is removed from the system.
901         *
902         * Params:
903         *     volume = a #GVolume that was removed.
904         */
905        gulong addOnVolumeRemoved(void delegate(VolumeIF, VolumeMonitor) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
906        {
907                auto wrapper = new OnVolumeRemovedDelegateWrapper(dlg);
908                wrapper.handlerId = Signals.connectData(
909                        this,
910                        "volume-removed",
911                        cast(GCallback)&callBackVolumeRemoved,
912                        cast(void*)wrapper,
913                        cast(GClosureNotify)&callBackVolumeRemovedDestroy,
914                        connectFlags);
915                return wrapper.handlerId;
916        }
917       
918        extern(C) static void callBackVolumeRemoved(GVolumeMonitor* volumemonitorStruct, GVolume* volume, OnVolumeRemovedDelegateWrapper wrapper)
919        {
920                wrapper.dlg(ObjectG.getDObject!(Volume, VolumeIF)(volume), wrapper.outer);
921        }
922       
923        extern(C) static void callBackVolumeRemovedDestroy(OnVolumeRemovedDelegateWrapper wrapper, GClosure* closure)
924        {
925                wrapper.remove(wrapper);
926        }
927}
Note: See TracBrowser for help on using the repository browser.