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 gio.ListModelT; 26 27 public import gio.c.functions; 28 public import gio.c.types; 29 public import gobject.ObjectG; 30 public import gobject.Signals; 31 public import std.algorithm; 32 33 34 /** 35 * #GListModel is an interface that represents a mutable list of 36 * #GObjects. Its main intention is as a model for various widgets in 37 * user interfaces, such as list views, but it can also be used as a 38 * convenient method of returning lists of data, with support for 39 * updates. 40 * 41 * Each object in the list may also report changes in itself via some 42 * mechanism (normally the #GObject::notify signal). Taken together 43 * with the #GListModel::items-changed signal, this provides for a list 44 * that can change its membership, and in which the members can change 45 * their individual properties. 46 * 47 * A good example would be the list of visible wireless network access 48 * points, where each access point can report dynamic properties such as 49 * signal strength. 50 * 51 * It is important to note that the #GListModel itself does not report 52 * changes to the individual items. It only reports changes to the list 53 * membership. If you want to observe changes to the objects themselves 54 * then you need to connect signals to the objects that you are 55 * interested in. 56 * 57 * All items in a #GListModel are of (or derived from) the same type. 58 * g_list_model_get_item_type() returns that type. The type may be an 59 * interface, in which case all objects in the list must implement it. 60 * 61 * The semantics are close to that of an array: 62 * g_list_model_get_n_items() returns the number of items in the list and 63 * g_list_model_get_item() returns an item at a (0-based) position. In 64 * order to allow implementations to calculate the list length lazily, 65 * you can also iterate over items: starting from 0, repeatedly call 66 * g_list_model_get_item() until it returns %NULL. 67 * 68 * An implementation may create objects lazily, but must take care to 69 * return the same object for a given position until all references to 70 * it are gone. 71 * 72 * On the other side, a consumer is expected only to hold references on 73 * objects that are currently "user visible", in order to facilitate the 74 * maximum level of laziness in the implementation of the list and to 75 * reduce the required number of signal connections at a given time. 76 * 77 * This interface is intended only to be used from a single thread. The 78 * thread in which it is appropriate to use it depends on the particular 79 * implementation, but typically it will be from the thread that owns 80 * the [thread-default main context][g-main-context-push-thread-default] 81 * in effect at the time that the model was created. 82 */ 83 public template ListModelT(TStruct) 84 { 85 /** Get the main Gtk struct */ 86 public GListModel* getListModelStruct(bool transferOwnership = false) 87 { 88 if (transferOwnership) 89 ownedRef = false; 90 return cast(GListModel*)getStruct(); 91 } 92 93 94 /** 95 * Get the item at @position. If @position is greater than the number of 96 * items in @list, %NULL is returned. 97 * 98 * %NULL is never returned for an index that is smaller than the length 99 * of the list. See g_list_model_get_n_items(). 100 * 101 * Params: 102 * position = the position of the item to fetch 103 * 104 * Returns: the item at @position. 105 * 106 * Since: 2.44 107 */ 108 public void* getItem(uint position) 109 { 110 return g_list_model_get_item(getListModelStruct(), position); 111 } 112 113 /** 114 * Gets the type of the items in @list. All items returned from 115 * g_list_model_get_type() are of that type or a subtype, or are an 116 * implementation of that interface. 117 * 118 * The item type of a #GListModel can not change during the life of the 119 * model. 120 * 121 * Returns: the #GType of the items contained in @list. 122 * 123 * Since: 2.44 124 */ 125 public GType getItemType() 126 { 127 return g_list_model_get_item_type(getListModelStruct()); 128 } 129 130 /** 131 * Gets the number of items in @list. 132 * 133 * Depending on the model implementation, calling this function may be 134 * less efficient than iterating the list with increasing values for 135 * @position until g_list_model_get_item() returns %NULL. 136 * 137 * Returns: the number of items in @list. 138 * 139 * Since: 2.44 140 */ 141 public uint getNItems() 142 { 143 return g_list_model_get_n_items(getListModelStruct()); 144 } 145 146 /** 147 * Get the item at @position. If @position is greater than the number of 148 * items in @list, %NULL is returned. 149 * 150 * %NULL is never returned for an index that is smaller than the length 151 * of the list. See g_list_model_get_n_items(). 152 * 153 * Params: 154 * position = the position of the item to fetch 155 * 156 * Returns: the object at @position. 157 * 158 * Since: 2.44 159 */ 160 public ObjectG getObject(uint position) 161 { 162 auto __p = g_list_model_get_object(getListModelStruct(), position); 163 164 if(__p is null) 165 { 166 return null; 167 } 168 169 return ObjectG.getDObject!(ObjectG)(cast(GObject*) __p, true); 170 } 171 172 /** 173 * Emits the #GListModel::items-changed signal on @list. 174 * 175 * This function should only be called by classes implementing 176 * #GListModel. It has to be called after the internal representation 177 * of @list has been updated, because handlers connected to this signal 178 * might query the new state of the list. 179 * 180 * Implementations must only make changes to the model (as visible to 181 * its consumer) in places that will not cause problems for that 182 * consumer. For models that are driven directly by a write API (such 183 * as #GListStore), changes can be reported in response to uses of that 184 * API. For models that represent remote data, changes should only be 185 * made from a fresh mainloop dispatch. It is particularly not 186 * permitted to make changes in response to a call to the #GListModel 187 * consumer API. 188 * 189 * Stated another way: in general, it is assumed that code making a 190 * series of accesses to the model via the API, without returning to the 191 * mainloop, and without calling other code, will continue to view the 192 * same contents of the model. 193 * 194 * Params: 195 * position = the position at which @list changed 196 * removed = the number of items removed 197 * added = the number of items added 198 * 199 * Since: 2.44 200 */ 201 public void itemsChanged(uint position, uint removed, uint added) 202 { 203 g_list_model_items_changed(getListModelStruct(), position, removed, added); 204 } 205 206 /** 207 * This signal is emitted whenever items were added to or removed 208 * from @list. At @position, @removed items were removed and @added 209 * items were added in their place. 210 * 211 * Note: If @removed != @added, the positions of all later items 212 * in the model change. 213 * 214 * Params: 215 * position = the position at which @list changed 216 * removed = the number of items removed 217 * added = the number of items added 218 * 219 * Since: 2.44 220 */ 221 gulong addOnItemsChanged(void delegate(uint, uint, uint, ListModelIF) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 222 { 223 return Signals.connect(this, "items-changed", dlg, connectFlags ^ ConnectFlags.SWAPPED); 224 } 225 }