1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
|
// -*- c++ -*-
// Generated by gtkmmproc -- DO NOT MODIFY!
#ifndef _GTKMM_ACCELGROUP_H
#define _GTKMM_ACCELGROUP_H
#include <glibmm.h>
/* $Id$ */
/* Copyright (C) 1998-2002 The gtkmm Development Team
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include <gdkmm/types.h>
#include <gtkmm/object.h>
#ifndef DOXYGEN_SHOULD_SKIP_THIS
typedef struct _GtkAccelGroup GtkAccelGroup;
typedef struct _GtkAccelGroupClass GtkAccelGroupClass;
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
namespace Gtk
{ class AccelGroup_Class; } // namespace Gtk
namespace Gtk
{
/** A Gtk::AccelGroup represents a group of keyboard accelerators, typically
* attached to a toplevel Gtk::Window (with Gtk::Window::add_accel_group()).
* Usually you won't need to create a Gtk::AccelGroup directly; instead, gtkmm
* automatically sets up the accelerators for your menus. Note that
* accelerators are different from mnemonics. Accelerators are shortcuts for
* activating a menu item; they appear alongside the menu item for which
* they're a shortcut. For example "Ctrl+Q" might appear alongside the "Quit"
* menu item. Mnemonics are shortcuts for GUI elements such as text entries or
* buttons; they appear as underlined characters. See the Gtk::Label
* constructor. Menu items can have both accelerators and mnemonics, of course.
*
* You can use Gtk::Window::get_accel_group() to get an accel group for that window,
* then use it with other widgets too.
*/
class AccelGroup : public Glib::Object
{
#ifndef DOXYGEN_SHOULD_SKIP_THIS
public:
typedef AccelGroup CppObjectType;
typedef AccelGroup_Class CppClassType;
typedef GtkAccelGroup BaseObjectType;
typedef GtkAccelGroupClass BaseClassType;
private: friend class AccelGroup_Class;
static CppClassType accelgroup_class_;
private:
// noncopyable
AccelGroup(const AccelGroup&);
AccelGroup& operator=(const AccelGroup&);
protected:
explicit AccelGroup(const Glib::ConstructParams& construct_params);
explicit AccelGroup(GtkAccelGroup* castitem);
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
public:
virtual ~AccelGroup();
#ifndef DOXYGEN_SHOULD_SKIP_THIS
static GType get_type() G_GNUC_CONST;
static GType get_base_type() G_GNUC_CONST;
#endif
///Provides access to the underlying C GObject.
GtkAccelGroup* gobj() { return reinterpret_cast<GtkAccelGroup*>(gobject_); }
///Provides access to the underlying C GObject.
const GtkAccelGroup* gobj() const { return reinterpret_cast<GtkAccelGroup*>(gobject_); }
///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
GtkAccelGroup* gobj_copy();
private:
protected:
AccelGroup();
public:
/** Creates a new Gtk::AccelGroup object.
* @return A Glib::RefPtr<> to a newly created Gtk::AccelGroup object.
*/
static Glib::RefPtr<AccelGroup> create();
/** Locks the given accelerator group.
*
* Locking an acelerator group prevents the accelerators contained
* within it to be changed during runtime. Refer to
* gtk_accel_map_change_entry() about runtime accelerator changes.
*
* If called more than once, @a accel_group remains locked until
* unlock() has been called an equivalent number
* of times.
*/
void lock();
/** Undoes the last call to lock() on this @a accel_group .
*/
void unlock();
/** Removes an accelerator previously installed through
* connect().
* @param accel_key Key value of the accelerator.
* @param accel_mods Modifier combination of the accelerator.
* @return <tt>true</tt> if there was an accelerator which could be
* removed, <tt>false</tt> otherwise.
*/
bool disconnect_key(guint accel_key, Gdk::ModifierType accel_mods);
/** Determines whether a given keyval and modifier mask constitute
* a valid keyboard accelerator. For example, the 'a' keyval
* plus Gdk::CONTROL_MASK is valid - this is a "Ctrl+a" accelerator.
* But you can't, for instance, use the GDK_Control_L keyval
* as an accelerator.
*/
static bool valid(guint keyval, Gdk::ModifierType modifiers);
/** Parse the accelerator string.
* @param accelerator See the Gtk::AccelKey constructor for the format.
* @param accelerator_key Output argument
* @param accelerator_mods Output argument
*/
static void parse(const Glib::ustring& accelerator, guint& accelerator_key, Gdk::ModifierType& accelerator_mods);
/** Converts an accelerator keyval and modifier mask
* into a string parseable by parse().
* For example, if you pass in 'q' and Gdk::CONTROL_MASK, it returns "<Control>q".
*/
static Glib::ustring name(guint accelerator_key, Gdk::ModifierType accelerator_mods);
/** Converts an accelerator keyval and modifier mask into a string
* which can be used to represent the accelerator to the user.
* @param accelerator_key Accelerator keyval.
* @param accelerator_mods Accelerator modifier mask.
* @return A newly-allocated string representing the accelerator.
*
* Since: 2.6.
*/
static Glib::ustring get_label(guint accelerator_key, Gdk::ModifierType accelerator_mods);
/** Sets the modifiers that will be considered significant for keyboard
* accelerators. The default mod mask is Gdk::CONTROL_MASK |
* Gdk::SHIFT_MASK | Gdk::MOD1_MASK, that is, Control, Shift, and Alt.
* Other modifiers will ignored by default.
* You must include at least the three default modifiers in any
* value you pass to this function.
*
* The default mod mask should be changed on application startup,
* before using any accelerator groups.
*/
static void set_default_mod_mask(Gdk::ModifierType default_mod_mask);
/// See set_default_mod_mask().
static Gdk::ModifierType get_default_mod_mask();
//TODO: This is undocumented in GTK+ at the moment. When would it be used and where does the quark come from? murrayc.
bool activate(GQuark accel_quark, const Glib::RefPtr<Glib::Object>& acceleratable, guint accel_key, Gdk::ModifierType accel_mods);
//Let's not wrap this, because the GtkAccelGroupFindFunc callback uses GClosures, and it's not clear that this is useful.
//AccelKey find(const SlotFind& slot);
//GtkAccelKey* gtk_accel_group_find(GtkAccelGroup* accel_group, GtkAccelGroupFindFunc find_func, gpointer data);
/** Finds the first accelerator in any Gtk::AccelGroup attached
* to @a object that matches @a accel_key and @a accel_mods , and
* activates that accelerator.
* If an accelerator was activated and handled this keypress, <tt>true</tt>
* is returned.
* @param object The G::Object, usually a Gtk::Window, on which
* to activate the accelerator.
* @param accel_key Accelerator keyval from a key event.
* @param accel_mods Keyboard state mask from a key event.
* @return <tt>true</tt> if the accelerator was handled, <tt>false</tt> otherwise.
*/
static bool activate(Gtk::Object& object, guint accel_key, Gdk::ModifierType accel_mods);
//TODO: Discover real parameter names:
Glib::SignalProxy3< bool,const Glib::RefPtr<Glib::Object>&,guint,Gdk::ModifierType > signal_accel_activate();
//TODO: The C type is unpleasant:
Glib::SignalProxy3< void,guint,Gdk::ModifierType,GClosure* > signal_accel_changed();
public:
public:
//C++ methods used to invoke GTK+ virtual functions:
protected:
//GTK+ Virtual Functions (override these to change behaviour):
//Default Signal Handlers::
virtual void on_accel_changed(guint keyval, Gdk::ModifierType modifier, GClosure* accel_closure);
};
} // namespace Gtk
namespace Glib
{
/** @relates Gtk::AccelGroup
* @param object The C instance
* @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
* @result A C++ instance that wraps this C instance.
*/
Glib::RefPtr<Gtk::AccelGroup> wrap(GtkAccelGroup* object, bool take_copy = false);
}
#endif /* _GTKMM_ACCELGROUP_H */
|
