← Back to branch summary

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

« back to all changes in this revision

Viewing changes to gtk/gtkmm/cellrenderertoggle.cc

  • 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:
gtk/gtkmm/cellrenderertoggle.cc
 
1
// Generated by gtkmmproc -- DO NOT MODIFY!
 
2
 
 
3
 
 
4
#include <gtkmm/cellrenderertoggle.h>
 
5
#include <gtkmm/private/cellrenderertoggle_p.h>
 
6
 
 
7
// -*- c++ -*-
 
8
/* $Id: cellrenderertoggle.ccg,v 1.2 2006/05/10 20:59:27 murrayc Exp $ */
 
9
 
 
10
/* 
 
11
 *
 
12
 * Copyright 1998-2002 The gtkmm Development Team
 
13
 *
 
14
 * This library is free software; you can redistribute it and/or
 
15
 * modify it under the terms of the GNU Lesser General Public
 
16
 * License as published by the Free Software Foundation; either
 
17
 * version 2.1 of the License, or (at your option) any later version.
 
18
 *
 
19
 * This library is distributed in the hope that it will be useful,
 
20
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
21
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
22
 * Lesser General Public License for more details.
 
23
 *
 
24
 * You should have received a copy of the GNU Lesser General Public
 
25
 * License along with this library; if not, write to the Free
 
26
 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
27
 */
 
28
 
 
29
#include <gtk/gtk.h>
 
30
 
 
31
namespace Gtk
 
32
{
 
33
 
 
34
Glib::PropertyProxy_Base CellRendererToggle::_property_renderable()
 
35
{
 
36
  return property_active();
 
37
}
 
38
 
 
39
} //namespace Gtk
 
40
 
 
41
namespace
 
42
{
 
43
 
 
44
 
 
45
static void CellRendererToggle_signal_toggled_callback(GtkCellRendererToggle* self, const gchar* p0,void* data)
 
46
{
 
47
  using namespace Gtk;
 
48
  typedef sigc::slot< void,const Glib::ustring& > SlotType;
 
49
 
 
50
  // Do not try to call a signal on a disassociated wrapper.
 
51
  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
 
52
  {
 
53
    #ifdef GLIBMM_EXCEPTIONS_ENABLED
 
54
    try
 
55
    {
 
56
    #endif //GLIBMM_EXCEPTIONS_ENABLED
 
57
      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
 
58
        (*static_cast<SlotType*>(slot))(Glib::convert_const_gchar_ptr_to_ustring(p0)
 
59
);
 
60
    #ifdef GLIBMM_EXCEPTIONS_ENABLED
 
61
    }
 
62
    catch(...)
 
63
    {
 
64
      Glib::exception_handlers_invoke();
 
65
    }
 
66
    #endif //GLIBMM_EXCEPTIONS_ENABLED
 
67
  }
 
68
}
 
69
 
 
70
static const Glib::SignalProxyInfo CellRendererToggle_signal_toggled_info =
 
71
{
 
72
  "toggled",
 
73
  (GCallback) &CellRendererToggle_signal_toggled_callback,
 
74
  (GCallback) &CellRendererToggle_signal_toggled_callback
 
75
};
 
76
 
 
77
 
 
78
} // anonymous namespace
 
79
 
 
80
 
 
81
namespace Glib
 
82
{
 
83
 
 
84
Gtk::CellRendererToggle* wrap(GtkCellRendererToggle* object, bool take_copy)
 
85
{
 
86
  return dynamic_cast<Gtk::CellRendererToggle *> (Glib::wrap_auto ((GObject*)(object), take_copy));
 
87
}
 
88
 
 
89
} /* namespace Glib */
 
90
 
 
91
namespace Gtk
 
92
{
 
93
 
 
94
 
 
95
/* The *_Class implementation: */
 
96
 
 
97
const Glib::Class& CellRendererToggle_Class::init()
 
98
{
 
99
  if(!gtype_) // create the GType if necessary
 
100
  {
 
101
    // Glib::Class has to know the class init function to clone custom types.
 
102
    class_init_func_ = &CellRendererToggle_Class::class_init_function;
 
103
 
 
104
    // This is actually just optimized away, apparently with no harm.
 
105
    // Make sure that the parent type has been created.
 
106
    //CppClassParent::CppObjectType::get_type();
 
107
 
 
108
    // Create the wrapper type, with the same class/instance size as the base type.
 
109
    register_derived_type(gtk_cell_renderer_toggle_get_type());
 
110
 
 
111
    // Add derived versions of interfaces, if the C type implements any interfaces:
 
112
 
 
113
  }
 
114
 
 
115
  return *this;
 
116
}
 
117
 
 
118
 
 
119
void CellRendererToggle_Class::class_init_function(void* g_class, void* class_data)
 
120
{
 
121
  BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
 
122
  CppClassParent::class_init_function(klass, class_data);
 
123
 
 
124
 
 
125
  klass->toggled = &toggled_callback;
 
126
}
 
127
 
 
128
 
 
129
void CellRendererToggle_Class::toggled_callback(GtkCellRendererToggle* self, const gchar* p0)
 
130
{
 
131
  Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
 
132
      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 
133
 
 
134
  // Non-gtkmmproc-generated custom classes implicitly call the default
 
135
  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 
136
  // generated classes can use this optimisation, which avoids the unnecessary
 
137
  // parameter conversions if there is no possibility of the virtual function
 
138
  // being overridden:
 
139
  if(obj_base && obj_base->is_derived_())
 
140
  {
 
141
    CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
 
142
    if(obj) // This can be NULL during destruction.
 
143
    {
 
144
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
 
145
      try // Trap C++ exceptions which would normally be lost because this is a C callback.
 
146
      {
 
147
      #endif //GLIBMM_EXCEPTIONS_ENABLED
 
148
        // Call the virtual member method, which derived classes might override.
 
149
        obj->on_toggled(Glib::convert_const_gchar_ptr_to_ustring(p0)
 
150
);
 
151
        return;
 
152
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
 
153
      }
 
154
      catch(...)
 
155
      {
 
156
        Glib::exception_handlers_invoke();
 
157
      }
 
158
      #endif //GLIBMM_EXCEPTIONS_ENABLED
 
159
    }
 
160
  }
 
161
  
 
162
  BaseClassType *const base = static_cast<BaseClassType*>(
 
163
        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class (The original underlying C class).
 
164
    );
 
165
 
 
166
  // Call the original underlying C function:
 
167
  if(base && base->toggled)
 
168
    (*base->toggled)(self, p0);
 
169
}
 
170
 
 
171
 
 
172
Glib::ObjectBase* CellRendererToggle_Class::wrap_new(GObject* o)
 
173
{
 
174
  return manage(new CellRendererToggle((GtkCellRendererToggle*)(o)));
 
175
 
 
176
}
 
177
 
 
178
 
 
179
/* The implementation: */
 
180
 
 
181
CellRendererToggle::CellRendererToggle(const Glib::ConstructParams& construct_params)
 
182
:
 
183
  Gtk::CellRenderer(construct_params)
 
184
{
 
185
  }
 
186
 
 
187
CellRendererToggle::CellRendererToggle(GtkCellRendererToggle* castitem)
 
188
:
 
189
  Gtk::CellRenderer((GtkCellRenderer*)(castitem))
 
190
{
 
191
  }
 
192
 
 
193
CellRendererToggle::~CellRendererToggle()
 
194
{
 
195
  destroy_();
 
196
}
 
197
 
 
198
CellRendererToggle::CppClassType CellRendererToggle::cellrenderertoggle_class_; // initialize static member
 
199
 
 
200
GType CellRendererToggle::get_type()
 
201
{
 
202
  return cellrenderertoggle_class_.init().get_type();
 
203
}
 
204
 
 
205
 
 
206
GType CellRendererToggle::get_base_type()
 
207
{
 
208
  return gtk_cell_renderer_toggle_get_type();
 
209
}
 
210
 
 
211
 
 
212
CellRendererToggle::CellRendererToggle()
 
213
:
 
214
  // Mark this class as non-derived to allow C++ vfuncs to be skipped.
 
215
  Glib::ObjectBase(0),
 
216
  Gtk::CellRenderer(Glib::ConstructParams(cellrenderertoggle_class_.init()))
 
217
{
 
218
  
 
219
 
 
220
}
 
221
 
 
222
bool CellRendererToggle::get_radio() const
 
223
{
 
224
  return gtk_cell_renderer_toggle_get_radio(const_cast<GtkCellRendererToggle*>(gobj()));
 
225
}
 
226
 
 
227
void CellRendererToggle::set_radio(bool radio)
 
228
{
 
229
gtk_cell_renderer_toggle_set_radio(gobj(), static_cast<int>(radio)); 
 
230
}
 
231
 
 
232
bool CellRendererToggle::get_active() const
 
233
{
 
234
  return gtk_cell_renderer_toggle_get_active(const_cast<GtkCellRendererToggle*>(gobj()));
 
235
}
 
236
 
 
237
void CellRendererToggle::set_active(bool setting)
 
238
{
 
239
gtk_cell_renderer_toggle_set_active(gobj(), static_cast<int>(setting)); 
 
240
}
 
241
 
 
242
bool CellRendererToggle::get_activatable() const
 
243
{
 
244
  return gtk_cell_renderer_toggle_get_activatable(const_cast<GtkCellRendererToggle*>(gobj()));
 
245
}
 
246
 
 
247
void CellRendererToggle::set_activatable(bool setting)
 
248
{
 
249
gtk_cell_renderer_toggle_set_activatable(gobj(), static_cast<int>(setting)); 
 
250
}
 
251
 
 
252
 
 
253
Glib::SignalProxy1< void,const Glib::ustring& > CellRendererToggle::signal_toggled()
 
254
{
 
255
  return Glib::SignalProxy1< void,const Glib::ustring& >(this, &CellRendererToggle_signal_toggled_info);
 
256
}
 
257
 
 
258
 
 
259
#ifdef GLIBMM_PROPERTIES_ENABLED
 
260
Glib::PropertyProxy<bool> CellRendererToggle::property_activatable() 
 
261
{
 
262
  return Glib::PropertyProxy<bool>(this, "activatable");
 
263
}
 
264
#endif //GLIBMM_PROPERTIES_ENABLED
 
265
 
 
266
#ifdef GLIBMM_PROPERTIES_ENABLED
 
267
Glib::PropertyProxy_ReadOnly<bool> CellRendererToggle::property_activatable() const
 
268
{
 
269
  return Glib::PropertyProxy_ReadOnly<bool>(this, "activatable");
 
270
}
 
271
#endif //GLIBMM_PROPERTIES_ENABLED
 
272
 
 
273
#ifdef GLIBMM_PROPERTIES_ENABLED
 
274
Glib::PropertyProxy<bool> CellRendererToggle::property_active() 
 
275
{
 
276
  return Glib::PropertyProxy<bool>(this, "active");
 
277
}
 
278
#endif //GLIBMM_PROPERTIES_ENABLED
 
279
 
 
280
#ifdef GLIBMM_PROPERTIES_ENABLED
 
281
Glib::PropertyProxy_ReadOnly<bool> CellRendererToggle::property_active() const
 
282
{
 
283
  return Glib::PropertyProxy_ReadOnly<bool>(this, "active");
 
284
}
 
285
#endif //GLIBMM_PROPERTIES_ENABLED
 
286
 
 
287
#ifdef GLIBMM_PROPERTIES_ENABLED
 
288
Glib::PropertyProxy<bool> CellRendererToggle::property_inconsistent() 
 
289
{
 
290
  return Glib::PropertyProxy<bool>(this, "inconsistent");
 
291
}
 
292
#endif //GLIBMM_PROPERTIES_ENABLED
 
293
 
 
294
#ifdef GLIBMM_PROPERTIES_ENABLED
 
295
Glib::PropertyProxy_ReadOnly<bool> CellRendererToggle::property_inconsistent() const
 
296
{
 
297
  return Glib::PropertyProxy_ReadOnly<bool>(this, "inconsistent");
 
298
}
 
299
#endif //GLIBMM_PROPERTIES_ENABLED
 
300
 
 
301
#ifdef GLIBMM_PROPERTIES_ENABLED
 
302
Glib::PropertyProxy<bool> CellRendererToggle::property_radio() 
 
303
{
 
304
  return Glib::PropertyProxy<bool>(this, "radio");
 
305
}
 
306
#endif //GLIBMM_PROPERTIES_ENABLED
 
307
 
 
308
#ifdef GLIBMM_PROPERTIES_ENABLED
 
309
Glib::PropertyProxy_ReadOnly<bool> CellRendererToggle::property_radio() const
 
310
{
 
311
  return Glib::PropertyProxy_ReadOnly<bool>(this, "radio");
 
312
}
 
313
#endif //GLIBMM_PROPERTIES_ENABLED
 
314
 
 
315
#ifdef GLIBMM_PROPERTIES_ENABLED
 
316
Glib::PropertyProxy<int> CellRendererToggle::property_indicator_size() 
 
317
{
 
318
  return Glib::PropertyProxy<int>(this, "indicator-size");
 
319
}
 
320
#endif //GLIBMM_PROPERTIES_ENABLED
 
321
 
 
322
#ifdef GLIBMM_PROPERTIES_ENABLED
 
323
Glib::PropertyProxy_ReadOnly<int> CellRendererToggle::property_indicator_size() const
 
324
{
 
325
  return Glib::PropertyProxy_ReadOnly<int>(this, "indicator-size");
 
326
}
 
327
#endif //GLIBMM_PROPERTIES_ENABLED
 
328
 
 
329
 
 
330
void Gtk::CellRendererToggle::on_toggled(const Glib::ustring& path)
 
331
{
 
332
  BaseClassType *const base = static_cast<BaseClassType*>(
 
333
      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_)) // Get the parent class of the object class (The original underlying C class).
 
334
  );
 
335
 
 
336
  if(base && base->toggled)
 
337
    (*base->toggled)(gobj(),path.c_str());
 
338
}
 
339
 
 
340
 
 
341
} // namespace Gtk
 
342
 
 
343