← Back to branch summary

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

« back to all changes in this revision

Viewing changes to gtk/gtkmm/recentchooser.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/recentchooser.cc
 
1
// Generated by gtkmmproc -- DO NOT MODIFY!
 
2
 
 
3
 
 
4
#include <gtkmm/recentchooser.h>
 
5
#include <gtkmm/private/recentchooser_p.h>
 
6
 
 
7
/* Copyright 2006 The gtkmm Development Team
 
8
 *
 
9
 * This library is free software; you can redistribute it and/or
 
10
 * modify it under the terms of the GNU Lesser General Public
 
11
 * License as published by the Free Software Foundation; either
 
12
 * version 2.1 of the License, or (at your option) any later version.
 
13
 *
 
14
 * This library is distributed in the hope that it will be useful,
 
15
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
16
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
17
 * Lesser General Public License for more details.
 
18
 *
 
19
 * You should have received a copy of the GNU Lesser General Public
 
20
 * License along with this library; if not, write to the Free
 
21
 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
22
 */
 
23
 
 
24
#include <glibmm/vectorutils.h>
 
25
 
 
26
#include <gtk/gtk.h>
 
27
 
 
28
// This Signal Proxy allows the C++ coder to specify a sigc::slot instead of a static function.
 
29
 
 
30
static int SignalProxy_Compare_gtk_callback(GtkRecentInfo* a, GtkRecentInfo* b, gpointer data)
 
31
{
 
32
  const Gtk::RecentChooser::SlotCompare* the_slot = static_cast<Gtk::RecentChooser::SlotCompare*>(data);
 
33
 
 
34
  try
 
35
  {
 
36
    return (*the_slot)(Glib::wrap(a, true /* take reference */), Glib::wrap(b, true /* take reference */));
 
37
  }
 
38
  catch(...)
 
39
  {
 
40
    Glib::exception_handlers_invoke();
 
41
  }
 
42
 
 
43
  return 0;
 
44
}
 
45
 
 
46
static void SignalProxy_Compare_gtk_callback_destroy(gpointer data)
 
47
{
 
48
  delete static_cast<Gtk::RecentChooser::SlotCompare*>(data);
 
49
}
 
50
 
 
51
 
 
52
namespace Gtk
 
53
{
 
54
 
 
55
void RecentChooser::set_sort_func(const SlotCompare& slot)
 
56
{
 
57
  SlotCompare* slot_copy = new SlotCompare(slot);
 
58
 
 
59
  gtk_recent_chooser_set_sort_func(
 
60
      gobj(),
 
61
      &SignalProxy_Compare_gtk_callback, slot_copy,
 
62
      &SignalProxy_Compare_gtk_callback_destroy);
 
63
}
 
64
 
 
65
std::vector<Glib::ustring> RecentChooser::get_uris() const
 
66
{
 
67
  return Glib::ArrayHandler<Glib::ustring>::array_to_vector(gtk_recent_chooser_get_uris(const_cast<GtkRecentChooser*>(gobj()), NULL), Glib::OWNERSHIP_DEEP);
 
68
}
 
69
 
 
70
void RecentChooser::unset_limit()
 
71
{
 
72
  gtk_recent_chooser_set_limit(gobj(), -1 /* See C docs */);
 
73
}
 
74
 
 
75
} // namespace Gtk
 
76
 
 
77
 
 
78
namespace
 
79
{
 
80
 
 
81
 
 
82
static const Glib::SignalProxyInfo RecentChooser_signal_selection_changed_info =
 
83
{
 
84
  "selection-changed",
 
85
  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
 
86
  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 
87
};
 
88
 
 
89
 
 
90
static const Glib::SignalProxyInfo RecentChooser_signal_item_activated_info =
 
91
{
 
92
  "item-activated",
 
93
  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
 
94
  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 
95
};
 
96
 
 
97
 
 
98
} // anonymous namespace
 
99
 
 
100
// static
 
101
GType Glib::Value<Gtk::RecentSortType>::value_type()
 
102
{
 
103
  return gtk_recent_sort_type_get_type();
 
104
}
 
105
 
 
106
 
 
107
Gtk::RecentChooserError::RecentChooserError(Gtk::RecentChooserError::Code error_code, const Glib::ustring& error_message)
 
108
:
 
109
  Glib::Error (GTK_RECENT_CHOOSER_ERROR, error_code, error_message)
 
110
{}
 
111
 
 
112
Gtk::RecentChooserError::RecentChooserError(GError* gobject)
 
113
:
 
114
  Glib::Error (gobject)
 
115
{}
 
116
 
 
117
Gtk::RecentChooserError::Code Gtk::RecentChooserError::code() const
 
118
{
 
119
  return static_cast<Code>(Glib::Error::code());
 
120
}
 
121
 
 
122
void Gtk::RecentChooserError::throw_func(GError* gobject)
 
123
{
 
124
  throw Gtk::RecentChooserError(gobject);
 
125
}
 
126
 
 
127
// static
 
128
GType Glib::Value<Gtk::RecentChooserError::Code>::value_type()
 
129
{
 
130
  return gtk_recent_chooser_error_get_type();
 
131
}
 
132
 
 
133
 
 
134
namespace Glib
 
135
{
 
136
 
 
137
Glib::RefPtr<Gtk::RecentChooser> wrap(GtkRecentChooser* object, bool take_copy)
 
138
{
 
139
  return Glib::RefPtr<Gtk::RecentChooser>( dynamic_cast<Gtk::RecentChooser*> (Glib::wrap_auto_interface<Gtk::RecentChooser> ((GObject*)(object), take_copy)) );
 
140
  //We use dynamic_cast<> in case of multiple inheritance.
 
141
}
 
142
 
 
143
} // namespace Glib
 
144
 
 
145
 
 
146
namespace Gtk
 
147
{
 
148
 
 
149
 
 
150
/* The *_Class implementation: */
 
151
 
 
152
const Glib::Interface_Class& RecentChooser_Class::init()
 
153
{
 
154
  if(!gtype_) // create the GType if necessary
 
155
  {
 
156
    // Glib::Interface_Class has to know the interface init function
 
157
    // in order to add interfaces to implementing types.
 
158
    class_init_func_ = &RecentChooser_Class::iface_init_function;
 
159
 
 
160
    // We can not derive from another interface, and it is not necessary anyway.
 
161
    gtype_ = gtk_recent_chooser_get_type();
 
162
  }
 
163
 
 
164
  return *this;
 
165
}
 
166
 
 
167
void RecentChooser_Class::iface_init_function(void* g_iface, void*)
 
168
{
 
169
  BaseClassType *const klass = static_cast<BaseClassType*>(g_iface);
 
170
 
 
171
  //This is just to avoid an "unused variable" warning when there are no vfuncs or signal handlers to connect.
 
172
  //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
 
173
  g_assert(klass != 0); 
 
174
 
 
175
  klass->get_current_uri = &get_current_uri_vfunc_callback;
 
176
  klass->unselect_uri = &unselect_uri_vfunc_callback;
 
177
  klass->select_all = &select_all_vfunc_callback;
 
178
  klass->unselect_all = &unselect_all_vfunc_callback;
 
179
  klass->get_recent_manager = &get_recent_manager_vfunc_callback;
 
180
  klass->add_filter = &add_filter_vfunc_callback;
 
181
  klass->remove_filter = &remove_filter_vfunc_callback;
 
182
 
 
183
  klass->selection_changed = &selection_changed_callback;
 
184
  klass->item_activated = &item_activated_callback;
 
185
}
 
186
 
 
187
gchar* RecentChooser_Class::get_current_uri_vfunc_callback(GtkRecentChooser* self)
 
188
{
 
189
  Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
 
190
      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 
191
 
 
192
  // Non-gtkmmproc-generated custom classes implicitly call the default
 
193
  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 
194
  // generated classes can use this optimisation, which avoids the unnecessary
 
195
  // parameter conversions if there is no possibility of the virtual function
 
196
  // being overridden:
 
197
  if(obj_base && obj_base->is_derived_())
 
198
  {
 
199
    CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
 
200
    if(obj) // This can be NULL during destruction.
 
201
    {
 
202
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
 
203
      try // Trap C++ exceptions which would normally be lost because this is a C callback.
 
204
      {
 
205
      #endif //GLIBMM_EXCEPTIONS_ENABLED
 
206
        // Call the virtual member method, which derived classes might override.
 
207
        return g_strdup((obj->get_current_uri_vfunc()).c_str());
 
208
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
 
209
      }
 
210
      catch(...)
 
211
      {
 
212
        Glib::exception_handlers_invoke();
 
213
      }
 
214
      #endif //GLIBMM_EXCEPTIONS_ENABLED
 
215
    }
 
216
  }
 
217
  
 
218
  BaseClassType *const base = static_cast<BaseClassType*>(
 
219
      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
 
220
g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
 
221
)  );
 
222
 
 
223
  // Call the original underlying C function:
 
224
  if(base && base->get_current_uri)
 
225
    return (*base->get_current_uri)(self);
 
226
 
 
227
 
 
228
  typedef gchar* RType;
 
229
  return RType();
 
230
}
 
231
void RecentChooser_Class::unselect_uri_vfunc_callback(GtkRecentChooser* self, const gchar* uri)
 
232
{
 
233
  Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
 
234
      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 
235
 
 
236
  // Non-gtkmmproc-generated custom classes implicitly call the default
 
237
  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 
238
  // generated classes can use this optimisation, which avoids the unnecessary
 
239
  // parameter conversions if there is no possibility of the virtual function
 
240
  // being overridden:
 
241
  if(obj_base && obj_base->is_derived_())
 
242
  {
 
243
    CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
 
244
    if(obj) // This can be NULL during destruction.
 
245
    {
 
246
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
 
247
      try // Trap C++ exceptions which would normally be lost because this is a C callback.
 
248
      {
 
249
      #endif //GLIBMM_EXCEPTIONS_ENABLED
 
250
        // Call the virtual member method, which derived classes might override.
 
251
        obj->unselect_uri_vfunc(Glib::convert_const_gchar_ptr_to_ustring(uri)
 
252
);
 
253
        return;
 
254
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
 
255
      }
 
256
      catch(...)
 
257
      {
 
258
        Glib::exception_handlers_invoke();
 
259
      }
 
260
      #endif //GLIBMM_EXCEPTIONS_ENABLED
 
261
    }
 
262
  }
 
263
  
 
264
  BaseClassType *const base = static_cast<BaseClassType*>(
 
265
      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
 
266
g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
 
267
)  );
 
268
 
 
269
  // Call the original underlying C function:
 
270
  if(base && base->unselect_uri)
 
271
    (*base->unselect_uri)(self, uri);
 
272
 
 
273
}
 
274
void RecentChooser_Class::select_all_vfunc_callback(GtkRecentChooser* self)
 
275
{
 
276
  Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
 
277
      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 
278
 
 
279
  // Non-gtkmmproc-generated custom classes implicitly call the default
 
280
  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 
281
  // generated classes can use this optimisation, which avoids the unnecessary
 
282
  // parameter conversions if there is no possibility of the virtual function
 
283
  // being overridden:
 
284
  if(obj_base && obj_base->is_derived_())
 
285
  {
 
286
    CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
 
287
    if(obj) // This can be NULL during destruction.
 
288
    {
 
289
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
 
290
      try // Trap C++ exceptions which would normally be lost because this is a C callback.
 
291
      {
 
292
      #endif //GLIBMM_EXCEPTIONS_ENABLED
 
293
        // Call the virtual member method, which derived classes might override.
 
294
        obj->select_all_vfunc();
 
295
        return;
 
296
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
 
297
      }
 
298
      catch(...)
 
299
      {
 
300
        Glib::exception_handlers_invoke();
 
301
      }
 
302
      #endif //GLIBMM_EXCEPTIONS_ENABLED
 
303
    }
 
304
  }
 
305
  
 
306
  BaseClassType *const base = static_cast<BaseClassType*>(
 
307
      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
 
308
g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
 
309
)  );
 
310
 
 
311
  // Call the original underlying C function:
 
312
  if(base && base->select_all)
 
313
    (*base->select_all)(self);
 
314
 
 
315
}
 
316
void RecentChooser_Class::unselect_all_vfunc_callback(GtkRecentChooser* self)
 
317
{
 
318
  Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
 
319
      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 
320
 
 
321
  // Non-gtkmmproc-generated custom classes implicitly call the default
 
322
  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 
323
  // generated classes can use this optimisation, which avoids the unnecessary
 
324
  // parameter conversions if there is no possibility of the virtual function
 
325
  // being overridden:
 
326
  if(obj_base && obj_base->is_derived_())
 
327
  {
 
328
    CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
 
329
    if(obj) // This can be NULL during destruction.
 
330
    {
 
331
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
 
332
      try // Trap C++ exceptions which would normally be lost because this is a C callback.
 
333
      {
 
334
      #endif //GLIBMM_EXCEPTIONS_ENABLED
 
335
        // Call the virtual member method, which derived classes might override.
 
336
        obj->unselect_all_vfunc();
 
337
        return;
 
338
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
 
339
      }
 
340
      catch(...)
 
341
      {
 
342
        Glib::exception_handlers_invoke();
 
343
      }
 
344
      #endif //GLIBMM_EXCEPTIONS_ENABLED
 
345
    }
 
346
  }
 
347
  
 
348
  BaseClassType *const base = static_cast<BaseClassType*>(
 
349
      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
 
350
g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
 
351
)  );
 
352
 
 
353
  // Call the original underlying C function:
 
354
  if(base && base->unselect_all)
 
355
    (*base->unselect_all)(self);
 
356
 
 
357
}
 
358
GtkRecentManager* RecentChooser_Class::get_recent_manager_vfunc_callback(GtkRecentChooser* self)
 
359
{
 
360
  Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
 
361
      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 
362
 
 
363
  // Non-gtkmmproc-generated custom classes implicitly call the default
 
364
  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 
365
  // generated classes can use this optimisation, which avoids the unnecessary
 
366
  // parameter conversions if there is no possibility of the virtual function
 
367
  // being overridden:
 
368
  if(obj_base && obj_base->is_derived_())
 
369
  {
 
370
    CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
 
371
    if(obj) // This can be NULL during destruction.
 
372
    {
 
373
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
 
374
      try // Trap C++ exceptions which would normally be lost because this is a C callback.
 
375
      {
 
376
      #endif //GLIBMM_EXCEPTIONS_ENABLED
 
377
        // Call the virtual member method, which derived classes might override.
 
378
        return Glib::unwrap(obj->get_recent_manager_vfunc());
 
379
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
 
380
      }
 
381
      catch(...)
 
382
      {
 
383
        Glib::exception_handlers_invoke();
 
384
      }
 
385
      #endif //GLIBMM_EXCEPTIONS_ENABLED
 
386
    }
 
387
  }
 
388
  
 
389
  BaseClassType *const base = static_cast<BaseClassType*>(
 
390
      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
 
391
g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
 
392
)  );
 
393
 
 
394
  // Call the original underlying C function:
 
395
  if(base && base->get_recent_manager)
 
396
    return (*base->get_recent_manager)(self);
 
397
 
 
398
 
 
399
  typedef GtkRecentManager* RType;
 
400
  return RType();
 
401
}
 
402
void RecentChooser_Class::add_filter_vfunc_callback(GtkRecentChooser* self, GtkRecentFilter* filter)
 
403
{
 
404
  Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
 
405
      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 
406
 
 
407
  // Non-gtkmmproc-generated custom classes implicitly call the default
 
408
  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 
409
  // generated classes can use this optimisation, which avoids the unnecessary
 
410
  // parameter conversions if there is no possibility of the virtual function
 
411
  // being overridden:
 
412
  if(obj_base && obj_base->is_derived_())
 
413
  {
 
414
    CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
 
415
    if(obj) // This can be NULL during destruction.
 
416
    {
 
417
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
 
418
      try // Trap C++ exceptions which would normally be lost because this is a C callback.
 
419
      {
 
420
      #endif //GLIBMM_EXCEPTIONS_ENABLED
 
421
        // Call the virtual member method, which derived classes might override.
 
422
        obj->add_filter_vfunc(Glib::wrap(filter, true)
 
423
);
 
424
        return;
 
425
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
 
426
      }
 
427
      catch(...)
 
428
      {
 
429
        Glib::exception_handlers_invoke();
 
430
      }
 
431
      #endif //GLIBMM_EXCEPTIONS_ENABLED
 
432
    }
 
433
  }
 
434
  
 
435
  BaseClassType *const base = static_cast<BaseClassType*>(
 
436
      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
 
437
g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
 
438
)  );
 
439
 
 
440
  // Call the original underlying C function:
 
441
  if(base && base->add_filter)
 
442
    (*base->add_filter)(self, filter);
 
443
 
 
444
}
 
445
void RecentChooser_Class::remove_filter_vfunc_callback(GtkRecentChooser* self, GtkRecentFilter* filter)
 
446
{
 
447
  Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
 
448
      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 
449
 
 
450
  // Non-gtkmmproc-generated custom classes implicitly call the default
 
451
  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 
452
  // generated classes can use this optimisation, which avoids the unnecessary
 
453
  // parameter conversions if there is no possibility of the virtual function
 
454
  // being overridden:
 
455
  if(obj_base && obj_base->is_derived_())
 
456
  {
 
457
    CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
 
458
    if(obj) // This can be NULL during destruction.
 
459
    {
 
460
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
 
461
      try // Trap C++ exceptions which would normally be lost because this is a C callback.
 
462
      {
 
463
      #endif //GLIBMM_EXCEPTIONS_ENABLED
 
464
        // Call the virtual member method, which derived classes might override.
 
465
        obj->remove_filter_vfunc(Glib::wrap(filter, true)
 
466
);
 
467
        return;
 
468
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
 
469
      }
 
470
      catch(...)
 
471
      {
 
472
        Glib::exception_handlers_invoke();
 
473
      }
 
474
      #endif //GLIBMM_EXCEPTIONS_ENABLED
 
475
    }
 
476
  }
 
477
  
 
478
  BaseClassType *const base = static_cast<BaseClassType*>(
 
479
      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
 
480
g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
 
481
)  );
 
482
 
 
483
  // Call the original underlying C function:
 
484
  if(base && base->remove_filter)
 
485
    (*base->remove_filter)(self, filter);
 
486
 
 
487
}
 
488
 
 
489
void RecentChooser_Class::selection_changed_callback(GtkRecentChooser* self)
 
490
{
 
491
  Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
 
492
      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 
493
 
 
494
  // Non-gtkmmproc-generated custom classes implicitly call the default
 
495
  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 
496
  // generated classes can use this optimisation, which avoids the unnecessary
 
497
  // parameter conversions if there is no possibility of the virtual function
 
498
  // being overridden:
 
499
  if(obj_base && obj_base->is_derived_())
 
500
  {
 
501
    CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
 
502
    if(obj) // This can be NULL during destruction.
 
503
    {
 
504
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
 
505
      try // Trap C++ exceptions which would normally be lost because this is a C callback.
 
506
      {
 
507
      #endif //GLIBMM_EXCEPTIONS_ENABLED
 
508
        // Call the virtual member method, which derived classes might override.
 
509
        obj->on_selection_changed();
 
510
        return;
 
511
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
 
512
      }
 
513
      catch(...)
 
514
      {
 
515
        Glib::exception_handlers_invoke();
 
516
      }
 
517
      #endif //GLIBMM_EXCEPTIONS_ENABLED
 
518
    }
 
519
  }
 
520
  
 
521
  BaseClassType *const base = static_cast<BaseClassType*>(
 
522
        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
 
523
g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
 
524
)    );
 
525
 
 
526
  // Call the original underlying C function:
 
527
  if(base && base->selection_changed)
 
528
    (*base->selection_changed)(self);
 
529
}
 
530
void RecentChooser_Class::item_activated_callback(GtkRecentChooser* self)
 
531
{
 
532
  Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
 
533
      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 
534
 
 
535
  // Non-gtkmmproc-generated custom classes implicitly call the default
 
536
  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 
537
  // generated classes can use this optimisation, which avoids the unnecessary
 
538
  // parameter conversions if there is no possibility of the virtual function
 
539
  // being overridden:
 
540
  if(obj_base && obj_base->is_derived_())
 
541
  {
 
542
    CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
 
543
    if(obj) // This can be NULL during destruction.
 
544
    {
 
545
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
 
546
      try // Trap C++ exceptions which would normally be lost because this is a C callback.
 
547
      {
 
548
      #endif //GLIBMM_EXCEPTIONS_ENABLED
 
549
        // Call the virtual member method, which derived classes might override.
 
550
        obj->on_item_activated();
 
551
        return;
 
552
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
 
553
      }
 
554
      catch(...)
 
555
      {
 
556
        Glib::exception_handlers_invoke();
 
557
      }
 
558
      #endif //GLIBMM_EXCEPTIONS_ENABLED
 
559
    }
 
560
  }
 
561
  
 
562
  BaseClassType *const base = static_cast<BaseClassType*>(
 
563
        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
 
564
g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
 
565
)    );
 
566
 
 
567
  // Call the original underlying C function:
 
568
  if(base && base->item_activated)
 
569
    (*base->item_activated)(self);
 
570
}
 
571
 
 
572
 
 
573
Glib::ObjectBase* RecentChooser_Class::wrap_new(GObject* object)
 
574
{
 
575
  return new RecentChooser((GtkRecentChooser*)(object));
 
576
}
 
577
 
 
578
 
 
579
/* The implementation: */
 
580
 
 
581
RecentChooser::RecentChooser()
 
582
:
 
583
  Glib::Interface(recentchooser_class_.init())
 
584
{}
 
585
 
 
586
RecentChooser::RecentChooser(GtkRecentChooser* castitem)
 
587
:
 
588
  Glib::Interface((GObject*)(castitem))
 
589
{}
 
590
 
 
591
RecentChooser::RecentChooser(const Glib::Interface_Class& interface_class)
 
592
: Glib::Interface(interface_class)
 
593
{
 
594
}
 
595
 
 
596
RecentChooser::~RecentChooser()
 
597
{}
 
598
 
 
599
// static
 
600
void RecentChooser::add_interface(GType gtype_implementer)
 
601
{
 
602
  recentchooser_class_.init().add_interface(gtype_implementer);
 
603
}
 
604
 
 
605
RecentChooser::CppClassType RecentChooser::recentchooser_class_; // initialize static member
 
606
 
 
607
GType RecentChooser::get_type()
 
608
{
 
609
  return recentchooser_class_.init().get_type();
 
610
}
 
611
 
 
612
 
 
613
GType RecentChooser::get_base_type()
 
614
{
 
615
  return gtk_recent_chooser_get_type();
 
616
}
 
617
 
 
618
 
 
619
void RecentChooser::set_show_private(bool show_private)
 
620
{
 
621
gtk_recent_chooser_set_show_private(gobj(), static_cast<int>(show_private)); 
 
622
}
 
623
 
 
624
bool RecentChooser::get_show_private() const
 
625
{
 
626
  return gtk_recent_chooser_get_show_private(const_cast<GtkRecentChooser*>(gobj()));
 
627
}
 
628
 
 
629
void RecentChooser::set_show_not_found(bool show_not_found)
 
630
{
 
631
gtk_recent_chooser_set_show_not_found(gobj(), static_cast<int>(show_not_found)); 
 
632
}
 
633
 
 
634
bool RecentChooser::get_show_not_found() const
 
635
{
 
636
  return gtk_recent_chooser_get_show_not_found(const_cast<GtkRecentChooser*>(gobj()));
 
637
}
 
638
 
 
639
void RecentChooser::set_select_multiple(bool select_multiple)
 
640
{
 
641
gtk_recent_chooser_set_select_multiple(gobj(), static_cast<int>(select_multiple)); 
 
642
}
 
643
 
 
644
bool RecentChooser::get_select_multiple() const
 
645
{
 
646
  return gtk_recent_chooser_get_select_multiple(const_cast<GtkRecentChooser*>(gobj()));
 
647
}
 
648
 
 
649
void RecentChooser::set_limit(int limit)
 
650
{
 
651
gtk_recent_chooser_set_limit(gobj(), limit); 
 
652
}
 
653
 
 
654
int RecentChooser::get_limit() const
 
655
{
 
656
  return gtk_recent_chooser_get_limit(const_cast<GtkRecentChooser*>(gobj()));
 
657
}
 
658
 
 
659
void RecentChooser::set_local_only(bool local_only)
 
660
{
 
661
gtk_recent_chooser_set_local_only(gobj(), static_cast<int>(local_only)); 
 
662
}
 
663
 
 
664
bool RecentChooser::get_local_only() const
 
665
{
 
666
  return gtk_recent_chooser_get_local_only(const_cast<GtkRecentChooser*>(gobj()));
 
667
}
 
668
 
 
669
void RecentChooser::set_show_tips(bool show_tips)
 
670
{
 
671
gtk_recent_chooser_set_show_tips(gobj(), static_cast<int>(show_tips)); 
 
672
}
 
673
 
 
674
bool RecentChooser::get_show_tips() const
 
675
{
 
676
  return gtk_recent_chooser_get_show_tips(const_cast<GtkRecentChooser*>(gobj()));
 
677
}
 
678
 
 
679
void RecentChooser::set_show_icons(bool show_icons)
 
680
{
 
681
gtk_recent_chooser_set_show_icons(gobj(), static_cast<int>(show_icons)); 
 
682
}
 
683
 
 
684
bool RecentChooser::get_show_icons() const
 
685
{
 
686
  return gtk_recent_chooser_get_show_icons(const_cast<GtkRecentChooser*>(gobj()));
 
687
}
 
688
 
 
689
void RecentChooser::set_sort_type(RecentSortType sort_type)
 
690
{
 
691
gtk_recent_chooser_set_sort_type(gobj(), ((GtkRecentSortType)(sort_type))); 
 
692
}
 
693
 
 
694
RecentSortType RecentChooser::get_sort_type() const
 
695
{
 
696
  return ((RecentSortType)(gtk_recent_chooser_get_sort_type(const_cast<GtkRecentChooser*>(gobj()))));
 
697
}
 
698
 
 
699
bool RecentChooser::set_current_uri(const Glib::ustring& uri)
 
700
{
 
701
  GError* gerror = 0;
 
702
  bool retvalue = gtk_recent_chooser_set_current_uri(gobj(), uri.c_str(), &(gerror));
 
703
  if(gerror)
 
704
    ::Glib::Error::throw_exception(gerror);
 
705
 
 
706
  return retvalue;
 
707
 
 
708
}
 
709
 
 
710
Glib::ustring RecentChooser::get_current_uri() const
 
711
{
 
712
  return Glib::convert_return_gchar_ptr_to_ustring(gtk_recent_chooser_get_current_uri(const_cast<GtkRecentChooser*>(gobj())));
 
713
}
 
714
 
 
715
Glib::RefPtr<RecentInfo> RecentChooser::get_current_item()
 
716
{
 
717
 
 
718
  Glib::RefPtr<RecentInfo> retvalue = Glib::wrap(gtk_recent_chooser_get_current_item(gobj()));
 
719
  if(retvalue)
 
720
    retvalue->reference(); //The function does not do a ref for us.
 
721
  return retvalue;
 
722
 
 
723
}
 
724
 
 
725
Glib::RefPtr<const RecentInfo> RecentChooser::get_current_item() const
 
726
{
 
727
 
 
728
  Glib::RefPtr<const RecentInfo> retvalue = Glib::wrap(gtk_recent_chooser_get_current_item(const_cast<GtkRecentChooser*>(gobj())));
 
729
  if(retvalue)
 
730
    retvalue->reference(); //The function does not do a ref for us.
 
731
  return retvalue;
 
732
 
 
733
}
 
734
 
 
735
bool RecentChooser::select_uri(const Glib::ustring& uri)
 
736
{
 
737
  GError* gerror = 0;
 
738
  bool retvalue = gtk_recent_chooser_select_uri(gobj(), uri.c_str(), &(gerror));
 
739
  if(gerror)
 
740
    ::Glib::Error::throw_exception(gerror);
 
741
 
 
742
  return retvalue;
 
743
 
 
744
}
 
745
 
 
746
void RecentChooser::unselect_uri(const Glib::ustring& uri)
 
747
{
 
748
gtk_recent_chooser_unselect_uri(gobj(), uri.c_str()); 
 
749
}
 
750
 
 
751
void RecentChooser::select_all()
 
752
{
 
753
gtk_recent_chooser_select_all(gobj()); 
 
754
}
 
755
 
 
756
void RecentChooser::unselect_all()
 
757
{
 
758
gtk_recent_chooser_unselect_all(gobj()); 
 
759
}
 
760
 
 
761
std::vector<Glib::RefPtr<RecentInfo> > RecentChooser::get_items() const
 
762
{
 
763
  return Glib::ListHandler<Glib::RefPtr<RecentInfo>, RecentInfoTraits>::list_to_vector(gtk_recent_chooser_get_items(const_cast<GtkRecentChooser*>(gobj())), Glib::OWNERSHIP_SHALLOW);
 
764
}
 
765
 
 
766
void RecentChooser::add_filter(const Glib::RefPtr<RecentFilter>& filter)
 
767
{
 
768
gtk_recent_chooser_add_filter(gobj(), Glib::unwrap(filter)); 
 
769
}
 
770
 
 
771
void RecentChooser::remove_filter(const Glib::RefPtr<RecentFilter>& filter)
 
772
{
 
773
gtk_recent_chooser_remove_filter(gobj(), Glib::unwrap(filter)); 
 
774
}
 
775
 
 
776
std::vector< Glib::RefPtr<RecentFilter> > RecentChooser::list_filters()
 
777
{
 
778
  return Glib::SListHandler<Glib::RefPtr<RecentFilter> >::slist_to_vector(gtk_recent_chooser_list_filters(gobj()), Glib::OWNERSHIP_SHALLOW);
 
779
}
 
780
 
 
781
std::vector< Glib::RefPtr<const RecentFilter> > RecentChooser::list_filters() const
 
782
{
 
783
  return Glib::SListHandler<Glib::RefPtr<const RecentFilter> >::slist_to_vector(gtk_recent_chooser_list_filters(const_cast<GtkRecentChooser*>(gobj())), Glib::OWNERSHIP_SHALLOW);
 
784
}
 
785
 
 
786
void RecentChooser::set_filter(const Glib::RefPtr<RecentFilter>& filter)
 
787
{
 
788
gtk_recent_chooser_set_filter(gobj(), Glib::unwrap(filter)); 
 
789
}
 
790
 
 
791
Glib::RefPtr<RecentFilter> RecentChooser::get_filter()
 
792
{
 
793
 
 
794
  Glib::RefPtr<RecentFilter> retvalue = Glib::wrap(gtk_recent_chooser_get_filter(gobj()));
 
795
  if(retvalue)
 
796
    retvalue->reference(); //The function does not do a ref for us.
 
797
  return retvalue;
 
798
 
 
799
}
 
800
 
 
801
Glib::RefPtr<const RecentFilter> RecentChooser::get_filter() const
 
802
{
 
803
  return const_cast<RecentChooser*>(this)->get_filter();
 
804
}
 
805
 
 
806
 
 
807
Glib::SignalProxy0< void > RecentChooser::signal_selection_changed()
 
808
{
 
809
  return Glib::SignalProxy0< void >(this, &RecentChooser_signal_selection_changed_info);
 
810
}
 
811
 
 
812
 
 
813
Glib::SignalProxy0< void > RecentChooser::signal_item_activated()
 
814
{
 
815
  return Glib::SignalProxy0< void >(this, &RecentChooser_signal_item_activated_info);
 
816
}
 
817
 
 
818
 
 
819
#ifdef GLIBMM_PROPERTIES_ENABLED
 
820
Glib::PropertyProxy<bool> RecentChooser::property_show_private() 
 
821
{
 
822
  return Glib::PropertyProxy<bool>(this, "show-private");
 
823
}
 
824
#endif //GLIBMM_PROPERTIES_ENABLED
 
825
 
 
826
#ifdef GLIBMM_PROPERTIES_ENABLED
 
827
Glib::PropertyProxy_ReadOnly<bool> RecentChooser::property_show_private() const
 
828
{
 
829
  return Glib::PropertyProxy_ReadOnly<bool>(this, "show-private");
 
830
}
 
831
#endif //GLIBMM_PROPERTIES_ENABLED
 
832
 
 
833
#ifdef GLIBMM_PROPERTIES_ENABLED
 
834
Glib::PropertyProxy<bool> RecentChooser::property_show_tips() 
 
835
{
 
836
  return Glib::PropertyProxy<bool>(this, "show-tips");
 
837
}
 
838
#endif //GLIBMM_PROPERTIES_ENABLED
 
839
 
 
840
#ifdef GLIBMM_PROPERTIES_ENABLED
 
841
Glib::PropertyProxy_ReadOnly<bool> RecentChooser::property_show_tips() const
 
842
{
 
843
  return Glib::PropertyProxy_ReadOnly<bool>(this, "show-tips");
 
844
}
 
845
#endif //GLIBMM_PROPERTIES_ENABLED
 
846
 
 
847
#ifdef GLIBMM_PROPERTIES_ENABLED
 
848
Glib::PropertyProxy<bool> RecentChooser::property_show_icons() 
 
849
{
 
850
  return Glib::PropertyProxy<bool>(this, "show-icons");
 
851
}
 
852
#endif //GLIBMM_PROPERTIES_ENABLED
 
853
 
 
854
#ifdef GLIBMM_PROPERTIES_ENABLED
 
855
Glib::PropertyProxy_ReadOnly<bool> RecentChooser::property_show_icons() const
 
856
{
 
857
  return Glib::PropertyProxy_ReadOnly<bool>(this, "show-icons");
 
858
}
 
859
#endif //GLIBMM_PROPERTIES_ENABLED
 
860
 
 
861
#ifdef GLIBMM_PROPERTIES_ENABLED
 
862
Glib::PropertyProxy<bool> RecentChooser::property_show_not_found() 
 
863
{
 
864
  return Glib::PropertyProxy<bool>(this, "show-not-found");
 
865
}
 
866
#endif //GLIBMM_PROPERTIES_ENABLED
 
867
 
 
868
#ifdef GLIBMM_PROPERTIES_ENABLED
 
869
Glib::PropertyProxy_ReadOnly<bool> RecentChooser::property_show_not_found() const
 
870
{
 
871
  return Glib::PropertyProxy_ReadOnly<bool>(this, "show-not-found");
 
872
}
 
873
#endif //GLIBMM_PROPERTIES_ENABLED
 
874
 
 
875
#ifdef GLIBMM_PROPERTIES_ENABLED
 
876
Glib::PropertyProxy<bool> RecentChooser::property_select_multiple() 
 
877
{
 
878
  return Glib::PropertyProxy<bool>(this, "select-multiple");
 
879
}
 
880
#endif //GLIBMM_PROPERTIES_ENABLED
 
881
 
 
882
#ifdef GLIBMM_PROPERTIES_ENABLED
 
883
Glib::PropertyProxy_ReadOnly<bool> RecentChooser::property_select_multiple() const
 
884
{
 
885
  return Glib::PropertyProxy_ReadOnly<bool>(this, "select-multiple");
 
886
}
 
887
#endif //GLIBMM_PROPERTIES_ENABLED
 
888
 
 
889
#ifdef GLIBMM_PROPERTIES_ENABLED
 
890
Glib::PropertyProxy<bool> RecentChooser::property_local_only() 
 
891
{
 
892
  return Glib::PropertyProxy<bool>(this, "local-only");
 
893
}
 
894
#endif //GLIBMM_PROPERTIES_ENABLED
 
895
 
 
896
#ifdef GLIBMM_PROPERTIES_ENABLED
 
897
Glib::PropertyProxy_ReadOnly<bool> RecentChooser::property_local_only() const
 
898
{
 
899
  return Glib::PropertyProxy_ReadOnly<bool>(this, "local-only");
 
900
}
 
901
#endif //GLIBMM_PROPERTIES_ENABLED
 
902
 
 
903
#ifdef GLIBMM_PROPERTIES_ENABLED
 
904
Glib::PropertyProxy<int> RecentChooser::property_limit() 
 
905
{
 
906
  return Glib::PropertyProxy<int>(this, "limit");
 
907
}
 
908
#endif //GLIBMM_PROPERTIES_ENABLED
 
909
 
 
910
#ifdef GLIBMM_PROPERTIES_ENABLED
 
911
Glib::PropertyProxy_ReadOnly<int> RecentChooser::property_limit() const
 
912
{
 
913
  return Glib::PropertyProxy_ReadOnly<int>(this, "limit");
 
914
}
 
915
#endif //GLIBMM_PROPERTIES_ENABLED
 
916
 
 
917
#ifdef GLIBMM_PROPERTIES_ENABLED
 
918
Glib::PropertyProxy<RecentSortType> RecentChooser::property_sort_type() 
 
919
{
 
920
  return Glib::PropertyProxy<RecentSortType>(this, "sort-type");
 
921
}
 
922
#endif //GLIBMM_PROPERTIES_ENABLED
 
923
 
 
924
#ifdef GLIBMM_PROPERTIES_ENABLED
 
925
Glib::PropertyProxy_ReadOnly<RecentSortType> RecentChooser::property_sort_type() const
 
926
{
 
927
  return Glib::PropertyProxy_ReadOnly<RecentSortType>(this, "sort-type");
 
928
}
 
929
#endif //GLIBMM_PROPERTIES_ENABLED
 
930
 
 
931
#ifdef GLIBMM_PROPERTIES_ENABLED
 
932
Glib::PropertyProxy< Glib::RefPtr<RecentFilter> > RecentChooser::property_filter() 
 
933
{
 
934
  return Glib::PropertyProxy< Glib::RefPtr<RecentFilter> >(this, "filter");
 
935
}
 
936
#endif //GLIBMM_PROPERTIES_ENABLED
 
937
 
 
938
#ifdef GLIBMM_PROPERTIES_ENABLED
 
939
Glib::PropertyProxy_ReadOnly< Glib::RefPtr<RecentFilter> > RecentChooser::property_filter() const
 
940
{
 
941
  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<RecentFilter> >(this, "filter");
 
942
}
 
943
#endif //GLIBMM_PROPERTIES_ENABLED
 
944
 
 
945
 
 
946
void Gtk::RecentChooser::on_selection_changed()
 
947
{
 
948
  BaseClassType *const base = static_cast<BaseClassType*>(
 
949
      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
 
950
g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
 
951
)  );
 
952
 
 
953
  if(base && base->selection_changed)
 
954
    (*base->selection_changed)(gobj());
 
955
}
 
956
void Gtk::RecentChooser::on_item_activated()
 
957
{
 
958
  BaseClassType *const base = static_cast<BaseClassType*>(
 
959
      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
 
960
g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
 
961
)  );
 
962
 
 
963
  if(base && base->item_activated)
 
964
    (*base->item_activated)(gobj());
 
965
}
 
966
 
 
967
Glib::ustring Gtk::RecentChooser::get_current_uri_vfunc() const
 
968
{
 
969
  BaseClassType *const base = static_cast<BaseClassType*>(
 
970
      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
 
971
g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
 
972
)  );
 
973
 
 
974
  if(base && base->get_current_uri)
 
975
    return Glib::convert_const_gchar_ptr_to_ustring((*base->get_current_uri)(const_cast<GtkRecentChooser*>(gobj())));
 
976
 
 
977
  typedef Glib::ustring RType;
 
978
  return RType();
 
979
}
 
980
void Gtk::RecentChooser::unselect_uri_vfunc(const Glib::ustring& uri) 
 
981
{
 
982
  BaseClassType *const base = static_cast<BaseClassType*>(
 
983
      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
 
984
g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
 
985
)  );
 
986
 
 
987
  if(base && base->unselect_uri)
 
988
    (*base->unselect_uri)(gobj(),uri.c_str());
 
989
}
 
990
void Gtk::RecentChooser::select_all_vfunc() 
 
991
{
 
992
  BaseClassType *const base = static_cast<BaseClassType*>(
 
993
      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
 
994
g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
 
995
)  );
 
996
 
 
997
  if(base && base->select_all)
 
998
    (*base->select_all)(gobj());
 
999
}
 
1000
void Gtk::RecentChooser::unselect_all_vfunc() 
 
1001
{
 
1002
  BaseClassType *const base = static_cast<BaseClassType*>(
 
1003
      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
 
1004
g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
 
1005
)  );
 
1006
 
 
1007
  if(base && base->unselect_all)
 
1008
    (*base->unselect_all)(gobj());
 
1009
}
 
1010
Glib::RefPtr<RecentManager> Gtk::RecentChooser::get_recent_manager_vfunc() 
 
1011
{
 
1012
  BaseClassType *const base = static_cast<BaseClassType*>(
 
1013
      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
 
1014
g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
 
1015
)  );
 
1016
 
 
1017
  if(base && base->get_recent_manager)
 
1018
    return Glib::wrap((*base->get_recent_manager)(gobj()));
 
1019
 
 
1020
  typedef Glib::RefPtr<RecentManager> RType;
 
1021
  return RType();
 
1022
}
 
1023
void Gtk::RecentChooser::add_filter_vfunc(const Glib::RefPtr<RecentFilter>& filter) 
 
1024
{
 
1025
  BaseClassType *const base = static_cast<BaseClassType*>(
 
1026
      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
 
1027
g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
 
1028
)  );
 
1029
 
 
1030
  if(base && base->add_filter)
 
1031
    (*base->add_filter)(gobj(),Glib::unwrap(filter));
 
1032
}
 
1033
void Gtk::RecentChooser::remove_filter_vfunc(const Glib::RefPtr<RecentFilter>& filter) 
 
1034
{
 
1035
  BaseClassType *const base = static_cast<BaseClassType*>(
 
1036
      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
 
1037
g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
 
1038
)  );
 
1039
 
 
1040
  if(base && base->remove_filter)
 
1041
    (*base->remove_filter)(gobj(),Glib::unwrap(filter));
 
1042
}
 
1043
 
 
1044
 
 
1045
} // namespace Gtk
 
1046
 
 
1047