gtkD/srcgstreamer/gstreamer/IndexFactory.d

   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 as published by
   6  * the Free Software Foundation; either version 2.1 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * gtkD is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public License
  15  * along with gtkD; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 // generated automatically - do not change
  20 // find conversion definition on APILookup.txt
  21 // implement new conversion functionalities on the wrap.utils pakage
  22
  23 /*
  24  * Conversion parameters:
  25  * inFile  = GstIndexFactory.html
  26  * outPack = gstreamer
  27  * outFile = IndexFactory
  28  * strct   = GstIndexFactory
  29  * realStrct=
  30  * ctorStrct=
  31  * clss    = IndexFactory
  32  * interf  =
  33  * class Code: No
  34  * interface Code: No
  35  * template for:
  36  * extend  =
  37  * implements:
  38  * prefixes:
  39  *      - gst_index_factory_
  40  *      - gst_
  41  * omit structs:
  42  * omit prefixes:
  43  * omit code:
  44  * imports:
  45  *      - glib.Str
  46  *      - gstreamer.Index
  47  * structWrap:
  48  *      - GstIndex* -> Index
  49  *      - GstIndexFactory* -> IndexFactory
  50  * module aliases:
  51  * local aliases:
  52  */
  53
  54 module gstreamer.IndexFactory;
  55
  56 private import gstreamerc.gstreamertypes;
  57
  58 private import gstreamerc.gstreamer;
  59
  60 private import glib.Str;
  61 private import gstreamer.Index;
  62
  63
  64
  65 /**
  66  * Description
  67  * GstIndexFactory is used to dynamically create GstIndex implementations.
  68  */
  69 private import gstreamer.PluginFeature;
  70 public class IndexFactory : PluginFeature
  71 {
  72
  73         /** the main Gtk struct */
  74         protected GstIndexFactory* gstIndexFactory;
  75
  76
  77         public GstIndexFactory* getIndexFactoryStruct()
  78         {
  79                 return gstIndexFactory;
  80         }
  81
  82
  83         /** the main Gtk struct as a void* */
  84         protected void* getStruct()
  85         {
  86                 return cast(void*)gstIndexFactory;
  87         }
  88
  89         /**
  90          * Sets our main struct and passes it to the parent class
  91          */
  92         public this (GstIndexFactory* gstIndexFactory)
  93         {
  94                 super(cast(GstPluginFeature*)gstIndexFactory);
  95                 this.gstIndexFactory = gstIndexFactory;
  96         }
  97
  98         /**
  99          */
 100
 101
 102         /**
 103          * Create a new indexfactory with the given parameters
 104          * name:
 105          *  name of indexfactory to create
 106          * longdesc:
 107          *  long description of indexfactory to create
 108          * type:
 109          *  the GType of the GstIndex element of this factory
 110          * Returns:
 111          *  a new GstIndexFactory.
 112          */
 113         public this (char[] name, char[] longdesc, GType type)
 114         {
 115                 // GstIndexFactory* gst_index_factory_new (const gchar *name,  const gchar *longdesc,  GType type);
 116                 this(cast(GstIndexFactory*)gst_index_factory_new(Str.toStringz(name), Str.toStringz(longdesc), type) );
 117         }
 118
 119         /**
 120          * Removes the index from the global list.
 121          * factory:
 122          *  factory to destroy
 123          */
 124         public void destroy()
 125         {
 126                 // void gst_index_factory_destroy (GstIndexFactory *factory);
 127                 gst_index_factory_destroy(gstIndexFactory);
 128         }
 129
 130         /**
 131          * Search for an indexfactory of the given name.
 132          * name:
 133          *  name of indexfactory to find
 134          * Returns:
 135          *  GstIndexFactory if found, NULL otherwise
 136          */
 137         public static IndexFactory find(char[] name)
 138         {
 139                 // GstIndexFactory* gst_index_factory_find (const gchar *name);
 140                 return new IndexFactory( gst_index_factory_find(Str.toStringz(name)) );
 141         }
 142
 143         /**
 144          * Create a new GstIndex instance from the
 145          * given indexfactory.
 146          * factory:
 147          *  the factory used to create the instance
 148          * Returns:
 149          *  A new GstIndex instance.
 150          */
 151         public Index create()
 152         {
 153                 // GstIndex* gst_index_factory_create (GstIndexFactory *factory);
 154                 return new Index( gst_index_factory_create(gstIndexFactory) );
 155         }
 156
 157         /**
 158          * Create a new GstIndex instance from the
 159          * indexfactory with the given name.
 160          * name:
 161          *  the name of the factory used to create the instance
 162          * Returns:
 163          *  A new GstIndex instance.
 164          * See Also
 165          * GstIndex
 166          */
 167         public static Index make(char[] name)
 168         {
 169                 // GstIndex* gst_index_factory_make (const gchar *name);
 170                 return new Index( gst_index_factory_make(Str.toStringz(name)) );
 171         }
 172 }