libs/gtkmm2/gtk/gtkmm/separator.h

   1 // -*- c++ -*-
   2 // Generated by gtkmmproc -- DO NOT MODIFY!
   3 #ifndef _GTKMM_SEPARATOR_H
   4 #define _GTKMM_SEPARATOR_H
   5
   6
   7 #include <glibmm.h>
   8
   9 /* $Id$ */
  10
  11 /* separator.h
  12  *
  13  * Copyright (C) 1998-2002 The gtkmm Development Team
  14  *
  15  * This library is free software; you can redistribute it and/or
  16  * modify it under the terms of the GNU Library General Public
  17  * License as published by the Free Software Foundation; either
  18  * version 2 of the License, or (at your option) any later version.
  19  *
  20  * This library is distributed in the hope that it will be useful,
  21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  23  * Library General Public License for more details.
  24  *
  25  * You should have received a copy of the GNU Library General Public
  26  * License along with this library; if not, write to the Free
  27  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  28  */
  29
  30 #include <gtkmm/widget.h>
  31
  32
  33 #ifndef DOXYGEN_SHOULD_SKIP_THIS
  34 typedef struct _GtkSeparator GtkSeparator;
  35 typedef struct _GtkSeparatorClass GtkSeparatorClass;
  36 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
  37
  38
  39 namespace Gtk
  40 { class Separator_Class; } // namespace Gtk
  41 #ifndef DOXYGEN_SHOULD_SKIP_THIS
  42 typedef struct _GtkVSeparator GtkVSeparator;
  43 typedef struct _GtkVSeparatorClass GtkVSeparatorClass;
  44 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
  45
  46
  47 namespace Gtk
  48 { class VSeparator_Class; } // namespace Gtk
  49 #ifndef DOXYGEN_SHOULD_SKIP_THIS
  50 typedef struct _GtkHSeparator GtkHSeparator;
  51 typedef struct _GtkHSeparatorClass GtkHSeparatorClass;
  52 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
  53
  54
  55 namespace Gtk
  56 { class HSeparator_Class; } // namespace Gtk
  57 namespace Gtk
  58 {
  59
  60 /** Separator base class.
  61  * Abstract base class for Gtk::VSeperator and Gtk::HSeperator.
  62  */
  63
  64 class Separator : public Widget
  65 {
  66   public:
  67 #ifndef DOXYGEN_SHOULD_SKIP_THIS
  68   typedef Separator CppObjectType;
  69   typedef Separator_Class CppClassType;
  70   typedef GtkSeparator BaseObjectType;
  71   typedef GtkSeparatorClass BaseClassType;
  72 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
  73
  74   virtual ~Separator();
  75
  76 #ifndef DOXYGEN_SHOULD_SKIP_THIS
  77
  78 private:
  79   friend class Separator_Class;
  80   static CppClassType separator_class_;
  81
  82   // noncopyable
  83   Separator(const Separator&);
  84   Separator& operator=(const Separator&);
  85
  86 protected:
  87   explicit Separator(const Glib::ConstructParams& construct_params);
  88   explicit Separator(GtkSeparator* castitem);
  89
  90 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
  91
  92 public:
  93 #ifndef DOXYGEN_SHOULD_SKIP_THIS
  94   static GType get_type()      G_GNUC_CONST;
  95   static GType get_base_type() G_GNUC_CONST;
  96 #endif
  97
  98   ///Provides access to the underlying C GtkObject.
  99   GtkSeparator*       gobj()       { return reinterpret_cast<GtkSeparator*>(gobject_); }
 100
 101   ///Provides access to the underlying C GtkObject.
 102   const GtkSeparator* gobj() const { return reinterpret_cast<GtkSeparator*>(gobject_); }
 103
 104
 105 public:
 106   //C++ methods used to invoke GTK+ virtual functions:
 107 #ifdef GLIBMM_VFUNCS_ENABLED
 108 #endif //GLIBMM_VFUNCS_ENABLED
 109
 110 protected:
 111   //GTK+ Virtual Functions (override these to change behaviour):
 112 #ifdef GLIBMM_VFUNCS_ENABLED
 113 #endif //GLIBMM_VFUNCS_ENABLED
 114
 115   //Default Signal Handlers::
 116 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 117 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 118
 119
 120 private:
 121
 122 public:
 123
 124
 125 protected:
 126   Separator();
 127
 128
 129 };
 130
 131 /** Vertical line widget.
 132  * Filler widget used to separate widgets with a visible line.
 133  * This widget has no window and receives no configuration events.
 134  * It should be considered a leaf widget.
 135  * @ingroup Widgets
 136  */
 137
 138 class VSeparator : public Separator
 139 {
 140   public:
 141 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 142   typedef VSeparator CppObjectType;
 143   typedef VSeparator_Class CppClassType;
 144   typedef GtkVSeparator BaseObjectType;
 145   typedef GtkVSeparatorClass BaseClassType;
 146 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
 147
 148   virtual ~VSeparator();
 149
 150 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 151
 152 private:
 153   friend class VSeparator_Class;
 154   static CppClassType vseparator_class_;
 155
 156   // noncopyable
 157   VSeparator(const VSeparator&);
 158   VSeparator& operator=(const VSeparator&);
 159
 160 protected:
 161   explicit VSeparator(const Glib::ConstructParams& construct_params);
 162   explicit VSeparator(GtkVSeparator* castitem);
 163
 164 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
 165
 166 public:
 167 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 168   static GType get_type()      G_GNUC_CONST;
 169   static GType get_base_type() G_GNUC_CONST;
 170 #endif
 171
 172   ///Provides access to the underlying C GtkObject.
 173   GtkVSeparator*       gobj()       { return reinterpret_cast<GtkVSeparator*>(gobject_); }
 174
 175   ///Provides access to the underlying C GtkObject.
 176   const GtkVSeparator* gobj() const { return reinterpret_cast<GtkVSeparator*>(gobject_); }
 177
 178
 179 public:
 180   //C++ methods used to invoke GTK+ virtual functions:
 181 #ifdef GLIBMM_VFUNCS_ENABLED
 182 #endif //GLIBMM_VFUNCS_ENABLED
 183
 184 protected:
 185   //GTK+ Virtual Functions (override these to change behaviour):
 186 #ifdef GLIBMM_VFUNCS_ENABLED
 187 #endif //GLIBMM_VFUNCS_ENABLED
 188
 189   //Default Signal Handlers::
 190 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 191 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 192
 193
 194 private:
 195
 196 public:
 197   VSeparator();
 198
 199
 200 };
 201
 202
 203 /** Horizontal line widget.
 204  * Filler widget used to separate widgets with a visible line.
 205  * This widget has no window and receives no configuration events.
 206  * It should be considered a leaf widget.
 207  * @ingroup Widgets
 208  */
 209
 210 class HSeparator : public Separator
 211 {
 212   public:
 213 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 214   typedef HSeparator CppObjectType;
 215   typedef HSeparator_Class CppClassType;
 216   typedef GtkHSeparator BaseObjectType;
 217   typedef GtkHSeparatorClass BaseClassType;
 218 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
 219
 220   virtual ~HSeparator();
 221
 222 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 223
 224 private:
 225   friend class HSeparator_Class;
 226   static CppClassType hseparator_class_;
 227
 228   // noncopyable
 229   HSeparator(const HSeparator&);
 230   HSeparator& operator=(const HSeparator&);
 231
 232 protected:
 233   explicit HSeparator(const Glib::ConstructParams& construct_params);
 234   explicit HSeparator(GtkHSeparator* castitem);
 235
 236 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
 237
 238 public:
 239 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 240   static GType get_type()      G_GNUC_CONST;
 241   static GType get_base_type() G_GNUC_CONST;
 242 #endif
 243
 244   ///Provides access to the underlying C GtkObject.
 245   GtkHSeparator*       gobj()       { return reinterpret_cast<GtkHSeparator*>(gobject_); }
 246
 247   ///Provides access to the underlying C GtkObject.
 248   const GtkHSeparator* gobj() const { return reinterpret_cast<GtkHSeparator*>(gobject_); }
 249
 250
 251 public:
 252   //C++ methods used to invoke GTK+ virtual functions:
 253 #ifdef GLIBMM_VFUNCS_ENABLED
 254 #endif //GLIBMM_VFUNCS_ENABLED
 255
 256 protected:
 257   //GTK+ Virtual Functions (override these to change behaviour):
 258 #ifdef GLIBMM_VFUNCS_ENABLED
 259 #endif //GLIBMM_VFUNCS_ENABLED
 260
 261   //Default Signal Handlers::
 262 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 263 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 264
 265
 266 private:
 267
 268 public:
 269   HSeparator();
 270
 271
 272 };
 273
 274 } /* namespace Gtk */
 275
 276
 277 namespace Glib
 278 {
 279   /** A Glib::wrap() method for this object.
 280    *
 281    * @param object The C instance.
 282    * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
 283    * @result A C++ instance that wraps this C instance.
 284    *
 285    * @relates Gtk::Separator
 286    */
 287   Gtk::Separator* wrap(GtkSeparator* object, bool take_copy = false);
 288 } //namespace Glib
 289
 290
 291 namespace Glib
 292 {
 293   /** A Glib::wrap() method for this object.
 294    *
 295    * @param object The C instance.
 296    * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
 297    * @result A C++ instance that wraps this C instance.
 298    *
 299    * @relates Gtk::VSeparator
 300    */
 301   Gtk::VSeparator* wrap(GtkVSeparator* object, bool take_copy = false);
 302 } //namespace Glib
 303
 304
 305 namespace Glib
 306 {
 307   /** A Glib::wrap() method for this object.
 308    *
 309    * @param object The C instance.
 310    * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
 311    * @result A C++ instance that wraps this C instance.
 312    *
 313    * @relates Gtk::HSeparator
 314    */
 315   Gtk::HSeparator* wrap(GtkHSeparator* object, bool take_copy = false);
 316 } //namespace Glib
 317
 318
 319 #endif /* _GTKMM_SEPARATOR_H */
 320