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 gstreamer.DeviceProvider; 26 27 private import glib.ListG; 28 private import glib.Str; 29 private import gobject.ObjectG; 30 private import gobject.Signals; 31 private import gstreamer.Bus; 32 private import gstreamer.Device; 33 private import gstreamer.DeviceProviderFactory; 34 private import gstreamer.ObjectGst; 35 private import gstreamer.Plugin; 36 private import gstreamer.c.functions; 37 public import gstreamer.c.types; 38 public import gstreamerc.gstreamertypes; 39 private import std.algorithm; 40 41 42 /** 43 * A #GstDeviceProvider subclass is provided by a plugin that handles devices 44 * if there is a way to programatically list connected devices. It can also 45 * optionally provide updates to the list of connected devices. 46 * 47 * Each #GstDeviceProvider subclass is a singleton, a plugin should 48 * normally provide a single subclass for all devices. 49 * 50 * Applications would normally use a #GstDeviceMonitor to monitor devices 51 * from all relevant providers. 52 * 53 * Since: 1.4 54 */ 55 public class DeviceProvider : ObjectGst 56 { 57 /** the main Gtk struct */ 58 protected GstDeviceProvider* gstDeviceProvider; 59 60 /** Get the main Gtk struct */ 61 public GstDeviceProvider* getDeviceProviderStruct(bool transferOwnership = false) 62 { 63 if (transferOwnership) 64 ownedRef = false; 65 return gstDeviceProvider; 66 } 67 68 /** the main Gtk struct as a void* */ 69 protected override void* getStruct() 70 { 71 return cast(void*)gstDeviceProvider; 72 } 73 74 /** 75 * Sets our main struct and passes it to the parent class. 76 */ 77 public this (GstDeviceProvider* gstDeviceProvider, bool ownedRef = false) 78 { 79 this.gstDeviceProvider = gstDeviceProvider; 80 super(cast(GstObject*)gstDeviceProvider, ownedRef); 81 } 82 83 84 /** */ 85 public static GType getType() 86 { 87 return gst_device_provider_get_type(); 88 } 89 90 /** 91 * Create a new device providerfactory capable of instantiating objects of the 92 * @type and add the factory to @plugin. 93 * 94 * Params: 95 * plugin = #GstPlugin to register the device provider with, or %NULL for 96 * a static device provider. 97 * name = name of device providers of this type 98 * rank = rank of device provider (higher rank means more importance when autoplugging) 99 * type = GType of device provider to register 100 * 101 * Returns: %TRUE, if the registering succeeded, %FALSE on error 102 * 103 * Since: 1.4 104 */ 105 public static bool register(Plugin plugin, string name, uint rank, GType type) 106 { 107 return gst_device_provider_register((plugin is null) ? null : plugin.getPluginStruct(), Str.toStringz(name), rank, type) != 0; 108 } 109 110 /** */ 111 public bool canMonitor() 112 { 113 return gst_device_provider_can_monitor(gstDeviceProvider) != 0; 114 } 115 116 /** 117 * Posts a message on the provider's #GstBus to inform applications that 118 * a new device has been added. 119 * 120 * This is for use by subclasses. 121 * 122 * Params: 123 * device = a #GstDevice that has been added 124 * 125 * Since: 1.4 126 */ 127 public void deviceAdd(Device device) 128 { 129 gst_device_provider_device_add(gstDeviceProvider, (device is null) ? null : device.getDeviceStruct()); 130 } 131 132 /** 133 * Posts a message on the provider's #GstBus to inform applications that 134 * a device has been removed. 135 * 136 * This is for use by subclasses. 137 * 138 * Params: 139 * device = a #GstDevice that has been removed 140 * 141 * Since: 1.4 142 */ 143 public void deviceRemove(Device device) 144 { 145 gst_device_provider_device_remove(gstDeviceProvider, (device is null) ? null : device.getDeviceStruct()); 146 } 147 148 /** 149 * Gets the #GstBus of this #GstDeviceProvider 150 * 151 * Returns: a #GstBus 152 * 153 * Since: 1.4 154 */ 155 public Bus getBus() 156 { 157 auto p = gst_device_provider_get_bus(gstDeviceProvider); 158 159 if(p is null) 160 { 161 return null; 162 } 163 164 return ObjectG.getDObject!(Bus)(cast(GstBus*) p, true); 165 } 166 167 /** 168 * Gets a list of devices that this provider understands. This may actually 169 * probe the hardware if the provider is not currently started. 170 * 171 * Returns: a #GList of 172 * #GstDevice 173 * 174 * Since: 1.4 175 */ 176 public ListG getDevices() 177 { 178 auto p = gst_device_provider_get_devices(gstDeviceProvider); 179 180 if(p is null) 181 { 182 return null; 183 } 184 185 return new ListG(cast(GList*) p, true); 186 } 187 188 /** 189 * Retrieves the factory that was used to create this device provider. 190 * 191 * Returns: the #GstDeviceProviderFactory used for 192 * creating this device provider. no refcounting is needed. 193 * 194 * Since: 1.4 195 */ 196 public DeviceProviderFactory getFactory() 197 { 198 auto p = gst_device_provider_get_factory(gstDeviceProvider); 199 200 if(p is null) 201 { 202 return null; 203 } 204 205 return ObjectG.getDObject!(DeviceProviderFactory)(cast(GstDeviceProviderFactory*) p); 206 } 207 208 /** 209 * Get the provider factory names of the #GstDeviceProvider instances that 210 * are hidden by @provider. 211 * 212 * Returns: a list of hidden providers factory names or %NULL when 213 * nothing is hidden by @provider. Free with g_strfreev. 214 * 215 * Since: 1.6 216 */ 217 public string[] getHiddenProviders() 218 { 219 auto retStr = gst_device_provider_get_hidden_providers(gstDeviceProvider); 220 221 scope(exit) Str.freeStringArray(retStr); 222 return Str.toStringArray(retStr); 223 } 224 225 /** 226 * Make @provider hide the devices from the factory with @name. 227 * 228 * This function is used when @provider will also provide the devices reported 229 * by provider factory @name. A monitor should stop monitoring the 230 * device provider with @name to avoid duplicate devices. 231 * 232 * Params: 233 * name = a provider factory name 234 * 235 * Since: 1.6 236 */ 237 public void hideProvider(string name) 238 { 239 gst_device_provider_hide_provider(gstDeviceProvider, Str.toStringz(name)); 240 } 241 242 /** 243 * Starts providering the devices. This will cause #GST_MESSAGE_DEVICE_ADDED 244 * and #GST_MESSAGE_DEVICE_REMOVED messages to be posted on the provider's bus 245 * when devices are added or removed from the system. 246 * 247 * Since the #GstDeviceProvider is a singleton, 248 * gst_device_provider_start() may already have been called by another 249 * user of the object, gst_device_provider_stop() needs to be called the same 250 * number of times. 251 * 252 * Returns: %TRUE if the device providering could be started 253 * 254 * Since: 1.4 255 */ 256 public bool start() 257 { 258 return gst_device_provider_start(gstDeviceProvider) != 0; 259 } 260 261 /** 262 * Decreases the use-count by one. If the use count reaches zero, this 263 * #GstDeviceProvider will stop providering the devices. This needs to be 264 * called the same number of times that gst_device_provider_start() was called. 265 * 266 * Since: 1.4 267 */ 268 public void stop() 269 { 270 gst_device_provider_stop(gstDeviceProvider); 271 } 272 273 /** 274 * Make @provider unhide the devices from factory @name. 275 * 276 * This function is used when @provider will no longer provide the devices 277 * reported by provider factory @name. A monitor should start 278 * monitoring the devices from provider factory @name in order to see 279 * all devices again. 280 * 281 * Params: 282 * name = a provider factory name 283 * 284 * Since: 1.6 285 */ 286 public void unhideProvider(string name) 287 { 288 gst_device_provider_unhide_provider(gstDeviceProvider, Str.toStringz(name)); 289 } 290 291 protected class OnProviderHiddenDelegateWrapper 292 { 293 void delegate(string, DeviceProvider) dlg; 294 gulong handlerId; 295 296 this(void delegate(string, DeviceProvider) dlg) 297 { 298 this.dlg = dlg; 299 onProviderHiddenListeners ~= this; 300 } 301 302 void remove(OnProviderHiddenDelegateWrapper source) 303 { 304 foreach(index, wrapper; onProviderHiddenListeners) 305 { 306 if (wrapper.handlerId == source.handlerId) 307 { 308 onProviderHiddenListeners[index] = null; 309 onProviderHiddenListeners = std.algorithm.remove(onProviderHiddenListeners, index); 310 break; 311 } 312 } 313 } 314 } 315 OnProviderHiddenDelegateWrapper[] onProviderHiddenListeners; 316 317 /** */ 318 gulong addOnProviderHidden(void delegate(string, DeviceProvider) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 319 { 320 auto wrapper = new OnProviderHiddenDelegateWrapper(dlg); 321 wrapper.handlerId = Signals.connectData( 322 this, 323 "provider-hidden", 324 cast(GCallback)&callBackProviderHidden, 325 cast(void*)wrapper, 326 cast(GClosureNotify)&callBackProviderHiddenDestroy, 327 connectFlags); 328 return wrapper.handlerId; 329 } 330 331 extern(C) static void callBackProviderHidden(GstDeviceProvider* deviceproviderStruct, char* object, OnProviderHiddenDelegateWrapper wrapper) 332 { 333 wrapper.dlg(Str.toString(object), wrapper.outer); 334 } 335 336 extern(C) static void callBackProviderHiddenDestroy(OnProviderHiddenDelegateWrapper wrapper, GClosure* closure) 337 { 338 wrapper.remove(wrapper); 339 } 340 341 protected class OnProviderUnhiddenDelegateWrapper 342 { 343 void delegate(string, DeviceProvider) dlg; 344 gulong handlerId; 345 346 this(void delegate(string, DeviceProvider) dlg) 347 { 348 this.dlg = dlg; 349 onProviderUnhiddenListeners ~= this; 350 } 351 352 void remove(OnProviderUnhiddenDelegateWrapper source) 353 { 354 foreach(index, wrapper; onProviderUnhiddenListeners) 355 { 356 if (wrapper.handlerId == source.handlerId) 357 { 358 onProviderUnhiddenListeners[index] = null; 359 onProviderUnhiddenListeners = std.algorithm.remove(onProviderUnhiddenListeners, index); 360 break; 361 } 362 } 363 } 364 } 365 OnProviderUnhiddenDelegateWrapper[] onProviderUnhiddenListeners; 366 367 /** */ 368 gulong addOnProviderUnhidden(void delegate(string, DeviceProvider) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 369 { 370 auto wrapper = new OnProviderUnhiddenDelegateWrapper(dlg); 371 wrapper.handlerId = Signals.connectData( 372 this, 373 "provider-unhidden", 374 cast(GCallback)&callBackProviderUnhidden, 375 cast(void*)wrapper, 376 cast(GClosureNotify)&callBackProviderUnhiddenDestroy, 377 connectFlags); 378 return wrapper.handlerId; 379 } 380 381 extern(C) static void callBackProviderUnhidden(GstDeviceProvider* deviceproviderStruct, char* object, OnProviderUnhiddenDelegateWrapper wrapper) 382 { 383 wrapper.dlg(Str.toString(object), wrapper.outer); 384 } 385 386 extern(C) static void callBackProviderUnhiddenDestroy(OnProviderUnhiddenDelegateWrapper wrapper, GClosure* closure) 387 { 388 wrapper.remove(wrapper); 389 } 390 }