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

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

Initial release

File size: 17.4 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.MountOperation;
22
23private import gi.gio;
24public  import gi.giotypes;
25private import glib.ArrayG;
26private import glib.ConstructionException;
27private import glib.Str;
28private import gobject.ObjectG;
29private import gobject.Signals;
30private import std.algorithm;
31
32
33/**
34 * #GMountOperation provides a mechanism for interacting with the user.
35 * It can be used for authenticating mountable operations, such as loop
36 * mounting files, hard drive partitions or server locations. It can
37 * also be used to ask the user questions or show a list of applications
38 * preventing unmount or eject operations from completing.
39 *
40 * Note that #GMountOperation is used for more than just #GMount
41 * objects – for example it is also used in g_drive_start() and
42 * g_drive_stop().
43 *
44 * Users should instantiate a subclass of this that implements all the
45 * various callbacks to show the required dialogs, such as
46 * #GtkMountOperation. If no user interaction is desired (for example
47 * when automounting filesystems at login time), usually %NULL can be
48 * passed, see each method taking a #GMountOperation for details.
49 */
50public class MountOperation : ObjectG
51{
52        /** the main Gtk struct */
53        protected GMountOperation* gMountOperation;
54
55        /** Get the main Gtk struct */
56        public GMountOperation* getMountOperationStruct()
57        {
58                return gMountOperation;
59        }
60
61        /** the main Gtk struct as a void* */
62        protected override void* getStruct()
63        {
64                return cast(void*)gMountOperation;
65        }
66
67        protected override void setStruct(GObject* obj)
68        {
69                gMountOperation = cast(GMountOperation*)obj;
70                super.setStruct(obj);
71        }
72
73        /**
74         * Sets our main struct and passes it to the parent class.
75         */
76        public this (GMountOperation* gMountOperation, bool ownedRef = false)
77        {
78                this.gMountOperation = gMountOperation;
79                super(cast(GObject*)gMountOperation, ownedRef);
80        }
81
82
83        /** */
84        public static GType getType()
85        {
86                return g_mount_operation_get_type();
87        }
88
89        /**
90         * Creates a new mount operation.
91         *
92         * Returns: a #GMountOperation.
93         *
94         * Throws: ConstructionException GTK+ fails to create the object.
95         */
96        public this()
97        {
98                auto p = g_mount_operation_new();
99               
100                if(p is null)
101                {
102                        throw new ConstructionException("null returned by new");
103                }
104               
105                this(cast(GMountOperation*) p, true);
106        }
107
108        /**
109         * Check to see whether the mount operation is being used
110         * for an anonymous user.
111         *
112         * Returns: %TRUE if mount operation is anonymous.
113         */
114        public bool getAnonymous()
115        {
116                return g_mount_operation_get_anonymous(gMountOperation) != 0;
117        }
118
119        /**
120         * Gets a choice from the mount operation.
121         *
122         * Returns: an integer containing an index of the user's choice from
123         *     the choice's list, or %0.
124         */
125        public int getChoice()
126        {
127                return g_mount_operation_get_choice(gMountOperation);
128        }
129
130        /**
131         * Gets the domain of the mount operation.
132         *
133         * Returns: a string set to the domain.
134         */
135        public string getDomain()
136        {
137                return Str.toString(g_mount_operation_get_domain(gMountOperation));
138        }
139
140        /**
141         * Gets a password from the mount operation.
142         *
143         * Returns: a string containing the password within @op.
144         */
145        public string getPassword()
146        {
147                return Str.toString(g_mount_operation_get_password(gMountOperation));
148        }
149
150        /**
151         * Gets the state of saving passwords for the mount operation.
152         *
153         * Returns: a #GPasswordSave flag.
154         */
155        public GPasswordSave getPasswordSave()
156        {
157                return g_mount_operation_get_password_save(gMountOperation);
158        }
159
160        /**
161         * Get the user name from the mount operation.
162         *
163         * Returns: a string containing the user name.
164         */
165        public string getUsername()
166        {
167                return Str.toString(g_mount_operation_get_username(gMountOperation));
168        }
169
170        /**
171         * Emits the #GMountOperation::reply signal.
172         *
173         * Params:
174         *     result = a #GMountOperationResult
175         */
176        public void reply(GMountOperationResult result)
177        {
178                g_mount_operation_reply(gMountOperation, result);
179        }
180
181        /**
182         * Sets the mount operation to use an anonymous user if @anonymous is %TRUE.
183         *
184         * Params:
185         *     anonymous = boolean value.
186         */
187        public void setAnonymous(bool anonymous)
188        {
189                g_mount_operation_set_anonymous(gMountOperation, anonymous);
190        }
191
192        /**
193         * Sets a default choice for the mount operation.
194         *
195         * Params:
196         *     choice = an integer.
197         */
198        public void setChoice(int choice)
199        {
200                g_mount_operation_set_choice(gMountOperation, choice);
201        }
202
203        /**
204         * Sets the mount operation's domain.
205         *
206         * Params:
207         *     domain = the domain to set.
208         */
209        public void setDomain(string domain)
210        {
211                g_mount_operation_set_domain(gMountOperation, Str.toStringz(domain));
212        }
213
214        /**
215         * Sets the mount operation's password to @password.
216         *
217         * Params:
218         *     password = password to set.
219         */
220        public void setPassword(string password)
221        {
222                g_mount_operation_set_password(gMountOperation, Str.toStringz(password));
223        }
224
225        /**
226         * Sets the state of saving passwords for the mount operation.
227         *
228         * Params:
229         *     save = a set of #GPasswordSave flags.
230         */
231        public void setPasswordSave(GPasswordSave save)
232        {
233                g_mount_operation_set_password_save(gMountOperation, save);
234        }
235
236        /**
237         * Sets the user name within @op to @username.
238         *
239         * Params:
240         *     username = input username.
241         */
242        public void setUsername(string username)
243        {
244                g_mount_operation_set_username(gMountOperation, Str.toStringz(username));
245        }
246
247        protected class OnAbortedDelegateWrapper
248        {
249                static OnAbortedDelegateWrapper[] listeners;
250                void delegate(MountOperation) dlg;
251                gulong handlerId;
252               
253                this(void delegate(MountOperation) dlg)
254                {
255                        this.dlg = dlg;
256                        this.listeners ~= this;
257                }
258               
259                void remove(OnAbortedDelegateWrapper source)
260                {
261                        foreach(index, wrapper; listeners)
262                        {
263                                if (wrapper.handlerId == source.handlerId)
264                                {
265                                        listeners[index] = null;
266                                        listeners = std.algorithm.remove(listeners, index);
267                                        break;
268                                }
269                        }
270                }
271        }
272
273        /**
274         * Emitted by the backend when e.g. a device becomes unavailable
275         * while a mount operation is in progress.
276         *
277         * Implementations of GMountOperation should handle this signal
278         * by dismissing open password dialogs.
279         *
280         * Since: 2.20
281         */
282        gulong addOnAborted(void delegate(MountOperation) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
283        {
284                auto wrapper = new OnAbortedDelegateWrapper(dlg);
285                wrapper.handlerId = Signals.connectData(
286                        this,
287                        "aborted",
288                        cast(GCallback)&callBackAborted,
289                        cast(void*)wrapper,
290                        cast(GClosureNotify)&callBackAbortedDestroy,
291                        connectFlags);
292                return wrapper.handlerId;
293        }
294       
295        extern(C) static void callBackAborted(GMountOperation* mountoperationStruct, OnAbortedDelegateWrapper wrapper)
296        {
297                wrapper.dlg(wrapper.outer);
298        }
299       
300        extern(C) static void callBackAbortedDestroy(OnAbortedDelegateWrapper wrapper, GClosure* closure)
301        {
302                wrapper.remove(wrapper);
303        }
304
305        protected class OnAskPasswordDelegateWrapper
306        {
307                static OnAskPasswordDelegateWrapper[] listeners;
308                void delegate(string, string, string, GAskPasswordFlags, MountOperation) dlg;
309                gulong handlerId;
310               
311                this(void delegate(string, string, string, GAskPasswordFlags, MountOperation) dlg)
312                {
313                        this.dlg = dlg;
314                        this.listeners ~= this;
315                }
316               
317                void remove(OnAskPasswordDelegateWrapper source)
318                {
319                        foreach(index, wrapper; listeners)
320                        {
321                                if (wrapper.handlerId == source.handlerId)
322                                {
323                                        listeners[index] = null;
324                                        listeners = std.algorithm.remove(listeners, index);
325                                        break;
326                                }
327                        }
328                }
329        }
330
331        /**
332         * Emitted when a mount operation asks the user for a password.
333         *
334         * If the message contains a line break, the first line should be
335         * presented as a heading. For example, it may be used as the
336         * primary text in a #GtkMessageDialog.
337         *
338         * Params:
339         *     message = string containing a message to display to the user.
340         *     defaultUser = string containing the default user name.
341         *     defaultDomain = string containing the default domain.
342         *     flags = a set of #GAskPasswordFlags.
343         */
344        gulong addOnAskPassword(void delegate(string, string, string, GAskPasswordFlags, MountOperation) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
345        {
346                auto wrapper = new OnAskPasswordDelegateWrapper(dlg);
347                wrapper.handlerId = Signals.connectData(
348                        this,
349                        "ask-password",
350                        cast(GCallback)&callBackAskPassword,
351                        cast(void*)wrapper,
352                        cast(GClosureNotify)&callBackAskPasswordDestroy,
353                        connectFlags);
354                return wrapper.handlerId;
355        }
356       
357        extern(C) static void callBackAskPassword(GMountOperation* mountoperationStruct, char* message, char* defaultUser, char* defaultDomain, GAskPasswordFlags flags, OnAskPasswordDelegateWrapper wrapper)
358        {
359                wrapper.dlg(Str.toString(message), Str.toString(defaultUser), Str.toString(defaultDomain), flags, wrapper.outer);
360        }
361       
362        extern(C) static void callBackAskPasswordDestroy(OnAskPasswordDelegateWrapper wrapper, GClosure* closure)
363        {
364                wrapper.remove(wrapper);
365        }
366
367        protected class OnAskQuestionDelegateWrapper
368        {
369                static OnAskQuestionDelegateWrapper[] listeners;
370                void delegate(string, string[], MountOperation) dlg;
371                gulong handlerId;
372               
373                this(void delegate(string, string[], MountOperation) dlg)
374                {
375                        this.dlg = dlg;
376                        this.listeners ~= this;
377                }
378               
379                void remove(OnAskQuestionDelegateWrapper source)
380                {
381                        foreach(index, wrapper; listeners)
382                        {
383                                if (wrapper.handlerId == source.handlerId)
384                                {
385                                        listeners[index] = null;
386                                        listeners = std.algorithm.remove(listeners, index);
387                                        break;
388                                }
389                        }
390                }
391        }
392
393        /**
394         * Emitted when asking the user a question and gives a list of
395         * choices for the user to choose from.
396         *
397         * If the message contains a line break, the first line should be
398         * presented as a heading. For example, it may be used as the
399         * primary text in a #GtkMessageDialog.
400         *
401         * Params:
402         *     message = string containing a message to display to the user.
403         *     choices = an array of strings for each possible choice.
404         */
405        gulong addOnAskQuestion(void delegate(string, string[], MountOperation) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
406        {
407                auto wrapper = new OnAskQuestionDelegateWrapper(dlg);
408                wrapper.handlerId = Signals.connectData(
409                        this,
410                        "ask-question",
411                        cast(GCallback)&callBackAskQuestion,
412                        cast(void*)wrapper,
413                        cast(GClosureNotify)&callBackAskQuestionDestroy,
414                        connectFlags);
415                return wrapper.handlerId;
416        }
417       
418        extern(C) static void callBackAskQuestion(GMountOperation* mountoperationStruct, char* message, char** choices, OnAskQuestionDelegateWrapper wrapper)
419        {
420                wrapper.dlg(Str.toString(message), Str.toStringArray(choices), wrapper.outer);
421        }
422       
423        extern(C) static void callBackAskQuestionDestroy(OnAskQuestionDelegateWrapper wrapper, GClosure* closure)
424        {
425                wrapper.remove(wrapper);
426        }
427
428        protected class OnReplyDelegateWrapper
429        {
430                static OnReplyDelegateWrapper[] listeners;
431                void delegate(GMountOperationResult, MountOperation) dlg;
432                gulong handlerId;
433               
434                this(void delegate(GMountOperationResult, MountOperation) dlg)
435                {
436                        this.dlg = dlg;
437                        this.listeners ~= this;
438                }
439               
440                void remove(OnReplyDelegateWrapper source)
441                {
442                        foreach(index, wrapper; listeners)
443                        {
444                                if (wrapper.handlerId == source.handlerId)
445                                {
446                                        listeners[index] = null;
447                                        listeners = std.algorithm.remove(listeners, index);
448                                        break;
449                                }
450                        }
451                }
452        }
453
454        /**
455         * Emitted when the user has replied to the mount operation.
456         *
457         * Params:
458         *     result = a #GMountOperationResult indicating how the request was handled
459         */
460        gulong addOnReply(void delegate(GMountOperationResult, MountOperation) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
461        {
462                auto wrapper = new OnReplyDelegateWrapper(dlg);
463                wrapper.handlerId = Signals.connectData(
464                        this,
465                        "reply",
466                        cast(GCallback)&callBackReply,
467                        cast(void*)wrapper,
468                        cast(GClosureNotify)&callBackReplyDestroy,
469                        connectFlags);
470                return wrapper.handlerId;
471        }
472       
473        extern(C) static void callBackReply(GMountOperation* mountoperationStruct, GMountOperationResult result, OnReplyDelegateWrapper wrapper)
474        {
475                wrapper.dlg(result, wrapper.outer);
476        }
477       
478        extern(C) static void callBackReplyDestroy(OnReplyDelegateWrapper wrapper, GClosure* closure)
479        {
480                wrapper.remove(wrapper);
481        }
482
483        protected class OnShowProcessesDelegateWrapper
484        {
485                static OnShowProcessesDelegateWrapper[] listeners;
486                void delegate(string, ArrayG, string[], MountOperation) dlg;
487                gulong handlerId;
488               
489                this(void delegate(string, ArrayG, string[], MountOperation) dlg)
490                {
491                        this.dlg = dlg;
492                        this.listeners ~= this;
493                }
494               
495                void remove(OnShowProcessesDelegateWrapper source)
496                {
497                        foreach(index, wrapper; listeners)
498                        {
499                                if (wrapper.handlerId == source.handlerId)
500                                {
501                                        listeners[index] = null;
502                                        listeners = std.algorithm.remove(listeners, index);
503                                        break;
504                                }
505                        }
506                }
507        }
508
509        /**
510         * Emitted when one or more processes are blocking an operation
511         * e.g. unmounting/ejecting a #GMount or stopping a #GDrive.
512         *
513         * Note that this signal may be emitted several times to update the
514         * list of blocking processes as processes close files. The
515         * application should only respond with g_mount_operation_reply() to
516         * the latest signal (setting #GMountOperation:choice to the choice
517         * the user made).
518         *
519         * If the message contains a line break, the first line should be
520         * presented as a heading. For example, it may be used as the
521         * primary text in a #GtkMessageDialog.
522         *
523         * Params:
524         *     message = string containing a message to display to the user.
525         *     processes = an array of #GPid for processes
526         *         blocking the operation.
527         *     choices = an array of strings for each possible choice.
528         *
529         * Since: 2.22
530         */
531        gulong addOnShowProcesses(void delegate(string, ArrayG, string[], MountOperation) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
532        {
533                auto wrapper = new OnShowProcessesDelegateWrapper(dlg);
534                wrapper.handlerId = Signals.connectData(
535                        this,
536                        "show-processes",
537                        cast(GCallback)&callBackShowProcesses,
538                        cast(void*)wrapper,
539                        cast(GClosureNotify)&callBackShowProcessesDestroy,
540                        connectFlags);
541                return wrapper.handlerId;
542        }
543       
544        extern(C) static void callBackShowProcesses(GMountOperation* mountoperationStruct, char* message, GArray* processes, char** choices, OnShowProcessesDelegateWrapper wrapper)
545        {
546                wrapper.dlg(Str.toString(message), new ArrayG(processes), Str.toStringArray(choices), wrapper.outer);
547        }
548       
549        extern(C) static void callBackShowProcessesDestroy(OnShowProcessesDelegateWrapper wrapper, GClosure* closure)
550        {
551                wrapper.remove(wrapper);
552        }
553
554        protected class OnShowUnmountProgressDelegateWrapper
555        {
556                static OnShowUnmountProgressDelegateWrapper[] listeners;
557                void delegate(string, long, long, MountOperation) dlg;
558                gulong handlerId;
559               
560                this(void delegate(string, long, long, MountOperation) dlg)
561                {
562                        this.dlg = dlg;
563                        this.listeners ~= this;
564                }
565               
566                void remove(OnShowUnmountProgressDelegateWrapper source)
567                {
568                        foreach(index, wrapper; listeners)
569                        {
570                                if (wrapper.handlerId == source.handlerId)
571                                {
572                                        listeners[index] = null;
573                                        listeners = std.algorithm.remove(listeners, index);
574                                        break;
575                                }
576                        }
577                }
578        }
579
580        /**
581         * Emitted when an unmount operation has been busy for more than some time
582         * (typically 1.5 seconds).
583         *
584         * When unmounting or ejecting a volume, the kernel might need to flush
585         * pending data in its buffers to the volume stable storage, and this operation
586         * can take a considerable amount of time. This signal may be emitted several
587         * times as long as the unmount operation is outstanding, and then one
588         * last time when the operation is completed, with @bytes_left set to zero.
589         *
590         * Implementations of GMountOperation should handle this signal by
591         * showing an UI notification, and then dismiss it, or show another notification
592         * of completion, when @bytes_left reaches zero.
593         *
594         * If the message contains a line break, the first line should be
595         * presented as a heading. For example, it may be used as the
596         * primary text in a #GtkMessageDialog.
597         *
598         * Params:
599         *     message = string containing a mesage to display to the user
600         *     timeLeft = the estimated time left before the operation completes,
601         *         in microseconds, or -1
602         *     bytesLeft = the amount of bytes to be written before the operation
603         *         completes (or -1 if such amount is not known), or zero if the operation
604         *         is completed
605         *
606         * Since: 2.34
607         */
608        gulong addOnShowUnmountProgress(void delegate(string, long, long, MountOperation) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
609        {
610                auto wrapper = new OnShowUnmountProgressDelegateWrapper(dlg);
611                wrapper.handlerId = Signals.connectData(
612                        this,
613                        "show-unmount-progress",
614                        cast(GCallback)&callBackShowUnmountProgress,
615                        cast(void*)wrapper,
616                        cast(GClosureNotify)&callBackShowUnmountProgressDestroy,
617                        connectFlags);
618                return wrapper.handlerId;
619        }
620       
621        extern(C) static void callBackShowUnmountProgress(GMountOperation* mountoperationStruct, char* message, long timeLeft, long bytesLeft, OnShowUnmountProgressDelegateWrapper wrapper)
622        {
623                wrapper.dlg(Str.toString(message), timeLeft, bytesLeft, wrapper.outer);
624        }
625       
626        extern(C) static void callBackShowUnmountProgressDestroy(OnShowUnmountProgressDelegateWrapper wrapper, GClosure* closure)
627        {
628                wrapper.remove(wrapper);
629        }
630}
Note: See TracBrowser for help on using the repository browser.