← Back to branch summary

~ubuntu-branches/ubuntu/precise/atkmm1.6/precise

« back to all changes in this revision

Viewing changes to atk/atkmm/editabletext.cc

  • Committer: Bazaar Package Importer
  • Author(s): Krzysztof Klimonda
  • Date: 2010-11-02 20:35:53 UTC
  • Revision ID: james.westby@ubuntu.com-20101102203553-syno2w6yedmcdgk8
Tags: upstream-2.22.1
Import upstream version 2.22.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
atk/atkmm/editabletext.cc
 
1
// Generated by gtkmmproc -- DO NOT MODIFY!
 
2
 
 
3
 
 
4
#include <atkmm/editabletext.h>
 
5
#include <atkmm/private/editabletext_p.h>
 
6
 
 
7
// -*- c++ -*-
 
8
/* $Id: editabletext.ccg,v 1.1 2003/01/21 13:37:05 murrayc Exp $ */
 
9
 
 
10
/* Copyright 1998-2002 The gtkmm Development Team
 
11
 *
 
12
 * This library is free software; you can redistribute it and/or
 
13
 * modify it under the terms of the GNU Lesser General Public
 
14
 * License as published by the Free Software Foundation; either
 
15
 * version 2.1 of the License, or (at your option) any later version.
 
16
 *
 
17
 * This library is distributed in the hope that it will be useful,
 
18
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
19
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
20
 * Lesser General Public License for more details.
 
21
 *
 
22
 * You should have received a copy of the GNU Lesser General Public
 
23
 * License along with this library; if not, write to the Free
 
24
 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
25
 */
 
26
 
 
27
#include <atkmm/object.h>
 
28
#include <atk/atkeditabletext.h>
 
29
 
 
30
 
 
31
namespace
 
32
{
 
33
} // anonymous namespace
 
34
 
 
35
 
 
36
namespace Glib
 
37
{
 
38
 
 
39
Glib::RefPtr<Atk::EditableText> wrap(AtkEditableText* object, bool take_copy)
 
40
{
 
41
  return Glib::RefPtr<Atk::EditableText>( dynamic_cast<Atk::EditableText*> (Glib::wrap_auto_interface<Atk::EditableText> ((GObject*)(object), take_copy)) );
 
42
  //We use dynamic_cast<> in case of multiple inheritance.
 
43
}
 
44
 
 
45
} // namespace Glib
 
46
 
 
47
 
 
48
namespace Atk
 
49
{
 
50
 
 
51
 
 
52
/* The *_Class implementation: */
 
53
 
 
54
const Glib::Interface_Class& EditableText_Class::init()
 
55
{
 
56
  if(!gtype_) // create the GType if necessary
 
57
  {
 
58
    // Glib::Interface_Class has to know the interface init function
 
59
    // in order to add interfaces to implementing types.
 
60
    class_init_func_ = &EditableText_Class::iface_init_function;
 
61
 
 
62
    // We can not derive from another interface, and it is not necessary anyway.
 
63
    gtype_ = atk_editable_text_get_type();
 
64
  }
 
65
 
 
66
  return *this;
 
67
}
 
68
 
 
69
void EditableText_Class::iface_init_function(void* g_iface, void*)
 
70
{
 
71
  BaseClassType *const klass = static_cast<BaseClassType*>(g_iface);
 
72
 
 
73
  //This is just to avoid an "unused variable" warning when there are no vfuncs or signal handlers to connect.
 
74
  //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
 
75
  g_assert(klass != 0); 
 
76
 
 
77
  klass->set_run_attributes = &set_run_attributes_vfunc_callback;
 
78
  klass->set_text_contents = &set_text_contents_vfunc_callback;
 
79
  klass->insert_text = &insert_text_vfunc_callback;
 
80
  klass->copy_text = &copy_text_vfunc_callback;
 
81
  klass->cut_text = &cut_text_vfunc_callback;
 
82
  klass->delete_text = &delete_text_vfunc_callback;
 
83
  klass->paste_text = &paste_text_vfunc_callback;
 
84
 
 
85
}
 
86
 
 
87
gboolean EditableText_Class::set_run_attributes_vfunc_callback(AtkEditableText* self, AtkAttributeSet* attrib_set, gint start_offset, gint end_offset)
 
88
{
 
89
  Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
 
90
      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 
91
 
 
92
  // Non-gtkmmproc-generated custom classes implicitly call the default
 
93
  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 
94
  // generated classes can use this optimisation, which avoids the unnecessary
 
95
  // parameter conversions if there is no possibility of the virtual function
 
96
  // being overridden:
 
97
  if(obj_base && obj_base->is_derived_())
 
98
  {
 
99
    CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
 
100
    if(obj) // This can be NULL during destruction.
 
101
    {
 
102
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
 
103
      try // Trap C++ exceptions which would normally be lost because this is a C callback.
 
104
      {
 
105
      #endif //GLIBMM_EXCEPTIONS_ENABLED
 
106
        // Call the virtual member method, which derived classes might override.
 
107
        return static_cast<int>(obj->set_run_attributes_vfunc(attrib_set, start_offset
 
108
, end_offset
 
109
));
 
110
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
 
111
      }
 
112
      catch(...)
 
113
      {
 
114
        Glib::exception_handlers_invoke();
 
115
      }
 
116
      #endif //GLIBMM_EXCEPTIONS_ENABLED
 
117
    }
 
118
  }
 
119
  
 
120
  BaseClassType *const base = static_cast<BaseClassType*>(
 
121
      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
 
122
g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
 
123
)  );
 
124
 
 
125
  // Call the original underlying C function:
 
126
  if(base && base->set_run_attributes)
 
127
    return (*base->set_run_attributes)(self, attrib_set, start_offset, end_offset);
 
128
 
 
129
 
 
130
  typedef gboolean RType;
 
131
  return RType();
 
132
}
 
133
void EditableText_Class::set_text_contents_vfunc_callback(AtkEditableText* self, const gchar* string)
 
134
{
 
135
  Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
 
136
      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 
137
 
 
138
  // Non-gtkmmproc-generated custom classes implicitly call the default
 
139
  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 
140
  // generated classes can use this optimisation, which avoids the unnecessary
 
141
  // parameter conversions if there is no possibility of the virtual function
 
142
  // being overridden:
 
143
  if(obj_base && obj_base->is_derived_())
 
144
  {
 
145
    CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
 
146
    if(obj) // This can be NULL during destruction.
 
147
    {
 
148
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
 
149
      try // Trap C++ exceptions which would normally be lost because this is a C callback.
 
150
      {
 
151
      #endif //GLIBMM_EXCEPTIONS_ENABLED
 
152
        // Call the virtual member method, which derived classes might override.
 
153
        obj->set_text_contents_vfunc(Glib::convert_const_gchar_ptr_to_ustring(string)
 
154
);
 
155
        return;
 
156
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
 
157
      }
 
158
      catch(...)
 
159
      {
 
160
        Glib::exception_handlers_invoke();
 
161
      }
 
162
      #endif //GLIBMM_EXCEPTIONS_ENABLED
 
163
    }
 
164
  }
 
165
  
 
166
  BaseClassType *const base = static_cast<BaseClassType*>(
 
167
      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
 
168
g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
 
169
)  );
 
170
 
 
171
  // Call the original underlying C function:
 
172
  if(base && base->set_text_contents)
 
173
    (*base->set_text_contents)(self, string);
 
174
 
 
175
}
 
176
void EditableText_Class::insert_text_vfunc_callback(AtkEditableText* self, const gchar* string, gint length, gint* position)
 
177
{
 
178
  Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
 
179
      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 
180
 
 
181
  // Non-gtkmmproc-generated custom classes implicitly call the default
 
182
  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 
183
  // generated classes can use this optimisation, which avoids the unnecessary
 
184
  // parameter conversions if there is no possibility of the virtual function
 
185
  // being overridden:
 
186
  if(obj_base && obj_base->is_derived_())
 
187
  {
 
188
    CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
 
189
    if(obj) // This can be NULL during destruction.
 
190
    {
 
191
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
 
192
      try // Trap C++ exceptions which would normally be lost because this is a C callback.
 
193
      {
 
194
      #endif //GLIBMM_EXCEPTIONS_ENABLED
 
195
        // Call the virtual member method, which derived classes might override.
 
196
        obj->insert_text_vfunc(Glib::convert_const_gchar_ptr_to_ustring(string)
 
197
, length
 
198
, *(position)
 
199
);
 
200
        return;
 
201
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
 
202
      }
 
203
      catch(...)
 
204
      {
 
205
        Glib::exception_handlers_invoke();
 
206
      }
 
207
      #endif //GLIBMM_EXCEPTIONS_ENABLED
 
208
    }
 
209
  }
 
210
  
 
211
  BaseClassType *const base = static_cast<BaseClassType*>(
 
212
      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
 
213
g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
 
214
)  );
 
215
 
 
216
  // Call the original underlying C function:
 
217
  if(base && base->insert_text)
 
218
    (*base->insert_text)(self, string, length, position);
 
219
 
 
220
}
 
221
void EditableText_Class::copy_text_vfunc_callback(AtkEditableText* self, gint start_pos, gint end_pos)
 
222
{
 
223
  Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
 
224
      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 
225
 
 
226
  // Non-gtkmmproc-generated custom classes implicitly call the default
 
227
  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 
228
  // generated classes can use this optimisation, which avoids the unnecessary
 
229
  // parameter conversions if there is no possibility of the virtual function
 
230
  // being overridden:
 
231
  if(obj_base && obj_base->is_derived_())
 
232
  {
 
233
    CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
 
234
    if(obj) // This can be NULL during destruction.
 
235
    {
 
236
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
 
237
      try // Trap C++ exceptions which would normally be lost because this is a C callback.
 
238
      {
 
239
      #endif //GLIBMM_EXCEPTIONS_ENABLED
 
240
        // Call the virtual member method, which derived classes might override.
 
241
        obj->copy_text_vfunc(start_pos
 
242
, end_pos
 
243
);
 
244
        return;
 
245
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
 
246
      }
 
247
      catch(...)
 
248
      {
 
249
        Glib::exception_handlers_invoke();
 
250
      }
 
251
      #endif //GLIBMM_EXCEPTIONS_ENABLED
 
252
    }
 
253
  }
 
254
  
 
255
  BaseClassType *const base = static_cast<BaseClassType*>(
 
256
      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
 
257
g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
 
258
)  );
 
259
 
 
260
  // Call the original underlying C function:
 
261
  if(base && base->copy_text)
 
262
    (*base->copy_text)(self, start_pos, end_pos);
 
263
 
 
264
}
 
265
void EditableText_Class::cut_text_vfunc_callback(AtkEditableText* self, gint start_pos, gint end_pos)
 
266
{
 
267
  Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
 
268
      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 
269
 
 
270
  // Non-gtkmmproc-generated custom classes implicitly call the default
 
271
  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 
272
  // generated classes can use this optimisation, which avoids the unnecessary
 
273
  // parameter conversions if there is no possibility of the virtual function
 
274
  // being overridden:
 
275
  if(obj_base && obj_base->is_derived_())
 
276
  {
 
277
    CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
 
278
    if(obj) // This can be NULL during destruction.
 
279
    {
 
280
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
 
281
      try // Trap C++ exceptions which would normally be lost because this is a C callback.
 
282
      {
 
283
      #endif //GLIBMM_EXCEPTIONS_ENABLED
 
284
        // Call the virtual member method, which derived classes might override.
 
285
        obj->cut_text_vfunc(start_pos
 
286
, end_pos
 
287
);
 
288
        return;
 
289
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
 
290
      }
 
291
      catch(...)
 
292
      {
 
293
        Glib::exception_handlers_invoke();
 
294
      }
 
295
      #endif //GLIBMM_EXCEPTIONS_ENABLED
 
296
    }
 
297
  }
 
298
  
 
299
  BaseClassType *const base = static_cast<BaseClassType*>(
 
300
      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
 
301
g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
 
302
)  );
 
303
 
 
304
  // Call the original underlying C function:
 
305
  if(base && base->cut_text)
 
306
    (*base->cut_text)(self, start_pos, end_pos);
 
307
 
 
308
}
 
309
void EditableText_Class::delete_text_vfunc_callback(AtkEditableText* self, gint start_pos, gint end_pos)
 
310
{
 
311
  Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
 
312
      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 
313
 
 
314
  // Non-gtkmmproc-generated custom classes implicitly call the default
 
315
  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 
316
  // generated classes can use this optimisation, which avoids the unnecessary
 
317
  // parameter conversions if there is no possibility of the virtual function
 
318
  // being overridden:
 
319
  if(obj_base && obj_base->is_derived_())
 
320
  {
 
321
    CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
 
322
    if(obj) // This can be NULL during destruction.
 
323
    {
 
324
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
 
325
      try // Trap C++ exceptions which would normally be lost because this is a C callback.
 
326
      {
 
327
      #endif //GLIBMM_EXCEPTIONS_ENABLED
 
328
        // Call the virtual member method, which derived classes might override.
 
329
        obj->delete_text_vfunc(start_pos
 
330
, end_pos
 
331
);
 
332
        return;
 
333
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
 
334
      }
 
335
      catch(...)
 
336
      {
 
337
        Glib::exception_handlers_invoke();
 
338
      }
 
339
      #endif //GLIBMM_EXCEPTIONS_ENABLED
 
340
    }
 
341
  }
 
342
  
 
343
  BaseClassType *const base = static_cast<BaseClassType*>(
 
344
      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
 
345
g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
 
346
)  );
 
347
 
 
348
  // Call the original underlying C function:
 
349
  if(base && base->delete_text)
 
350
    (*base->delete_text)(self, start_pos, end_pos);
 
351
 
 
352
}
 
353
void EditableText_Class::paste_text_vfunc_callback(AtkEditableText* self, gint position)
 
354
{
 
355
  Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
 
356
      Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 
357
 
 
358
  // Non-gtkmmproc-generated custom classes implicitly call the default
 
359
  // Glib::ObjectBase constructor, which sets is_derived_. But gtkmmproc-
 
360
  // generated classes can use this optimisation, which avoids the unnecessary
 
361
  // parameter conversions if there is no possibility of the virtual function
 
362
  // being overridden:
 
363
  if(obj_base && obj_base->is_derived_())
 
364
  {
 
365
    CppObjectType *const obj = dynamic_cast<CppObjectType* const>(obj_base);
 
366
    if(obj) // This can be NULL during destruction.
 
367
    {
 
368
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
 
369
      try // Trap C++ exceptions which would normally be lost because this is a C callback.
 
370
      {
 
371
      #endif //GLIBMM_EXCEPTIONS_ENABLED
 
372
        // Call the virtual member method, which derived classes might override.
 
373
        obj->paste_text_vfunc(position
 
374
);
 
375
        return;
 
376
      #ifdef GLIBMM_EXCEPTIONS_ENABLED
 
377
      }
 
378
      catch(...)
 
379
      {
 
380
        Glib::exception_handlers_invoke();
 
381
      }
 
382
      #endif //GLIBMM_EXCEPTIONS_ENABLED
 
383
    }
 
384
  }
 
385
  
 
386
  BaseClassType *const base = static_cast<BaseClassType*>(
 
387
      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
 
388
g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
 
389
)  );
 
390
 
 
391
  // Call the original underlying C function:
 
392
  if(base && base->paste_text)
 
393
    (*base->paste_text)(self, position);
 
394
 
 
395
}
 
396
 
 
397
 
 
398
Glib::ObjectBase* EditableText_Class::wrap_new(GObject* object)
 
399
{
 
400
  return new EditableText((AtkEditableText*)(object));
 
401
}
 
402
 
 
403
 
 
404
/* The implementation: */
 
405
 
 
406
EditableText::EditableText()
 
407
:
 
408
  Glib::Interface(editabletext_class_.init())
 
409
{}
 
410
 
 
411
EditableText::EditableText(AtkEditableText* castitem)
 
412
:
 
413
  Glib::Interface((GObject*)(castitem))
 
414
{}
 
415
 
 
416
EditableText::EditableText(const Glib::Interface_Class& interface_class)
 
417
: Glib::Interface(interface_class)
 
418
{
 
419
}
 
420
 
 
421
EditableText::~EditableText()
 
422
{}
 
423
 
 
424
// static
 
425
void EditableText::add_interface(GType gtype_implementer)
 
426
{
 
427
  editabletext_class_.init().add_interface(gtype_implementer);
 
428
}
 
429
 
 
430
EditableText::CppClassType EditableText::editabletext_class_; // initialize static member
 
431
 
 
432
GType EditableText::get_type()
 
433
{
 
434
  return editabletext_class_.init().get_type();
 
435
}
 
436
 
 
437
 
 
438
GType EditableText::get_base_type()
 
439
{
 
440
  return atk_editable_text_get_type();
 
441
}
 
442
 
 
443
 
 
444
bool EditableText::set_run_attributes(const AttributeSet& attrib_set, int start_offset, int end_offset)
 
445
{
 
446
  return atk_editable_text_set_run_attributes(gobj(), (attrib_set).data(), start_offset, end_offset);
 
447
}
 
448
 
 
449
void EditableText::set_text_contents(const Glib::ustring& string)
 
450
{
 
451
atk_editable_text_set_text_contents(gobj(), string.c_str()); 
 
452
}
 
453
 
 
454
void EditableText::insert_text(const Glib::ustring& string, int length, int& position)
 
455
{
 
456
atk_editable_text_insert_text(gobj(), string.c_str(), length, &position); 
 
457
}
 
458
 
 
459
void EditableText::copy_text(int start_pos, int end_pos)
 
460
{
 
461
atk_editable_text_copy_text(gobj(), start_pos, end_pos); 
 
462
}
 
463
 
 
464
void EditableText::cut_text(int start_pos, int end_pos)
 
465
{
 
466
atk_editable_text_cut_text(gobj(), start_pos, end_pos); 
 
467
}
 
468
 
 
469
void EditableText::delete_text(int start_pos, int end_pos)
 
470
{
 
471
atk_editable_text_delete_text(gobj(), start_pos, end_pos); 
 
472
}
 
473
 
 
474
void EditableText::paste_text(int position)
 
475
{
 
476
atk_editable_text_paste_text(gobj(), position); 
 
477
}
 
478
 
 
479
 
 
480
bool Atk::EditableText::set_run_attributes_vfunc(AtkAttributeSet* attrib_set, int start_offset, int end_offset) 
 
481
{
 
482
  BaseClassType *const base = static_cast<BaseClassType*>(
 
483
      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
 
484
g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
 
485
)  );
 
486
 
 
487
  if(base && base->set_run_attributes)
 
488
    return (*base->set_run_attributes)(gobj(),attrib_set,start_offset,end_offset);
 
489
 
 
490
  typedef bool RType;
 
491
  return RType();
 
492
}
 
493
void Atk::EditableText::set_text_contents_vfunc(const Glib::ustring& string) 
 
494
{
 
495
  BaseClassType *const base = static_cast<BaseClassType*>(
 
496
      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
 
497
g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
 
498
)  );
 
499
 
 
500
  if(base && base->set_text_contents)
 
501
    (*base->set_text_contents)(gobj(),string.c_str());
 
502
}
 
503
void Atk::EditableText::insert_text_vfunc(const Glib::ustring& string, int length, int& position) 
 
504
{
 
505
  BaseClassType *const base = static_cast<BaseClassType*>(
 
506
      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
 
507
g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
 
508
)  );
 
509
 
 
510
  if(base && base->insert_text)
 
511
    (*base->insert_text)(gobj(),string.c_str(),length,&position);
 
512
}
 
513
void Atk::EditableText::copy_text_vfunc(int start_pos, int end_pos) 
 
514
{
 
515
  BaseClassType *const base = static_cast<BaseClassType*>(
 
516
      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
 
517
g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
 
518
)  );
 
519
 
 
520
  if(base && base->copy_text)
 
521
    (*base->copy_text)(gobj(),start_pos,end_pos);
 
522
}
 
523
void Atk::EditableText::cut_text_vfunc(int start_pos, int end_pos) 
 
524
{
 
525
  BaseClassType *const base = static_cast<BaseClassType*>(
 
526
      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
 
527
g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
 
528
)  );
 
529
 
 
530
  if(base && base->cut_text)
 
531
    (*base->cut_text)(gobj(),start_pos,end_pos);
 
532
}
 
533
void Atk::EditableText::delete_text_vfunc(int start_pos, int end_pos) 
 
534
{
 
535
  BaseClassType *const base = static_cast<BaseClassType*>(
 
536
      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
 
537
g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
 
538
)  );
 
539
 
 
540
  if(base && base->delete_text)
 
541
    (*base->delete_text)(gobj(),start_pos,end_pos);
 
542
}
 
543
void Atk::EditableText::paste_text_vfunc(int position) 
 
544
{
 
545
  BaseClassType *const base = static_cast<BaseClassType*>(
 
546
      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
 
547
g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
 
548
)  );
 
549
 
 
550
  if(base && base->paste_text)
 
551
    (*base->paste_text)(gobj(),position);
 
552
}
 
553
 
 
554
 
 
555
} // namespace Atk
 
556
 
 
557