1Gtk2::SimpleList(3) User Contributed Perl Documentation Gtk2::SimpleList(3)
2
6 Gtk2::SimpleList - A simple interface to Gtk2's complex MVC list widget
7
9 use Glib qw(TRUE FALSE);
10 use Gtk2 '-init';
11 use Gtk2::SimpleList;
12 my $slist = Gtk2::SimpleList->new (
14 'Text Field' => 'text',
15 'Markup Field' => 'markup',
16 'Int Field' => 'int',
17 'Double Field' => 'double',
18 'Bool Field' => 'bool',
19 'Scalar Field' => 'scalar',
20 'Pixbuf Field' => 'pixbuf',
21 );
22 @{$slist->{data}} = (
24 [ 'text', 1, 1.1, TRUE, $var, $pixbuf ],
25 [ 'text', 2, 2.2, FALSE, $var, $pixbuf ],
26 );
27 # (almost) anything you can do to an array you can do to
29 # $slist->{data} which is an array reference tied to the list model
30 push @{$slist->{data}}, [ 'text', 3, 3.3, TRUE, $var, $pixbuf ];
31 # mess with selections
33 $slist->get_selection->set_mode ('multiple');
34 $slist->get_selection->unselect_all;
35 $slist->select (1, 3, 5..9); # select rows by index
36 $slist->unselect (3, 8); # unselect rows by index
37 @sel = $slist->get_selected_indices;
38 # simple way to make text columns editable
40 $slist->set_column_editable ($col_num, TRUE);
41 # Gtk2::SimpleList derives from Gtk2::TreeView, so all methods
43 # on a treeview are available.
44 $slist->set_rules_hint (TRUE);
45 $slist->signal_connect (row_activated => sub {
46 my ($sl, $path, $column) = @_;
47 my $row_ref = $sl->get_row_data_from_path ($path);
48 # $row_ref is now an array ref to the double-clicked row's data.
49 });
50 # turn an existing TreeView into a SimpleList; useful for
52 # Glade-generated interfaces.
53 $simplelist = Gtk2::SimpleList->new_from_treeview (
54 $glade->get_widget ('treeview'),
55 'Text Field' => 'text',
56 'Int Field' => 'int',
57 'Double Field' => 'double',
58 );
59
61 SimpleList is a simple interface to the powerful but complex
62 Gtk2::TreeView and Gtk2::ListStore combination, implementing using tied
63 arrays to make thing simple and easy.
64
66 Gtk2 has a powerful, but complex MVC (Model, View, Controller) system
67 used to implement list and tree widgets. Gtk2::SimpleList automates
68 the complex setup work and allows you to treat the list model as a more
69 natural list of lists structure.
70 After creating a new Gtk2::SimpleList object with the desired columns
72 you may set the list data with a simple Perl array assignment. Rows may
73 be added or deleted with all of the normal array operations. You can
74 treat the "data" member of the list simplelist object as an array
75 reference, and manipulate the list data with Perl's normal array
76 operators.
77 A mechanism has also been put into place allowing columns to be Perl
79 scalars. The scalar is converted to text through Perl's normal
80 mechanisms and then displayed in the list. This same mechanism can be
81 expanded by defining arbitrary new column types before calling the new
82 function.
83
85 Glib::Object
86 +--- Gtk2::Object
87 +--- Gtk2::Widget
88 +--- Gtk2::TreeView
89 +--- Gtk2::SimpleList
90
92 $slist = Gtk2::SimpleList->new ($cname, $ctype, ...)
93 • $cname (string)
94 • $ctype (string)
96 Creates a new Gtk2::SimpleList object with the specified columns.
98 The parameter "cname" is the name of the column, what will be
99 displayed in the list headers if they are turned on. The parameter
100 ctype is the type of the column, one of:
101 text normal text strings
103 markup pango markup strings
104 int integer values
105 double double-precision floating point values
106 bool boolean values, displayed as toggle-able checkboxes
107 scalar a perl scalar, displayed as a text string by default
108 pixbuf a Gtk2::Gdk::Pixbuf
109 or the name of a custom type you add with "add_column_type". These
111 should be provided in pairs according to the desired columns for
112 your list.
113 $slist = Gtk2::SimpleList->new_from_treeview ($treeview, $cname,
115 $ctype, ...)
116 • $treeview (Gtk2::TreeView)
117 • $cname (string)
119 • $ctype (string)
121 Like "Gtk2::SimpleList->new()", but turns an existing
123 Gtk2::TreeView into a Gtk2::SimpleList. This is intended mostly
124 for use with stuff like Glade, where the widget is created for you.
125 This will create and attach a new model and remove any existing
126 columns from treeview. Returns treeview, re-blessed as a
127 Gtk2::SimpleList.
128 $slist->set_data_array ($arrayref)
130 • $arrayref (array reference)
131 Set the data in the list to the array reference $arrayref. This is
133 completely equivalent to @{$list->{data}} = @{$arrayref} and is
134 only here for convenience and for those programmers who don't like
135 to type-cast and have static, set once data.
136 @indices = $slist->get_selected_indices
138 Return the indices of the selected rows in the ListStore.
139 $slist->get_row_data_from_path ($path)
141 • $path (Gtk2::TreePath) the path of the desired row
142 Returns an array ref with the data of the row indicated by $path.
144 $slist->select ($index, ...);
146 $slist->unselect ($index, ...);
147 • $index (integer)
148 Select or unselect rows in the list by index. If the list is set
150 for multiple selection, all indices in the list will be set/unset;
151 otherwise, just the first is used. If the list is set for no
152 selection, then nothing happens.
153 To set the selection mode, or to select all or none of the rows,
155 use the normal TreeView/TreeSelection stuff, e.g.
156 $slist->get_selection and the TreeSelection methods "get_mode",
157 "set_mode", "select_all", and "unselect_all".
158 $slist->set_column_editable ($index, $editable)
160 • $index (integer)
161 • $editable (boolean)
163 boolean = $slist->get_column_editable ($index)
165 • $index (integer)
166 This is a very simple interface to Gtk2::TreeView's editable text
168 column cells. All columns which use the attr "text" (basically,
169 any text or number column, see "add_column_type") automatically
170 have callbacks installed to update data when cells are edited.
171 With "set_column_editable", you can enable the in-place editing.
172 "get_column_editable" tells you if column index is currently
174 editable.
175 Gtk2::SimpleList->add_column_type ($type_name, ...)
177 $type_name (string)
178 Add a new column type to the list of possible types. Initially six
180 column types are defined, text, int, double, bool, scalar, and
181 pixbuf. The bool column type uses a toggle cell renderer, the
182 pixbuf uses a pixbuf cell renderer, and the rest use text cell
183 renderers. In the process of adding a new column type you may use
184 any cell renderer you wish.
185 The first parameter is the column type name, the list of six are
187 examples. There are no restrictions on the names and you may even
188 overwrite the existing ones should you choose to do so. The
189 remaining parameters are the type definition consisting of key
190 value pairs. There are three required: type, renderer, and attr.
191 The type key determines what actual datatype will be stored in the
192 underlying model representation; this is a package name, e.g.
193 Glib::String, Glib::Int, Glib::Boolean, but in general if you want
194 an arbitrary Perl data structure you will want to use
195 'Glib::Scalar'. The renderer key should hold the class name of the
196 cell renderer to create for this column type; this may be any of
197 Gtk2::CellRendererText, Gtk2::CellRendererToggle,
198 Gtk2::CellRendererPixbuf, or some other, possibly custom, cell
199 renderer class. The attr key is magical; it may be either a
200 string, in which case it specifies the attribute which will be set
201 from the specified column (e.g. 'text' for a text renderer,
202 'active' for a toggle renderer, etc), or it may be a reference to a
203 subroutine which will be called each time the renderer needs to
204 draw the data.
205 This function, described as a GtkTreeCellDataFunc in the API
207 reference, will receive 5 parameters: $treecol, $cell, $model,
208 $iter, $col_num (when SimpleList hooks up the function, it sets the
209 column number to be passed as the user data). The data value for
210 the particular cell in question is available via $model->get
211 ($iter, $col_num); you can then do whatever it is you have to do to
212 render the cell the way you want. Here are some examples:
213 # just displays the value in a scalar as
215 # Perl would convert it to a string
216 Gtk2::SimpleList->add_column_type( 'a_scalar',
217 type => 'Glib::Scalar',
218 renderer => 'Gtk2::CellRendererText',
219 attr => sub {
220 my ($treecol, $cell, $model, $iter, $col_num) = @_;
221 my $info = $model->get ($iter, $col_num);
222 $cell->set (text => $info);
223 }
224 );
225 # sums up the values in an array ref and displays
227 # that in a text renderer
228 Gtk2::SimpleList->add_column_type( 'sum_of_array',
229 type => 'Glib::Scalar',
230 renderer => 'Gtk2::CellRendererText',
231 attr => sub {
232 my ($treecol, $cell, $model, $iter, $col_num) = @_;
233 my $sum = 0;
234 my $info = $model->get ($iter, $col_num);
235 foreach (@$info)
236 {
237 $sum += $_;
238 }
239 $cell->set (text => $sum);
240 }
241 );
242
244 After creating a new Gtk2::SimpleList object there will be a member
245 called "data" which is a tied array. That means data may be treated as
246 an array, but in reality the data resides in something else. There is
247 no need to understand the details of this it just means that you put
248 data into, take data out of, and modify it just like any other array.
249 This includes using array operations like push, pop, unshift, and
250 shift. For those of you very familiar with perl this section will prove
251 redundant, but just in case:
252 Adding and removing rows:
254 # push a row onto the end of the list
256 push @{$slist->{data}}, [col1_data, col2_data, ..., coln_data];
257 # pop a row off of the end of the list
258 $rowref = pop @{$slist->{data}};
259 # unshift a row onto the beginning of the list
260 unshift @{$slist->{data}}, [col1_data, col2_data, ..., coln_data];
261 # shift a row off of the beginning of the list
262 $rowref = shift @{$slist->{data}};
263 # delete the row at index $n, 0 indexed
264 splice @{ $slist->{data} }, $n, 1;
265 # set the entire list to be the data in a array
266 @{$slist->{data}} = ( [row1, ...], [row2, ...], [row3, ...] );
267 Getting at the data in the list:
269 # get an array reference to the entire nth row
271 $rowref = $slist->{data}[n];
272 # get the scalar in the mth column of the nth row, 0 indexed
273 $val = $slist->{data}[n][m];
274 # set an array reference to the entire nth row
275 $slist->{data}[n] = [col1_data, col2_data, ..., coln_data];
276 # get the scalar in the mth column of the nth row, 0 indexed
277 $slist->{data}[n][m] = $rowm_coln_value;
278
280 Perl(1), Glib(3pm), Gtk2(3pm), Gtk2::TreeView(3pm),
281 Gtk2::TreeModel(3pm), Gtk2::ListStore(3pm).
282 Note: Gtk2::SimpleList is deprecated in favor of
284 Gtk2::Ex::Simple::List, part of the Gtk2-Perl-Ex project at
285 http://gtk2-perl-ex.sf.net .
286
288 muppet <scott at asofyet dot org>
289 Ross McFarland <rwmcfa1 at neces dot com>
290 Gavin Brown <gavin dot brown at uk dot com>
291
293 Copyright 2003-2004 by the Gtk2-Perl team.
294 This library is free software; you can redistribute it and/or modify it
296 under the terms of the GNU Library General Public License as published
297 by the Free Software Foundation; either version 2.1 of the License, or
298 (at your option) any later version.
299 This library is distributed in the hope that it will be useful, but
301 WITHOUT ANY WARRANTY; without even the implied warranty of
302 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
303 Library General Public License for more details.
304 You should have received a copy of the GNU Library General Public
306 License along with this library; if not, write to the Free Software
307 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
308 02110-1301 USA.
309perl v5.36.0 2022-07-22 Gtk2::SimpleList(3)