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.DeviceProviderFactory; 26 27 private import glib.ListG; 28 private import glib.Str; 29 private import gobject.ObjectG; 30 private import gstreamer.DeviceProvider; 31 private import gstreamer.PluginFeature; 32 private import gstreamer.c.functions; 33 public import gstreamer.c.types; 34 public import gstreamerc.gstreamertypes; 35 36 37 /** 38 * #GstDeviceProviderFactory is used to create instances of device providers. A 39 * GstDeviceProviderfactory can be added to a #GstPlugin as it is also a 40 * #GstPluginFeature. 41 * 42 * Use the gst_device_provider_factory_find() and 43 * gst_device_provider_factory_get() functions to create device 44 * provider instances or use gst_device_provider_factory_get_by_name() as a 45 * convenient shortcut. 46 * 47 * Since: 1.4 48 */ 49 public class DeviceProviderFactory : PluginFeature 50 { 51 /** the main Gtk struct */ 52 protected GstDeviceProviderFactory* gstDeviceProviderFactory; 53 54 /** Get the main Gtk struct */ 55 public GstDeviceProviderFactory* getDeviceProviderFactoryStruct(bool transferOwnership = false) 56 { 57 if (transferOwnership) 58 ownedRef = false; 59 return gstDeviceProviderFactory; 60 } 61 62 /** the main Gtk struct as a void* */ 63 protected override void* getStruct() 64 { 65 return cast(void*)gstDeviceProviderFactory; 66 } 67 68 /** 69 * Sets our main struct and passes it to the parent class. 70 */ 71 public this (GstDeviceProviderFactory* gstDeviceProviderFactory, bool ownedRef = false) 72 { 73 this.gstDeviceProviderFactory = gstDeviceProviderFactory; 74 super(cast(GstPluginFeature*)gstDeviceProviderFactory, ownedRef); 75 } 76 77 78 /** */ 79 public static GType getType() 80 { 81 return gst_device_provider_factory_get_type(); 82 } 83 84 /** 85 * Search for an device provider factory of the given name. Refs the returned 86 * device provider factory; caller is responsible for unreffing. 87 * 88 * Params: 89 * name = name of factory to find 90 * 91 * Returns: #GstDeviceProviderFactory if 92 * found, %NULL otherwise 93 * 94 * Since: 1.4 95 */ 96 public static DeviceProviderFactory find(string name) 97 { 98 auto p = gst_device_provider_factory_find(Str.toStringz(name)); 99 100 if(p is null) 101 { 102 return null; 103 } 104 105 return ObjectG.getDObject!(DeviceProviderFactory)(cast(GstDeviceProviderFactory*) p, true); 106 } 107 108 /** 109 * Returns the device provider of the type defined by the given device 110 * provider factory. 111 * 112 * Params: 113 * factoryname = a named factory to instantiate 114 * 115 * Returns: a #GstDeviceProvider or %NULL 116 * if unable to create device provider 117 * 118 * Since: 1.4 119 */ 120 public static DeviceProvider getByName(string factoryname) 121 { 122 auto p = gst_device_provider_factory_get_by_name(Str.toStringz(factoryname)); 123 124 if(p is null) 125 { 126 return null; 127 } 128 129 return ObjectG.getDObject!(DeviceProvider)(cast(GstDeviceProvider*) p, true); 130 } 131 132 /** 133 * Get a list of factories with a rank greater or equal to @minrank. 134 * The list of factories is returned by decreasing rank. 135 * 136 * Params: 137 * minrank = Minimum rank 138 * 139 * Returns: a #GList of #GstDeviceProviderFactory device providers. Use 140 * gst_plugin_feature_list_free() after usage. 141 * 142 * Since: 1.4 143 */ 144 public static ListG listGetDeviceProviders(GstRank minrank) 145 { 146 auto p = gst_device_provider_factory_list_get_device_providers(minrank); 147 148 if(p is null) 149 { 150 return null; 151 } 152 153 return new ListG(cast(GList*) p, true); 154 } 155 156 /** 157 * Returns the device provider of the type defined by the given device 158 * providerfactory. 159 * 160 * Returns: the #GstDeviceProvider or %NULL 161 * if the device provider couldn't be created 162 * 163 * Since: 1.4 164 */ 165 public DeviceProvider get() 166 { 167 auto p = gst_device_provider_factory_get(gstDeviceProviderFactory); 168 169 if(p is null) 170 { 171 return null; 172 } 173 174 return ObjectG.getDObject!(DeviceProvider)(cast(GstDeviceProvider*) p, true); 175 } 176 177 /** 178 * Get the #GType for device providers managed by this factory. The type can 179 * only be retrieved if the device provider factory is loaded, which can be 180 * assured with gst_plugin_feature_load(). 181 * 182 * Returns: the #GType for device providers managed by this factory. 183 * 184 * Since: 1.4 185 */ 186 public GType getDeviceProviderType() 187 { 188 return gst_device_provider_factory_get_device_provider_type(gstDeviceProviderFactory); 189 } 190 191 /** 192 * Get the metadata on @factory with @key. 193 * 194 * Params: 195 * key = a key 196 * 197 * Returns: the metadata with @key on @factory or %NULL 198 * when there was no metadata with the given @key. 199 * 200 * Since: 1.4 201 */ 202 public string getMetadata(string key) 203 { 204 return Str.toString(gst_device_provider_factory_get_metadata(gstDeviceProviderFactory, Str.toStringz(key))); 205 } 206 207 /** 208 * Get the available keys for the metadata on @factory. 209 * 210 * Returns: a %NULL-terminated array of key strings, or %NULL when there is no 211 * metadata. Free with g_strfreev() when no longer needed. 212 * 213 * Since: 1.4 214 */ 215 public string[] getMetadataKeys() 216 { 217 auto retStr = gst_device_provider_factory_get_metadata_keys(gstDeviceProviderFactory); 218 219 scope(exit) Str.freeStringArray(retStr); 220 return Str.toStringArray(retStr); 221 } 222 223 /** 224 * Check if @factory matches all of the given @classes 225 * 226 * Params: 227 * classes = a "/" separate list of classes to match, only match 228 * if all classes are matched 229 * 230 * Returns: %TRUE if @factory matches or if @classes is %NULL. 231 * 232 * Since: 1.4 233 */ 234 public bool hasClasses(string classes) 235 { 236 return gst_device_provider_factory_has_classes(gstDeviceProviderFactory, Str.toStringz(classes)) != 0; 237 } 238 239 /** 240 * Check if @factory matches all of the given classes 241 * 242 * Params: 243 * classes = a %NULL terminated array 244 * of classes to match, only match if all classes are matched 245 * 246 * Returns: %TRUE if @factory matches. 247 * 248 * Since: 1.4 249 */ 250 public bool hasClassesv(string[] classes) 251 { 252 return gst_device_provider_factory_has_classesv(gstDeviceProviderFactory, Str.toStringzArray(classes)) != 0; 253 } 254 }