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 * Conversion parameters: 26 * inFile = 27 * outPack = gtk 28 * outFile = TreeModel 29 * strct = 30 * realStrct= 31 * ctorStrct= 32 * clss = 33 * interf = 34 * class Code: Yes 35 * interface Code: No 36 * template for: 37 * extend = 38 * implements: 39 * prefixes: 40 * omit structs: 41 * omit prefixes: 42 * omit code: 43 * omit signals: 44 * imports: 45 * - glib.Str 46 * - gobject.Type 47 * - gobject.ObjectG 48 * - gobject.Signals 49 * - gobject.Value 50 * - gtk.TreeIter 51 * - gtk.TreePath 52 * - gtk.TreeModelT 53 * - gtk.TreeModelIF 54 * - gtkc.gobject 55 * - gtkc.Loader 56 * - gtkc.paths 57 * structWrap: 58 * module aliases: 59 * local aliases: 60 * overrides: 61 */ 62 63 module gtk.TreeModel; 64 65 public import gtkc.gtktypes; 66 67 private import gtkc.gtk; 68 private import glib.ConstructionException; 69 private import gobject.ObjectG; 70 71 private import glib.Str; 72 private import gobject.Type; 73 private import gobject.ObjectG; 74 private import gobject.Signals; 75 private import gobject.Value; 76 private import gtk.TreeIter; 77 private import gtk.TreePath; 78 private import gtk.TreeModelT; 79 private import gtk.TreeModelIF; 80 private import gtkc.gobject; 81 private import gtkc.Loader; 82 private import gtkc.paths; 83 84 85 86 struct CustomTreeModelClass 87 { 88 GObjectClass parentClass; 89 } 90 91 //We need this function for the interface implementation. 92 extern(C) GType function() c_gtk_tree_model_get_type; 93 alias c_gtk_tree_model_get_type gtk_tree_model_get_type; 94 95 /** 96 */ 97 public class TreeModel : ObjectG, TreeModelIF 98 { 99 static GObjectClass* parentClass = null; 100 101 shared static this() 102 { 103 Linker.link(gtk_tree_model_get_type, "gtk_tree_model_get_type", LIBRARY.GTK); 104 } 105 106 // Minimal implementation. 107 mixin TreeModelT!(GtkTreeModel); 108 109 /** the main Gtk struct as a void* */ 110 protected override void* getStruct() 111 { 112 return cast(void*)gtkTreeModel; 113 } 114 115 public this () 116 { 117 auto p = super(customTreeModelgetType(), null); 118 gtkTreeModel = cast(GtkTreeModel*) p.getObjectGStruct(); 119 120 setDataFull("customTreeModel", cast(void*)this, cast(GDestroyNotify)&destroyNotify); 121 } 122 123 /** 124 * Sets our main struct and passes it to the parent class 125 */ 126 public this (GtkTreeModel* gtkTreeModel) 127 { 128 super(cast(GObject*)gtkTreeModel); 129 this.gtkTreeModel = gtkTreeModel; 130 } 131 132 133 extern(C) 134 { 135 /* 136 * here we register our new type and its interfaces 137 * with the type system. If you want to implement 138 * additional interfaces like GtkTreeSortable, you 139 * will need to do it here. 140 */ 141 142 static GType customTreeModelgetType() 143 { 144 GType customTreeModelType = Type.fromName("CustomTreeModel"); 145 146 /* Some boilerplate type registration stuff */ 147 if (customTreeModelType == GType.INVALID) 148 { 149 GTypeInfo customTreeModelInfo = 150 { 151 CustomTreeModelClass.sizeof, /* class size */ 152 null, /* base_init */ 153 null, /* base_finalize */ 154 cast(GClassInitFunc) &customTreeModelClassInit,/* class init function */ 155 null, /* class finalize */ 156 null, /* class_data */ 157 GObject.sizeof, /* instance size */ 158 0, /* n_preallocs */ 159 //cast(GInstanceInitFunc) &customTreeModelInit /* instance init */ 160 null 161 }; 162 GInterfaceInfo treeModelInfo = 163 { 164 cast(GInterfaceInitFunc) &customTreeModelInit, 165 null, 166 null 167 }; 168 169 /* First register the new derived type with the GObject type system */ 170 customTreeModelType = Type.registerStatic (GType.OBJECT, "CustomTreeModel", 171 &customTreeModelInfo, cast(GTypeFlags)0); 172 173 /* Now register our GtkTreeModel interface with the type system */ 174 Type.addInterfaceStatic (customTreeModelType, gtk_tree_model_get_type() /*GTK_TYPE_TREE_MODEL*/, &treeModelInfo); 175 } 176 177 return customTreeModelType; 178 } 179 180 /* 181 * boilerplate GObject/GType stuff. 182 * Init callback for the type system, 183 * called once when our new class is created. 184 */ 185 186 static void customTreeModelClassInit (void* klass) 187 { 188 GObjectClass* objectClass; 189 190 parentClass = cast(GObjectClass*) Type.classPeekParent(klass); 191 objectClass = cast(GObjectClass*) klass; 192 193 objectClass.finalize = &customTreeModelFinalize; 194 } 195 196 /* 197 * init callback for the interface registration 198 * in customTreeModelGetType. Here we override 199 * the GtkTreeModel interface functions that 200 * we implement. 201 */ 202 203 static void customTreeModelInit (GtkTreeModelIface *iface) 204 { 205 iface.getFlags = &customTreeModelGetFlags; 206 iface.getNColumns = &customTreeModelGetNColumns; 207 iface.getColumnType = &customTreeModelGetColumnType; 208 iface.getIter = &customTreeModelGetIter; 209 iface.getPath = &customTreeModelGetPath; 210 iface.getValue = &customTreeModelGetValue; 211 iface.iterNext = &customTreeModelIterNext; 212 iface.iterChildren = &customTreeModelIterChildren; 213 iface.iterHasChild = &customTreeModelIterHasChild; 214 iface.iterNChildren = &customTreeModelIterNChildren; 215 iface.iterNthChild = &customTreeModelIterNthChild; 216 iface.iterParent = &customTreeModelIterParent; 217 } 218 219 /* 220 * this is called just before a custom list is 221 * destroyed. Free dynamically allocated memory here. 222 */ 223 224 static void customTreeModelFinalize (GObject *object) 225 { 226 /* must chain up - finalize parent */ 227 parentClass.finalize(object); 228 } 229 230 static GtkTreeModelFlags customTreeModelGetFlags(GtkTreeModel *tree_model) 231 { 232 auto tm = ObjectG.getDObject!(TreeModel)(tree_model); 233 234 return tm.getFlags(); 235 } 236 237 static int customTreeModelGetNColumns(GtkTreeModel *tree_model) 238 { 239 auto tm = ObjectG.getDObject!(TreeModel)(tree_model); 240 241 return tm.getNColumns(); 242 } 243 244 static GType customTreeModelGetColumnType(GtkTreeModel *tree_model, int index) 245 { 246 auto tm = ObjectG.getDObject!(TreeModel)(tree_model); 247 248 return tm.getColumnType(index); 249 } 250 251 static gboolean customTreeModelGetIter(GtkTreeModel *tree_model, GtkTreeIter *iter, GtkTreePath *path) 252 { 253 auto tm = ObjectG.getDObject!(TreeModel)(tree_model); 254 255 return tm.getIter(ObjectG.getDObject!(TreeIter)(iter), ObjectG.getDObject!(TreePath)(gtk_tree_path_copy(path))); 256 } 257 258 static GtkTreePath* customTreeModelGetPath(GtkTreeModel *tree_model, GtkTreeIter *iter) 259 { 260 auto tm = ObjectG.getDObject!(TreeModel)(tree_model); 261 TreePath path = tm.getPath(ObjectG.getDObject!(TreeIter)(iter)); 262 263 return (path is null) ? null : gtk_tree_path_copy(path.getTreePathStruct()); 264 } 265 266 static void customTreeModelGetValue(GtkTreeModel *tree_model, GtkTreeIter *iter, int column, GValue *value) 267 { 268 auto tm = ObjectG.getDObject!(TreeModel)(tree_model); 269 270 tm.getValue(ObjectG.getDObject!(TreeIter)(iter), column, ObjectG.getDObject!(Value)(value)); 271 } 272 273 static gboolean customTreeModelIterNext(GtkTreeModel *tree_model, GtkTreeIter *iter) 274 { 275 auto tm = ObjectG.getDObject!(TreeModel)(tree_model); 276 277 return tm.iterNext(ObjectG.getDObject!(TreeIter)(iter)); 278 } 279 280 static gboolean customTreeModelIterChildren(GtkTreeModel *tree_model, GtkTreeIter *iter, GtkTreeIter *parent) 281 { 282 auto tm = ObjectG.getDObject!(TreeModel)(tree_model); 283 284 return tm.iterChildren(ObjectG.getDObject!(TreeIter)(iter), ObjectG.getDObject!(TreeIter)(parent)); 285 } 286 287 static gboolean customTreeModelIterHasChild(GtkTreeModel *tree_model, GtkTreeIter *iter) 288 { 289 auto tm = ObjectG.getDObject!(TreeModel)(tree_model); 290 291 return tm.iterHasChild(ObjectG.getDObject!(TreeIter)(iter)); 292 } 293 294 static int customTreeModelIterNChildren(GtkTreeModel *tree_model, GtkTreeIter *iter) 295 { 296 auto tm = ObjectG.getDObject!(TreeModel)(tree_model); 297 298 return tm.iterNChildren(ObjectG.getDObject!(TreeIter)(iter)); 299 } 300 301 static gboolean customTreeModelIterNthChild(GtkTreeModel *tree_model, GtkTreeIter *iter, GtkTreeIter *parent, int n) 302 { 303 auto tm = ObjectG.getDObject!(TreeModel)(tree_model); 304 305 return tm.iterNthChild(ObjectG.getDObject!(TreeIter)(iter), ObjectG.getDObject!(TreeIter)(parent), n); 306 } 307 308 static gboolean customTreeModelIterParent(GtkTreeModel *tree_model, GtkTreeIter *iter, GtkTreeIter *child) 309 { 310 auto tm = ObjectG.getDObject!(TreeModel)(tree_model); 311 312 return tm.iterParent(ObjectG.getDObject!(TreeIter)(iter), ObjectG.getDObject!(TreeIter)(child)); 313 } 314 } 315 } 316 317 /** 318 */ 319