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