libs/gtkmm2/atk/atkmm/stateset.h

   1 // -*- c++ -*-
   2 // Generated by gtkmmproc -- DO NOT MODIFY!
   3 #ifndef _ATKMM_STATESET_H
   4 #define _ATKMM_STATESET_H
   5
   6
   7 #include <glibmm.h>
   8
   9 /* $Id$ */
  10
  11 /* Copyright (C) 1998-2002 The gtkmm Development Team
  12  *
  13  * This library is free software; you can redistribute it and/or
  14  * modify it under the terms of the GNU Library General Public
  15  * License as published by the Free Software Foundation; either
  16  * version 2 of the License, or (at your option) any later version.
  17  *
  18  * This library is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21  * Library General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU Library General Public
  24  * License along with this library; if not, write to the Free
  25  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  26  */
  27
  28
  29 #ifndef DOXYGEN_SHOULD_SKIP_THIS
  30 typedef struct _AtkStateSet AtkStateSet;
  31 typedef struct _AtkStateSetClass AtkStateSetClass;
  32 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
  33
  34
  35 namespace Atk
  36 { class StateSet_Class; } // namespace Atk
  37 namespace Atk
  38 {
  39
  40
  41 /** @addtogroup atkmmEnums Enums and Flags */
  42
  43 /**
  44  * @ingroup atkmmEnums
  45  */
  46 enum StateType
  47 {
  48   STATE_INVALID,
  49   STATE_ACTIVE,
  50   STATE_ARMED,
  51   STATE_BUSY,
  52   STATE_CHECKED,
  53   STATE_DEFUNCT,
  54   STATE_EDITABLE,
  55   STATE_ENABLED,
  56   STATE_EXPANDABLE,
  57   STATE_EXPANDED,
  58   STATE_FOCUSABLE,
  59   STATE_FOCUSED,
  60   STATE_HORIZONTAL,
  61   STATE_ICONIFIED,
  62   STATE_MODAL,
  63   STATE_MULTI_LINE,
  64   STATE_MULTISELECTABLE,
  65   STATE_OPAQUE,
  66   STATE_PRESSED,
  67   STATE_RESIZABLE,
  68   STATE_SELECTABLE,
  69   STATE_SELECTED,
  70   STATE_SENSITIVE,
  71   STATE_SHOWING,
  72   STATE_SINGLE_LINE,
  73   STATE_STALE,
  74   STATE_TRANSIENT,
  75   STATE_VERTICAL,
  76   STATE_VISIBLE,
  77   STATE_MANAGES_DESCENDANTS,
  78   STATE_INDETERMINATE,
  79   STATE_TRUNCATED,
  80   STATE_REQUIRED,
  81   STATE_LAST_DEFINED
  82 };
  83
  84 } // namespace Atk
  85
  86
  87 #ifndef DOXYGEN_SHOULD_SKIP_THIS
  88 namespace Glib
  89 {
  90
  91 template <>
  92 class Value<Atk::StateType> : public Glib::Value_Enum<Atk::StateType>
  93 {
  94 public:
  95   static GType value_type() G_GNUC_CONST;
  96 };
  97
  98 } // namespace Glib
  99 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
 100
 101
 102 namespace Atk
 103 {
 104
 105
 106 /** An AtkStateSet determines a component's state set.
 107  * It is composed of a set of Atk::States.
 108  */
 109
 110 class StateSet : public Glib::Object
 111 {
 112
 113 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 114
 115 public:
 116   typedef StateSet CppObjectType;
 117   typedef StateSet_Class CppClassType;
 118   typedef AtkStateSet BaseObjectType;
 119   typedef AtkStateSetClass BaseClassType;
 120
 121 private:  friend class StateSet_Class;
 122   static CppClassType stateset_class_;
 123
 124 private:
 125   // noncopyable
 126   StateSet(const StateSet&);
 127   StateSet& operator=(const StateSet&);
 128
 129 protected:
 130   explicit StateSet(const Glib::ConstructParams& construct_params);
 131   explicit StateSet(AtkStateSet* castitem);
 132
 133 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
 134
 135 public:
 136   virtual ~StateSet();
 137
 138 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 139   static GType get_type()      G_GNUC_CONST;
 140   static GType get_base_type() G_GNUC_CONST;
 141 #endif
 142
 143   ///Provides access to the underlying C GObject.
 144   AtkStateSet*       gobj()       { return reinterpret_cast<AtkStateSet*>(gobject_); }
 145
 146   ///Provides access to the underlying C GObject.
 147   const AtkStateSet* gobj() const { return reinterpret_cast<AtkStateSet*>(gobject_); }
 148
 149   ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
 150   AtkStateSet* gobj_copy();
 151
 152 private:
 153
 154
 155 protected:
 156   StateSet();
 157
 158 public:
 159
 160   static Glib::RefPtr<StateSet> create();
 161
 162
 163   /** Checks whether the state set is empty, i.e.\ has no states set.
 164    * @return <tt>true</tt> if @a set  has no states set, otherwise <tt>false</tt>.
 165    */
 166   bool is_empty() const;
 167
 168   //Note that we use Atk::StateType instead of StateType, because there is a Gtk::StateType too, and Doxygen gets confused.
 169
 170   /** Add a new state for the specified type to the current state set if
 171    * it is not already present.
 172    * @param type An Atk::StateType.
 173    * @return <tt>true</tt> if  the state for @a type  is not already in @a set .
 174    */
 175   bool add_state(Atk::StateType type);
 176   void add_states(const Glib::ArrayHandle<Atk::StateType>& types);
 177
 178
 179   /** Removes all states from the state set.
 180    */
 181   void clear_states();
 182
 183   /** Checks whether the state for the specified type is in the specified set.
 184    * @param type An Atk::StateType.
 185    * @return <tt>true</tt> if @a type  is the state type is in @a set .
 186    */
 187   bool contains_state(Atk::StateType type);
 188    bool contains_states(const Glib::ArrayHandle<Atk::StateType>& types) const;
 189
 190
 191   /** Removes the state for the specified type from the state set.
 192    * @param type An Atk::Type.
 193    * @return <tt>true</tt> if @a type  was the state type is in @a set .
 194    */
 195   bool remove_state(Atk::StateType type);
 196
 197   /** Constructs the intersection of the two sets, returning <tt>0</tt> if the
 198    * intersection is empty.
 199    * @param compare_set Another Atk::StateSet.
 200    * @return A new Atk::StateSet which is the intersection of the two sets.
 201    */
 202   Glib::RefPtr<StateSet> and_sets(const Glib::RefPtr<StateSet>& compare_set);
 203
 204   /** Constructs the union of the two sets.
 205    * @param compare_set Another Atk::StateSet.
 206    * @return A new Atk::StateSet which is the union of the two sets,
 207    * returning <tt>0</tt> is empty.
 208    */
 209   Glib::RefPtr<StateSet> or_sets(const Glib::RefPtr<StateSet>& compare_set);
 210
 211   /** Constructs the exclusive-or of the two sets, returning <tt>0</tt> is empty.
 212    * The set returned by this operation contains the states in exactly
 213    * one of the two sets.
 214    * @param compare_set Another Atk::StateSet.
 215    * @return A new Atk::StateSet which contains the states which are
 216    * in exactly one of the two sets.
 217    */
 218   Glib::RefPtr<StateSet> xor_sets(const Glib::RefPtr<StateSet>& compare_set);
 219
 220
 221 public:
 222
 223 public:
 224   //C++ methods used to invoke GTK+ virtual functions:
 225 #ifdef GLIBMM_VFUNCS_ENABLED
 226 #endif //GLIBMM_VFUNCS_ENABLED
 227
 228 protected:
 229   //GTK+ Virtual Functions (override these to change behaviour):
 230 #ifdef GLIBMM_VFUNCS_ENABLED
 231 #endif //GLIBMM_VFUNCS_ENABLED
 232
 233   //Default Signal Handlers::
 234 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 235 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 236
 237
 238 };
 239
 240 } // namespace Atk
 241
 242
 243 namespace Glib
 244 {
 245   /** A Glib::wrap() method for this object.
 246    *
 247    * @param object The C instance.
 248    * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
 249    * @result A C++ instance that wraps this C instance.
 250    *
 251    * @relates Atk::StateSet
 252    */
 253   Glib::RefPtr<Atk::StateSet> wrap(AtkStateSet* object, bool take_copy = false);
 254 }
 255
 256
 257 #endif /* _ATKMM_STATESET_H */
 258