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