diff options
author | Taybin Rutkin <taybin@taybin.com> | 2005-05-13 20:47:18 +0000 |
---|---|---|
committer | Taybin Rutkin <taybin@taybin.com> | 2005-05-13 20:47:18 +0000 |
commit | d09f6b3016bacbc2871a8946cbb24ad705076509 (patch) | |
tree | f27312839c2a772cb2ce068a4f28b2449ad869df /libs/gtkmm2/gtk/gtkmm/private |
Initial revision
git-svn-id: svn://localhost/trunk/ardour2@4 d708f5d6-7413-0410-9779-e7cbd77b26cf
Diffstat (limited to 'libs/gtkmm2/gtk/gtkmm/private')
136 files changed, 6507 insertions, 0 deletions
diff --git a/libs/gtkmm2/gtk/gtkmm/private/aboutdialog_p.h b/libs/gtkmm2/gtk/gtkmm/private/aboutdialog_p.h new file mode 100644 index 0000000000..60a53a69ba --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/aboutdialog_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_ABOUTDIALOG_P_H +#define _GTKMM_ABOUTDIALOG_P_H +#include <gtkmm/private/dialog_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class AboutDialog_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef AboutDialog CppObjectType; + typedef GtkAboutDialog BaseObjectType; + typedef GtkAboutDialogClass BaseClassType; + typedef Gtk::Dialog_Class CppClassParent; + typedef GtkDialogClass BaseClassParent; + + friend class AboutDialog; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_ABOUTDIALOG_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/accelgroup_p.h b/libs/gtkmm2/gtk/gtkmm/private/accelgroup_p.h new file mode 100644 index 0000000000..6caa6d52e4 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/accelgroup_p.h @@ -0,0 +1,45 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_ACCELGROUP_P_H +#define _GTKMM_ACCELGROUP_P_H +#include <glibmm/private/object_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class AccelGroup_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef AccelGroup CppObjectType; + typedef GtkAccelGroup BaseObjectType; + typedef GtkAccelGroupClass BaseClassType; + typedef Glib::Object_Class CppClassParent; + typedef GObjectClass BaseClassParent; + + friend class AccelGroup; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void accel_changed_callback(GtkAccelGroup* self, guint p0, GdkModifierType p1, GClosure* p2); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_ACCELGROUP_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/accellabel_p.h b/libs/gtkmm2/gtk/gtkmm/private/accellabel_p.h new file mode 100644 index 0000000000..fea48d72d6 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/accellabel_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_ACCELLABEL_P_H +#define _GTKMM_ACCELLABEL_P_H +#include <gtkmm/private/label_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class AccelLabel_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef AccelLabel CppObjectType; + typedef GtkAccelLabel BaseObjectType; + typedef GtkAccelLabelClass BaseClassType; + typedef Gtk::Label_Class CppClassParent; + typedef GtkLabelClass BaseClassParent; + + friend class AccelLabel; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_ACCELLABEL_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/action_p.h b/libs/gtkmm2/gtk/gtkmm/private/action_p.h new file mode 100644 index 0000000000..b143a7e57d --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/action_p.h @@ -0,0 +1,49 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_ACTION_P_H +#define _GTKMM_ACTION_P_H +#include <glibmm/private/object_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class Action_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef Action CppObjectType; + typedef GtkAction BaseObjectType; + typedef GtkActionClass BaseClassType; + typedef Glib::Object_Class CppClassParent; + typedef GObjectClass BaseClassParent; + + friend class Action; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void activate_callback(GtkAction* self); + + //Callbacks (virtual functions): + static GtkWidget* create_menu_item_vfunc_callback(GtkAction* self); + static GtkWidget* create_tool_item_vfunc_callback(GtkAction* self); + static void connect_proxy_vfunc_callback(GtkAction* self, GtkWidget* proxy); + static void disconnect_proxy_vfunc_callback(GtkAction* self, GtkWidget* proxy); +}; + + +} // namespace Gtk + +#endif /* _GTKMM_ACTION_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/actiongroup_p.h b/libs/gtkmm2/gtk/gtkmm/private/actiongroup_p.h new file mode 100644 index 0000000000..468723aa92 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/actiongroup_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_ACTIONGROUP_P_H +#define _GTKMM_ACTIONGROUP_P_H +#include <glibmm/private/object_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class ActionGroup_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef ActionGroup CppObjectType; + typedef GtkActionGroup BaseObjectType; + typedef GtkActionGroupClass BaseClassType; + typedef Glib::Object_Class CppClassParent; + typedef GObjectClass BaseClassParent; + + friend class ActionGroup; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_ACTIONGROUP_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/adjustment_p.h b/libs/gtkmm2/gtk/gtkmm/private/adjustment_p.h new file mode 100644 index 0000000000..4a13ed8c2b --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/adjustment_p.h @@ -0,0 +1,46 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_ADJUSTMENT_P_H +#define _GTKMM_ADJUSTMENT_P_H +#include <gtkmm/private/object_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class Adjustment_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef Adjustment CppObjectType; + typedef GtkAdjustment BaseObjectType; + typedef GtkAdjustmentClass BaseClassType; + typedef Gtk::Object_Class CppClassParent; + typedef GtkObjectClass BaseClassParent; + + friend class Adjustment; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void changed_callback(GtkAdjustment* self); + static void value_changed_callback(GtkAdjustment* self); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_ADJUSTMENT_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/alignment_p.h b/libs/gtkmm2/gtk/gtkmm/private/alignment_p.h new file mode 100644 index 0000000000..debf6ee966 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/alignment_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_ALIGNMENT_P_H +#define _GTKMM_ALIGNMENT_P_H +#include <gtkmm/private/bin_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class Alignment_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef Alignment CppObjectType; + typedef GtkAlignment BaseObjectType; + typedef GtkAlignmentClass BaseClassType; + typedef Gtk::Bin_Class CppClassParent; + typedef GtkBinClass BaseClassParent; + + friend class Alignment; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_ALIGNMENT_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/arrow_p.h b/libs/gtkmm2/gtk/gtkmm/private/arrow_p.h new file mode 100644 index 0000000000..7e3e5dd4b7 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/arrow_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_ARROW_P_H +#define _GTKMM_ARROW_P_H +#include <gtkmm/private/misc_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class Arrow_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef Arrow CppObjectType; + typedef GtkArrow BaseObjectType; + typedef GtkArrowClass BaseClassType; + typedef Gtk::Misc_Class CppClassParent; + typedef GtkMiscClass BaseClassParent; + + friend class Arrow; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_ARROW_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/aspectframe_p.h b/libs/gtkmm2/gtk/gtkmm/private/aspectframe_p.h new file mode 100644 index 0000000000..6e5e3ec8b9 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/aspectframe_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_ASPECTFRAME_P_H +#define _GTKMM_ASPECTFRAME_P_H +#include <gtkmm/private/frame_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class AspectFrame_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef AspectFrame CppObjectType; + typedef GtkAspectFrame BaseObjectType; + typedef GtkAspectFrameClass BaseClassType; + typedef Gtk::Frame_Class CppClassParent; + typedef GtkFrameClass BaseClassParent; + + friend class AspectFrame; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_ASPECTFRAME_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/bin_p.h b/libs/gtkmm2/gtk/gtkmm/private/bin_p.h new file mode 100644 index 0000000000..b81931b19e --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/bin_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_BIN_P_H +#define _GTKMM_BIN_P_H +#include <gtkmm/private/container_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class Bin_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef Bin CppObjectType; + typedef GtkBin BaseObjectType; + typedef GtkBinClass BaseClassType; + typedef Gtk::Container_Class CppClassParent; + typedef GtkContainerClass BaseClassParent; + + friend class Bin; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_BIN_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/box_p.h b/libs/gtkmm2/gtk/gtkmm/private/box_p.h new file mode 100644 index 0000000000..bf26cdbf7d --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/box_p.h @@ -0,0 +1,118 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_BOX_P_H +#define _GTKMM_BOX_P_H +#include <gtkmm/private/container_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class Box_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef Box CppObjectType; + typedef GtkBox BaseObjectType; + typedef GtkBoxClass BaseClassType; + typedef Gtk::Container_Class CppClassParent; + typedef GtkContainerClass BaseClassParent; + + friend class Box; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + + +#include <glibmm/class.h> + +namespace Gtk +{ + +class VBox_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef VBox CppObjectType; + typedef GtkVBox BaseObjectType; + typedef GtkVBoxClass BaseClassType; + typedef Gtk::Box_Class CppClassParent; + typedef GtkBoxClass BaseClassParent; + + friend class VBox; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + + +#include <glibmm/class.h> + +namespace Gtk +{ + +class HBox_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef HBox CppObjectType; + typedef GtkHBox BaseObjectType; + typedef GtkHBoxClass BaseClassType; + typedef Gtk::Box_Class CppClassParent; + typedef GtkBoxClass BaseClassParent; + + friend class HBox; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_BOX_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/button_p.h b/libs/gtkmm2/gtk/gtkmm/private/button_p.h new file mode 100644 index 0000000000..7fe15f9a48 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/button_p.h @@ -0,0 +1,50 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_BUTTON_P_H +#define _GTKMM_BUTTON_P_H +#include <gtkmm/private/bin_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class Button_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef Button CppObjectType; + typedef GtkButton BaseObjectType; + typedef GtkButtonClass BaseClassType; + typedef Gtk::Bin_Class CppClassParent; + typedef GtkBinClass BaseClassParent; + + friend class Button; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void pressed_callback(GtkButton* self); + static void released_callback(GtkButton* self); + static void clicked_callback(GtkButton* self); + static void enter_callback(GtkButton* self); + static void leave_callback(GtkButton* self); + static void activate_callback(GtkButton* self); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_BUTTON_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/buttonbox_p.h b/libs/gtkmm2/gtk/gtkmm/private/buttonbox_p.h new file mode 100644 index 0000000000..59a656dbb5 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/buttonbox_p.h @@ -0,0 +1,118 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_BUTTONBOX_P_H +#define _GTKMM_BUTTONBOX_P_H +#include <gtkmm/private/box_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class ButtonBox_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef ButtonBox CppObjectType; + typedef GtkButtonBox BaseObjectType; + typedef GtkButtonBoxClass BaseClassType; + typedef Gtk::Box_Class CppClassParent; + typedef GtkBoxClass BaseClassParent; + + friend class ButtonBox; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + + +#include <glibmm/class.h> + +namespace Gtk +{ + +class VButtonBox_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef VButtonBox CppObjectType; + typedef GtkVButtonBox BaseObjectType; + typedef GtkVButtonBoxClass BaseClassType; + typedef Gtk::ButtonBox_Class CppClassParent; + typedef GtkButtonBoxClass BaseClassParent; + + friend class VButtonBox; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + + +#include <glibmm/class.h> + +namespace Gtk +{ + +class HButtonBox_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef HButtonBox CppObjectType; + typedef GtkHButtonBox BaseObjectType; + typedef GtkHButtonBoxClass BaseClassType; + typedef Gtk::ButtonBox_Class CppClassParent; + typedef GtkButtonBoxClass BaseClassParent; + + friend class HButtonBox; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_BUTTONBOX_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/calendar_p.h b/libs/gtkmm2/gtk/gtkmm/private/calendar_p.h new file mode 100644 index 0000000000..f138739966 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/calendar_p.h @@ -0,0 +1,51 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_CALENDAR_P_H +#define _GTKMM_CALENDAR_P_H +#include <gtkmm/private/widget_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class Calendar_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef Calendar CppObjectType; + typedef GtkCalendar BaseObjectType; + typedef GtkCalendarClass BaseClassType; + typedef Gtk::Widget_Class CppClassParent; + typedef GtkWidgetClass BaseClassParent; + + friend class Calendar; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void month_changed_callback(GtkCalendar* self); + static void day_selected_callback(GtkCalendar* self); + static void day_selected_double_click_callback(GtkCalendar* self); + static void prev_month_callback(GtkCalendar* self); + static void next_month_callback(GtkCalendar* self); + static void prev_year_callback(GtkCalendar* self); + static void next_year_callback(GtkCalendar* self); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_CALENDAR_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/celleditable_p.h b/libs/gtkmm2/gtk/gtkmm/private/celleditable_p.h new file mode 100644 index 0000000000..31250f561b --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/celleditable_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_CELLEDITABLE_P_H +#define _GTKMM_CELLEDITABLE_P_H +#include <glibmm/private/interface_p.h> + +#include <glibmm/private/interface_p.h> + +namespace Gtk +{ + +class CellEditable_Class : public Glib::Interface_Class +{ +public: + typedef CellEditable CppObjectType; + typedef GtkCellEditable BaseObjectType; + typedef GtkCellEditableIface BaseClassType; + typedef Glib::Interface_Class CppClassParent; + + friend class CellEditable; + + const Glib::Interface_Class& init(); + + static void iface_init_function(void* g_iface, void* iface_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void editing_done_callback(GtkCellEditable* self); + static void remove_widget_callback(GtkCellEditable* self); + + //Callbacks (virtual functions): + static void start_editing_vfunc_callback(GtkCellEditable* self, GdkEvent* event); +}; + + +} // namespace Gtk + +#endif /* _GTKMM_CELLEDITABLE_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/celllayout_p.h b/libs/gtkmm2/gtk/gtkmm/private/celllayout_p.h new file mode 100644 index 0000000000..1af5318448 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/celllayout_p.h @@ -0,0 +1,47 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_CELLLAYOUT_P_H +#define _GTKMM_CELLLAYOUT_P_H +#include <glibmm/private/interface_p.h> + +#include <glibmm/private/interface_p.h> + +namespace Gtk +{ + +class CellLayout_Class : public Glib::Interface_Class +{ +public: + typedef CellLayout CppObjectType; + typedef GtkCellLayout BaseObjectType; + typedef GtkCellLayoutIface BaseClassType; + typedef Glib::Interface_Class CppClassParent; + + friend class CellLayout; + + const Glib::Interface_Class& init(); + + static void iface_init_function(void* g_iface, void* iface_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): + static void pack_start_vfunc_callback(GtkCellLayout* self, GtkCellRenderer* cell, gboolean expand); + static void pack_end_vfunc_callback(GtkCellLayout* self, GtkCellRenderer* cell, gboolean expand); + static void clear_vfunc_callback(GtkCellLayout* self); + static void add_attribute_vfunc_callback(GtkCellLayout* self, GtkCellRenderer* cell, const gchar* attribute, gint column); + static void clear_attributes_vfunc_callback(GtkCellLayout* self, GtkCellRenderer* cell); + static void reorder_vfunc_callback(GtkCellLayout* self, GtkCellRenderer* cell, gint position); +}; + + +} // namespace Gtk + +#endif /* _GTKMM_CELLLAYOUT_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/cellrenderer_p.h b/libs/gtkmm2/gtk/gtkmm/private/cellrenderer_p.h new file mode 100644 index 0000000000..c7fac80cb6 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/cellrenderer_p.h @@ -0,0 +1,50 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_CELLRENDERER_P_H +#define _GTKMM_CELLRENDERER_P_H +#include <gtkmm/private/object_p.h> +#include <gtk/gtkcellrenderer.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class CellRenderer_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef CellRenderer CppObjectType; + typedef GtkCellRenderer BaseObjectType; + typedef GtkCellRendererClass BaseClassType; + typedef Gtk::Object_Class CppClassParent; + typedef GtkObjectClass BaseClassParent; + + friend class CellRenderer; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void editing_canceled_callback(GtkCellRenderer* self); + + //Callbacks (virtual functions): + static void get_size_vfunc_callback(GtkCellRenderer* self, GtkWidget* widget, GdkRectangle* cell_area, gint* x_offset, gint* y_offset, gint* width, gint* height); + static void render_vfunc_callback(GtkCellRenderer* self, GdkDrawable* window, GtkWidget* widget, GdkRectangle* background_area, GdkRectangle* cell_area, GdkRectangle* expose_area, GtkCellRendererState flags); + static gboolean activate_vfunc_callback(GtkCellRenderer* self, GdkEvent* event, GtkWidget* widget, const gchar* path, GdkRectangle* background_area, GdkRectangle* cell_area, GtkCellRendererState flags); + static GtkCellEditable* start_editing_vfunc_callback(GtkCellRenderer* self, GdkEvent* event, GtkWidget* widget, const gchar* path, GdkRectangle* background_area, GdkRectangle* cell_area, GtkCellRendererState flags); +}; + + +} // namespace Gtk + +#endif /* _GTKMM_CELLRENDERER_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/cellrenderercombo_p.h b/libs/gtkmm2/gtk/gtkmm/private/cellrenderercombo_p.h new file mode 100644 index 0000000000..af5eda9c5f --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/cellrenderercombo_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_CELLRENDERERCOMBO_P_H +#define _GTKMM_CELLRENDERERCOMBO_P_H +#include <gtkmm/private/cellrenderertext_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class CellRendererCombo_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef CellRendererCombo CppObjectType; + typedef GtkCellRendererCombo BaseObjectType; + typedef GtkCellRendererComboClass BaseClassType; + typedef Gtk::CellRendererText_Class CppClassParent; + typedef GtkCellRendererTextClass BaseClassParent; + + friend class CellRendererCombo; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_CELLRENDERERCOMBO_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/cellrendererpixbuf_p.h b/libs/gtkmm2/gtk/gtkmm/private/cellrendererpixbuf_p.h new file mode 100644 index 0000000000..5bf100b376 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/cellrendererpixbuf_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_CELLRENDERERPIXBUF_P_H +#define _GTKMM_CELLRENDERERPIXBUF_P_H +#include <gtkmm/private/cellrenderer_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class CellRendererPixbuf_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef CellRendererPixbuf CppObjectType; + typedef GtkCellRendererPixbuf BaseObjectType; + typedef GtkCellRendererPixbufClass BaseClassType; + typedef Gtk::CellRenderer_Class CppClassParent; + typedef GtkCellRendererClass BaseClassParent; + + friend class CellRendererPixbuf; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_CELLRENDERERPIXBUF_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/cellrendererprogress_p.h b/libs/gtkmm2/gtk/gtkmm/private/cellrendererprogress_p.h new file mode 100644 index 0000000000..f95a9f133b --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/cellrendererprogress_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_CELLRENDERERPROGRESS_P_H +#define _GTKMM_CELLRENDERERPROGRESS_P_H +#include <gtkmm/private/cellrenderer_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class CellRendererProgress_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef CellRendererProgress CppObjectType; + typedef GtkCellRendererProgress BaseObjectType; + typedef GtkCellRendererProgressClass BaseClassType; + typedef Gtk::CellRenderer_Class CppClassParent; + typedef GtkCellRendererClass BaseClassParent; + + friend class CellRendererProgress; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_CELLRENDERERPROGRESS_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/cellrenderertext_p.h b/libs/gtkmm2/gtk/gtkmm/private/cellrenderertext_p.h new file mode 100644 index 0000000000..1505a568f9 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/cellrenderertext_p.h @@ -0,0 +1,45 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_CELLRENDERERTEXT_P_H +#define _GTKMM_CELLRENDERERTEXT_P_H +#include <gtkmm/private/cellrenderer_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class CellRendererText_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef CellRendererText CppObjectType; + typedef GtkCellRendererText BaseObjectType; + typedef GtkCellRendererTextClass BaseClassType; + typedef Gtk::CellRenderer_Class CppClassParent; + typedef GtkCellRendererClass BaseClassParent; + + friend class CellRendererText; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void edited_callback(GtkCellRendererText* self, const gchar* p0, const gchar* p1); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_CELLRENDERERTEXT_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/cellrenderertoggle_p.h b/libs/gtkmm2/gtk/gtkmm/private/cellrenderertoggle_p.h new file mode 100644 index 0000000000..6566624b9d --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/cellrenderertoggle_p.h @@ -0,0 +1,45 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_CELLRENDERERTOGGLE_P_H +#define _GTKMM_CELLRENDERERTOGGLE_P_H +#include <gtkmm/private/cellrenderer_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class CellRendererToggle_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef CellRendererToggle CppObjectType; + typedef GtkCellRendererToggle BaseObjectType; + typedef GtkCellRendererToggleClass BaseClassType; + typedef Gtk::CellRenderer_Class CppClassParent; + typedef GtkCellRendererClass BaseClassParent; + + friend class CellRendererToggle; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void toggled_callback(GtkCellRendererToggle* self, const gchar* p0); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_CELLRENDERERTOGGLE_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/cellview_p.h b/libs/gtkmm2/gtk/gtkmm/private/cellview_p.h new file mode 100644 index 0000000000..6046537896 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/cellview_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_CELLVIEW_P_H +#define _GTKMM_CELLVIEW_P_H +#include <gtkmm/private/widget_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class CellView_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef CellView CppObjectType; + typedef GtkCellView BaseObjectType; + typedef GtkCellViewClass BaseClassType; + typedef Gtk::Widget_Class CppClassParent; + typedef GtkWidgetClass BaseClassParent; + + friend class CellView; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_CELLVIEW_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/checkbutton_p.h b/libs/gtkmm2/gtk/gtkmm/private/checkbutton_p.h new file mode 100644 index 0000000000..1e579d79b9 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/checkbutton_p.h @@ -0,0 +1,45 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_CHECKBUTTON_P_H +#define _GTKMM_CHECKBUTTON_P_H +#include <gtkmm/private/togglebutton_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class CheckButton_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef CheckButton CppObjectType; + typedef GtkCheckButton BaseObjectType; + typedef GtkCheckButtonClass BaseClassType; + typedef Gtk::ToggleButton_Class CppClassParent; + typedef GtkToggleButtonClass BaseClassParent; + + friend class CheckButton; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): + static void draw_indicator_vfunc_callback(GtkCheckButton* self, GdkRectangle* area); +}; + + +} // namespace Gtk + +#endif /* _GTKMM_CHECKBUTTON_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/checkmenuitem_p.h b/libs/gtkmm2/gtk/gtkmm/private/checkmenuitem_p.h new file mode 100644 index 0000000000..8ae77c14b7 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/checkmenuitem_p.h @@ -0,0 +1,46 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_CHECKMENUITEM_P_H +#define _GTKMM_CHECKMENUITEM_P_H +#include <gtkmm/private/menuitem_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class CheckMenuItem_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef CheckMenuItem CppObjectType; + typedef GtkCheckMenuItem BaseObjectType; + typedef GtkCheckMenuItemClass BaseClassType; + typedef Gtk::MenuItem_Class CppClassParent; + typedef GtkMenuItemClass BaseClassParent; + + friend class CheckMenuItem; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void toggled_callback(GtkCheckMenuItem* self); + + //Callbacks (virtual functions): + static void draw_indicator_vfunc_callback(GtkCheckMenuItem* self, GdkRectangle* area); +}; + + +} // namespace Gtk + +#endif /* _GTKMM_CHECKMENUITEM_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/clipboard_p.h b/libs/gtkmm2/gtk/gtkmm/private/clipboard_p.h new file mode 100644 index 0000000000..1bad952a67 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/clipboard_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_CLIPBOARD_P_H +#define _GTKMM_CLIPBOARD_P_H +#include <glibmm/private/object_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class Clipboard_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef Clipboard CppObjectType; + typedef GtkClipboard BaseObjectType; + typedef GtkClipboardClass BaseClassType; + typedef Glib::Object_Class CppClassParent; + typedef GObjectClass BaseClassParent; + + friend class Clipboard; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_CLIPBOARD_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/colorbutton_p.h b/libs/gtkmm2/gtk/gtkmm/private/colorbutton_p.h new file mode 100644 index 0000000000..20b2dfb9e6 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/colorbutton_p.h @@ -0,0 +1,45 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_COLORBUTTON_P_H +#define _GTKMM_COLORBUTTON_P_H +#include <gtkmm/private/button_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class ColorButton_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef ColorButton CppObjectType; + typedef GtkColorButton BaseObjectType; + typedef GtkColorButtonClass BaseClassType; + typedef Gtk::Button_Class CppClassParent; + typedef GtkButtonClass BaseClassParent; + + friend class ColorButton; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void color_set_callback(GtkColorButton* self); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_COLORBUTTON_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/colorselection_p.h b/libs/gtkmm2/gtk/gtkmm/private/colorselection_p.h new file mode 100644 index 0000000000..662aca3486 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/colorselection_p.h @@ -0,0 +1,83 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_COLORSELECTION_P_H +#define _GTKMM_COLORSELECTION_P_H +#include <gtkmm/private/box_p.h> +#include <gtkmm/private/dialog_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class ColorSelection_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef ColorSelection CppObjectType; + typedef GtkColorSelection BaseObjectType; + typedef GtkColorSelectionClass BaseClassType; + typedef Gtk::VBox_Class CppClassParent; + typedef GtkVBoxClass BaseClassParent; + + friend class ColorSelection; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void color_changed_callback(GtkColorSelection* self); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + + +#include <glibmm/class.h> + +namespace Gtk +{ + +class ColorSelectionDialog_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef ColorSelectionDialog CppObjectType; + typedef GtkColorSelectionDialog BaseObjectType; + typedef GtkColorSelectionDialogClass BaseClassType; + typedef Gtk::Dialog_Class CppClassParent; + typedef GtkDialogClass BaseClassParent; + + friend class ColorSelectionDialog; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_COLORSELECTION_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/combo_p.h b/libs/gtkmm2/gtk/gtkmm/private/combo_p.h new file mode 100644 index 0000000000..c272fe4afa --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/combo_p.h @@ -0,0 +1,124 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_COMBO_P_H +#define _GTKMM_COMBO_P_H +#include <gtkmm/private/box_p.h> +#include <gtkmm/private/item_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class ComboDropDownItem_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef ComboDropDownItem CppObjectType; + typedef GtkListItem BaseObjectType; + typedef GtkListItemClass BaseClassType; + typedef Gtk::Item_Class CppClassParent; + typedef GtkItemClass BaseClassParent; + + friend class ComboDropDownItem; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void scroll_horizontal_callback(GtkListItem* self, GtkScrollType p0, gfloat p1); + static void scroll_vertical_callback(GtkListItem* self, GtkScrollType p0, gfloat p1); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + + +#include <glibmm/class.h> + +namespace Gtk +{ + +class ComboDropDown_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef ComboDropDown CppObjectType; + typedef GtkList BaseObjectType; + typedef GtkListClass BaseClassType; + typedef Gtk::Container_Class CppClassParent; + typedef GtkContainerClass BaseClassParent; + + friend class ComboDropDown; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void select_child_callback(GtkList* self, GtkWidget* p0); + static void selection_changed_callback(GtkList* self); + static void unselect_child_callback(GtkList* self, GtkWidget* p0); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + + +#include <glibmm/class.h> + +namespace Gtk +{ + +class Combo_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef Combo CppObjectType; + typedef GtkCombo BaseObjectType; + typedef GtkComboClass BaseClassType; + typedef Gtk::HBox_Class CppClassParent; + typedef GtkHBoxClass BaseClassParent; + + friend class Combo; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_COMBO_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/combobox_p.h b/libs/gtkmm2/gtk/gtkmm/private/combobox_p.h new file mode 100644 index 0000000000..242c755f70 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/combobox_p.h @@ -0,0 +1,45 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_COMBOBOX_P_H +#define _GTKMM_COMBOBOX_P_H +#include <gtkmm/private/bin_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class ComboBox_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef ComboBox CppObjectType; + typedef GtkComboBox BaseObjectType; + typedef GtkComboBoxClass BaseClassType; + typedef Gtk::Bin_Class CppClassParent; + typedef GtkBinClass BaseClassParent; + + friend class ComboBox; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void changed_callback(GtkComboBox* self); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_COMBOBOX_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/comboboxentry_p.h b/libs/gtkmm2/gtk/gtkmm/private/comboboxentry_p.h new file mode 100644 index 0000000000..bbc8a5028a --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/comboboxentry_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_COMBOBOXENTRY_P_H +#define _GTKMM_COMBOBOXENTRY_P_H +#include <gtkmm/private/combobox_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class ComboBoxEntry_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef ComboBoxEntry CppObjectType; + typedef GtkComboBoxEntry BaseObjectType; + typedef GtkComboBoxEntryClass BaseClassType; + typedef Gtk::ComboBox_Class CppClassParent; + typedef GtkComboBoxClass BaseClassParent; + + friend class ComboBoxEntry; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_COMBOBOXENTRY_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/container_p.h b/libs/gtkmm2/gtk/gtkmm/private/container_p.h new file mode 100644 index 0000000000..3f1b158887 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/container_p.h @@ -0,0 +1,55 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_CONTAINER_P_H +#define _GTKMM_CONTAINER_P_H +#include <gtkmm/private/widget_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class Container_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef Container CppObjectType; + typedef GtkContainer BaseObjectType; + typedef GtkContainerClass BaseClassType; + typedef Gtk::Widget_Class CppClassParent; + typedef GtkWidgetClass BaseClassParent; + + friend class Container; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void add_callback(GtkContainer* self, GtkWidget* p0); + static void remove_callback(GtkContainer* self, GtkWidget* p0); + static void check_resize_callback(GtkContainer* self); + static void set_focus_child_callback(GtkContainer* self, GtkWidget* p0); + static void destroy_callback(GtkObject* self); + static void remove_callback_custom(GtkContainer* self, GtkWidget* p0); + + //Callbacks (virtual functions): + static GtkType child_type_vfunc_callback(GtkContainer* self); + static void forall_vfunc_callback(GtkContainer* self, gboolean include_internals, GtkCallback callback, gpointer callback_data); + static gchar* composite_name_vfunc_callback(GtkContainer* self, GtkWidget* child); + static void set_child_property_vfunc_callback(GtkContainer* self, GtkWidget* child, guint property_id, const GValue* value, GParamSpec* pspec); + static void get_child_property_vfunc_callback(GtkContainer* self, GtkWidget* child, guint property_id, GValue* value, GParamSpec* pspec); +}; + + +} // namespace Gtk + +#endif /* _GTKMM_CONTAINER_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/curve_p.h b/libs/gtkmm2/gtk/gtkmm/private/curve_p.h new file mode 100644 index 0000000000..dc07066521 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/curve_p.h @@ -0,0 +1,83 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_CURVE_P_H +#define _GTKMM_CURVE_P_H +#include <gtkmm/private/drawingarea_p.h> +#include <gtkmm/private/box_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class Curve_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef Curve CppObjectType; + typedef GtkCurve BaseObjectType; + typedef GtkCurveClass BaseClassType; + typedef Gtk::DrawingArea_Class CppClassParent; + typedef GtkDrawingAreaClass BaseClassParent; + + friend class Curve; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void curve_type_changed_callback(GtkCurve* self); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + + +#include <glibmm/class.h> + +namespace Gtk +{ + +class GammaCurve_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef GammaCurve CppObjectType; + typedef GtkGammaCurve BaseObjectType; + typedef GtkGammaCurveClass BaseClassType; + typedef Gtk::VBox_Class CppClassParent; + typedef GtkVBoxClass BaseClassParent; + + friend class GammaCurve; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_CURVE_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/dialog_p.h b/libs/gtkmm2/gtk/gtkmm/private/dialog_p.h new file mode 100644 index 0000000000..9eeef1e8fe --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/dialog_p.h @@ -0,0 +1,45 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_DIALOG_P_H +#define _GTKMM_DIALOG_P_H +#include <gtkmm/private/window_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class Dialog_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef Dialog CppObjectType; + typedef GtkDialog BaseObjectType; + typedef GtkDialogClass BaseClassType; + typedef Gtk::Window_Class CppClassParent; + typedef GtkWindowClass BaseClassParent; + + friend class Dialog; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void response_callback(GtkDialog* self, gint p0); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_DIALOG_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/drawingarea_p.h b/libs/gtkmm2/gtk/gtkmm/private/drawingarea_p.h new file mode 100644 index 0000000000..cd639999b3 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/drawingarea_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_DRAWINGAREA_P_H +#define _GTKMM_DRAWINGAREA_P_H +#include <gtkmm/private/widget_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class DrawingArea_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef DrawingArea CppObjectType; + typedef GtkDrawingArea BaseObjectType; + typedef GtkDrawingAreaClass BaseClassType; + typedef Gtk::Widget_Class CppClassParent; + typedef GtkWidgetClass BaseClassParent; + + friend class DrawingArea; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_DRAWINGAREA_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/editable_p.h b/libs/gtkmm2/gtk/gtkmm/private/editable_p.h new file mode 100644 index 0000000000..caf727830a --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/editable_p.h @@ -0,0 +1,51 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_EDITABLE_P_H +#define _GTKMM_EDITABLE_P_H +#include <glibmm/private/interface_p.h> + +#include <glibmm/private/interface_p.h> + +namespace Gtk +{ + +class Editable_Class : public Glib::Interface_Class +{ +public: + typedef Editable CppObjectType; + typedef GtkEditable BaseObjectType; + typedef GtkEditableClass BaseClassType; + typedef Glib::Interface_Class CppClassParent; + + friend class Editable; + + const Glib::Interface_Class& init(); + + static void iface_init_function(void* g_iface, void* iface_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void insert_text_callback(GtkEditable* self, const gchar* text, gint length, gint* position); + static void delete_text_callback(GtkEditable* self, gint start_pos, gint end_pos); + static void changed_callback(GtkEditable* self); + + //Callbacks (virtual functions): + static void do_insert_text_vfunc_callback(GtkEditable* self, const gchar* text, gint length, gint* position); + static void do_delete_text_vfunc_callback(GtkEditable* self, gint start_pos, gint end_pos); + static gchar* get_chars_vfunc_callback(GtkEditable* self, gint start_pos, gint end_pos); + static void set_selection_bounds_vfunc_callback(GtkEditable* self, gint start_pos, gint end_pos); + static gboolean get_selection_bounds_vfunc_callback(GtkEditable* self, gint* start_pos, gint* end_pos); + static void set_position_vfunc_callback(GtkEditable* self, gint position); + static gint get_position_vfunc_callback(GtkEditable* self); +}; + + +} // namespace Gtk + +#endif /* _GTKMM_EDITABLE_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/entry_p.h b/libs/gtkmm2/gtk/gtkmm/private/entry_p.h new file mode 100644 index 0000000000..5d25b64902 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/entry_p.h @@ -0,0 +1,47 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_ENTRY_P_H +#define _GTKMM_ENTRY_P_H +#include <gtkmm/private/widget_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class Entry_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef Entry CppObjectType; + typedef GtkEntry BaseObjectType; + typedef GtkEntryClass BaseClassType; + typedef Gtk::Widget_Class CppClassParent; + typedef GtkWidgetClass BaseClassParent; + + friend class Entry; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void populate_popup_callback(GtkEntry* self, GtkMenu* p0); + static void insert_at_cursor_callback(GtkEntry* self, const gchar* p0); + static void activate_callback(GtkEntry* self); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_ENTRY_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/entrycompletion_p.h b/libs/gtkmm2/gtk/gtkmm/private/entrycompletion_p.h new file mode 100644 index 0000000000..2a9b97a3ad --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/entrycompletion_p.h @@ -0,0 +1,46 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_ENTRYCOMPLETION_P_H +#define _GTKMM_ENTRYCOMPLETION_P_H +#include <glibmm/private/object_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class EntryCompletion_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef EntryCompletion CppObjectType; + typedef GtkEntryCompletion BaseObjectType; + typedef GtkEntryCompletionClass BaseClassType; + typedef Glib::Object_Class CppClassParent; + typedef GObjectClass BaseClassParent; + + friend class EntryCompletion; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void action_activated_callback(GtkEntryCompletion* self, gint p0); + static gboolean match_selected_callback_custom(GtkEntryCompletion* self, GtkTreeModel* c_model, GtkTreeIter* c_iter); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_ENTRYCOMPLETION_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/enums_p.h b/libs/gtkmm2/gtk/gtkmm/private/enums_p.h new file mode 100644 index 0000000000..68c26cc900 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/enums_p.h @@ -0,0 +1,6 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_ENUMS_P_H +#define _GTKMM_ENUMS_P_H +#endif /* _GTKMM_ENUMS_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/eventbox_p.h b/libs/gtkmm2/gtk/gtkmm/private/eventbox_p.h new file mode 100644 index 0000000000..91b3303f1f --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/eventbox_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_EVENTBOX_P_H +#define _GTKMM_EVENTBOX_P_H +#include <gtkmm/private/bin_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class EventBox_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef EventBox CppObjectType; + typedef GtkEventBox BaseObjectType; + typedef GtkEventBoxClass BaseClassType; + typedef Gtk::Bin_Class CppClassParent; + typedef GtkBinClass BaseClassParent; + + friend class EventBox; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_EVENTBOX_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/expander_p.h b/libs/gtkmm2/gtk/gtkmm/private/expander_p.h new file mode 100644 index 0000000000..674bf038cd --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/expander_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_EXPANDER_P_H +#define _GTKMM_EXPANDER_P_H +#include <gtkmm/private/bin_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class Expander_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef Expander CppObjectType; + typedef GtkExpander BaseObjectType; + typedef GtkExpanderClass BaseClassType; + typedef Gtk::Bin_Class CppClassParent; + typedef GtkBinClass BaseClassParent; + + friend class Expander; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_EXPANDER_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/filechooser_p.h b/libs/gtkmm2/gtk/gtkmm/private/filechooser_p.h new file mode 100644 index 0000000000..9b864a7dda --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/filechooser_p.h @@ -0,0 +1,41 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_FILECHOOSER_P_H +#define _GTKMM_FILECHOOSER_P_H +#include <glibmm/private/interface_p.h> + +#include <glibmm/private/interface_p.h> + +namespace Gtk +{ + +class FileChooser_Class : public Glib::Interface_Class +{ +public: + typedef FileChooser CppObjectType; + typedef GtkFileChooser BaseObjectType; + typedef GtkFileChooserClass BaseClassType; + typedef Glib::Interface_Class CppClassParent; + + friend class FileChooser; + + const Glib::Interface_Class& init(); + + static void iface_init_function(void* g_iface, void* iface_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_FILECHOOSER_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/filechooserbutton_p.h b/libs/gtkmm2/gtk/gtkmm/private/filechooserbutton_p.h new file mode 100644 index 0000000000..60aa6eff06 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/filechooserbutton_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_FILECHOOSERBUTTON_P_H +#define _GTKMM_FILECHOOSERBUTTON_P_H +#include <gtkmm/private/box_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class FileChooserButton_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef FileChooserButton CppObjectType; + typedef GtkFileChooserButton BaseObjectType; + typedef GtkFileChooserButtonClass BaseClassType; + typedef Gtk::HBox_Class CppClassParent; + typedef GtkHBoxClass BaseClassParent; + + friend class FileChooserButton; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_FILECHOOSERBUTTON_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/filechooserdialog_p.h b/libs/gtkmm2/gtk/gtkmm/private/filechooserdialog_p.h new file mode 100644 index 0000000000..38e4d9aa12 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/filechooserdialog_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_FILECHOOSERDIALOG_P_H +#define _GTKMM_FILECHOOSERDIALOG_P_H +#include <gtkmm/private/dialog_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class FileChooserDialog_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef FileChooserDialog CppObjectType; + typedef GtkFileChooserDialog BaseObjectType; + typedef GtkFileChooserDialogClass BaseClassType; + typedef Gtk::Dialog_Class CppClassParent; + typedef GtkDialogClass BaseClassParent; + + friend class FileChooserDialog; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_FILECHOOSERDIALOG_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/filechooserwidget_p.h b/libs/gtkmm2/gtk/gtkmm/private/filechooserwidget_p.h new file mode 100644 index 0000000000..09e093dca1 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/filechooserwidget_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_FILECHOOSERWIDGET_P_H +#define _GTKMM_FILECHOOSERWIDGET_P_H +#include <gtkmm/private/box_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class FileChooserWidget_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef FileChooserWidget CppObjectType; + typedef GtkFileChooserWidget BaseObjectType; + typedef GtkFileChooserWidgetClass BaseClassType; + typedef Gtk::VBox_Class CppClassParent; + typedef GtkVBoxClass BaseClassParent; + + friend class FileChooserWidget; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_FILECHOOSERWIDGET_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/filefilter_p.h b/libs/gtkmm2/gtk/gtkmm/private/filefilter_p.h new file mode 100644 index 0000000000..cfc5b84d36 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/filefilter_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_FILEFILTER_P_H +#define _GTKMM_FILEFILTER_P_H +#include <gtkmm/private/object_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class FileFilter_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef FileFilter CppObjectType; + typedef GtkFileFilter BaseObjectType; + typedef GtkFileFilterClass BaseClassType; + typedef Gtk::Object_Class CppClassParent; + typedef GtkObjectClass BaseClassParent; + + friend class FileFilter; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_FILEFILTER_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/fileselection_p.h b/libs/gtkmm2/gtk/gtkmm/private/fileselection_p.h new file mode 100644 index 0000000000..9ab7fc7c1f --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/fileselection_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_FILESELECTION_P_H +#define _GTKMM_FILESELECTION_P_H +#include <gtkmm/private/dialog_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class FileSelection_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef FileSelection CppObjectType; + typedef GtkFileSelection BaseObjectType; + typedef GtkFileSelectionClass BaseClassType; + typedef Gtk::Dialog_Class CppClassParent; + typedef GtkDialogClass BaseClassParent; + + friend class FileSelection; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_FILESELECTION_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/fixed_p.h b/libs/gtkmm2/gtk/gtkmm/private/fixed_p.h new file mode 100644 index 0000000000..b1c4abe756 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/fixed_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_FIXED_P_H +#define _GTKMM_FIXED_P_H +#include <gtkmm/private/container_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class Fixed_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef Fixed CppObjectType; + typedef GtkFixed BaseObjectType; + typedef GtkFixedClass BaseClassType; + typedef Gtk::Container_Class CppClassParent; + typedef GtkContainerClass BaseClassParent; + + friend class Fixed; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_FIXED_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/fontbutton_p.h b/libs/gtkmm2/gtk/gtkmm/private/fontbutton_p.h new file mode 100644 index 0000000000..746f160914 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/fontbutton_p.h @@ -0,0 +1,45 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_FONTBUTTON_P_H +#define _GTKMM_FONTBUTTON_P_H +#include <gtkmm/private/button_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class FontButton_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef FontButton CppObjectType; + typedef GtkFontButton BaseObjectType; + typedef GtkFontButtonClass BaseClassType; + typedef Gtk::Button_Class CppClassParent; + typedef GtkButtonClass BaseClassParent; + + friend class FontButton; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void font_set_callback(GtkFontButton* self); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_FONTBUTTON_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/fontselection_p.h b/libs/gtkmm2/gtk/gtkmm/private/fontselection_p.h new file mode 100644 index 0000000000..50da4e3401 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/fontselection_p.h @@ -0,0 +1,82 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_FONTSELECTION_P_H +#define _GTKMM_FONTSELECTION_P_H +#include <gtkmm/private/box_p.h> +#include <gtkmm/private/dialog_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class FontSelection_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef FontSelection CppObjectType; + typedef GtkFontSelection BaseObjectType; + typedef GtkFontSelectionClass BaseClassType; + typedef Gtk::VBox_Class CppClassParent; + typedef GtkVBoxClass BaseClassParent; + + friend class FontSelection; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + + +#include <glibmm/class.h> + +namespace Gtk +{ + +class FontSelectionDialog_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef FontSelectionDialog CppObjectType; + typedef GtkFontSelectionDialog BaseObjectType; + typedef GtkFontSelectionDialogClass BaseClassType; + typedef Gtk::Dialog_Class CppClassParent; + typedef GtkDialogClass BaseClassParent; + + friend class FontSelectionDialog; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_FONTSELECTION_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/frame_p.h b/libs/gtkmm2/gtk/gtkmm/private/frame_p.h new file mode 100644 index 0000000000..297c7efbe7 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/frame_p.h @@ -0,0 +1,45 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_FRAME_P_H +#define _GTKMM_FRAME_P_H +#include <gtkmm/private/bin_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class Frame_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef Frame CppObjectType; + typedef GtkFrame BaseObjectType; + typedef GtkFrameClass BaseClassType; + typedef Gtk::Bin_Class CppClassParent; + typedef GtkBinClass BaseClassParent; + + friend class Frame; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): + static void compute_child_allocation_vfunc_callback(GtkFrame* self, GtkAllocation* allocation); +}; + + +} // namespace Gtk + +#endif /* _GTKMM_FRAME_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/handlebox_p.h b/libs/gtkmm2/gtk/gtkmm/private/handlebox_p.h new file mode 100644 index 0000000000..d1e0b3c30d --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/handlebox_p.h @@ -0,0 +1,46 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_HANDLEBOX_P_H +#define _GTKMM_HANDLEBOX_P_H +#include <gtkmm/private/bin_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class HandleBox_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef HandleBox CppObjectType; + typedef GtkHandleBox BaseObjectType; + typedef GtkHandleBoxClass BaseClassType; + typedef Gtk::Bin_Class CppClassParent; + typedef GtkBinClass BaseClassParent; + + friend class HandleBox; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void child_attached_callback(GtkHandleBox* self, GtkWidget* p0); + static void child_detached_callback(GtkHandleBox* self, GtkWidget* p0); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_HANDLEBOX_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/iconfactory_p.h b/libs/gtkmm2/gtk/gtkmm/private/iconfactory_p.h new file mode 100644 index 0000000000..8840e8abde --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/iconfactory_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_ICONFACTORY_P_H +#define _GTKMM_ICONFACTORY_P_H +#include <glibmm/private/object_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class IconFactory_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef IconFactory CppObjectType; + typedef GtkIconFactory BaseObjectType; + typedef GtkIconFactoryClass BaseClassType; + typedef Glib::Object_Class CppClassParent; + typedef GObjectClass BaseClassParent; + + friend class IconFactory; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_ICONFACTORY_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/iconinfo_p.h b/libs/gtkmm2/gtk/gtkmm/private/iconinfo_p.h new file mode 100644 index 0000000000..e391510843 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/iconinfo_p.h @@ -0,0 +1,6 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_ICONINFO_P_H +#define _GTKMM_ICONINFO_P_H +#endif /* _GTKMM_ICONINFO_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/iconset_p.h b/libs/gtkmm2/gtk/gtkmm/private/iconset_p.h new file mode 100644 index 0000000000..1e861df94c --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/iconset_p.h @@ -0,0 +1,6 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_ICONSET_P_H +#define _GTKMM_ICONSET_P_H +#endif /* _GTKMM_ICONSET_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/iconsource_p.h b/libs/gtkmm2/gtk/gtkmm/private/iconsource_p.h new file mode 100644 index 0000000000..304da67691 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/iconsource_p.h @@ -0,0 +1,6 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_ICONSOURCE_P_H +#define _GTKMM_ICONSOURCE_P_H +#endif /* _GTKMM_ICONSOURCE_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/icontheme_p.h b/libs/gtkmm2/gtk/gtkmm/private/icontheme_p.h new file mode 100644 index 0000000000..a54fdbc17e --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/icontheme_p.h @@ -0,0 +1,45 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_ICONTHEME_P_H +#define _GTKMM_ICONTHEME_P_H +#include <glibmm/private/object_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class IconTheme_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef IconTheme CppObjectType; + typedef GtkIconTheme BaseObjectType; + typedef GtkIconThemeClass BaseClassType; + typedef Glib::Object_Class CppClassParent; + typedef GObjectClass BaseClassParent; + + friend class IconTheme; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void changed_callback(GtkIconTheme* self); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_ICONTHEME_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/iconview_p.h b/libs/gtkmm2/gtk/gtkmm/private/iconview_p.h new file mode 100644 index 0000000000..beed996eda --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/iconview_p.h @@ -0,0 +1,47 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_ICONVIEW_P_H +#define _GTKMM_ICONVIEW_P_H +#include <gtkmm/private/container_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class IconView_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef IconView CppObjectType; + typedef GtkIconView BaseObjectType; + typedef GtkIconViewClass BaseClassType; + typedef Gtk::Container_Class CppClassParent; + typedef GtkContainerClass BaseClassParent; + + friend class IconView; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void set_scroll_adjustments_callback(GtkIconView* self, GtkAdjustment* p0, GtkAdjustment* p1); + static void item_activated_callback(GtkIconView* self, GtkTreePath* p0); + static void selection_changed_callback(GtkIconView* self); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_ICONVIEW_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/image_p.h b/libs/gtkmm2/gtk/gtkmm/private/image_p.h new file mode 100644 index 0000000000..c01599d6c7 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/image_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_IMAGE_P_H +#define _GTKMM_IMAGE_P_H +#include <gtkmm/private/misc_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class Image_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef Image CppObjectType; + typedef GtkImage BaseObjectType; + typedef GtkImageClass BaseClassType; + typedef Gtk::Misc_Class CppClassParent; + typedef GtkMiscClass BaseClassParent; + + friend class Image; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_IMAGE_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/imagemenuitem_p.h b/libs/gtkmm2/gtk/gtkmm/private/imagemenuitem_p.h new file mode 100644 index 0000000000..4099489f25 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/imagemenuitem_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_IMAGEMENUITEM_P_H +#define _GTKMM_IMAGEMENUITEM_P_H +#include <gtkmm/private/menuitem_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class ImageMenuItem_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef ImageMenuItem CppObjectType; + typedef GtkImageMenuItem BaseObjectType; + typedef GtkImageMenuItemClass BaseClassType; + typedef Gtk::MenuItem_Class CppClassParent; + typedef GtkMenuItemClass BaseClassParent; + + friend class ImageMenuItem; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_IMAGEMENUITEM_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/inputdialog_p.h b/libs/gtkmm2/gtk/gtkmm/private/inputdialog_p.h new file mode 100644 index 0000000000..3197f6efb5 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/inputdialog_p.h @@ -0,0 +1,46 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_INPUTDIALOG_P_H +#define _GTKMM_INPUTDIALOG_P_H +#include <gtkmm/private/dialog_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class InputDialog_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef InputDialog CppObjectType; + typedef GtkInputDialog BaseObjectType; + typedef GtkInputDialogClass BaseClassType; + typedef Gtk::Dialog_Class CppClassParent; + typedef GtkDialogClass BaseClassParent; + + friend class InputDialog; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void enable_device_callback(GtkInputDialog* self, GdkDevice* p0); + static void disable_device_callback(GtkInputDialog* self, GdkDevice* p0); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_INPUTDIALOG_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/invisible_p.h b/libs/gtkmm2/gtk/gtkmm/private/invisible_p.h new file mode 100644 index 0000000000..0709dc8989 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/invisible_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_INVISIBLE_P_H +#define _GTKMM_INVISIBLE_P_H +#include <gtkmm/private/widget_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class Invisible_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef Invisible CppObjectType; + typedef GtkInvisible BaseObjectType; + typedef GtkInvisibleClass BaseClassType; + typedef Gtk::Widget_Class CppClassParent; + typedef GtkWidgetClass BaseClassParent; + + friend class Invisible; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_INVISIBLE_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/item_p.h b/libs/gtkmm2/gtk/gtkmm/private/item_p.h new file mode 100644 index 0000000000..2baa4fa0de --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/item_p.h @@ -0,0 +1,47 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_ITEM_P_H +#define _GTKMM_ITEM_P_H +#include <gtkmm/private/bin_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class Item_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef Item CppObjectType; + typedef GtkItem BaseObjectType; + typedef GtkItemClass BaseClassType; + typedef Gtk::Bin_Class CppClassParent; + typedef GtkBinClass BaseClassParent; + + friend class Item; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void select_callback(GtkItem* self); + static void deselect_callback(GtkItem* self); + static void toggle_callback(GtkItem* self); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_ITEM_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/label_p.h b/libs/gtkmm2/gtk/gtkmm/private/label_p.h new file mode 100644 index 0000000000..5254aba319 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/label_p.h @@ -0,0 +1,46 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_LABEL_P_H +#define _GTKMM_LABEL_P_H +#include <gtkmm/private/misc_p.h> +#include <gtk/gtkmenu.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class Label_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef Label CppObjectType; + typedef GtkLabel BaseObjectType; + typedef GtkLabelClass BaseClassType; + typedef Gtk::Misc_Class CppClassParent; + typedef GtkMiscClass BaseClassParent; + + friend class Label; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void populate_popup_callback(GtkLabel* self, GtkMenu* p0); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_LABEL_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/layout_p.h b/libs/gtkmm2/gtk/gtkmm/private/layout_p.h new file mode 100644 index 0000000000..1c4c2773c5 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/layout_p.h @@ -0,0 +1,45 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_LAYOUT_P_H +#define _GTKMM_LAYOUT_P_H +#include <gtkmm/private/container_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class Layout_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef Layout CppObjectType; + typedef GtkLayout BaseObjectType; + typedef GtkLayoutClass BaseClassType; + typedef Gtk::Container_Class CppClassParent; + typedef GtkContainerClass BaseClassParent; + + friend class Layout; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void set_scroll_adjustments_callback(GtkLayout* self, GtkAdjustment* p0, GtkAdjustment* p1); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_LAYOUT_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/liststore_p.h b/libs/gtkmm2/gtk/gtkmm/private/liststore_p.h new file mode 100644 index 0000000000..522ec0b0ca --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/liststore_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_LISTSTORE_P_H +#define _GTKMM_LISTSTORE_P_H +#include <glibmm/private/object_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class ListStore_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef ListStore CppObjectType; + typedef GtkListStore BaseObjectType; + typedef GtkListStoreClass BaseClassType; + typedef Glib::Object_Class CppClassParent; + typedef GObjectClass BaseClassParent; + + friend class ListStore; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_LISTSTORE_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/main_p.h b/libs/gtkmm2/gtk/gtkmm/private/main_p.h new file mode 100644 index 0000000000..a911a52b39 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/main_p.h @@ -0,0 +1,6 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_MAIN_P_H +#define _GTKMM_MAIN_P_H +#endif /* _GTKMM_MAIN_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/menu_p.h b/libs/gtkmm2/gtk/gtkmm/private/menu_p.h new file mode 100644 index 0000000000..97d6e21f30 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/menu_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_MENU_P_H +#define _GTKMM_MENU_P_H +#include <gtkmm/private/menushell_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class Menu_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef Menu CppObjectType; + typedef GtkMenu BaseObjectType; + typedef GtkMenuClass BaseClassType; + typedef Gtk::MenuShell_Class CppClassParent; + typedef GtkMenuShellClass BaseClassParent; + + friend class Menu; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_MENU_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/menubar_p.h b/libs/gtkmm2/gtk/gtkmm/private/menubar_p.h new file mode 100644 index 0000000000..e36353f8c6 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/menubar_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_MENUBAR_P_H +#define _GTKMM_MENUBAR_P_H +#include <gtkmm/private/menushell_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class MenuBar_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef MenuBar CppObjectType; + typedef GtkMenuBar BaseObjectType; + typedef GtkMenuBarClass BaseClassType; + typedef Gtk::MenuShell_Class CppClassParent; + typedef GtkMenuShellClass BaseClassParent; + + friend class MenuBar; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_MENUBAR_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/menuitem_p.h b/libs/gtkmm2/gtk/gtkmm/private/menuitem_p.h new file mode 100644 index 0000000000..c900ddc67f --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/menuitem_p.h @@ -0,0 +1,48 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_MENUITEM_P_H +#define _GTKMM_MENUITEM_P_H +#include <gtkmm/private/item_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class MenuItem_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef MenuItem CppObjectType; + typedef GtkMenuItem BaseObjectType; + typedef GtkMenuItemClass BaseClassType; + typedef Gtk::Item_Class CppClassParent; + typedef GtkItemClass BaseClassParent; + + friend class MenuItem; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void activate_callback(GtkMenuItem* self); + static void activate_item_callback(GtkMenuItem* self); + static void toggle_size_request_callback(GtkMenuItem* self, int* p0); + static void toggle_size_allocate_callback(GtkMenuItem* self, gint p0); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_MENUITEM_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/menushell_p.h b/libs/gtkmm2/gtk/gtkmm/private/menushell_p.h new file mode 100644 index 0000000000..676e85d40e --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/menushell_p.h @@ -0,0 +1,50 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_MENUSHELL_P_H +#define _GTKMM_MENUSHELL_P_H +#include <gtkmm/private/container_p.h> +#include <gtkmm/menu.h> +#include <gtkmm/menubar.h> +#include <gtkmm/window.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class MenuShell_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef MenuShell CppObjectType; + typedef GtkMenuShell BaseObjectType; + typedef GtkMenuShellClass BaseClassType; + typedef Gtk::Container_Class CppClassParent; + typedef GtkContainerClass BaseClassParent; + + friend class MenuShell; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void deactivate_callback(GtkMenuShell* self); + static void selection_done_callback(GtkMenuShell* self); + + //Callbacks (virtual functions): + static void insert_vfunc_callback(GtkMenuShell* self, GtkWidget* child, int position); + }; + + +} // namespace Gtk + +#endif /* _GTKMM_MENUSHELL_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/menutoolbutton_p.h b/libs/gtkmm2/gtk/gtkmm/private/menutoolbutton_p.h new file mode 100644 index 0000000000..401e1b5242 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/menutoolbutton_p.h @@ -0,0 +1,45 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_MENUTOOLBUTTON_P_H +#define _GTKMM_MENUTOOLBUTTON_P_H +#include <gtkmm/private/toolbutton_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class MenuToolButton_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef MenuToolButton CppObjectType; + typedef GtkMenuToolButton BaseObjectType; + typedef GtkMenuToolButtonClass BaseClassType; + typedef Gtk::ToolButton_Class CppClassParent; + typedef GtkToolButtonClass BaseClassParent; + + friend class MenuToolButton; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void show_menu_callback(GtkMenuToolButton* self); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_MENUTOOLBUTTON_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/messagedialog_p.h b/libs/gtkmm2/gtk/gtkmm/private/messagedialog_p.h new file mode 100644 index 0000000000..829b79c77e --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/messagedialog_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_MESSAGEDIALOG_P_H +#define _GTKMM_MESSAGEDIALOG_P_H +#include <gtkmm/private/dialog_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class MessageDialog_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef MessageDialog CppObjectType; + typedef GtkMessageDialog BaseObjectType; + typedef GtkMessageDialogClass BaseClassType; + typedef Gtk::Dialog_Class CppClassParent; + typedef GtkDialogClass BaseClassParent; + + friend class MessageDialog; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_MESSAGEDIALOG_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/misc_p.h b/libs/gtkmm2/gtk/gtkmm/private/misc_p.h new file mode 100644 index 0000000000..adeb898dfe --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/misc_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_MISC_P_H +#define _GTKMM_MISC_P_H +#include <gtkmm/private/widget_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class Misc_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef Misc CppObjectType; + typedef GtkMisc BaseObjectType; + typedef GtkMiscClass BaseClassType; + typedef Gtk::Widget_Class CppClassParent; + typedef GtkWidgetClass BaseClassParent; + + friend class Misc; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_MISC_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/notebook_p.h b/libs/gtkmm2/gtk/gtkmm/private/notebook_p.h new file mode 100644 index 0000000000..de761d21c9 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/notebook_p.h @@ -0,0 +1,45 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_NOTEBOOK_P_H +#define _GTKMM_NOTEBOOK_P_H +#include <gtkmm/private/container_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class Notebook_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef Notebook CppObjectType; + typedef GtkNotebook BaseObjectType; + typedef GtkNotebookClass BaseClassType; + typedef Gtk::Container_Class CppClassParent; + typedef GtkContainerClass BaseClassParent; + + friend class Notebook; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void switch_page_callback(GtkNotebook* self, GtkNotebookPage* p0, guint p1); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_NOTEBOOK_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/object_p.h b/libs/gtkmm2/gtk/gtkmm/private/object_p.h new file mode 100644 index 0000000000..dc4ba98bef --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/object_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_OBJECT_P_H +#define _GTKMM_OBJECT_P_H +#include <glibmm/private/object_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class Object_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef Object CppObjectType; + typedef GtkObject BaseObjectType; + typedef GtkObjectClass BaseClassType; + typedef Glib::Object_Class CppClassParent; + typedef GObjectClass BaseClassParent; + + friend class Object; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_OBJECT_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/optionmenu_p.h b/libs/gtkmm2/gtk/gtkmm/private/optionmenu_p.h new file mode 100644 index 0000000000..414d3e631d --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/optionmenu_p.h @@ -0,0 +1,45 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_OPTIONMENU_P_H +#define _GTKMM_OPTIONMENU_P_H +#include <gtkmm/private/button_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class OptionMenu_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef OptionMenu CppObjectType; + typedef GtkOptionMenu BaseObjectType; + typedef GtkOptionMenuClass BaseClassType; + typedef Gtk::Button_Class CppClassParent; + typedef GtkButtonClass BaseClassParent; + + friend class OptionMenu; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void changed_callback(GtkOptionMenu* self); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_OPTIONMENU_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/paned_p.h b/libs/gtkmm2/gtk/gtkmm/private/paned_p.h new file mode 100644 index 0000000000..8d8af1f20d --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/paned_p.h @@ -0,0 +1,118 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_PANED_P_H +#define _GTKMM_PANED_P_H +#include <gtkmm/private/container_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class Paned_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef Paned CppObjectType; + typedef GtkPaned BaseObjectType; + typedef GtkPanedClass BaseClassType; + typedef Gtk::Container_Class CppClassParent; + typedef GtkContainerClass BaseClassParent; + + friend class Paned; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + + +#include <glibmm/class.h> + +namespace Gtk +{ + +class HPaned_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef HPaned CppObjectType; + typedef GtkHPaned BaseObjectType; + typedef GtkHPanedClass BaseClassType; + typedef Gtk::Paned_Class CppClassParent; + typedef GtkPanedClass BaseClassParent; + + friend class HPaned; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + + +#include <glibmm/class.h> + +namespace Gtk +{ + +class VPaned_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef VPaned CppObjectType; + typedef GtkVPaned BaseObjectType; + typedef GtkVPanedClass BaseClassType; + typedef Gtk::Paned_Class CppClassParent; + typedef GtkPanedClass BaseClassParent; + + friend class VPaned; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_PANED_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/plug_p.h b/libs/gtkmm2/gtk/gtkmm/private/plug_p.h new file mode 100644 index 0000000000..86c6e9b3f6 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/plug_p.h @@ -0,0 +1,45 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_PLUG_P_H +#define _GTKMM_PLUG_P_H +#include <gtkmm/private/window_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class Plug_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef Plug CppObjectType; + typedef GtkPlug BaseObjectType; + typedef GtkPlugClass BaseClassType; + typedef Gtk::Window_Class CppClassParent; + typedef GtkWindowClass BaseClassParent; + + friend class Plug; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void embedded_callback(GtkPlug* self); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_PLUG_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/progressbar_p.h b/libs/gtkmm2/gtk/gtkmm/private/progressbar_p.h new file mode 100644 index 0000000000..783de015ea --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/progressbar_p.h @@ -0,0 +1,45 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_PROGRESSBAR_P_H +#define _GTKMM_PROGRESSBAR_P_H +#include <gtkmm/private/widget_p.h> +#include <gtk/gtkprogress.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class ProgressBar_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef ProgressBar CppObjectType; + typedef GtkProgressBar BaseObjectType; + typedef GtkProgressBarClass BaseClassType; + typedef Gtk::Widget_Class CppClassParent; + typedef GtkProgressClass BaseClassParent; + + friend class ProgressBar; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_PROGRESSBAR_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/radioaction_p.h b/libs/gtkmm2/gtk/gtkmm/private/radioaction_p.h new file mode 100644 index 0000000000..ab9ae13b95 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/radioaction_p.h @@ -0,0 +1,45 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_RADIOACTION_P_H +#define _GTKMM_RADIOACTION_P_H +#include <gtkmm/private/toggleaction_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class RadioAction_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef RadioAction CppObjectType; + typedef GtkRadioAction BaseObjectType; + typedef GtkRadioActionClass BaseClassType; + typedef Gtk::ToggleAction_Class CppClassParent; + typedef GtkToggleActionClass BaseClassParent; + + friend class RadioAction; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void changed_callback(GtkRadioAction* self, GtkRadioAction* p0); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_RADIOACTION_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/radiobutton_p.h b/libs/gtkmm2/gtk/gtkmm/private/radiobutton_p.h new file mode 100644 index 0000000000..bb0797be6c --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/radiobutton_p.h @@ -0,0 +1,45 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_RADIOBUTTON_P_H +#define _GTKMM_RADIOBUTTON_P_H +#include <gtkmm/private/checkbutton_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class RadioButton_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef RadioButton CppObjectType; + typedef GtkRadioButton BaseObjectType; + typedef GtkRadioButtonClass BaseClassType; + typedef Gtk::CheckButton_Class CppClassParent; + typedef GtkCheckButtonClass BaseClassParent; + + friend class RadioButton; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void group_changed_callback(GtkRadioButton* self); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_RADIOBUTTON_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/radiomenuitem_p.h b/libs/gtkmm2/gtk/gtkmm/private/radiomenuitem_p.h new file mode 100644 index 0000000000..aa49592fc7 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/radiomenuitem_p.h @@ -0,0 +1,45 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_RADIOMENUITEM_P_H +#define _GTKMM_RADIOMENUITEM_P_H +#include <gtkmm/private/checkmenuitem_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class RadioMenuItem_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef RadioMenuItem CppObjectType; + typedef GtkRadioMenuItem BaseObjectType; + typedef GtkRadioMenuItemClass BaseClassType; + typedef Gtk::CheckMenuItem_Class CppClassParent; + typedef GtkCheckMenuItemClass BaseClassParent; + + friend class RadioMenuItem; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void group_changed_callback(GtkRadioMenuItem* self); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_RADIOMENUITEM_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/radiotoolbutton_p.h b/libs/gtkmm2/gtk/gtkmm/private/radiotoolbutton_p.h new file mode 100644 index 0000000000..034902a829 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/radiotoolbutton_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_RADIOTOOLBUTTON_P_H +#define _GTKMM_RADIOTOOLBUTTON_P_H +#include <gtkmm/private/toggletoolbutton_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class RadioToolButton_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef RadioToolButton CppObjectType; + typedef GtkRadioToolButton BaseObjectType; + typedef GtkRadioToolButtonClass BaseClassType; + typedef Gtk::ToggleToolButton_Class CppClassParent; + typedef GtkToggleToolButtonClass BaseClassParent; + + friend class RadioToolButton; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_RADIOTOOLBUTTON_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/range_p.h b/libs/gtkmm2/gtk/gtkmm/private/range_p.h new file mode 100644 index 0000000000..78c6b0c5a3 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/range_p.h @@ -0,0 +1,48 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_RANGE_P_H +#define _GTKMM_RANGE_P_H +#include <gtkmm/private/widget_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class Range_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef Range CppObjectType; + typedef GtkRange BaseObjectType; + typedef GtkRangeClass BaseClassType; + typedef Gtk::Widget_Class CppClassParent; + typedef GtkWidgetClass BaseClassParent; + + friend class Range; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void value_changed_callback(GtkRange* self); + static void adjust_bounds_callback(GtkRange* self, gdouble p0); + static void move_slider_callback(GtkRange* self, GtkScrollType p0); + + //Callbacks (virtual functions): + static void get_range_border_vfunc_callback(GtkRange* self, GtkBorder* border); +}; + + +} // namespace Gtk + +#endif /* _GTKMM_RANGE_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/rc_p.h b/libs/gtkmm2/gtk/gtkmm/private/rc_p.h new file mode 100644 index 0000000000..963495fb4f --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/rc_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_RC_P_H +#define _GTKMM_RC_P_H +#include <glibmm/private/object_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class RcStyle_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef RcStyle CppObjectType; + typedef GtkRcStyle BaseObjectType; + typedef GtkRcStyleClass BaseClassType; + typedef Glib::Object_Class CppClassParent; + typedef GObjectClass BaseClassParent; + + friend class RcStyle; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_RC_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/ruler_p.h b/libs/gtkmm2/gtk/gtkmm/private/ruler_p.h new file mode 100644 index 0000000000..9c44986646 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/ruler_p.h @@ -0,0 +1,120 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_RULER_P_H +#define _GTKMM_RULER_P_H +#include <gtkmm/private/widget_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class Ruler_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef Ruler CppObjectType; + typedef GtkRuler BaseObjectType; + typedef GtkRulerClass BaseClassType; + typedef Gtk::Widget_Class CppClassParent; + typedef GtkWidgetClass BaseClassParent; + + friend class Ruler; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): + static void draw_ticks_vfunc_callback(GtkRuler* self); + static void draw_pos_vfunc_callback(GtkRuler* self); +}; + + +} // namespace Gtk + + +#include <glibmm/class.h> + +namespace Gtk +{ + +class VRuler_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef VRuler CppObjectType; + typedef GtkVRuler BaseObjectType; + typedef GtkVRulerClass BaseClassType; + typedef Gtk::Ruler_Class CppClassParent; + typedef GtkRulerClass BaseClassParent; + + friend class VRuler; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + + +#include <glibmm/class.h> + +namespace Gtk +{ + +class HRuler_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef HRuler CppObjectType; + typedef GtkHRuler BaseObjectType; + typedef GtkHRulerClass BaseClassType; + typedef Gtk::Ruler_Class CppClassParent; + typedef GtkRulerClass BaseClassParent; + + friend class HRuler; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_RULER_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/scale_p.h b/libs/gtkmm2/gtk/gtkmm/private/scale_p.h new file mode 100644 index 0000000000..aa5dddf050 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/scale_p.h @@ -0,0 +1,120 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_SCALE_P_H +#define _GTKMM_SCALE_P_H +#include <gtkmm/private/range_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class Scale_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef Scale CppObjectType; + typedef GtkScale BaseObjectType; + typedef GtkScaleClass BaseClassType; + typedef Gtk::Range_Class CppClassParent; + typedef GtkRangeClass BaseClassParent; + + friend class Scale; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static gchar* format_value_callback(GtkScale* self, gdouble p0); + + //Callbacks (virtual functions): + static void draw_value_vfunc_callback(GtkScale* self); +}; + + +} // namespace Gtk + + +#include <glibmm/class.h> + +namespace Gtk +{ + +class VScale_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef VScale CppObjectType; + typedef GtkVScale BaseObjectType; + typedef GtkVScaleClass BaseClassType; + typedef Gtk::Scale_Class CppClassParent; + typedef GtkScaleClass BaseClassParent; + + friend class VScale; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + + +#include <glibmm/class.h> + +namespace Gtk +{ + +class HScale_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef HScale CppObjectType; + typedef GtkHScale BaseObjectType; + typedef GtkHScaleClass BaseClassType; + typedef Gtk::Scale_Class CppClassParent; + typedef GtkScaleClass BaseClassParent; + + friend class HScale; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_SCALE_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/scrollbar_p.h b/libs/gtkmm2/gtk/gtkmm/private/scrollbar_p.h new file mode 100644 index 0000000000..4781e3f466 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/scrollbar_p.h @@ -0,0 +1,118 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_SCROLLBAR_P_H +#define _GTKMM_SCROLLBAR_P_H +#include <gtkmm/private/range_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class Scrollbar_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef Scrollbar CppObjectType; + typedef GtkScrollbar BaseObjectType; + typedef GtkScrollbarClass BaseClassType; + typedef Gtk::Range_Class CppClassParent; + typedef GtkRangeClass BaseClassParent; + + friend class Scrollbar; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + + +#include <glibmm/class.h> + +namespace Gtk +{ + +class VScrollbar_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef VScrollbar CppObjectType; + typedef GtkVScrollbar BaseObjectType; + typedef GtkVScrollbarClass BaseClassType; + typedef Gtk::Scrollbar_Class CppClassParent; + typedef GtkScrollbarClass BaseClassParent; + + friend class VScrollbar; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + + +#include <glibmm/class.h> + +namespace Gtk +{ + +class HScrollbar_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef HScrollbar CppObjectType; + typedef GtkHScrollbar BaseObjectType; + typedef GtkHScrollbarClass BaseClassType; + typedef Gtk::Scrollbar_Class CppClassParent; + typedef GtkScrollbarClass BaseClassParent; + + friend class HScrollbar; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_SCROLLBAR_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/scrolledwindow_p.h b/libs/gtkmm2/gtk/gtkmm/private/scrolledwindow_p.h new file mode 100644 index 0000000000..f66dde8f03 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/scrolledwindow_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_SCROLLEDWINDOW_P_H +#define _GTKMM_SCROLLEDWINDOW_P_H +#include <gtkmm/private/bin_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class ScrolledWindow_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef ScrolledWindow CppObjectType; + typedef GtkScrolledWindow BaseObjectType; + typedef GtkScrolledWindowClass BaseClassType; + typedef Gtk::Bin_Class CppClassParent; + typedef GtkBinClass BaseClassParent; + + friend class ScrolledWindow; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_SCROLLEDWINDOW_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/selectiondata_p.h b/libs/gtkmm2/gtk/gtkmm/private/selectiondata_p.h new file mode 100644 index 0000000000..cb52061df2 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/selectiondata_p.h @@ -0,0 +1,6 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_SELECTIONDATA_P_H +#define _GTKMM_SELECTIONDATA_P_H +#endif /* _GTKMM_SELECTIONDATA_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/separator_p.h b/libs/gtkmm2/gtk/gtkmm/private/separator_p.h new file mode 100644 index 0000000000..a82c02557d --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/separator_p.h @@ -0,0 +1,118 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_SEPARATOR_P_H +#define _GTKMM_SEPARATOR_P_H +#include <gtkmm/private/widget_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class Separator_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef Separator CppObjectType; + typedef GtkSeparator BaseObjectType; + typedef GtkSeparatorClass BaseClassType; + typedef Gtk::Widget_Class CppClassParent; + typedef GtkWidgetClass BaseClassParent; + + friend class Separator; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + + +#include <glibmm/class.h> + +namespace Gtk +{ + +class VSeparator_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef VSeparator CppObjectType; + typedef GtkVSeparator BaseObjectType; + typedef GtkVSeparatorClass BaseClassType; + typedef Gtk::Separator_Class CppClassParent; + typedef GtkSeparatorClass BaseClassParent; + + friend class VSeparator; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + + +#include <glibmm/class.h> + +namespace Gtk +{ + +class HSeparator_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef HSeparator CppObjectType; + typedef GtkHSeparator BaseObjectType; + typedef GtkHSeparatorClass BaseClassType; + typedef Gtk::Separator_Class CppClassParent; + typedef GtkSeparatorClass BaseClassParent; + + friend class HSeparator; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_SEPARATOR_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/separatormenuitem_p.h b/libs/gtkmm2/gtk/gtkmm/private/separatormenuitem_p.h new file mode 100644 index 0000000000..1987425009 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/separatormenuitem_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_SEPARATORMENUITEM_P_H +#define _GTKMM_SEPARATORMENUITEM_P_H +#include <gtkmm/private/menuitem_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class SeparatorMenuItem_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef SeparatorMenuItem CppObjectType; + typedef GtkSeparatorMenuItem BaseObjectType; + typedef GtkSeparatorMenuItemClass BaseClassType; + typedef Gtk::MenuItem_Class CppClassParent; + typedef GtkMenuItemClass BaseClassParent; + + friend class SeparatorMenuItem; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_SEPARATORMENUITEM_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/separatortoolitem_p.h b/libs/gtkmm2/gtk/gtkmm/private/separatortoolitem_p.h new file mode 100644 index 0000000000..5de5fc7e88 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/separatortoolitem_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_SEPARATORTOOLITEM_P_H +#define _GTKMM_SEPARATORTOOLITEM_P_H +#include <gtkmm/private/toolitem_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class SeparatorToolItem_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef SeparatorToolItem CppObjectType; + typedef GtkSeparatorToolItem BaseObjectType; + typedef GtkSeparatorToolItemClass BaseClassType; + typedef Gtk::ToolItem_Class CppClassParent; + typedef GtkToolItemClass BaseClassParent; + + friend class SeparatorToolItem; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_SEPARATORTOOLITEM_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/settings_p.h b/libs/gtkmm2/gtk/gtkmm/private/settings_p.h new file mode 100644 index 0000000000..72e13b447a --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/settings_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_SETTINGS_P_H +#define _GTKMM_SETTINGS_P_H +#include <glibmm/private/object_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class Settings_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef Settings CppObjectType; + typedef GtkSettings BaseObjectType; + typedef GtkSettingsClass BaseClassType; + typedef Glib::Object_Class CppClassParent; + typedef GObjectClass BaseClassParent; + + friend class Settings; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_SETTINGS_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/sizegroup_p.h b/libs/gtkmm2/gtk/gtkmm/private/sizegroup_p.h new file mode 100644 index 0000000000..f33b8bdf58 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/sizegroup_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_SIZEGROUP_P_H +#define _GTKMM_SIZEGROUP_P_H +#include <glibmm/private/object_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class SizeGroup_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef SizeGroup CppObjectType; + typedef GtkSizeGroup BaseObjectType; + typedef GtkSizeGroupClass BaseClassType; + typedef Glib::Object_Class CppClassParent; + typedef GObjectClass BaseClassParent; + + friend class SizeGroup; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_SIZEGROUP_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/socket_p.h b/libs/gtkmm2/gtk/gtkmm/private/socket_p.h new file mode 100644 index 0000000000..5689897e40 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/socket_p.h @@ -0,0 +1,46 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_SOCKET_P_H +#define _GTKMM_SOCKET_P_H +#include <gtkmm/private/container_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class Socket_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef Socket CppObjectType; + typedef GtkSocket BaseObjectType; + typedef GtkSocketClass BaseClassType; + typedef Gtk::Container_Class CppClassParent; + typedef GtkContainerClass BaseClassParent; + + friend class Socket; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void plug_added_callback(GtkSocket* self); + static gboolean plug_removed_callback(GtkSocket* self); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_SOCKET_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/spinbutton_p.h b/libs/gtkmm2/gtk/gtkmm/private/spinbutton_p.h new file mode 100644 index 0000000000..f69aee70cf --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/spinbutton_p.h @@ -0,0 +1,47 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_SPINBUTTON_P_H +#define _GTKMM_SPINBUTTON_P_H +#include <gtkmm/private/entry_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class SpinButton_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef SpinButton CppObjectType; + typedef GtkSpinButton BaseObjectType; + typedef GtkSpinButtonClass BaseClassType; + typedef Gtk::Entry_Class CppClassParent; + typedef GtkEntryClass BaseClassParent; + + friend class SpinButton; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static gint input_callback(GtkSpinButton* self, gdouble* p0); + static gboolean output_callback(GtkSpinButton* self); + static void value_changed_callback(GtkSpinButton* self); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_SPINBUTTON_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/statusbar_p.h b/libs/gtkmm2/gtk/gtkmm/private/statusbar_p.h new file mode 100644 index 0000000000..23efc95695 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/statusbar_p.h @@ -0,0 +1,46 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_STATUSBAR_P_H +#define _GTKMM_STATUSBAR_P_H +#include <gtkmm/private/box_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class Statusbar_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef Statusbar CppObjectType; + typedef GtkStatusbar BaseObjectType; + typedef GtkStatusbarClass BaseClassType; + typedef Gtk::HBox_Class CppClassParent; + typedef GtkHBoxClass BaseClassParent; + + friend class Statusbar; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void text_pushed_callback(GtkStatusbar* self, guint p0, const gchar* p1); + static void text_popped_callback(GtkStatusbar* self, guint p0, const gchar* p1); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_STATUSBAR_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/stockitem_p.h b/libs/gtkmm2/gtk/gtkmm/private/stockitem_p.h new file mode 100644 index 0000000000..0ac19c3f37 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/stockitem_p.h @@ -0,0 +1,6 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_STOCKITEM_P_H +#define _GTKMM_STOCKITEM_P_H +#endif /* _GTKMM_STOCKITEM_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/style_p.h b/libs/gtkmm2/gtk/gtkmm/private/style_p.h new file mode 100644 index 0000000000..8c10fca392 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/style_p.h @@ -0,0 +1,75 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_STYLE_P_H +#define _GTKMM_STYLE_P_H +#include <glibmm/private/object_p.h> +#include <gtk/gtkrc.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class Style_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef Style CppObjectType; + typedef GtkStyle BaseObjectType; + typedef GtkStyleClass BaseClassType; + typedef Glib::Object_Class CppClassParent; + typedef GObjectClass BaseClassParent; + + friend class Style; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void realize_callback(GtkStyle* self); + static void unrealize_callback(GtkStyle* self); + + //Callbacks (virtual functions): + static void realize_vfunc_callback(GtkStyle* self); + static void unrealize_vfunc_callback(GtkStyle* self); + static void copy_vfunc_callback(GtkStyle* self, GtkStyle* src); + static GtkStyle* clone_vfunc_callback(GtkStyle* self); + static void init_from_rc_vfunc_callback(GtkStyle* self, GtkRcStyle* rc_style); + static void set_background_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type); + static GdkPixbuf* render_icon_vfunc_callback(GtkStyle* self, const GtkIconSource* source, GtkTextDirection direction, GtkStateType state, GtkIconSize size, GtkWidget* widget, const gchar* detail); + static void draw_hline_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x1, gint x2, gint y); + static void draw_vline_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint y1, gint y2, gint x); + static void draw_shadow_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height); + static void draw_polygon_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, GdkPoint* point, gint npoints, gboolean fill); + static void draw_arrow_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, GtkArrowType arrow_type, gboolean fill, gint x, gint y, gint width, gint height); + static void draw_diamond_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height); + static void draw_string_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, const gchar* string); + static void draw_box_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height); + static void draw_flat_box_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height); + static void draw_check_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height); + static void draw_option_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height); + static void draw_tab_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height); + static void draw_shadow_gap_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height, GtkPositionType gap_side, gint gap_x, gint gap_width); + static void draw_box_gap_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height, GtkPositionType gap_side, gint gap_x, gint gap_width); + static void draw_extension_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height, GtkPositionType gap_side); + static void draw_focus_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height); + static void draw_slider_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height, GtkOrientation orientation); + static void draw_handle_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height, GtkOrientation orientation); + static void draw_expander_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, GtkExpanderStyle expander_style); + static void draw_layout_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, gboolean use_text, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, PangoLayout* layout); + static void draw_resize_grip_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, GdkWindowEdge edge, gint x, gint y, gint width, gint height); +}; + + +} // namespace Gtk + +#endif /* _GTKMM_STYLE_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/table_p.h b/libs/gtkmm2/gtk/gtkmm/private/table_p.h new file mode 100644 index 0000000000..8fae19b7cf --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/table_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_TABLE_P_H +#define _GTKMM_TABLE_P_H +#include <gtkmm/private/container_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class Table_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef Table CppObjectType; + typedef GtkTable BaseObjectType; + typedef GtkTableClass BaseClassType; + typedef Gtk::Container_Class CppClassParent; + typedef GtkContainerClass BaseClassParent; + + friend class Table; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_TABLE_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/targetlist_p.h b/libs/gtkmm2/gtk/gtkmm/private/targetlist_p.h new file mode 100644 index 0000000000..508f488cfd --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/targetlist_p.h @@ -0,0 +1,6 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_TARGETLIST_P_H +#define _GTKMM_TARGETLIST_P_H +#endif /* _GTKMM_TARGETLIST_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/tearoffmenuitem_p.h b/libs/gtkmm2/gtk/gtkmm/private/tearoffmenuitem_p.h new file mode 100644 index 0000000000..e6378ac638 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/tearoffmenuitem_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_TEAROFFMENUITEM_P_H +#define _GTKMM_TEAROFFMENUITEM_P_H +#include <gtkmm/private/menuitem_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class TearoffMenuItem_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef TearoffMenuItem CppObjectType; + typedef GtkTearoffMenuItem BaseObjectType; + typedef GtkTearoffMenuItemClass BaseClassType; + typedef Gtk::MenuItem_Class CppClassParent; + typedef GtkMenuItemClass BaseClassParent; + + friend class TearoffMenuItem; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_TEAROFFMENUITEM_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/textattributes_p.h b/libs/gtkmm2/gtk/gtkmm/private/textattributes_p.h new file mode 100644 index 0000000000..4b922c4c44 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/textattributes_p.h @@ -0,0 +1,6 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_TEXTATTRIBUTES_P_H +#define _GTKMM_TEXTATTRIBUTES_P_H +#endif /* _GTKMM_TEXTATTRIBUTES_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/textbuffer_p.h b/libs/gtkmm2/gtk/gtkmm/private/textbuffer_p.h new file mode 100644 index 0000000000..59db070205 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/textbuffer_p.h @@ -0,0 +1,56 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_TEXTBUFFER_P_H +#define _GTKMM_TEXTBUFFER_P_H +#include <glibmm/private/object_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class TextBuffer_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef TextBuffer CppObjectType; + typedef GtkTextBuffer BaseObjectType; + typedef GtkTextBufferClass BaseClassType; + typedef Glib::Object_Class CppClassParent; + typedef GObjectClass BaseClassParent; + + friend class TextBuffer; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void insert_text_callback(GtkTextBuffer* self, GtkTextIter* p0, const gchar* p1, gint p2); + static void insert_pixbuf_callback(GtkTextBuffer* self, GtkTextIter* p0, GdkPixbuf* p1); + static void insert_child_anchor_callback(GtkTextBuffer* self, GtkTextIter* p0, GtkTextChildAnchor* p1); + static void delete_range_callback(GtkTextBuffer* self, GtkTextIter* p0, GtkTextIter* p1); + static void changed_callback(GtkTextBuffer* self); + static void modified_changed_callback(GtkTextBuffer* self); + static void mark_set_callback(GtkTextBuffer* self, const GtkTextIter* p0, GtkTextMark* p1); + static void mark_deleted_callback(GtkTextBuffer* self, GtkTextMark* p0); + static void apply_tag_callback(GtkTextBuffer* self, GtkTextTag* p0, const GtkTextIter* p1, const GtkTextIter* p2); + static void remove_tag_callback(GtkTextBuffer* self, GtkTextTag* p0, const GtkTextIter* p1, const GtkTextIter* p2); + static void begin_user_action_callback(GtkTextBuffer* self); + static void end_user_action_callback(GtkTextBuffer* self); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_TEXTBUFFER_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/textchildanchor_p.h b/libs/gtkmm2/gtk/gtkmm/private/textchildanchor_p.h new file mode 100644 index 0000000000..a3a9822c45 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/textchildanchor_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_TEXTCHILDANCHOR_P_H +#define _GTKMM_TEXTCHILDANCHOR_P_H +#include <glibmm/private/object_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class TextChildAnchor_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef TextChildAnchor CppObjectType; + typedef GtkTextChildAnchor BaseObjectType; + typedef GtkTextChildAnchorClass BaseClassType; + typedef Glib::Object_Class CppClassParent; + typedef GObjectClass BaseClassParent; + + friend class TextChildAnchor; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_TEXTCHILDANCHOR_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/textiter_p.h b/libs/gtkmm2/gtk/gtkmm/private/textiter_p.h new file mode 100644 index 0000000000..b234c358b0 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/textiter_p.h @@ -0,0 +1,6 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_TEXTITER_P_H +#define _GTKMM_TEXTITER_P_H +#endif /* _GTKMM_TEXTITER_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/textmark_p.h b/libs/gtkmm2/gtk/gtkmm/private/textmark_p.h new file mode 100644 index 0000000000..bba46d8c62 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/textmark_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_TEXTMARK_P_H +#define _GTKMM_TEXTMARK_P_H +#include <glibmm/private/object_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class TextMark_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef TextMark CppObjectType; + typedef GtkTextMark BaseObjectType; + typedef GtkTextMarkClass BaseClassType; + typedef Glib::Object_Class CppClassParent; + typedef GObjectClass BaseClassParent; + + friend class TextMark; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_TEXTMARK_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/texttag_p.h b/libs/gtkmm2/gtk/gtkmm/private/texttag_p.h new file mode 100644 index 0000000000..8cab5dac5b --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/texttag_p.h @@ -0,0 +1,46 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_TEXTTAG_P_H +#define _GTKMM_TEXTTAG_P_H +#include <glibmm/private/object_p.h> +#include <gtk/gtktexttag.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class TextTag_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef TextTag CppObjectType; + typedef GtkTextTag BaseObjectType; + typedef GtkTextTagClass BaseClassType; + typedef Glib::Object_Class CppClassParent; + typedef GObjectClass BaseClassParent; + + friend class TextTag; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static gboolean event_callback(GtkTextTag* self, GObject* p0, GdkEvent* p1, const GtkTextIter* p2); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_TEXTTAG_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/texttagtable_p.h b/libs/gtkmm2/gtk/gtkmm/private/texttagtable_p.h new file mode 100644 index 0000000000..19964742d5 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/texttagtable_p.h @@ -0,0 +1,47 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_TEXTTAGTABLE_P_H +#define _GTKMM_TEXTTAGTABLE_P_H +#include <glibmm/private/object_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class TextTagTable_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef TextTagTable CppObjectType; + typedef GtkTextTagTable BaseObjectType; + typedef GtkTextTagTableClass BaseClassType; + typedef Glib::Object_Class CppClassParent; + typedef GObjectClass BaseClassParent; + + friend class TextTagTable; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void tag_changed_callback(GtkTextTagTable* self, GtkTextTag* p0, gboolean p1); + static void tag_added_callback(GtkTextTagTable* self, GtkTextTag* p0); + static void tag_removed_callback(GtkTextTagTable* self, GtkTextTag* p0); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_TEXTTAGTABLE_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/textview_p.h b/libs/gtkmm2/gtk/gtkmm/private/textview_p.h new file mode 100644 index 0000000000..328d08f8d2 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/textview_p.h @@ -0,0 +1,48 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_TEXTVIEW_P_H +#define _GTKMM_TEXTVIEW_P_H +#include <gtkmm/private/container_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class TextView_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef TextView CppObjectType; + typedef GtkTextView BaseObjectType; + typedef GtkTextViewClass BaseClassType; + typedef Gtk::Container_Class CppClassParent; + typedef GtkContainerClass BaseClassParent; + + friend class TextView; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void set_scroll_adjustments_callback(GtkTextView* self, GtkAdjustment* p0, GtkAdjustment* p1); + static void populate_popup_callback(GtkTextView* self, GtkMenu* p0); + static void set_anchor_callback(GtkTextView* self); + static void insert_at_cursor_callback(GtkTextView* self, const gchar* p0); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_TEXTVIEW_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/toggleaction_p.h b/libs/gtkmm2/gtk/gtkmm/private/toggleaction_p.h new file mode 100644 index 0000000000..61de249561 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/toggleaction_p.h @@ -0,0 +1,45 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_TOGGLEACTION_P_H +#define _GTKMM_TOGGLEACTION_P_H +#include <gtkmm/private/action_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class ToggleAction_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef ToggleAction CppObjectType; + typedef GtkToggleAction BaseObjectType; + typedef GtkToggleActionClass BaseClassType; + typedef Gtk::Action_Class CppClassParent; + typedef GtkActionClass BaseClassParent; + + friend class ToggleAction; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void toggled_callback(GtkToggleAction* self); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_TOGGLEACTION_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/togglebutton_p.h b/libs/gtkmm2/gtk/gtkmm/private/togglebutton_p.h new file mode 100644 index 0000000000..73b571158f --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/togglebutton_p.h @@ -0,0 +1,45 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_TOGGLEBUTTON_P_H +#define _GTKMM_TOGGLEBUTTON_P_H +#include <gtkmm/private/button_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class ToggleButton_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef ToggleButton CppObjectType; + typedef GtkToggleButton BaseObjectType; + typedef GtkToggleButtonClass BaseClassType; + typedef Gtk::Button_Class CppClassParent; + typedef GtkButtonClass BaseClassParent; + + friend class ToggleButton; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void toggled_callback(GtkToggleButton* self); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_TOGGLEBUTTON_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/toggletoolbutton_p.h b/libs/gtkmm2/gtk/gtkmm/private/toggletoolbutton_p.h new file mode 100644 index 0000000000..9ed1cd4da0 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/toggletoolbutton_p.h @@ -0,0 +1,45 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_TOGGLETOOLBUTTON_P_H +#define _GTKMM_TOGGLETOOLBUTTON_P_H +#include <gtkmm/private/toolbutton_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class ToggleToolButton_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef ToggleToolButton CppObjectType; + typedef GtkToggleToolButton BaseObjectType; + typedef GtkToggleToolButtonClass BaseClassType; + typedef Gtk::ToolButton_Class CppClassParent; + typedef GtkToolButtonClass BaseClassParent; + + friend class ToggleToolButton; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void toggled_callback(GtkToggleToolButton* self); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_TOGGLETOOLBUTTON_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/toolbar_p.h b/libs/gtkmm2/gtk/gtkmm/private/toolbar_p.h new file mode 100644 index 0000000000..f2bb20e0d3 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/toolbar_p.h @@ -0,0 +1,47 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_TOOLBAR_P_H +#define _GTKMM_TOOLBAR_P_H +#include <gtkmm/private/container_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class Toolbar_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef Toolbar CppObjectType; + typedef GtkToolbar BaseObjectType; + typedef GtkToolbarClass BaseClassType; + typedef Gtk::Container_Class CppClassParent; + typedef GtkContainerClass BaseClassParent; + + friend class Toolbar; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void orientation_changed_callback(GtkToolbar* self, GtkOrientation p0); + static void style_changed_callback(GtkToolbar* self, GtkToolbarStyle p0); + static gboolean popup_context_menu_callback(GtkToolbar* self, gint p0, gint p1, gint p2); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_TOOLBAR_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/toolbutton_p.h b/libs/gtkmm2/gtk/gtkmm/private/toolbutton_p.h new file mode 100644 index 0000000000..2cac2dda6b --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/toolbutton_p.h @@ -0,0 +1,45 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_TOOLBUTTON_P_H +#define _GTKMM_TOOLBUTTON_P_H +#include <gtkmm/private/toolitem_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class ToolButton_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef ToolButton CppObjectType; + typedef GtkToolButton BaseObjectType; + typedef GtkToolButtonClass BaseClassType; + typedef Gtk::ToolItem_Class CppClassParent; + typedef GtkToolItemClass BaseClassParent; + + friend class ToolButton; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void clicked_callback(GtkToolButton* self); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_TOOLBUTTON_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/toolitem_p.h b/libs/gtkmm2/gtk/gtkmm/private/toolitem_p.h new file mode 100644 index 0000000000..a35fb73560 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/toolitem_p.h @@ -0,0 +1,46 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_TOOLITEM_P_H +#define _GTKMM_TOOLITEM_P_H +#include <gtkmm/private/bin_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class ToolItem_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef ToolItem CppObjectType; + typedef GtkToolItem BaseObjectType; + typedef GtkToolItemClass BaseClassType; + typedef Gtk::Bin_Class CppClassParent; + typedef GtkBinClass BaseClassParent; + + friend class ToolItem; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static gboolean create_menu_proxy_callback(GtkToolItem* self); + static void toolbar_reconfigured_callback(GtkToolItem* self); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_TOOLITEM_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/tooltips_p.h b/libs/gtkmm2/gtk/gtkmm/private/tooltips_p.h new file mode 100644 index 0000000000..1872000504 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/tooltips_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_TOOLTIPS_P_H +#define _GTKMM_TOOLTIPS_P_H +#include <gtkmm/private/object_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class Tooltips_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef Tooltips CppObjectType; + typedef GtkTooltips BaseObjectType; + typedef GtkTooltipsClass BaseClassType; + typedef Gtk::Object_Class CppClassParent; + typedef GtkObjectClass BaseClassParent; + + friend class Tooltips; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_TOOLTIPS_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/treedragdest_p.h b/libs/gtkmm2/gtk/gtkmm/private/treedragdest_p.h new file mode 100644 index 0000000000..0486146e02 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/treedragdest_p.h @@ -0,0 +1,43 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_TREEDRAGDEST_P_H +#define _GTKMM_TREEDRAGDEST_P_H +#include <glibmm/private/interface_p.h> + +#include <glibmm/private/interface_p.h> + +namespace Gtk +{ + +class TreeDragDest_Class : public Glib::Interface_Class +{ +public: + typedef TreeDragDest CppObjectType; + typedef GtkTreeDragDest BaseObjectType; + typedef GtkTreeDragDestIface BaseClassType; + typedef Glib::Interface_Class CppClassParent; + + friend class TreeDragDest; + + const Glib::Interface_Class& init(); + + static void iface_init_function(void* g_iface, void* iface_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): + static gboolean drag_data_received_vfunc_callback(GtkTreeDragDest* self, GtkTreePath* dest, GtkSelectionData* selection_data); + static gboolean row_drop_possible_vfunc_callback(GtkTreeDragDest* self, GtkTreePath* dest_path, GtkSelectionData* selection_data); +}; + + +} // namespace Gtk + +#endif /* _GTKMM_TREEDRAGDEST_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/treedragsource_p.h b/libs/gtkmm2/gtk/gtkmm/private/treedragsource_p.h new file mode 100644 index 0000000000..07f02f964f --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/treedragsource_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_TREEDRAGSOURCE_P_H +#define _GTKMM_TREEDRAGSOURCE_P_H +#include <glibmm/private/interface_p.h> + +#include <glibmm/private/interface_p.h> + +namespace Gtk +{ + +class TreeDragSource_Class : public Glib::Interface_Class +{ +public: + typedef TreeDragSource CppObjectType; + typedef GtkTreeDragSource BaseObjectType; + typedef GtkTreeDragSourceIface BaseClassType; + typedef Glib::Interface_Class CppClassParent; + + friend class TreeDragSource; + + const Glib::Interface_Class& init(); + + static void iface_init_function(void* g_iface, void* iface_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): + static gboolean drag_data_get_vfunc_callback(GtkTreeDragSource* self, GtkTreePath* path, GtkSelectionData* selection_data); + static gboolean row_draggable_vfunc_callback(GtkTreeDragSource* self, GtkTreePath* path); + static gboolean drag_data_delete_vfunc_callback(GtkTreeDragSource* self, GtkTreePath* path); +}; + + +} // namespace Gtk + +#endif /* _GTKMM_TREEDRAGSOURCE_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/treeiter_p.h b/libs/gtkmm2/gtk/gtkmm/private/treeiter_p.h new file mode 100644 index 0000000000..bc45469e97 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/treeiter_p.h @@ -0,0 +1,6 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_TREEITER_P_H +#define _GTKMM_TREEITER_P_H +#endif /* _GTKMM_TREEITER_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/treemodel_p.h b/libs/gtkmm2/gtk/gtkmm/private/treemodel_p.h new file mode 100644 index 0000000000..401d707834 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/treemodel_p.h @@ -0,0 +1,60 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_TREEMODEL_P_H +#define _GTKMM_TREEMODEL_P_H +#include <glibmm/private/interface_p.h> + +#include <glibmm/private/interface_p.h> + +namespace Gtk +{ + +class TreeModel_Class : public Glib::Interface_Class +{ +public: + typedef TreeModel CppObjectType; + typedef GtkTreeModel BaseObjectType; + typedef GtkTreeModelIface BaseClassType; + typedef Glib::Interface_Class CppClassParent; + + friend class TreeModel; + + const Glib::Interface_Class& init(); + + static void iface_init_function(void* g_iface, void* iface_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void row_changed_callback(GtkTreeModel* self, GtkTreePath* path, GtkTreeIter* iter); + static void row_inserted_callback(GtkTreeModel* self, GtkTreePath* path, GtkTreeIter* iter); + static void row_has_child_toggled_callback(GtkTreeModel* self, GtkTreePath* path, GtkTreeIter* iter); + static void row_deleted_callback(GtkTreeModel* self, GtkTreePath* path); + static void rows_reordered_callback(GtkTreeModel* self, GtkTreePath* path, GtkTreeIter* iter, gint* new_order); + + //Callbacks (virtual functions): + static GtkTreeModelFlags get_flags_vfunc_callback(GtkTreeModel* self); + static gint get_n_columns_vfunc_callback(GtkTreeModel* self); + static GType get_column_type_vfunc_callback(GtkTreeModel* self, gint index); + static gboolean iter_next_vfunc_callback(GtkTreeModel* self, GtkTreeIter* iter); + static gboolean get_iter_vfunc_callback(GtkTreeModel* self, GtkTreeIter* iter, GtkTreePath* path); + static gboolean iter_children_vfunc_callback(GtkTreeModel* self, GtkTreeIter* iter, GtkTreeIter* parent); + static gboolean iter_parent_vfunc_callback(GtkTreeModel* self, GtkTreeIter* iter, GtkTreeIter* child); + static gboolean iter_nth_child_vfunc_callback(GtkTreeModel* self, GtkTreeIter* iter, GtkTreeIter* parent, int n); + static int iter_n_children_vfunc_callback(GtkTreeModel* self, GtkTreeIter* iter); + static gboolean iter_has_child_vfunc_callback(GtkTreeModel* self, GtkTreeIter* iter); + static void ref_node_vfunc_callback(GtkTreeModel* self, GtkTreeIter* iter); + static void unref_node_vfunc_callback(GtkTreeModel* self, GtkTreeIter* iter); + static GtkTreePath* get_path_vfunc_callback(GtkTreeModel* self, GtkTreeIter* iter); + static void get_value_vfunc_callback(GtkTreeModel* self, GtkTreeIter* iter, gint column, GValue* value); +}; + + +} // namespace Gtk + +#endif /* _GTKMM_TREEMODEL_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/treemodelfilter_p.h b/libs/gtkmm2/gtk/gtkmm/private/treemodelfilter_p.h new file mode 100644 index 0000000000..cd4f27a229 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/treemodelfilter_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_TREEMODELFILTER_P_H +#define _GTKMM_TREEMODELFILTER_P_H +#include <glibmm/private/object_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class TreeModelFilter_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef TreeModelFilter CppObjectType; + typedef GtkTreeModelFilter BaseObjectType; + typedef GtkTreeModelFilterClass BaseClassType; + typedef Glib::Object_Class CppClassParent; + typedef GObjectClass BaseClassParent; + + friend class TreeModelFilter; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_TREEMODELFILTER_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/treemodelsort_p.h b/libs/gtkmm2/gtk/gtkmm/private/treemodelsort_p.h new file mode 100644 index 0000000000..ce050925cb --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/treemodelsort_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_TREEMODELSORT_P_H +#define _GTKMM_TREEMODELSORT_P_H +#include <glibmm/private/object_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class TreeModelSort_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef TreeModelSort CppObjectType; + typedef GtkTreeModelSort BaseObjectType; + typedef GtkTreeModelSortClass BaseClassType; + typedef Glib::Object_Class CppClassParent; + typedef GObjectClass BaseClassParent; + + friend class TreeModelSort; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_TREEMODELSORT_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/treepath_p.h b/libs/gtkmm2/gtk/gtkmm/private/treepath_p.h new file mode 100644 index 0000000000..829820cfe5 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/treepath_p.h @@ -0,0 +1,6 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_TREEPATH_P_H +#define _GTKMM_TREEPATH_P_H +#endif /* _GTKMM_TREEPATH_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/treerowreference_p.h b/libs/gtkmm2/gtk/gtkmm/private/treerowreference_p.h new file mode 100644 index 0000000000..00bcc4b2fe --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/treerowreference_p.h @@ -0,0 +1,6 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_TREEROWREFERENCE_P_H +#define _GTKMM_TREEROWREFERENCE_P_H +#endif /* _GTKMM_TREEROWREFERENCE_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/treeselection_p.h b/libs/gtkmm2/gtk/gtkmm/private/treeselection_p.h new file mode 100644 index 0000000000..ee7fcce1e7 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/treeselection_p.h @@ -0,0 +1,45 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_TREESELECTION_P_H +#define _GTKMM_TREESELECTION_P_H +#include <glibmm/private/object_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class TreeSelection_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef TreeSelection CppObjectType; + typedef GtkTreeSelection BaseObjectType; + typedef GtkTreeSelectionClass BaseClassType; + typedef Glib::Object_Class CppClassParent; + typedef GObjectClass BaseClassParent; + + friend class TreeSelection; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void changed_callback(GtkTreeSelection* self); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_TREESELECTION_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/treesortable_p.h b/libs/gtkmm2/gtk/gtkmm/private/treesortable_p.h new file mode 100644 index 0000000000..f93f94c10d --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/treesortable_p.h @@ -0,0 +1,48 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_TREESORTABLE_P_H +#define _GTKMM_TREESORTABLE_P_H +#include <glibmm/private/interface_p.h> + +#include <glibmm/private/interface_p.h> + +namespace Gtk +{ + +class TreeSortable_Class : public Glib::Interface_Class +{ +public: + typedef TreeSortable CppObjectType; + typedef GtkTreeSortable BaseObjectType; + typedef GtkTreeSortableIface BaseClassType; + typedef Glib::Interface_Class CppClassParent; + + friend class TreeSortable; + + const Glib::Interface_Class& init(); + + static void iface_init_function(void* g_iface, void* iface_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void sort_column_changed_callback(GtkTreeSortable* self); + + //Callbacks (virtual functions): + static gboolean get_sort_column_id_vfunc_callback(GtkTreeSortable* self, int* sort_column_id, GtkSortType* order); + static void set_sort_column_id_vfunc_callback(GtkTreeSortable* self, int sort_column_id, GtkSortType order); + static void set_sort_func_vfunc_callback(GtkTreeSortable* self, int sort_column_id, GtkTreeIterCompareFunc func, gpointer data, GtkDestroyNotify destroy); + static void set_default_sort_func_vfunc_callback(GtkTreeSortable* self, GtkTreeIterCompareFunc func, gpointer data, GtkDestroyNotify destroy); + static gboolean has_default_sort_func_vfunc_callback(GtkTreeSortable* self); + static void sort_column_changed_vfunc_callback(GtkTreeSortable* self); +}; + + +} // namespace Gtk + +#endif /* _GTKMM_TREESORTABLE_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/treestore_p.h b/libs/gtkmm2/gtk/gtkmm/private/treestore_p.h new file mode 100644 index 0000000000..fb1c7bc681 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/treestore_p.h @@ -0,0 +1,44 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_TREESTORE_P_H +#define _GTKMM_TREESTORE_P_H +#include <glibmm/private/object_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class TreeStore_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef TreeStore CppObjectType; + typedef GtkTreeStore BaseObjectType; + typedef GtkTreeStoreClass BaseClassType; + typedef Glib::Object_Class CppClassParent; + typedef GObjectClass BaseClassParent; + + friend class TreeStore; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_TREESTORE_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/treeview_p.h b/libs/gtkmm2/gtk/gtkmm/private/treeview_p.h new file mode 100644 index 0000000000..127465f857 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/treeview_p.h @@ -0,0 +1,52 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_TREEVIEW_P_H +#define _GTKMM_TREEVIEW_P_H +#include <gtkmm/private/container_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class TreeView_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef TreeView CppObjectType; + typedef GtkTreeView BaseObjectType; + typedef GtkTreeViewClass BaseClassType; + typedef Gtk::Container_Class CppClassParent; + typedef GtkContainerClass BaseClassParent; + + friend class TreeView; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void set_scroll_adjustments_callback(GtkTreeView* self, GtkAdjustment* p0, GtkAdjustment* p1); + static void row_activated_callback(GtkTreeView* self, GtkTreePath* p0, GtkTreeViewColumn* p1); + static gboolean test_expand_row_callback(GtkTreeView* self, GtkTreeIter* p0, GtkTreePath* p1); + static gboolean test_collapse_row_callback(GtkTreeView* self, GtkTreeIter* p0, GtkTreePath* p1); + static void row_expanded_callback(GtkTreeView* self, GtkTreeIter* p0, GtkTreePath* p1); + static void row_collapsed_callback(GtkTreeView* self, GtkTreeIter* p0, GtkTreePath* p1); + static void cursor_changed_callback(GtkTreeView* self); + static void columns_changed_callback(GtkTreeView* self); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_TREEVIEW_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/treeviewcolumn_p.h b/libs/gtkmm2/gtk/gtkmm/private/treeviewcolumn_p.h new file mode 100644 index 0000000000..f47a4a3279 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/treeviewcolumn_p.h @@ -0,0 +1,45 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_TREEVIEWCOLUMN_P_H +#define _GTKMM_TREEVIEWCOLUMN_P_H +#include <gtkmm/private/object_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class TreeViewColumn_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef TreeViewColumn CppObjectType; + typedef GtkTreeViewColumn BaseObjectType; + typedef GtkTreeViewColumnClass BaseClassType; + typedef Gtk::Object_Class CppClassParent; + typedef GtkObjectClass BaseClassParent; + + friend class TreeViewColumn; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void clicked_callback(GtkTreeViewColumn* self); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_TREEVIEWCOLUMN_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/uimanager_p.h b/libs/gtkmm2/gtk/gtkmm/private/uimanager_p.h new file mode 100644 index 0000000000..6932d4f791 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/uimanager_p.h @@ -0,0 +1,46 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_UIMANAGER_P_H +#define _GTKMM_UIMANAGER_P_H +#include <glibmm/private/object_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class UIManager_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef UIManager CppObjectType; + typedef GtkUIManager BaseObjectType; + typedef GtkUIManagerClass BaseClassType; + typedef Glib::Object_Class CppClassParent; + typedef GObjectClass BaseClassParent; + + friend class UIManager; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void add_widget_callback(GtkUIManager* self, GtkWidget* p0); + static void actions_changed_callback(GtkUIManager* self); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_UIMANAGER_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/viewport_p.h b/libs/gtkmm2/gtk/gtkmm/private/viewport_p.h new file mode 100644 index 0000000000..18fce1d06c --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/viewport_p.h @@ -0,0 +1,45 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_VIEWPORT_P_H +#define _GTKMM_VIEWPORT_P_H +#include <gtkmm/private/bin_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class Viewport_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef Viewport CppObjectType; + typedef GtkViewport BaseObjectType; + typedef GtkViewportClass BaseClassType; + typedef Gtk::Bin_Class CppClassParent; + typedef GtkBinClass BaseClassParent; + + friend class Viewport; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void set_scroll_adjustments_callback(GtkViewport* self, GtkAdjustment* p0, GtkAdjustment* p1); + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_VIEWPORT_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/widget_p.h b/libs/gtkmm2/gtk/gtkmm/private/widget_p.h new file mode 100644 index 0000000000..ce8df67d36 --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/widget_p.h @@ -0,0 +1,107 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_WIDGET_P_H +#define _GTKMM_WIDGET_P_H +#include <gtkmm/private/object_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class Widget_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef Widget CppObjectType; + typedef GtkWidget BaseObjectType; + typedef GtkWidgetClass BaseClassType; + typedef Gtk::Object_Class CppClassParent; + typedef GtkObjectClass BaseClassParent; + + friend class Widget; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void show_callback(GtkWidget* self); + static void hide_callback(GtkWidget* self); + static void map_callback(GtkWidget* self); + static void unmap_callback(GtkWidget* self); + static void realize_callback(GtkWidget* self); + static void unrealize_callback(GtkWidget* self); + static void size_request_callback(GtkWidget* self, GtkRequisition* p0); + static void size_allocate_callback(GtkWidget* self, GtkAllocation* p0); + static void state_changed_callback(GtkWidget* self, GtkStateType p0); + static void parent_set_callback(GtkWidget* self, GtkWidget* p0); + static void hierarchy_changed_callback(GtkWidget* self, GtkWidget* p0); + static void style_set_callback(GtkWidget* self, GtkStyle* p0); + static void direction_changed_callback(GtkWidget* self, GtkTextDirection p0); + static void grab_notify_callback(GtkWidget* self, gboolean p0); + static void child_notify_callback(GtkWidget* self, GParamSpec* p0); + static gboolean mnemonic_activate_callback(GtkWidget* self, gboolean p0); + static void grab_focus_callback(GtkWidget* self); + static gboolean focus_callback(GtkWidget* self, GtkDirectionType p0); + static gboolean event_callback(GtkWidget* self, GdkEvent* p0); + static gboolean button_press_event_callback(GtkWidget* self, GdkEventButton* p0); + static gboolean button_release_event_callback(GtkWidget* self, GdkEventButton* p0); + static gboolean scroll_event_callback(GtkWidget* self, GdkEventScroll* p0); + static gboolean motion_notify_event_callback(GtkWidget* self, GdkEventMotion* p0); + static gboolean delete_event_callback(GtkWidget* self, GdkEventAny* p0); + static gboolean expose_event_callback(GtkWidget* self, GdkEventExpose* p0); + static gboolean key_press_event_callback(GtkWidget* self, GdkEventKey* p0); + static gboolean key_release_event_callback(GtkWidget* self, GdkEventKey* p0); + static gboolean enter_notify_event_callback(GtkWidget* self, GdkEventCrossing* p0); + static gboolean leave_notify_event_callback(GtkWidget* self, GdkEventCrossing* p0); + static gboolean configure_event_callback(GtkWidget* self, GdkEventConfigure* p0); + static gboolean focus_in_event_callback(GtkWidget* self, GdkEventFocus* p0); + static gboolean focus_out_event_callback(GtkWidget* self, GdkEventFocus* p0); + static gboolean map_event_callback(GtkWidget* self, GdkEventAny* p0); + static gboolean unmap_event_callback(GtkWidget* self, GdkEventAny* p0); + static gboolean property_notify_event_callback(GtkWidget* self, GdkEventProperty* p0); + static gboolean selection_clear_event_callback(GtkWidget* self, GdkEventSelection* p0); + static gboolean selection_request_event_callback(GtkWidget* self, GdkEventSelection* p0); + static gboolean selection_notify_event_callback(GtkWidget* self, GdkEventSelection* p0); + static gboolean proximity_in_event_callback(GtkWidget* self, GdkEventProximity* p0); + static gboolean proximity_out_event_callback(GtkWidget* self, GdkEventProximity* p0); + static gboolean visibility_notify_event_callback(GtkWidget* self, GdkEventVisibility* p0); + static gboolean client_event_callback(GtkWidget* self, GdkEventClient* p0); + static gboolean no_expose_event_callback(GtkWidget* self, GdkEventAny* p0); + static gboolean window_state_event_callback(GtkWidget* self, GdkEventWindowState* p0); + static void selection_get_callback(GtkWidget* self, GtkSelectionData* p0, guint p1, guint p2); + static void selection_received_callback(GtkWidget* self, GtkSelectionData* p0, guint p1); + static void drag_begin_callback(GtkWidget* self, GdkDragContext* p0); + static void drag_end_callback(GtkWidget* self, GdkDragContext* p0); + static void drag_data_get_callback(GtkWidget* self, GdkDragContext* p0, GtkSelectionData* p1, guint p2, guint p3); + static void drag_data_delete_callback(GtkWidget* self, GdkDragContext* p0); + static void drag_leave_callback(GtkWidget* self, GdkDragContext* p0, guint p1); + static gboolean drag_motion_callback(GtkWidget* self, GdkDragContext* p0, gint p1, gint p2, guint p3); + static gboolean drag_drop_callback(GtkWidget* self, GdkDragContext* p0, gint p1, gint p2, guint p3); + static void drag_data_received_callback(GtkWidget* self, GdkDragContext* p0, gint p1, gint p2, GtkSelectionData* p3, guint p4, guint p5); + static AtkObject* get_accessible_callback(GtkWidget* self); + static void screen_changed_callback(GtkWidget* self, GdkScreen* p0); + static void hierarchy_changed_callback_custom(GtkWidget* self, GtkWidget* p0); + static void parent_set_callback_custom(GtkWidget* self, GtkWidget* p0); + + //Callbacks (virtual functions): + static void dispose_vfunc_callback(GObject* self); + static void dispatch_child_properties_changed_vfunc_callback(GtkWidget* self, guint n_pspecs, GParamSpec** pspecs); + static void show_all_vfunc_callback(GtkWidget* self); + static void hide_all_vfunc_callback(GtkWidget* self); + static AtkObject* get_accessible_vfunc_callback(GtkWidget* self); +}; + + +} // namespace Gtk + +#endif /* _GTKMM_WIDGET_P_H */ + diff --git a/libs/gtkmm2/gtk/gtkmm/private/window_p.h b/libs/gtkmm2/gtk/gtkmm/private/window_p.h new file mode 100644 index 0000000000..5413a7284a --- /dev/null +++ b/libs/gtkmm2/gtk/gtkmm/private/window_p.h @@ -0,0 +1,84 @@ +// -*- c++ -*- +// Generated by gtkmmproc -- DO NOT MODIFY! +#ifndef _GTKMM_WINDOW_P_H +#define _GTKMM_WINDOW_P_H +#include <gtkmm/private/bin_p.h> + +#include <glibmm/class.h> + +namespace Gtk +{ + +class Window_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef Window CppObjectType; + typedef GtkWindow BaseObjectType; + typedef GtkWindowClass BaseClassType; + typedef Gtk::Bin_Class CppClassParent; + typedef GtkBinClass BaseClassParent; + + friend class Window; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + static void set_focus_callback(GtkWindow* self, GtkWidget* p0); + static gboolean frame_event_callback(GtkWindow* self, GdkEvent* p0); + + //Callbacks (virtual functions): + static void dispose_vfunc_callback(GObject* self); + }; + + +} // namespace Gtk + + +#include <glibmm/class.h> + +namespace Gtk +{ + +class WindowGroup_Class : public Glib::Class +{ +public: +#ifndef DOXYGEN_SHOULD_SKIP_THIS + typedef WindowGroup CppObjectType; + typedef GtkWindowGroup BaseObjectType; + typedef GtkWindowGroupClass BaseClassType; + typedef Glib::Object_Class CppClassParent; + typedef GObjectClass BaseClassParent; + + friend class WindowGroup; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + + const Glib::Class& init(); + + static void class_init_function(void* g_class, void* class_data); + + static Glib::ObjectBase* wrap_new(GObject*); + +protected: + + //Callbacks (default signal handlers): + //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any. + //You could prevent the original default signal handlers being called by overriding the *_impl method. + + //Callbacks (virtual functions): +}; + + +} // namespace Gtk + +#endif /* _GTKMM_WINDOW_P_H */ + |