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