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() 59 { 60 return gFileMonitor; 61 } 62 63 /** the main Gtk struct as a void* */ 64 protected override void* getStruct() 65 { 66 return cast(void*)gFileMonitor; 67 } 68 69 protected override void setStruct(GObject* obj) 70 { 71 gFileMonitor = cast(GFileMonitor*)obj; 72 super.setStruct(obj); 73 } 74 75 /** 76 * Sets our main struct and passes it to the parent class. 77 */ 78 public this (GFileMonitor* gFileMonitor, bool ownedRef = false) 79 { 80 this.gFileMonitor = gFileMonitor; 81 super(cast(GObject*)gFileMonitor, ownedRef); 82 } 83 84 85 /** */ 86 public static GType getType() 87 { 88 return g_file_monitor_get_type(); 89 } 90 91 /** 92 * Cancels a file monitor. 93 * 94 * Returns: always %TRUE 95 */ 96 public bool cancel() 97 { 98 return g_file_monitor_cancel(gFileMonitor) != 0; 99 } 100 101 /** 102 * Emits the #GFileMonitor::changed signal if a change 103 * has taken place. Should be called from file monitor 104 * implementations only. 105 * 106 * Implementations are responsible to call this method from the 107 * [thread-default main context][g-main-context-push-thread-default] of the 108 * thread that the monitor was created in. 109 * 110 * Params: 111 * child = a #GFile. 112 * otherFile = a #GFile. 113 * eventType = a set of #GFileMonitorEvent flags. 114 */ 115 public void emitEvent(FileIF child, FileIF otherFile, GFileMonitorEvent eventType) 116 { 117 g_file_monitor_emit_event(gFileMonitor, (child is null) ? null : child.getFileStruct(), (otherFile is null) ? null : otherFile.getFileStruct(), eventType); 118 } 119 120 /** 121 * Returns whether the monitor is canceled. 122 * 123 * Returns: %TRUE if monitor is canceled. %FALSE otherwise. 124 */ 125 public bool isCancelled() 126 { 127 return g_file_monitor_is_cancelled(gFileMonitor) != 0; 128 } 129 130 /** 131 * Sets the rate limit to which the @monitor will report 132 * consecutive change events to the same file. 133 * 134 * Params: 135 * limitMsecs = a non-negative integer with the limit in milliseconds 136 * to poll for changes 137 */ 138 public void setRateLimit(int limitMsecs) 139 { 140 g_file_monitor_set_rate_limit(gFileMonitor, limitMsecs); 141 } 142 143 protected class OnChangedDelegateWrapper 144 { 145 static OnChangedDelegateWrapper[] listeners; 146 void delegate(FileIF, FileIF, GFileMonitorEvent, FileMonitor) dlg; 147 gulong handlerId; 148 149 this(void delegate(FileIF, FileIF, GFileMonitorEvent, FileMonitor) dlg) 150 { 151 this.dlg = dlg; 152 this.listeners ~= this; 153 } 154 155 void remove(OnChangedDelegateWrapper source) 156 { 157 foreach(index, wrapper; listeners) 158 { 159 if (wrapper.handlerId == source.handlerId) 160 { 161 listeners[index] = null; 162 listeners = std.algorithm.remove(listeners, index); 163 break; 164 } 165 } 166 } 167 } 168 169 /** 170 * Emitted when @file has been changed. 171 * 172 * If using %G_FILE_MONITOR_WATCH_MOVES on a directory monitor, and 173 * the information is available (and if supported by the backend), 174 * @event_type may be %G_FILE_MONITOR_EVENT_RENAMED, 175 * %G_FILE_MONITOR_EVENT_MOVED_IN or %G_FILE_MONITOR_EVENT_MOVED_OUT. 176 * 177 * In all cases @file will be a child of the monitored directory. For 178 * renames, @file will be the old name and @other_file is the new 179 * name. For "moved in" events, @file is the name of the file that 180 * appeared and @other_file is the old name that it was moved from (in 181 * another directory). For "moved out" events, @file is the name of 182 * the file that used to be in this directory and @other_file is the 183 * name of the file at its new location. 184 * 185 * It makes sense to treat %G_FILE_MONITOR_EVENT_MOVED_IN as 186 * equivalent to %G_FILE_MONITOR_EVENT_CREATED and 187 * %G_FILE_MONITOR_EVENT_MOVED_OUT as equivalent to 188 * %G_FILE_MONITOR_EVENT_DELETED, with extra information. 189 * %G_FILE_MONITOR_EVENT_RENAMED is equivalent to a delete/create 190 * pair. This is exactly how the events will be reported in the case 191 * that the %G_FILE_MONITOR_WATCH_MOVES flag is not in use. 192 * 193 * If using the deprecated flag %G_FILE_MONITOR_SEND_MOVED flag and @event_type is 194 * #G_FILE_MONITOR_EVENT_MOVED, @file will be set to a #GFile containing the 195 * old path, and @other_file will be set to a #GFile containing the new path. 196 * 197 * In all the other cases, @other_file will be set to #NULL. 198 * 199 * Params: 200 * file = a #GFile. 201 * otherFile = a #GFile or #NULL. 202 * eventType = a #GFileMonitorEvent. 203 */ 204 gulong addOnChanged(void delegate(FileIF, FileIF, GFileMonitorEvent, FileMonitor) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 205 { 206 auto wrapper = new OnChangedDelegateWrapper(dlg); 207 wrapper.handlerId = Signals.connectData( 208 this, 209 "changed", 210 cast(GCallback)&callBackChanged, 211 cast(void*)wrapper, 212 cast(GClosureNotify)&callBackChangedDestroy, 213 connectFlags); 214 return wrapper.handlerId; 215 } 216 217 extern(C) static void callBackChanged(GFileMonitor* filemonitorStruct, GFile* file, GFile* otherFile, GFileMonitorEvent eventType, OnChangedDelegateWrapper wrapper) 218 { 219 wrapper.dlg(ObjectG.getDObject!(File, FileIF)(file), ObjectG.getDObject!(File, FileIF)(otherFile), eventType, wrapper.outer); 220 } 221 222 extern(C) static void callBackChangedDestroy(OnChangedDelegateWrapper wrapper, GClosure* closure) 223 { 224 wrapper.remove(wrapper); 225 } 226 }