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 gtk.TreeModelFilter; 26 27 private import glib.ConstructionException; 28 private import gobject.ObjectG; 29 private import gtk.TreeDragSourceIF; 30 private import gtk.TreeDragSourceT; 31 private import gtk.TreeIter; 32 private import gtk.TreeModelIF; 33 private import gtk.TreeModelT; 34 private import gtk.TreePath; 35 private import gtk.c.functions; 36 public import gtk.c.types; 37 public import gtkc.gtktypes; 38 39 40 /** 41 * A #GtkTreeModelFilter is a tree model which wraps another tree model, 42 * and can do the following things: 43 * 44 * - Filter specific rows, based on data from a “visible column”, a column 45 * storing booleans indicating whether the row should be filtered or not, 46 * or based on the return value of a “visible function”, which gets a 47 * model, iter and user_data and returns a boolean indicating whether the 48 * row should be filtered or not. 49 * 50 * - Modify the “appearance” of the model, using a modify function. 51 * This is extremely powerful and allows for just changing some 52 * values and also for creating a completely different model based 53 * on the given child model. 54 * 55 * - Set a different root node, also known as a “virtual root”. You can pass 56 * in a #GtkTreePath indicating the root node for the filter at construction 57 * time. 58 * 59 * The basic API is similar to #GtkTreeModelSort. For an example on its usage, 60 * see the section on #GtkTreeModelSort. 61 * 62 * When using #GtkTreeModelFilter, it is important to realize that 63 * #GtkTreeModelFilter maintains an internal cache of all nodes which are 64 * visible in its clients. The cache is likely to be a subtree of the tree 65 * exposed by the child model. #GtkTreeModelFilter will not cache the entire 66 * child model when unnecessary to not compromise the caching mechanism 67 * that is exposed by the reference counting scheme. If the child model 68 * implements reference counting, unnecessary signals may not be emitted 69 * because of reference counting rule 3, see the #GtkTreeModel 70 * documentation. (Note that e.g. #GtkTreeStore does not implement 71 * reference counting and will always emit all signals, even when 72 * the receiving node is not visible). 73 * 74 * Because of this, limitations for possible visible functions do apply. 75 * In general, visible functions should only use data or properties from 76 * the node for which the visibility state must be determined, its siblings 77 * or its parents. Usually, having a dependency on the state of any child 78 * node is not possible, unless references are taken on these explicitly. 79 * When no such reference exists, no signals may be received for these child 80 * nodes (see reference couting rule number 3 in the #GtkTreeModel section). 81 * 82 * Determining the visibility state of a given node based on the state 83 * of its child nodes is a frequently occurring use case. Therefore, 84 * #GtkTreeModelFilter explicitly supports this. For example, when a node 85 * does not have any children, you might not want the node to be visible. 86 * As soon as the first row is added to the node’s child level (or the 87 * last row removed), the node’s visibility should be updated. 88 * 89 * This introduces a dependency from the node on its child nodes. In order 90 * to accommodate this, #GtkTreeModelFilter must make sure the necessary 91 * signals are received from the child model. This is achieved by building, 92 * for all nodes which are exposed as visible nodes to #GtkTreeModelFilter's 93 * clients, the child level (if any) and take a reference on the first node 94 * in this level. Furthermore, for every row-inserted, row-changed or 95 * row-deleted signal (also these which were not handled because the node 96 * was not cached), #GtkTreeModelFilter will check if the visibility state 97 * of any parent node has changed. 98 * 99 * Beware, however, that this explicit support is limited to these two 100 * cases. For example, if you want a node to be visible only if two nodes 101 * in a child’s child level (2 levels deeper) are visible, you are on your 102 * own. In this case, either rely on #GtkTreeStore to emit all signals 103 * because it does not implement reference counting, or for models that 104 * do implement reference counting, obtain references on these child levels 105 * yourself. 106 */ 107 public class TreeModelFilter : ObjectG, TreeDragSourceIF, TreeModelIF 108 { 109 /** the main Gtk struct */ 110 protected GtkTreeModelFilter* gtkTreeModelFilter; 111 112 /** Get the main Gtk struct */ 113 public GtkTreeModelFilter* getTreeModelFilterStruct(bool transferOwnership = false) 114 { 115 if (transferOwnership) 116 ownedRef = false; 117 return gtkTreeModelFilter; 118 } 119 120 /** the main Gtk struct as a void* */ 121 protected override void* getStruct() 122 { 123 return cast(void*)gtkTreeModelFilter; 124 } 125 126 /** 127 * Sets our main struct and passes it to the parent class. 128 */ 129 public this (GtkTreeModelFilter* gtkTreeModelFilter, bool ownedRef = false) 130 { 131 this.gtkTreeModelFilter = gtkTreeModelFilter; 132 super(cast(GObject*)gtkTreeModelFilter, ownedRef); 133 } 134 135 // add the TreeDragSource capabilities 136 mixin TreeDragSourceT!(GtkTreeModelFilter); 137 138 // add the TreeModel capabilities 139 mixin TreeModelT!(GtkTreeModelFilter); 140 141 142 /** */ 143 public static GType getType() 144 { 145 return gtk_tree_model_filter_get_type(); 146 } 147 148 /** 149 * This function should almost never be called. It clears the @filter 150 * of any cached iterators that haven’t been reffed with 151 * gtk_tree_model_ref_node(). This might be useful if the child model 152 * being filtered is static (and doesn’t change often) and there has been 153 * a lot of unreffed access to nodes. As a side effect of this function, 154 * all unreffed iters will be invalid. 155 * 156 * Since: 2.4 157 */ 158 public void clearCache() 159 { 160 gtk_tree_model_filter_clear_cache(gtkTreeModelFilter); 161 } 162 163 /** 164 * Sets @filter_iter to point to the row in @filter that corresponds to the 165 * row pointed at by @child_iter. If @filter_iter was not set, %FALSE is 166 * returned. 167 * 168 * Params: 169 * filterIter = An uninitialized #GtkTreeIter. 170 * childIter = A valid #GtkTreeIter pointing to a row on the child model. 171 * 172 * Returns: %TRUE, if @filter_iter was set, i.e. if @child_iter is a 173 * valid iterator pointing to a visible row in child model. 174 * 175 * Since: 2.4 176 */ 177 public bool convertChildIterToIter(out TreeIter filterIter, TreeIter childIter) 178 { 179 GtkTreeIter* outfilterIter = gMalloc!GtkTreeIter(); 180 181 auto p = gtk_tree_model_filter_convert_child_iter_to_iter(gtkTreeModelFilter, outfilterIter, (childIter is null) ? null : childIter.getTreeIterStruct()) != 0; 182 183 filterIter = ObjectG.getDObject!(TreeIter)(outfilterIter, true); 184 185 return p; 186 } 187 188 /** 189 * Converts @child_path to a path relative to @filter. That is, @child_path 190 * points to a path in the child model. The rerturned path will point to the 191 * same row in the filtered model. If @child_path isn’t a valid path on the 192 * child model or points to a row which is not visible in @filter, then %NULL 193 * is returned. 194 * 195 * Params: 196 * childPath = A #GtkTreePath to convert. 197 * 198 * Returns: A newly allocated #GtkTreePath, or %NULL. 199 * 200 * Since: 2.4 201 */ 202 public TreePath convertChildPathToPath(TreePath childPath) 203 { 204 auto p = gtk_tree_model_filter_convert_child_path_to_path(gtkTreeModelFilter, (childPath is null) ? null : childPath.getTreePathStruct()); 205 206 if(p is null) 207 { 208 return null; 209 } 210 211 return ObjectG.getDObject!(TreePath)(cast(GtkTreePath*) p, true); 212 } 213 214 /** 215 * Sets @child_iter to point to the row pointed to by @filter_iter. 216 * 217 * Params: 218 * childIter = An uninitialized #GtkTreeIter. 219 * filterIter = A valid #GtkTreeIter pointing to a row on @filter. 220 * 221 * Since: 2.4 222 */ 223 public void convertIterToChildIter(out TreeIter childIter, TreeIter filterIter) 224 { 225 GtkTreeIter* outchildIter = gMalloc!GtkTreeIter(); 226 227 gtk_tree_model_filter_convert_iter_to_child_iter(gtkTreeModelFilter, outchildIter, (filterIter is null) ? null : filterIter.getTreeIterStruct()); 228 229 childIter = ObjectG.getDObject!(TreeIter)(outchildIter, true); 230 } 231 232 /** 233 * Converts @filter_path to a path on the child model of @filter. That is, 234 * @filter_path points to a location in @filter. The returned path will 235 * point to the same location in the model not being filtered. If @filter_path 236 * does not point to a location in the child model, %NULL is returned. 237 * 238 * Params: 239 * filterPath = A #GtkTreePath to convert. 240 * 241 * Returns: A newly allocated #GtkTreePath, or %NULL. 242 * 243 * Since: 2.4 244 */ 245 public TreePath convertPathToChildPath(TreePath filterPath) 246 { 247 auto p = gtk_tree_model_filter_convert_path_to_child_path(gtkTreeModelFilter, (filterPath is null) ? null : filterPath.getTreePathStruct()); 248 249 if(p is null) 250 { 251 return null; 252 } 253 254 return ObjectG.getDObject!(TreePath)(cast(GtkTreePath*) p, true); 255 } 256 257 /** 258 * Returns a pointer to the child model of @filter. 259 * 260 * Returns: A pointer to a #GtkTreeModel. 261 * 262 * Since: 2.4 263 */ 264 public TreeModelIF getModel() 265 { 266 auto p = gtk_tree_model_filter_get_model(gtkTreeModelFilter); 267 268 if(p is null) 269 { 270 return null; 271 } 272 273 return ObjectG.getDObject!(TreeModelIF)(cast(GtkTreeModel*) p); 274 } 275 276 /** 277 * Emits ::row_changed for each row in the child model, which causes 278 * the filter to re-evaluate whether a row is visible or not. 279 * 280 * Since: 2.4 281 */ 282 public void refilter() 283 { 284 gtk_tree_model_filter_refilter(gtkTreeModelFilter); 285 } 286 287 /** 288 * With the @n_columns and @types parameters, you give an array of column 289 * types for this model (which will be exposed to the parent model/view). 290 * The @func, @data and @destroy parameters are for specifying the modify 291 * function. The modify function will get called for each 292 * data access, the goal of the modify function is to return the data which 293 * should be displayed at the location specified using the parameters of the 294 * modify function. 295 * 296 * Note that gtk_tree_model_filter_set_modify_func() 297 * can only be called once for a given filter model. 298 * 299 * Params: 300 * types = The #GTypes of the columns. 301 * func = A #GtkTreeModelFilterModifyFunc 302 * data = User data to pass to the modify function, or %NULL. 303 * destroy = Destroy notifier of @data, or %NULL. 304 * 305 * Since: 2.4 306 */ 307 public void setModifyFunc(GType[] types, GtkTreeModelFilterModifyFunc func, void* data, GDestroyNotify destroy) 308 { 309 gtk_tree_model_filter_set_modify_func(gtkTreeModelFilter, cast(int)types.length, types.ptr, func, data, destroy); 310 } 311 312 /** 313 * Sets @column of the child_model to be the column where @filter should 314 * look for visibility information. @columns should be a column of type 315 * %G_TYPE_BOOLEAN, where %TRUE means that a row is visible, and %FALSE 316 * if not. 317 * 318 * Note that gtk_tree_model_filter_set_visible_func() or 319 * gtk_tree_model_filter_set_visible_column() can only be called 320 * once for a given filter model. 321 * 322 * Params: 323 * column = A #gint which is the column containing the visible information 324 * 325 * Since: 2.4 326 */ 327 public void setVisibleColumn(int column) 328 { 329 gtk_tree_model_filter_set_visible_column(gtkTreeModelFilter, column); 330 } 331 332 /** 333 * Sets the visible function used when filtering the @filter to be @func. 334 * The function should return %TRUE if the given row should be visible and 335 * %FALSE otherwise. 336 * 337 * If the condition calculated by the function changes over time (e.g. 338 * because it depends on some global parameters), you must call 339 * gtk_tree_model_filter_refilter() to keep the visibility information 340 * of the model up-to-date. 341 * 342 * Note that @func is called whenever a row is inserted, when it may still 343 * be empty. The visible function should therefore take special care of empty 344 * rows, like in the example below. 345 * 346 * |[<!-- language="C" --> 347 * static gboolean 348 * visible_func (GtkTreeModel *model, 349 * GtkTreeIter *iter, 350 * gpointer data) 351 * { 352 * // Visible if row is non-empty and first column is “HI” 353 * gchar *str; 354 * gboolean visible = FALSE; 355 * 356 * gtk_tree_model_get (model, iter, 0, &str, -1); 357 * if (str && strcmp (str, "HI") == 0) 358 * visible = TRUE; 359 * g_free (str); 360 * 361 * return visible; 362 * } 363 * ]| 364 * 365 * Note that gtk_tree_model_filter_set_visible_func() or 366 * gtk_tree_model_filter_set_visible_column() can only be called 367 * once for a given filter model. 368 * 369 * Params: 370 * func = A #GtkTreeModelFilterVisibleFunc, the visible function 371 * data = User data to pass to the visible function, or %NULL 372 * destroy = Destroy notifier of @data, or %NULL 373 * 374 * Since: 2.4 375 */ 376 public void setVisibleFunc(GtkTreeModelFilterVisibleFunc func, void* data, GDestroyNotify destroy) 377 { 378 gtk_tree_model_filter_set_visible_func(gtkTreeModelFilter, func, data, destroy); 379 } 380 381 /** 382 * Creates a new #GtkTreeModel, with @child_model as the child_model 383 * and @root as the virtual root. 384 * 385 * Params: 386 * childModel = A #GtkTreeModel. 387 * root = A #GtkTreePath or %NULL. 388 * 389 * Returns: A new #GtkTreeModel. 390 * 391 * Since: 2.4 392 * 393 * Throws: ConstructionException GTK+ fails to create the object. 394 */ 395 public this(TreeModelIF childModel, TreePath root) 396 { 397 auto p = gtk_tree_model_filter_new((childModel is null) ? null : childModel.getTreeModelStruct(), (root is null) ? null : root.getTreePathStruct()); 398 399 if(p is null) 400 { 401 throw new ConstructionException("null returned by new"); 402 } 403 404 this(cast(GtkTreeModelFilter*) p, true); 405 } 406 }