← Back to branch summary

~ubuntu-branches/ubuntu/vivid/ardour/vivid-proposed

« back to all changes in this revision

Viewing changes to libs/gtkmm2/atk/atkmm/stateset.h

  • Committer: Package Import Robot
  • Author(s): Felipe Sateler, Jaromír Mikeš, Felipe Sateler
  • Date: 2014-05-22 14:39:25 UTC
  • mfrom: (29 sid)
  • mto: This revision was merged to the branch mainline in revision 30.
  • Revision ID: package-import@ubuntu.com-20140522143925-vwqfo9287pmkrroe
Tags: 1:2.8.16+git20131003-3
* Team upload

[ Jaromír Mikeš ]
* Add -dbg package

[ Felipe Sateler ]
* Upload to experimental

Show diffs side-by-side

added added

removed removed

Lines of Context:
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