1 /*
2  * This file is part of gtkD.
3  *
4  * gtkD is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU Lesser General Public License
6  * as published by the Free Software Foundation; either version 3
7  * of the License, or (at your option) any later version, with
8  * some exceptions, please read the COPYING file.
9  *
10  * gtkD is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public License
16  * along with gtkD; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA
18  */
19 
20 // generated automatically - do not change
21 // find conversion definition on APILookup.txt
22 // implement new conversion functionalities on the wrap.utils pakage
23 
24 
25 module gio.FileMonitor;
26 
27 private import gio.File;
28 private import gio.FileIF;
29 private import gobject.ObjectG;
30 private import gobject.Signals;
31 private import gtkc.gio;
32 public  import gtkc.giotypes;
33 private import std.algorithm;
34 
35 
36 /**
37  * Monitors a file or directory for changes.
38  * 
39  * To obtain a #GFileMonitor for a file or directory, use
40  * g_file_monitor(), g_file_monitor_file(), or
41  * g_file_monitor_directory().
42  * 
43  * To get informed about changes to the file or directory you are
44  * monitoring, connect to the #GFileMonitor::changed signal. The
45  * signal will be emitted in the
46  * [thread-default main context][g-main-context-push-thread-default]
47  * of the thread that the monitor was created in
48  * (though if the global default main context is blocked, this may
49  * cause notifications to be blocked even if the thread-default
50  * context is still running).
51  */
52 public class FileMonitor : ObjectG
53 {
54 	/** the main Gtk struct */
55 	protected GFileMonitor* gFileMonitor;
56 
57 	/** Get the main Gtk struct */
58 	public GFileMonitor* getFileMonitorStruct(bool transferOwnership = false)
59 	{
60 		if (transferOwnership)
61 			ownedRef = false;
62 		return gFileMonitor;
63 	}
64 
65 	/** the main Gtk struct as a void* */
66 	protected override void* getStruct()
67 	{
68 		return cast(void*)gFileMonitor;
69 	}
70 
71 	protected override void setStruct(GObject* obj)
72 	{
73 		gFileMonitor = cast(GFileMonitor*)obj;
74 		super.setStruct(obj);
75 	}
76 
77 	/**
78 	 * Sets our main struct and passes it to the parent class.
79 	 */
80 	public this (GFileMonitor* gFileMonitor, bool ownedRef = false)
81 	{
82 		this.gFileMonitor = gFileMonitor;
83 		super(cast(GObject*)gFileMonitor, ownedRef);
84 	}
85 
86 
87 	/** */
88 	public static GType getType()
89 	{
90 		return g_file_monitor_get_type();
91 	}
92 
93 	/**
94 	 * Cancels a file monitor.
95 	 *
96 	 * Returns: always %TRUE
97 	 */
98 	public bool cancel()
99 	{
100 		return g_file_monitor_cancel(gFileMonitor) != 0;
101 	}
102 
103 	/**
104 	 * Emits the #GFileMonitor::changed signal if a change
105 	 * has taken place. Should be called from file monitor
106 	 * implementations only.
107 	 *
108 	 * Implementations are responsible to call this method from the
109 	 * [thread-default main context][g-main-context-push-thread-default] of the
110 	 * thread that the monitor was created in.
111 	 *
112 	 * Params:
113 	 *     child = a #GFile.
114 	 *     otherFile = a #GFile.
115 	 *     eventType = a set of #GFileMonitorEvent flags.
116 	 */
117 	public void emitEvent(FileIF child, FileIF otherFile, GFileMonitorEvent eventType)
118 	{
119 		g_file_monitor_emit_event(gFileMonitor, (child is null) ? null : child.getFileStruct(), (otherFile is null) ? null : otherFile.getFileStruct(), eventType);
120 	}
121 
122 	/**
123 	 * Returns whether the monitor is canceled.
124 	 *
125 	 * Returns: %TRUE if monitor is canceled. %FALSE otherwise.
126 	 */
127 	public bool isCancelled()
128 	{
129 		return g_file_monitor_is_cancelled(gFileMonitor) != 0;
130 	}
131 
132 	/**
133 	 * Sets the rate limit to which the @monitor will report
134 	 * consecutive change events to the same file.
135 	 *
136 	 * Params:
137 	 *     limitMsecs = a non-negative integer with the limit in milliseconds
138 	 *         to poll for changes
139 	 */
140 	public void setRateLimit(int limitMsecs)
141 	{
142 		g_file_monitor_set_rate_limit(gFileMonitor, limitMsecs);
143 	}
144 
145 	protected class OnChangedDelegateWrapper
146 	{
147 		static OnChangedDelegateWrapper[] listeners;
148 		void delegate(FileIF, FileIF, GFileMonitorEvent, FileMonitor) dlg;
149 		gulong handlerId;
150 		
151 		this(void delegate(FileIF, FileIF, GFileMonitorEvent, FileMonitor) dlg)
152 		{
153 			this.dlg = dlg;
154 			this.listeners ~= this;
155 		}
156 		
157 		void remove(OnChangedDelegateWrapper source)
158 		{
159 			foreach(index, wrapper; listeners)
160 			{
161 				if (wrapper.handlerId == source.handlerId)
162 				{
163 					listeners[index] = null;
164 					listeners = std.algorithm.remove(listeners, index);
165 					break;
166 				}
167 			}
168 		}
169 	}
170 
171 	/**
172 	 * Emitted when @file has been changed.
173 	 *
174 	 * If using %G_FILE_MONITOR_WATCH_MOVES on a directory monitor, and
175 	 * the information is available (and if supported by the backend),
176 	 * @event_type may be %G_FILE_MONITOR_EVENT_RENAMED,
177 	 * %G_FILE_MONITOR_EVENT_MOVED_IN or %G_FILE_MONITOR_EVENT_MOVED_OUT.
178 	 *
179 	 * In all cases @file will be a child of the monitored directory.  For
180 	 * renames, @file will be the old name and @other_file is the new
181 	 * name.  For "moved in" events, @file is the name of the file that
182 	 * appeared and @other_file is the old name that it was moved from (in
183 	 * another directory).  For "moved out" events, @file is the name of
184 	 * the file that used to be in this directory and @other_file is the
185 	 * name of the file at its new location.
186 	 *
187 	 * It makes sense to treat %G_FILE_MONITOR_EVENT_MOVED_IN as
188 	 * equivalent to %G_FILE_MONITOR_EVENT_CREATED and
189 	 * %G_FILE_MONITOR_EVENT_MOVED_OUT as equivalent to
190 	 * %G_FILE_MONITOR_EVENT_DELETED, with extra information.
191 	 * %G_FILE_MONITOR_EVENT_RENAMED is equivalent to a delete/create
192 	 * pair.  This is exactly how the events will be reported in the case
193 	 * that the %G_FILE_MONITOR_WATCH_MOVES flag is not in use.
194 	 *
195 	 * If using the deprecated flag %G_FILE_MONITOR_SEND_MOVED flag and @event_type is
196 	 * #G_FILE_MONITOR_EVENT_MOVED, @file will be set to a #GFile containing the
197 	 * old path, and @other_file will be set to a #GFile containing the new path.
198 	 *
199 	 * In all the other cases, @other_file will be set to #NULL.
200 	 *
201 	 * Params:
202 	 *     file = a #GFile.
203 	 *     otherFile = a #GFile or #NULL.
204 	 *     eventType = a #GFileMonitorEvent.
205 	 */
206 	gulong addOnChanged(void delegate(FileIF, FileIF, GFileMonitorEvent, FileMonitor) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
207 	{
208 		auto wrapper = new OnChangedDelegateWrapper(dlg);
209 		wrapper.handlerId = Signals.connectData(
210 			this,
211 			"changed",
212 			cast(GCallback)&callBackChanged,
213 			cast(void*)wrapper,
214 			cast(GClosureNotify)&callBackChangedDestroy,
215 			connectFlags);
216 		return wrapper.handlerId;
217 	}
218 	
219 	extern(C) static void callBackChanged(GFileMonitor* filemonitorStruct, GFile* file, GFile* otherFile, GFileMonitorEvent eventType, OnChangedDelegateWrapper wrapper)
220 	{
221 		wrapper.dlg(ObjectG.getDObject!(File, FileIF)(file), ObjectG.getDObject!(File, FileIF)(otherFile), eventType, wrapper.outer);
222 	}
223 	
224 	extern(C) static void callBackChangedDestroy(OnChangedDelegateWrapper wrapper, GClosure* closure)
225 	{
226 		wrapper.remove(wrapper);
227 	}
228 }