~ubuntu-branches/ubuntu/precise/gtkmm3.0/precise

« back to all changes in this revision

Viewing changes to gtk/gtkmm/treeviewcolumn.h

  • Committer: Bazaar Package Importer
  • Author(s): Michael Biebl
  • Date: 2011-06-17 00:12:44 UTC
  • Revision ID: james.westby@ubuntu.com-20110617001244-9hl5an15hiaaahi6
Tags: upstream-3.0.1
ImportĀ upstreamĀ versionĀ 3.0.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
// -*- c++ -*-
 
2
// Generated by gtkmmproc -- DO NOT MODIFY!
 
3
#ifndef _GTKMM_TREEVIEWCOLUMN_H
 
4
#define _GTKMM_TREEVIEWCOLUMN_H
 
5
 
 
6
#include <gtkmmconfig.h>
 
7
 
 
8
 
 
9
#include <glibmm.h>
 
10
 
 
11
/* Copyright(C) 2002 The gtkmm Development Team
 
12
 *
 
13
 * This library is free software; you can redistribute it and/or
 
14
 * modify it under the terms of the GNU Lesser General Public
 
15
 * License as published by the Free Software Foundation; either
 
16
 * version 2.1 of the License, or(at your option) any later version.
 
17
 *
 
18
 * This library is distributed in the hope that it will be useful,
 
19
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
20
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
21
 * Lesser General Public License for more details.
 
22
 *
 
23
 * You should have received a copy of the GNU Lesser General Public
 
24
 * License along with this library; if not, write to the Free
 
25
 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
26
 */
 
27
 
 
28
// This is for including the config header before any code (such as
 
29
// the #ifndef GTKMM_DISABLE_DEPRECATED in deprecated classes) is generated:
 
30
 
 
31
 
 
32
#include <gtkmm/treeiter.h>
 
33
#include <gtkmm/button.h>
 
34
#include <gdkmm/window.h>
 
35
#include <gtkmm/treemodel.h>
 
36
#include <gtkmm/celllayout.h>
 
37
#include <gtkmm/cellrenderer_generation.h>
 
38
 
 
39
 
 
40
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
41
typedef struct _GtkTreeViewColumn GtkTreeViewColumn;
 
42
typedef struct _GtkTreeViewColumnClass GtkTreeViewColumnClass;
 
43
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
44
 
 
45
 
 
46
namespace Gtk
 
47
{ class TreeViewColumn_Class; } // namespace Gtk
 
48
namespace Gtk
 
49
{
 
50
 
 
51
 
 
52
/** @addtogroup gtkmmEnums gtkmm Enums and Flags */
 
53
 
 
54
/**
 
55
 * @ingroup gtkmmEnums
 
56
 */
 
57
enum TreeViewColumnSizing
 
58
{
 
59
  TREE_VIEW_COLUMN_GROW_ONLY,
 
60
  TREE_VIEW_COLUMN_AUTOSIZE,
 
61
  TREE_VIEW_COLUMN_FIXED
 
62
};
 
63
 
 
64
} // namespace Gtk
 
65
 
 
66
 
 
67
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
68
namespace Glib
 
69
{
 
70
 
 
71
template <>
 
72
class Value<Gtk::TreeViewColumnSizing> : public Glib::Value_Enum<Gtk::TreeViewColumnSizing>
 
73
{
 
74
public:
 
75
  static GType value_type() G_GNUC_CONST;
 
76
};
 
77
 
 
78
} // namespace Glib
 
79
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
80
 
 
81
 
 
82
namespace Gtk
 
83
{
 
84
 
 
85
 
 
86
// We use GTKMM_API here because gcc needs the extra help on win32 , even
 
87
// when using --export-all and auto-import.
 
88
// See http://bugzilla.gnome.org/show_bug.cgi?id=309030.
 
89
 
 
90
class TreeView;
 
91
 
 
92
//TODO: Deal with the GtkObject->GObject change?
 
93
/** Typedefed as Gtk::TreeView::Column.
 
94
 * This is a visible column in a Gtk::TreeView widget. It determines the geometry, type.
 
95
 *
 
96
 * @ingroup TreeView
 
97
*/
 
98
 
 
99
class GTKMM_API TreeViewColumn
 
100
  : public Object,
 
101
    public CellLayout
 
102
{
 
103
  public:
 
104
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
105
  typedef TreeViewColumn CppObjectType;
 
106
  typedef TreeViewColumn_Class CppClassType;
 
107
  typedef GtkTreeViewColumn BaseObjectType;
 
108
  typedef GtkTreeViewColumnClass BaseClassType;
 
109
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
110
 
 
111
  virtual ~TreeViewColumn();
 
112
 
 
113
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
114
 
 
115
private:
 
116
  friend class TreeViewColumn_Class;
 
117
  static CppClassType treeviewcolumn_class_;
 
118
 
 
119
  // noncopyable
 
120
  TreeViewColumn(const TreeViewColumn&);
 
121
  TreeViewColumn& operator=(const TreeViewColumn&);
 
122
 
 
123
protected:
 
124
  explicit TreeViewColumn(const Glib::ConstructParams& construct_params);
 
125
  explicit TreeViewColumn(GtkTreeViewColumn* castitem);
 
126
 
 
127
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
128
 
 
129
public:
 
130
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
131
  static GType get_type()      G_GNUC_CONST;
 
132
 
 
133
 
 
134
  static GType get_base_type() G_GNUC_CONST;
 
135
#endif
 
136
 
 
137
  ///Provides access to the underlying C GtkObject.
 
138
  GtkTreeViewColumn*       gobj()       { return reinterpret_cast<GtkTreeViewColumn*>(gobject_); }
 
139
 
 
140
  ///Provides access to the underlying C GtkObject.
 
141
  const GtkTreeViewColumn* gobj() const { return reinterpret_cast<GtkTreeViewColumn*>(gobject_); }
 
142
 
 
143
 
 
144
public:
 
145
  //C++ methods used to invoke GTK+ virtual functions:
 
146
 
 
147
protected:
 
148
  //GTK+ Virtual Functions (override these to change behaviour):
 
149
 
 
150
  //Default Signal Handlers::
 
151
  virtual void on_clicked();
 
152
 
 
153
 
 
154
private:
 
155
 
 
156
  
 
157
public:
 
158
  typedef TreeViewColumn Column;
 
159
 
 
160
  TreeViewColumn();
 
161
 
 
162
  explicit TreeViewColumn(const Glib::ustring& title);
 
163
  TreeViewColumn(const Glib::ustring& title, CellRenderer& cell);
 
164
 
 
165
  /** Create a default view column for the given model column type.
 
166
   */
 
167
  template<class T_ModelColumnType>
 
168
  TreeViewColumn(const Glib::ustring& title, const TreeModelColumn<T_ModelColumnType>& column);
 
169
 
 
170
  
 
171
  /** Packs the @a cell into the beginning of the column. If @a expand is <tt>false</tt>, then
 
172
   * the @a cell is allocated no more space than it needs. Any unused space is divided
 
173
   * evenly between cells for which @a expand is <tt>true</tt>.
 
174
   * @param cell The Gtk::CellRenderer.
 
175
   * @param expand <tt>true</tt> if @a cell is to be given extra space allocated to @a tree_column.
 
176
   */
 
177
  void pack_start(CellRenderer& cell, bool expand = true);
 
178
  
 
179
  /** Adds the @a cell to end of the column. If @a expand is <tt>false</tt>, then the @a cell
 
180
   * is allocated no more space than it needs. Any unused space is divided
 
181
   * evenly between cells for which @a expand is <tt>true</tt>.
 
182
   * @param cell The Gtk::CellRenderer.
 
183
   * @param expand <tt>true</tt> if @a cell is to be given extra space allocated to @a tree_column.
 
184
   */
 
185
  void pack_end(CellRenderer& cell, bool expand = true);
 
186
 
 
187
  /** Creates an appropriate CellRenderer for the @a column, and packs that cell into the beginning of the column.
 
188
   * If @a expand  is <tt>false</tt>, then
 
189
   * the cell is allocated no more space than it needs. Any unused space is divided
 
190
   * evenly between cells for which @a expand is <tt>true</tt>.
 
191
   *
 
192
   * You can use get_first_cell() or get_cells() to access the generated CellRenderer.
 
193
   *
 
194
   * @param column The model column that will be rendered by the view cell.
 
195
   * @param expand <tt>true</tt> if the cell is to be given extra space allocated to the view column.
 
196
   */
 
197
  template<class T_ModelColumnType>
 
198
  void pack_start(const TreeModelColumn<T_ModelColumnType>& column, bool expand = true);
 
199
 
 
200
  /** Creates an appropriate CellRenderer for the @a column, and packs that cell at the end of the column.
 
201
   * If @a expand  is <tt>false</tt>, then
 
202
   * the cell is allocated no more space than it needs. Any unused space is divided
 
203
   * evenly between cells for which @a expand is <tt>true</tt>.
 
204
   *
 
205
   * You can use get_first_cell() or get_cells() to access the generated CellRenderer.
 
206
   *
 
207
   * @param column The model column that will be rendered by the view cell.
 
208
   * @param expand <tt>true</tt> if the cell is to be given extra space allocated to the view column.
 
209
   */
 
210
  template<class T_ModelColumnType>
 
211
  void pack_end(const TreeModelColumn<T_ModelColumnType>& column, bool expand = true);
 
212
 
 
213
  
 
214
  /** Unsets all the mappings on all renderers on the @a tree_column.
 
215
   */
 
216
  void clear();
 
217
 
 
218
   //deprecated
 
219
 
 
220
  
 
221
  /** Adds an attribute mapping to the list in @a tree_column.  The @a column is the
 
222
   * column of the model to get a value from, and the @a attribute is the
 
223
   * parameter on @a cell_renderer to be set from the value. So for example
 
224
   * if column 2 of the model contains strings, you could have the
 
225
   * "text" attribute of a Gtk::CellRendererText get its values from
 
226
   * column 2.
 
227
   * @param cell_renderer The Gtk::CellRenderer to set attributes on.
 
228
   * @param attribute An attribute on the renderer.
 
229
   * @param column The column position on the model to get the attribute from.
 
230
   */
 
231
  void add_attribute(CellRenderer& cell_renderer, const Glib::ustring& attribute, int column);
 
232
 
 
233
  void add_attribute(const Glib::PropertyProxy_Base& property, const TreeModelColumnBase& column);
 
234
 
 
235
  void add_attribute(Gtk::CellRenderer& cell, const Glib::ustring& property_name, const TreeModelColumnBase& column);
 
236
  
 
237
 
 
238
  /** Associate a view CellRenderer with a model column, so that the CellRenderer renders the data in the model column.
 
239
   *
 
240
   * @param renderer The view cell renderer which will render the model column.
 
241
   * @param column The model column to be renderered by this view.
 
242
   */
 
243
  void set_renderer(Gtk::CellRenderer& renderer, const TreeModelColumnBase& column);
 
244
 
 
245
 // _WRAP_METHOD(void set_attributes(CellRenderer& cell_renderer, ...), )
 
246
 
 
247
  /** For instance,
 
248
   * void on_cell_data(Gtk::CellRenderer* cell, const Gtk::TreeModel::iterator& iter);
 
249
   *
 
250
   * This function is used instead of the standard attributes mapping for setting the column value, and should set the
 
251
   * value of the column's cell renderer as appropriate.
 
252
   */
 
253
  typedef sigc::slot<void, CellRenderer*, const Gtk::TreeModel::iterator&> SlotCellData;
 
254
 
 
255
  /** Sets the slot callback to use for the column.
 
256
   * This callback function is used instead of the standard attributes mapping for setting the column value, and should set the
 
257
   * value of the column's cell renderer as appropriate.
 
258
   *
 
259
   * See also unset_cell_data_func().
 
260
   *
 
261
   * @param cell_renderer A Gtk::CellRenderer
 
262
   * @param slot The callback slot to use. Create this with sigc::mem_fun(), or sigc::ptr_fun().
 
263
   */
 
264
  void set_cell_data_func(CellRenderer& cell_renderer, const SlotCellData& slot);
 
265
 
 
266
  /** Removes a previously set callback slot. See set_cell_data_func().
 
267
   */
 
268
  void unset_cell_data_func(CellRenderer& cell_renderer);
 
269
 
 
270
  
 
271
  /** Clears all existing attributes previously set with
 
272
   * set_attributes().
 
273
   * @param cell_renderer A Gtk::CellRenderer to clear the attribute mapping on.
 
274
   */
 
275
  void clear_attributes(CellRenderer& cell_renderer);
 
276
  
 
277
  /** Sets the spacing field of @a tree_column, which is the number of pixels to
 
278
   * place between cell renderers packed into it.
 
279
   * @param spacing Distance between cell renderers in pixels.
 
280
   */
 
281
  void set_spacing(int spacing);
 
282
  
 
283
  /** Returns the spacing of @a tree_column.
 
284
   * @return The spacing of @a tree_column.
 
285
   */
 
286
  int get_spacing() const;
 
287
  
 
288
  /** Sets the visibility of @a tree_column.
 
289
   * @param visible <tt>true</tt> if the @a tree_column is visible.
 
290
   */
 
291
  void set_visible(bool visible = true);
 
292
  
 
293
  /** Returns <tt>true</tt> if @a tree_column is visible.
 
294
   * @return Whether the column is visible or not.  If it is visible, then
 
295
   * the tree will show the column.
 
296
   */
 
297
  bool get_visible() const;
 
298
  
 
299
  /** If @a resizable is <tt>true</tt>, then the user can explicitly resize the column by
 
300
   * grabbing the outer edge of the column button.  If resizable is <tt>true</tt> and
 
301
   * sizing mode of the column is Gtk::TREE_VIEW_COLUMN_AUTOSIZE, then the sizing
 
302
   * mode is changed to Gtk::TREE_VIEW_COLUMN_GROW_ONLY.
 
303
   * @param resizable <tt>true</tt>, if the column can be resized.
 
304
   */
 
305
  void set_resizable(bool resizable = true);
 
306
  
 
307
  /** Returns <tt>true</tt> if the @a tree_column can be resized by the end user.
 
308
   * @return <tt>true</tt>, if the @a tree_column can be resized.
 
309
   */
 
310
  bool get_resizable() const;
 
311
  
 
312
  /** Sets the growth behavior of @a tree_column to @a type.
 
313
   * @param type The Gtk::TreeViewColumnSizing.
 
314
   */
 
315
  void set_sizing(TreeViewColumnSizing type);
 
316
  
 
317
  /** Returns the current type of @a tree_column.
 
318
   * @return The type of @a tree_column.
 
319
   */
 
320
  TreeViewColumnSizing get_sizing();
 
321
  
 
322
  /** Returns the current size of @a tree_column in pixels.
 
323
   * @return The current width of @a tree_column.
 
324
   */
 
325
  int get_width() const;
 
326
  
 
327
  /** Gets the fixed width of the column.  This value is only meaning may not be
 
328
   * the actual width of the column on the screen, just what is requested.
 
329
   * @return The fixed width of the column.
 
330
   */
 
331
  int get_fixed_width() const;
 
332
  
 
333
  /** Sets the size of the column in pixels.  This is meaningful only if the sizing
 
334
   * type is Gtk::TREE_VIEW_COLUMN_FIXED.  The size of the column is clamped to
 
335
   * the min/max width for the column.  Please note that the min/max width of the
 
336
   * column doesn't actually affect the "fixed_width" property of the widget, just
 
337
   * the actual size when displayed.
 
338
   * @param fixed_width The size to set @a tree_column to. Must be greater than 0.
 
339
   */
 
340
  void set_fixed_width(int fixed_width);
 
341
  
 
342
  /** Sets the minimum width of the @a tree_column.  If @a min_width is -1, then the
 
343
   * minimum width is unset.
 
344
   * @param min_width The minimum width of the column in pixels, or -1.
 
345
   */
 
346
  void set_min_width(int min_width);
 
347
  
 
348
  /** Returns the minimum width in pixels of the @a tree_column, or -1 if no minimum
 
349
   * width is set.
 
350
   * @return The minimum width of the @a tree_column.
 
351
   */
 
352
  int get_min_width() const;
 
353
  
 
354
  /** Sets the maximum width of the @a tree_column.  If @a max_width is -1, then the
 
355
   * maximum width is unset.  Note, the column can actually be wider than max
 
356
   * width if it's the last column in a view.  In this case, the column expands to
 
357
   * fill any extra space.
 
358
   * @param max_width The maximum width of the column in pixels, or -1.
 
359
   */
 
360
  void set_max_width(int max_width);
 
361
  
 
362
  /** Returns the maximum width in pixels of the @a tree_column, or -1 if no maximum
 
363
   * width is set.
 
364
   * @return The maximum width of the @a tree_column.
 
365
   */
 
366
  int get_max_width() const;
 
367
  
 
368
  /** Emits the "clicked" signal on the column.  This function will only work if
 
369
   *  @a tree_column is clickable.
 
370
   */
 
371
  void clicked();
 
372
 
 
373
  
 
374
  /** Sets the title of the @a tree_column.  If a custom widget has been set, then
 
375
   * this value is ignored.
 
376
   * @param title The title of the @a tree_column.
 
377
   */
 
378
  void set_title(const Glib::ustring& title);
 
379
  
 
380
  /** Returns the title of the widget.
 
381
   * @return The title of the column. This string should not be
 
382
   * modified or freed.
 
383
   */
 
384
  Glib::ustring get_title() const;
 
385
 
 
386
  
 
387
  /** Sets the column to take available extra space.  This space is shared equally
 
388
   * amongst all columns that have the expand set to <tt>true</tt>.  If no column has this
 
389
   * option set, then the last column gets all extra space.  By default, every
 
390
   * column is created with this <tt>false</tt>.
 
391
   * 
 
392
   * @newin{2,4}
 
393
   * @param expand <tt>true</tt> if the column should take available extra space, <tt>false</tt> if not.
 
394
   */
 
395
  void set_expand(bool expand = true);
 
396
  
 
397
  /** Return <tt>true</tt> if the column expands to take any available space.
 
398
   * 
 
399
   * @newin{2,4}
 
400
   * @return <tt>true</tt>, if the column expands.
 
401
   */
 
402
  bool get_expand() const;
 
403
 
 
404
  
 
405
  /** Sets the header to be active if @a active is <tt>true</tt>.  When the header is active,
 
406
   * then it can take keyboard focus, and can be clicked.
 
407
   * @param clickable <tt>true</tt> if the header is active.
 
408
   */
 
409
  void set_clickable(bool clickable = true);
 
410
  
 
411
  /** Returns <tt>true</tt> if the user can click on the header for the column.
 
412
   * @return <tt>true</tt> if user can click the column header.
 
413
   */
 
414
  bool get_clickable() const;
 
415
  
 
416
  /** Sets the widget in the header to be @a widget.  If widget is <tt>0</tt>, then the
 
417
   * header button is set with a Gtk::Label set to the title of @a tree_column.
 
418
   * @param widget A child Gtk::Widget, or <tt>0</tt>.
 
419
   */
 
420
  void set_widget(Gtk::Widget& widget);
 
421
  
 
422
  /** Returns the Gtk::Widget in the button on the column header.  If a custom
 
423
   * widget has not been set then <tt>0</tt> is returned.
 
424
   * @return The Gtk::Widget in the column header, or <tt>0</tt>.
 
425
   */
 
426
  Widget* get_widget();
 
427
  
 
428
  /** Returns the Gtk::Widget in the button on the column header.  If a custom
 
429
   * widget has not been set then <tt>0</tt> is returned.
 
430
   * @return The Gtk::Widget in the column header, or <tt>0</tt>.
 
431
   */
 
432
  const Widget* get_widget() const;
 
433
 
 
434
  
 
435
  /** Sets the alignment of the title or custom widget inside the column header.
 
436
   * The alignment determines its location inside the button -- 0.0 for left, 0.5
 
437
   * for center, 1.0 for right.
 
438
   * @param xalign The alignment, which is between [0.0 and 1.0] inclusive.
 
439
   */
 
440
  void set_alignment(float xalign);
 
441
  
 
442
  /** Sets the alignment of the title or custom widget inside the column header.
 
443
   * The alignment determines its location inside the button -- 0.0 for left, 0.5
 
444
   * for center, 1.0 for right.
 
445
   * @param xalign The alignment, which is between [0.0 and 1.0] inclusive.
 
446
   */
 
447
  void set_alignment(Align xalign);
 
448
 
 
449
  
 
450
  /** Returns the current x alignment of @a tree_column.  This value can range
 
451
   * between 0.0 and 1.0.
 
452
   * @return The current alignent of @a tree_column.
 
453
   */
 
454
  float get_alignment() const;
 
455
  
 
456
  /** If @a reorderable is <tt>true</tt>, then the column can be reordered by the end user
 
457
   * dragging the header.
 
458
   * @param reorderable <tt>true</tt>, if the column can be reordered.
 
459
   */
 
460
  void set_reorderable(bool reorderable = true);
 
461
  
 
462
  /** Returns <tt>true</tt> if the @a tree_column can be reordered by the user.
 
463
   * @return <tt>true</tt> if the @a tree_column can be reordered by the user.
 
464
   */
 
465
  bool get_reorderable() const;
 
466
 
 
467
  
 
468
  /** Sets the logical @a sort_column_id that this column sorts on when this column 
 
469
   * is selected for sorting.  Doing so makes the column header clickable.
 
470
   * @param sort_column_id The @a sort_column_id of the model to sort on.
 
471
   */
 
472
  void set_sort_column(const TreeModelColumnBase& sort_column_id);
 
473
  
 
474
  /** Sets the logical @a sort_column_id that this column sorts on when this column 
 
475
   * is selected for sorting.  Doing so makes the column header clickable.
 
476
   * @param sort_column_id The @a sort_column_id of the model to sort on.
 
477
   */
 
478
  void set_sort_column(int sort_column_id);
 
479
 
 
480
  
 
481
  /** Gets the logical @a sort_column_id that the model sorts on when this
 
482
   * column is selected for sorting.
 
483
   * See set_sort_column_id().
 
484
   * @return The current @a sort_column_id for this column, or -1 if
 
485
   * this column can't be used for sorting.
 
486
   */
 
487
  int get_sort_column_id() const;
 
488
  
 
489
  /** Call this function with a @a setting of <tt>true</tt> to display an arrow in
 
490
   * the header button indicating the column is sorted. Call
 
491
   * set_sort_order() to change the direction of
 
492
   * the arrow.
 
493
   * @param setting <tt>true</tt> to display an indicator that the column is sorted.
 
494
   */
 
495
  void set_sort_indicator(bool setting);
 
496
  
 
497
  /** Gets the value set by set_sort_indicator().
 
498
   * @return Whether the sort indicator arrow is displayed.
 
499
   */
 
500
  bool get_sort_indicator() const;
 
501
  
 
502
  /** Changes the appearance of the sort indicator. 
 
503
   * 
 
504
   * This <em>does not</em> actually sort the model.  Use
 
505
   * set_sort_column_id() if you want automatic sorting
 
506
   * support.  This function is primarily for custom sorting behavior, and should
 
507
   * be used in conjunction with gtk_tree_sortable_set_sort_column() to do
 
508
   * that. For custom models, the mechanism will vary. 
 
509
   * 
 
510
   * The sort indicator changes direction to indicate normal sort or reverse sort.
 
511
   * Note that you must have the sort indicator enabled to see anything when 
 
512
   * calling this function; see set_sort_indicator().
 
513
   * @param order Sort order that the sort indicator should indicate.
 
514
   */
 
515
  void set_sort_order(SortType order);
 
516
  
 
517
  /** Gets the value set by set_sort_order().
 
518
   * @return The sort order the sort indicator is indicating.
 
519
   */
 
520
  SortType get_sort_order() const;
 
521
 
 
522
 
 
523
  /** Sets the cell renderer based on the @a tree_model and @a iter.  That is, for
 
524
   * every attribute mapping in @a tree_column, it will get a value from the set
 
525
   * column on the @a iter, and use that value to set the attribute on the cell
 
526
   * renderer.  This is used primarily by the Gtk::TreeView.
 
527
   * @param tree_model The Gtk::TreeModel to to get the cell renderers attributes from.
 
528
   * @param iter The Gtk::TreeIter to to get the cell renderer's attributes from.
 
529
   * @param is_expander <tt>true</tt>, if the row has children.
 
530
   * @param is_expanded <tt>true</tt>, if the row has visible children.
 
531
   */
 
532
  void cell_set_cell_data(const Glib::RefPtr<TreeModel>& tree_model, const TreeModel::iterator& iter, bool is_expander, bool is_expanded);
 
533
 
 
534
  //TODO: cell_area can be NULL. Add a method override.
 
535
  //But see http://bugzilla.gnome.org/show_bug.cgi?id=542329 about the lack of C documentation.
 
536
  
 
537
  /** Obtains the width and height needed to render the column.  This is used
 
538
   * primarily by the Gtk::TreeView.
 
539
   * @param cell_area The area a cell in the column will be allocated.
 
540
   * @param x_offset Location to return x offset of a cell relative to @a cell_area.
 
541
   * @param y_offset Location to return y offset of a cell relative to @a cell_area.
 
542
   * @param width Location to return width needed to render a cell.
 
543
   * @param height Location to return height needed to render a cell.
 
544
   */
 
545
  void cell_get_size(const Gdk::Rectangle& cell_area, int& x_offset, int& y_offset, int& width, int& height) const;
 
546
 
 
547
  
 
548
  /** Returns <tt>true</tt> if any of the cells packed into the @a tree_column are visible.
 
549
   * For this to be meaningful, you must first initialize the cells with
 
550
   * cell_set_cell_data()
 
551
   * @return <tt>true</tt>, if any of the cells packed into the @a tree_column are currently visible.
 
552
   */
 
553
  bool cell_is_visible() const;
 
554
  
 
555
  /** Sets the current keyboard focus to be at @a cell, if the column contains
 
556
   * 2 or more editable and activatable cells.
 
557
   * 
 
558
   * @newin{2,2}
 
559
   * @param cell A Gtk::CellRenderer.
 
560
   */
 
561
  void focus_cell(CellRenderer& cell);
 
562
 
 
563
  
 
564
  /** Obtains the horizontal position and size of a cell in a column. If the
 
565
   * cell is not found in the column, @a start_pos and @a width are not changed and
 
566
   * <tt>false</tt> is returned.
 
567
   * @param cell_renderer A Gtk::CellRenderer.
 
568
   * @param start_pos Return location for the horizontal position of @a cell within
 
569
   *  @a tree_column.
 
570
   * @param width Return location for the width of @a cell.
 
571
   * @return <tt>true</tt> if @a cell belongs to @a tree_column.
 
572
   */
 
573
  bool get_cell_position(const CellRenderer& cell_renderer, int& start_pos, int& width) const;
 
574
  
 
575
  /** Flags the column, and the cell renderers added to this column, to have
 
576
   * their sizes renegotiated.
 
577
   * 
 
578
   * @newin{2,8}
 
579
   */
 
580
  void queue_resize();
 
581
 
 
582
  
 
583
  /** Returns the Gtk::TreeView wherein @a tree_column has been inserted.  If
 
584
   *  @a column is currently not inserted in any tree view, <tt>0</tt> is
 
585
   * returned.
 
586
   * 
 
587
   * @newin{2,12}
 
588
   * @return The tree view wherein @a column has been inserted if any,
 
589
   * <tt>0</tt> otherwise.
 
590
   */
 
591
  TreeView* get_tree_view();
 
592
  
 
593
  /** Returns the Gtk::TreeView wherein @a tree_column has been inserted.  If
 
594
   *  @a column is currently not inserted in any tree view, <tt>0</tt> is
 
595
   * returned.
 
596
   * 
 
597
   * @newin{2,12}
 
598
   * @return The tree view wherein @a column has been inserted if any,
 
599
   * <tt>0</tt> otherwise.
 
600
   */
 
601
  const TreeView* get_tree_view() const;
 
602
 
 
603
  
 
604
  Button* get_button();
 
605
  
 
606
  const Button* get_button() const;
 
607
  
 
608
  
 
609
  /**
 
610
   * @par Prototype:
 
611
   * <tt>void on_my_%clicked()</tt>
 
612
   */
 
613
 
 
614
  Glib::SignalProxy0< void > signal_clicked();
 
615
 
 
616
 
 
617
  #ifdef GLIBMM_PROPERTIES_ENABLED
 
618
/** Whether to display the column.
 
619
   *
 
620
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 
621
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 
622
   * the value of the property changes.
 
623
   */
 
624
  Glib::PropertyProxy<bool> property_visible() ;
 
625
#endif //#GLIBMM_PROPERTIES_ENABLED
 
626
 
 
627
#ifdef GLIBMM_PROPERTIES_ENABLED
 
628
/** Whether to display the column.
 
629
   *
 
630
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 
631
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 
632
   * the value of the property changes.
 
633
   */
 
634
  Glib::PropertyProxy_ReadOnly<bool> property_visible() const;
 
635
#endif //#GLIBMM_PROPERTIES_ENABLED
 
636
 
 
637
  #ifdef GLIBMM_PROPERTIES_ENABLED
 
638
/** Column is user-resizable.
 
639
   *
 
640
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 
641
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 
642
   * the value of the property changes.
 
643
   */
 
644
  Glib::PropertyProxy<bool> property_resizable() ;
 
645
#endif //#GLIBMM_PROPERTIES_ENABLED
 
646
 
 
647
#ifdef GLIBMM_PROPERTIES_ENABLED
 
648
/** Column is user-resizable.
 
649
   *
 
650
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 
651
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 
652
   * the value of the property changes.
 
653
   */
 
654
  Glib::PropertyProxy_ReadOnly<bool> property_resizable() const;
 
655
#endif //#GLIBMM_PROPERTIES_ENABLED
 
656
 
 
657
  #ifdef GLIBMM_PROPERTIES_ENABLED
 
658
/** Current width of the column.
 
659
   *
 
660
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 
661
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 
662
   * the value of the property changes.
 
663
   */
 
664
  Glib::PropertyProxy_ReadOnly<int> property_width() const;
 
665
#endif //#GLIBMM_PROPERTIES_ENABLED
 
666
 
 
667
 
 
668
  #ifdef GLIBMM_PROPERTIES_ENABLED
 
669
/** Space which is inserted between cells.
 
670
   *
 
671
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 
672
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 
673
   * the value of the property changes.
 
674
   */
 
675
  Glib::PropertyProxy<int> property_spacing() ;
 
676
#endif //#GLIBMM_PROPERTIES_ENABLED
 
677
 
 
678
#ifdef GLIBMM_PROPERTIES_ENABLED
 
679
/** Space which is inserted between cells.
 
680
   *
 
681
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 
682
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 
683
   * the value of the property changes.
 
684
   */
 
685
  Glib::PropertyProxy_ReadOnly<int> property_spacing() const;
 
686
#endif //#GLIBMM_PROPERTIES_ENABLED
 
687
 
 
688
  #ifdef GLIBMM_PROPERTIES_ENABLED
 
689
/** Resize mode of the column.
 
690
   *
 
691
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 
692
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 
693
   * the value of the property changes.
 
694
   */
 
695
  Glib::PropertyProxy<TreeViewColumnSizing> property_sizing() ;
 
696
#endif //#GLIBMM_PROPERTIES_ENABLED
 
697
 
 
698
#ifdef GLIBMM_PROPERTIES_ENABLED
 
699
/** Resize mode of the column.
 
700
   *
 
701
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 
702
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 
703
   * the value of the property changes.
 
704
   */
 
705
  Glib::PropertyProxy_ReadOnly<TreeViewColumnSizing> property_sizing() const;
 
706
#endif //#GLIBMM_PROPERTIES_ENABLED
 
707
 
 
708
  #ifdef GLIBMM_PROPERTIES_ENABLED
 
709
/** Current fixed width of the column.
 
710
   *
 
711
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 
712
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 
713
   * the value of the property changes.
 
714
   */
 
715
  Glib::PropertyProxy<int> property_fixed_width() ;
 
716
#endif //#GLIBMM_PROPERTIES_ENABLED
 
717
 
 
718
#ifdef GLIBMM_PROPERTIES_ENABLED
 
719
/** Current fixed width of the column.
 
720
   *
 
721
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 
722
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 
723
   * the value of the property changes.
 
724
   */
 
725
  Glib::PropertyProxy_ReadOnly<int> property_fixed_width() const;
 
726
#endif //#GLIBMM_PROPERTIES_ENABLED
 
727
 
 
728
  #ifdef GLIBMM_PROPERTIES_ENABLED
 
729
/** Minimum allowed width of the column.
 
730
   *
 
731
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 
732
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 
733
   * the value of the property changes.
 
734
   */
 
735
  Glib::PropertyProxy<int> property_min_width() ;
 
736
#endif //#GLIBMM_PROPERTIES_ENABLED
 
737
 
 
738
#ifdef GLIBMM_PROPERTIES_ENABLED
 
739
/** Minimum allowed width of the column.
 
740
   *
 
741
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 
742
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 
743
   * the value of the property changes.
 
744
   */
 
745
  Glib::PropertyProxy_ReadOnly<int> property_min_width() const;
 
746
#endif //#GLIBMM_PROPERTIES_ENABLED
 
747
 
 
748
  #ifdef GLIBMM_PROPERTIES_ENABLED
 
749
/** Maximum allowed width of the column.
 
750
   *
 
751
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 
752
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 
753
   * the value of the property changes.
 
754
   */
 
755
  Glib::PropertyProxy<int> property_max_width() ;
 
756
#endif //#GLIBMM_PROPERTIES_ENABLED
 
757
 
 
758
#ifdef GLIBMM_PROPERTIES_ENABLED
 
759
/** Maximum allowed width of the column.
 
760
   *
 
761
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 
762
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 
763
   * the value of the property changes.
 
764
   */
 
765
  Glib::PropertyProxy_ReadOnly<int> property_max_width() const;
 
766
#endif //#GLIBMM_PROPERTIES_ENABLED
 
767
 
 
768
  #ifdef GLIBMM_PROPERTIES_ENABLED
 
769
/** Title to appear in column header.
 
770
   *
 
771
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 
772
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 
773
   * the value of the property changes.
 
774
   */
 
775
  Glib::PropertyProxy<Glib::ustring> property_title() ;
 
776
#endif //#GLIBMM_PROPERTIES_ENABLED
 
777
 
 
778
#ifdef GLIBMM_PROPERTIES_ENABLED
 
779
/** Title to appear in column header.
 
780
   *
 
781
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 
782
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 
783
   * the value of the property changes.
 
784
   */
 
785
  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_title() const;
 
786
#endif //#GLIBMM_PROPERTIES_ENABLED
 
787
 
 
788
  #ifdef GLIBMM_PROPERTIES_ENABLED
 
789
/** Column gets share of extra width allocated to the widget.
 
790
   *
 
791
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 
792
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 
793
   * the value of the property changes.
 
794
   */
 
795
  Glib::PropertyProxy<bool> property_expand() ;
 
796
#endif //#GLIBMM_PROPERTIES_ENABLED
 
797
 
 
798
#ifdef GLIBMM_PROPERTIES_ENABLED
 
799
/** Column gets share of extra width allocated to the widget.
 
800
   *
 
801
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 
802
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 
803
   * the value of the property changes.
 
804
   */
 
805
  Glib::PropertyProxy_ReadOnly<bool> property_expand() const;
 
806
#endif //#GLIBMM_PROPERTIES_ENABLED
 
807
 
 
808
  #ifdef GLIBMM_PROPERTIES_ENABLED
 
809
/** Whether the header can be clicked.
 
810
   *
 
811
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 
812
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 
813
   * the value of the property changes.
 
814
   */
 
815
  Glib::PropertyProxy<bool> property_clickable() ;
 
816
#endif //#GLIBMM_PROPERTIES_ENABLED
 
817
 
 
818
#ifdef GLIBMM_PROPERTIES_ENABLED
 
819
/** Whether the header can be clicked.
 
820
   *
 
821
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 
822
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 
823
   * the value of the property changes.
 
824
   */
 
825
  Glib::PropertyProxy_ReadOnly<bool> property_clickable() const;
 
826
#endif //#GLIBMM_PROPERTIES_ENABLED
 
827
 
 
828
  #ifdef GLIBMM_PROPERTIES_ENABLED
 
829
/** Widget to put in column header button instead of column title.
 
830
   *
 
831
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 
832
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 
833
   * the value of the property changes.
 
834
   */
 
835
  Glib::PropertyProxy<Widget*> property_widget() ;
 
836
#endif //#GLIBMM_PROPERTIES_ENABLED
 
837
 
 
838
#ifdef GLIBMM_PROPERTIES_ENABLED
 
839
/** Widget to put in column header button instead of column title.
 
840
   *
 
841
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 
842
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 
843
   * the value of the property changes.
 
844
   */
 
845
  Glib::PropertyProxy_ReadOnly<Widget*> property_widget() const;
 
846
#endif //#GLIBMM_PROPERTIES_ENABLED
 
847
 
 
848
  #ifdef GLIBMM_PROPERTIES_ENABLED
 
849
/** X Alignment of the column header text or widget.
 
850
   *
 
851
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 
852
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 
853
   * the value of the property changes.
 
854
   */
 
855
  Glib::PropertyProxy<float> property_alignment() ;
 
856
#endif //#GLIBMM_PROPERTIES_ENABLED
 
857
 
 
858
#ifdef GLIBMM_PROPERTIES_ENABLED
 
859
/** X Alignment of the column header text or widget.
 
860
   *
 
861
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 
862
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 
863
   * the value of the property changes.
 
864
   */
 
865
  Glib::PropertyProxy_ReadOnly<float> property_alignment() const;
 
866
#endif //#GLIBMM_PROPERTIES_ENABLED
 
867
 
 
868
  #ifdef GLIBMM_PROPERTIES_ENABLED
 
869
/** Whether the column can be reordered around the headers.
 
870
   *
 
871
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 
872
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 
873
   * the value of the property changes.
 
874
   */
 
875
  Glib::PropertyProxy<bool> property_reorderable() ;
 
876
#endif //#GLIBMM_PROPERTIES_ENABLED
 
877
 
 
878
#ifdef GLIBMM_PROPERTIES_ENABLED
 
879
/** Whether the column can be reordered around the headers.
 
880
   *
 
881
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 
882
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 
883
   * the value of the property changes.
 
884
   */
 
885
  Glib::PropertyProxy_ReadOnly<bool> property_reorderable() const;
 
886
#endif //#GLIBMM_PROPERTIES_ENABLED
 
887
 
 
888
  #ifdef GLIBMM_PROPERTIES_ENABLED
 
889
/** Whether to show a sort indicator.
 
890
   *
 
891
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 
892
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 
893
   * the value of the property changes.
 
894
   */
 
895
  Glib::PropertyProxy<bool> property_sort_indicator() ;
 
896
#endif //#GLIBMM_PROPERTIES_ENABLED
 
897
 
 
898
#ifdef GLIBMM_PROPERTIES_ENABLED
 
899
/** Whether to show a sort indicator.
 
900
   *
 
901
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 
902
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 
903
   * the value of the property changes.
 
904
   */
 
905
  Glib::PropertyProxy_ReadOnly<bool> property_sort_indicator() const;
 
906
#endif //#GLIBMM_PROPERTIES_ENABLED
 
907
 
 
908
  #ifdef GLIBMM_PROPERTIES_ENABLED
 
909
/** Sort direction the sort indicator should indicate.
 
910
   *
 
911
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 
912
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 
913
   * the value of the property changes.
 
914
   */
 
915
  Glib::PropertyProxy<SortType> property_sort_order() ;
 
916
#endif //#GLIBMM_PROPERTIES_ENABLED
 
917
 
 
918
#ifdef GLIBMM_PROPERTIES_ENABLED
 
919
/** Sort direction the sort indicator should indicate.
 
920
   *
 
921
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 
922
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 
923
   * the value of the property changes.
 
924
   */
 
925
  Glib::PropertyProxy_ReadOnly<SortType> property_sort_order() const;
 
926
#endif //#GLIBMM_PROPERTIES_ENABLED
 
927
 
 
928
  #ifdef GLIBMM_PROPERTIES_ENABLED
 
929
/** Logical sort column ID this column sorts on when selected for sorting.
 
930
   *
 
931
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 
932
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 
933
   * the value of the property changes.
 
934
   */
 
935
  Glib::PropertyProxy<int> property_sort_column_id() ;
 
936
#endif //#GLIBMM_PROPERTIES_ENABLED
 
937
 
 
938
#ifdef GLIBMM_PROPERTIES_ENABLED
 
939
/** Logical sort column ID this column sorts on when selected for sorting.
 
940
   *
 
941
   * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
 
942
   * @return A PropertyProxy that allows you to get or set the property of the value, or receive notification when
 
943
   * the value of the property changes.
 
944
   */
 
945
  Glib::PropertyProxy_ReadOnly<int> property_sort_column_id() const;
 
946
#endif //#GLIBMM_PROPERTIES_ENABLED
 
947
 
 
948
 
 
949
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
950
private:
 
951
  // Only necessary because of the templated ctor, see below.
 
952
  static const Glib::Class& class_init_();
 
953
#endif //DOXYGEN_SHOULD_SKIP_THIS
 
954
 
 
955
 
 
956
};
 
957
 
 
958
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
959
 
 
960
template<class T_ModelColumnType> inline
 
961
void TreeViewColumn::pack_start(const TreeModelColumn<T_ModelColumnType>& column, bool expand)
 
962
{
 
963
  //Generate appropriate Renderer for the column:
 
964
  CellRenderer* pCellRenderer = manage( CellRenderer_Generation::generate_cellrenderer<T_ModelColumnType>() );
 
965
 
 
966
  //Use the renderer:
 
967
  pack_start(*pCellRenderer, expand);
 
968
  set_renderer(*pCellRenderer, column);
 
969
}
 
970
 
 
971
template<class T_ModelColumnType> inline
 
972
void TreeViewColumn::pack_end(const TreeModelColumn<T_ModelColumnType>& column, bool expand)
 
973
{
 
974
  //Generate appropriate Renderer for the column:
 
975
  CellRenderer* pCellRenderer= manage( CellRenderer_Generation::generate_cellrenderer<T_ModelColumnType>() );
 
976
 
 
977
  //Use the renderer:
 
978
  pack_end(*pCellRenderer, expand);
 
979
  set_renderer(*pCellRenderer, column);
 
980
}
 
981
 
 
982
template <class T_ModelColumnType> inline
 
983
TreeViewColumn::TreeViewColumn(const Glib::ustring& title,
 
984
                               const TreeModelColumn<T_ModelColumnType>& column)
 
985
:
 
986
  Glib::ObjectBase(0), // not (yet) a custom class
 
987
  Gtk::Object(Glib::ConstructParams(class_init_(), "title", title.c_str(), (char*) 0))
 
988
{
 
989
  pack_start(column, true /* expand */);
 
990
}
 
991
 
 
992
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
993
 
 
994
} // namespace Gtk
 
995
 
 
996
 
 
997
namespace Glib
 
998
{
 
999
  /** A Glib::wrap() method for this object.
 
1000
   * 
 
1001
   * @param object The C instance.
 
1002
   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
 
1003
   * @result A C++ instance that wraps this C instance.
 
1004
   *
 
1005
   * @relates Gtk::TreeViewColumn
 
1006
   */
 
1007
  Gtk::TreeViewColumn* wrap(GtkTreeViewColumn* object, bool take_copy = false);
 
1008
} //namespace Glib
 
1009
 
 
1010
 
 
1011
#endif /* _GTKMM_TREEVIEWCOLUMN_H */
 
1012