gtkD/src/gtk/Types.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  = gtk-Types.html
  26  * outPack = gtk
  27  * outFile = Types
  28  * strct   = GtkType
  29  * realStrct=
  30  * ctorStrct=
  31  * clss    = Types
  32  * interf  =
  33  * class Code: No
  34  * interface Code: No
  35  * template for:
  36  * extend  =
  37  * implements:
  38  * prefixes:
  39  *      - gtk_type_
  40  *      - gtk_
  41  * omit structs:
  42  * omit prefixes:
  43  * omit code:
  44  * imports:
  45  *      - glib.Str
  46  * structWrap:
  47  * module aliases:
  48  * local aliases:
  49  */
  50
  51 module gtk.Types;
  52
  53 version(noAssert)
  54 {
  55         version(Tango)
  56         {
  57                 import tango.io.Stdout; // use the tango loging?
  58         }
  59 }
  60
  61 private import gtkc.gtktypes;
  62
  63 private import gtkc.gtk;
  64
  65
  66 private import glib.Str;
  67
  68
  69
  70
  71 /**
  72  * Description
  73  * The GTK+ type system is extensible. Because of that, types have to be
  74  * managed at runtime.
  75  */
  76 public class Types
  77 {
  78
  79         /** the main Gtk struct */
  80         protected GtkType* gtkType;
  81
  82
  83         public GtkType* getTypesStruct()
  84         {
  85                 return gtkType;
  86         }
  87
  88
  89         /** the main Gtk struct as a void* */
  90         protected void* getStruct()
  91         {
  92                 return cast(void*)gtkType;
  93         }
  94
  95         /**
  96          * Sets our main struct and passes it to the parent class
  97          */
  98         public this (GtkType* gtkType)
  99         {
 100                 version(noAssert)
 101                 {
 102                         if ( gtkType is null )
 103                         {
 104                                 int zero = 0;
 105                                 version(Tango)
 106                                 {
 107                                         Stdout("struct gtkType is null on constructor").newline;
 108                                 }
 109                                 else
 110                                 {
 111                                         printf("struct gtkType is null on constructor");
 112                                 }
 113                                 zero = zero / zero;
 114                         }
 115                 }
 116                 else
 117                 {
 118                         assert(gtkType !is null, "struct gtkType is null on constructor");
 119                 }
 120                 this.gtkType = gtkType;
 121         }
 122
 123         /**
 124          */
 125
 126
 127
 128
 129
 130
 131
 132
 133
 134
 135
 136
 137
 138
 139
 140
 141
 142
 143
 144
 145
 146
 147
 148
 149
 150
 151
 152
 153
 154
 155
 156
 157
 158
 159
 160
 161
 162
 163
 164
 165
 166
 167
 168
 169
 170
 171
 172
 173
 174
 175
 176
 177
 178
 179
 180
 181
 182
 183
 184
 185         /**
 186          * Warning
 187          * gtk_type_init is deprecated and should not be used in newly-written code.
 188          * Initializes the data structures associated with GTK+ types.
 189          * debug_flags:
 190          */
 191         public static void init(GTypeDebugFlags debugFlags)
 192         {
 193                 // void gtk_type_init (GTypeDebugFlags debug_flags);
 194                 gtk_type_init(debugFlags);
 195         }
 196
 197         /**
 198          * Warning
 199          * gtk_type_unique is deprecated and should not be used in newly-written code.
 200          * Creates a new, unique type.
 201          * parent_type:
 202          * if zero, a fundamental type is created.
 203          * gtkinfo:
 204          * Returns:
 205          * the new GtkType.
 206          */
 207         public static GtkType unique(GtkType parentType, GtkTypeInfo* gtkinfo)
 208         {
 209                 // GtkType gtk_type_unique (GtkType parent_type,  const GtkTypeInfo *gtkinfo);
 210                 return gtk_type_unique(parentType, gtkinfo);
 211         }
 212
 213
 214
 215
 216         /**
 217          * Returns a pointer pointing to the class of type or NULL if there was
 218          * any trouble identifying type. Initializes the class if necessary.
 219          * type:
 220          * a GtkType.
 221          * Returns:
 222          * pointer to the class.
 223          */
 224         public static void* clss(GtkType type)
 225         {
 226                 // gpointer gtk_type_class (GtkType type);
 227                 return gtk_type_class(type);
 228         }
 229
 230         /**
 231          * Warning
 232          * gtk_type_new is deprecated and should not be used in newly-written code.
 233          * Creates a new object of a given type, and return a pointer to it.
 234          * Returns NULL if you give it an invalid type. It allocates the object
 235          * out of the type's memory chunk if there is a memory chunk. The object
 236          * has all the proper initializers called.
 237          * type:
 238          * a GtkType.
 239          * Returns:
 240          * pointer to a GtkTypeObject.
 241          */
 242         public static void* newTypes(GtkType type)
 243         {
 244                 // gpointer gtk_type_new (GtkType type);
 245                 return gtk_type_new(type);
 246         }
 247
 248
 249         /**
 250          * Warning
 251          * gtk_type_enum_get_values is deprecated and should not be used in newly-written code.
 252          * If enum_type has values, then return a pointer to all of them.
 253          * enum_type:
 254          * a GtkType.
 255          * Returns:
 256          * GtkEnumValue*
 257          */
 258         public static GtkEnumValue* enumGetValues(GtkType enumType)
 259         {
 260                 // GtkEnumValue* gtk_type_enum_get_values (GtkType enum_type);
 261                 return gtk_type_enum_get_values(enumType);
 262         }
 263
 264         /**
 265          * Warning
 266          * gtk_type_flags_get_values is deprecated and should not be used in newly-written code.
 267          * If flags_type has values, then return a pointer to all of them.
 268          * flags_type:
 269          * a GtkType.
 270          * Returns:
 271          * GtkFlagValue*
 272          */
 273         public static GtkFlagValue* flagsGetValues(GtkType flagsType)
 274         {
 275                 // GtkFlagValue* gtk_type_flags_get_values (GtkType flags_type);
 276                 return gtk_type_flags_get_values(flagsType);
 277         }
 278
 279         /**
 280          * Warning
 281          * gtk_type_enum_find_value is deprecated and should not be used in newly-written code.
 282          * Returns a pointer to one of enum_type's GtkEnumValues's whose name (or nickname) matches value_name.
 283          * enum_type:
 284          * a GtkType.
 285          * value_name:
 286          * the name to look for.
 287          * Returns:
 288          * GtkEnumValue*
 289          */
 290         public static GtkEnumValue* enumFindValue(GtkType enumType, char[] valueName)
 291         {
 292                 // GtkEnumValue* gtk_type_enum_find_value (GtkType enum_type,  const gchar *value_name);
 293                 return gtk_type_enum_find_value(enumType, Str.toStringz(valueName));
 294         }
 295
 296         /**
 297          * Warning
 298          * gtk_type_flags_find_value is deprecated and should not be used in newly-written code.
 299          * Returns a pointer to one of flag_type's GtkFlagValue's whose name (or nickname) matches value_name.
 300          * flags_type:
 301          * a GtkType.
 302          * value_name:
 303          * the name to look for.
 304          * Returns:
 305          * GtkFlagValue*
 306          */
 307         public static GtkFlagValue* flagsFindValue(GtkType flagsType, char[] valueName)
 308         {
 309                 // GtkFlagValue* gtk_type_flags_find_value (GtkType flags_type,  const gchar *value_name);
 310                 return gtk_type_flags_find_value(flagsType, Str.toStringz(valueName));
 311         }
 312 }