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 programmatically 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 	 * @device's reference count will be incremented, and any floating reference
123 	 * will be removed (see gst_object_ref_sink()).
124 	 *
125 	 * Params:
126 	 *     device = a #GstDevice that has been added
127 	 *
128 	 * Since: 1.4
129 	 */
130 	public void deviceAdd(Device device)
131 	{
132 		gst_device_provider_device_add(gstDeviceProvider, (device is null) ? null : device.getDeviceStruct());
133 	}
134 
135 	/**
136 	 * This function is used when @changed_device was modified into its new form
137 	 * @device. This will post a `DEVICE_CHANGED` message on the bus to let
138 	 * the application know that the device was modified. #GstDevice is immutable
139 	 * for MT. safety purposes so this is an "atomic" way of letting the application
140 	 * know when a device was modified.
141 	 *
142 	 * Params:
143 	 *     device = the new version of @changed_device
144 	 *     changedDevice = the old version of the device that has been udpated
145 	 *
146 	 * Since: 1.16
147 	 */
148 	public void deviceChanged(Device device, Device changedDevice)
149 	{
150 		gst_device_provider_device_changed(gstDeviceProvider, (device is null) ? null : device.getDeviceStruct(), (changedDevice is null) ? null : changedDevice.getDeviceStruct());
151 	}
152 
153 	/**
154 	 * Posts a message on the provider's #GstBus to inform applications that
155 	 * a device has been removed.
156 	 *
157 	 * This is for use by subclasses.
158 	 *
159 	 * Params:
160 	 *     device = a #GstDevice that has been removed
161 	 *
162 	 * Since: 1.4
163 	 */
164 	public void deviceRemove(Device device)
165 	{
166 		gst_device_provider_device_remove(gstDeviceProvider, (device is null) ? null : device.getDeviceStruct());
167 	}
168 
169 	/**
170 	 * Gets the #GstBus of this #GstDeviceProvider
171 	 *
172 	 * Returns: a #GstBus
173 	 *
174 	 * Since: 1.4
175 	 */
176 	public Bus getBus()
177 	{
178 		auto p = gst_device_provider_get_bus(gstDeviceProvider);
179 
180 		if(p is null)
181 		{
182 			return null;
183 		}
184 
185 		return ObjectG.getDObject!(Bus)(cast(GstBus*) p, true);
186 	}
187 
188 	/**
189 	 * Gets a list of devices that this provider understands. This may actually
190 	 * probe the hardware if the provider is not currently started.
191 	 *
192 	 * Returns: a #GList of
193 	 *     #GstDevice
194 	 *
195 	 * Since: 1.4
196 	 */
197 	public ListG getDevices()
198 	{
199 		auto p = gst_device_provider_get_devices(gstDeviceProvider);
200 
201 		if(p is null)
202 		{
203 			return null;
204 		}
205 
206 		return new ListG(cast(GList*) p, true);
207 	}
208 
209 	/**
210 	 * Retrieves the factory that was used to create this device provider.
211 	 *
212 	 * Returns: the #GstDeviceProviderFactory used for
213 	 *     creating this device provider. no refcounting is needed.
214 	 *
215 	 * Since: 1.4
216 	 */
217 	public DeviceProviderFactory getFactory()
218 	{
219 		auto p = gst_device_provider_get_factory(gstDeviceProvider);
220 
221 		if(p is null)
222 		{
223 			return null;
224 		}
225 
226 		return ObjectG.getDObject!(DeviceProviderFactory)(cast(GstDeviceProviderFactory*) p);
227 	}
228 
229 	/**
230 	 * Get the provider factory names of the #GstDeviceProvider instances that
231 	 * are hidden by @provider.
232 	 *
233 	 * Returns: a list of hidden providers factory names or %NULL when
234 	 *     nothing is hidden by @provider. Free with g_strfreev.
235 	 *
236 	 * Since: 1.6
237 	 */
238 	public string[] getHiddenProviders()
239 	{
240 		auto retStr = gst_device_provider_get_hidden_providers(gstDeviceProvider);
241 
242 		scope(exit) Str.freeStringArray(retStr);
243 		return Str.toStringArray(retStr);
244 	}
245 
246 	/**
247 	 * Get metadata with @key in @provider.
248 	 *
249 	 * Params:
250 	 *     key = the key to get
251 	 *
252 	 * Returns: the metadata for @key.
253 	 *
254 	 * Since: 1.14
255 	 */
256 	public string getMetadata(string key)
257 	{
258 		return Str.toString(gst_device_provider_get_metadata(gstDeviceProvider, Str.toStringz(key)));
259 	}
260 
261 	/**
262 	 * Make @provider hide the devices from the factory with @name.
263 	 *
264 	 * This function is used when @provider will also provide the devices reported
265 	 * by provider factory @name. A monitor should stop monitoring the
266 	 * device provider with @name to avoid duplicate devices.
267 	 *
268 	 * Params:
269 	 *     name = a provider factory name
270 	 *
271 	 * Since: 1.6
272 	 */
273 	public void hideProvider(string name)
274 	{
275 		gst_device_provider_hide_provider(gstDeviceProvider, Str.toStringz(name));
276 	}
277 
278 	/**
279 	 * Starts providering the devices. This will cause #GST_MESSAGE_DEVICE_ADDED
280 	 * and #GST_MESSAGE_DEVICE_REMOVED messages to be posted on the provider's bus
281 	 * when devices are added or removed from the system.
282 	 *
283 	 * Since the #GstDeviceProvider is a singleton,
284 	 * gst_device_provider_start() may already have been called by another
285 	 * user of the object, gst_device_provider_stop() needs to be called the same
286 	 * number of times.
287 	 *
288 	 * Returns: %TRUE if the device providering could be started
289 	 *
290 	 * Since: 1.4
291 	 */
292 	public bool start()
293 	{
294 		return gst_device_provider_start(gstDeviceProvider) != 0;
295 	}
296 
297 	/**
298 	 * Decreases the use-count by one. If the use count reaches zero, this
299 	 * #GstDeviceProvider will stop providering the devices. This needs to be
300 	 * called the same number of times that gst_device_provider_start() was called.
301 	 *
302 	 * Since: 1.4
303 	 */
304 	public void stop()
305 	{
306 		gst_device_provider_stop(gstDeviceProvider);
307 	}
308 
309 	/**
310 	 * Make @provider unhide the devices from factory @name.
311 	 *
312 	 * This function is used when @provider will no longer provide the devices
313 	 * reported by provider factory @name. A monitor should start
314 	 * monitoring the devices from provider factory @name in order to see
315 	 * all devices again.
316 	 *
317 	 * Params:
318 	 *     name = a provider factory name
319 	 *
320 	 * Since: 1.6
321 	 */
322 	public void unhideProvider(string name)
323 	{
324 		gst_device_provider_unhide_provider(gstDeviceProvider, Str.toStringz(name));
325 	}
326 
327 	/** */
328 	gulong addOnProviderHidden(void delegate(string, DeviceProvider) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
329 	{
330 		return Signals.connect(this, "provider-hidden", dlg, connectFlags ^ ConnectFlags.SWAPPED);
331 	}
332 
333 	/** */
334 	gulong addOnProviderUnhidden(void delegate(string, DeviceProvider) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
335 	{
336 		return Signals.connect(this, "provider-unhidden", dlg, connectFlags ^ ConnectFlags.SWAPPED);
337 	}
338 }