← Back to branch summary

~ubuntu-branches/ubuntu/hardy/texmacs/hardy

« back to all changes in this revision

Viewing changes to src/Window/Event/basic_event.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Ralf Treinen
  • Date: 2004-04-19 20:34:00 UTC
  • Revision ID: james.westby@ubuntu.com-20040419203400-g4e34ih0315wcn8v
Tags: upstream-1.0.3-R2
Import upstream version 1.0.3-R2

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/Window/Event/basic_event.cpp
 
1
 
 
2
/******************************************************************************
 
3
* MODULE     : basic_event.cpp
 
4
* DESCRIPTION: The most common events
 
5
* COPYRIGHT  : (C) 1999  Joris van der Hoeven
 
6
*******************************************************************************
 
7
* This software falls under the GNU general public license and comes WITHOUT
 
8
* ANY WARRANTY WHATSOEVER. See the file $TEXMACS_PATH/LICENSE for more details.
 
9
* If you don't have this file, write to the Free Software Foundation, Inc.,
 
10
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
11
******************************************************************************/
 
12
 
 
13
#include "Event/basic_event.hpp"
 
14
#include "window.hpp"
 
15
 
 
16
/******************************************************************************
 
17
* Attribute events
 
18
******************************************************************************/
 
19
 
 
20
get_size_event_rep::get_size_event_rep (SI& w2, SI& h2, int m):
 
21
  event_rep (GET_SIZE_EVENT), w (w2), h (h2), mode (m) {}
 
22
get_size_event_rep::operator tree () {
 
23
  if (mode==-1) return "get_min_size_event";
 
24
  if (mode== 0) return "get_size_event";
 
25
  else          return "get_max_size_event"; }
 
26
event get_size (SI& w, SI& h, int mode) {
 
27
  return new get_size_event_rep (w, h, mode); }
 
28
 
 
29
get_widget_event_rep::get_widget_event_rep (string ww, widget& w2):
 
30
  event_rep (GET_WIDGET_EVENT), which (ww), w (w2) {}
 
31
get_widget_event_rep::operator tree () {
 
32
  return tree (TUPLE, "get_widget_event", which); }
 
33
event get_widget (string which, widget& w) {
 
34
  return new get_widget_event_rep (which, w); }
 
35
 
 
36
set_widget_event_rep::set_widget_event_rep (string ww, widget w2):
 
37
  event_rep (SET_WIDGET_EVENT), which (ww), w (w2) {}
 
38
set_widget_event_rep::operator tree () {
 
39
  return tree (TUPLE, "set_widget_event", which); }
 
40
event set_widget (string which, widget w) {
 
41
  return new set_widget_event_rep (which, w); }
 
42
 
 
43
set_language_event_rep::set_language_event_rep (string ww, bool& rr):
 
44
  event_rep (SET_LANGUAGE_EVENT), which (ww), resize (rr) {}
 
45
set_language_event_rep::operator tree () {
 
46
  return tree (TUPLE, "set_language_event", which); }
 
47
event set_language (string which, bool& resize) {
 
48
  return new set_language_event_rep (which, resize); }
 
49
 
 
50
/******************************************************************************
 
51
* Structure events
 
52
******************************************************************************/
 
53
 
 
54
attach_window_event_rep::attach_window_event_rep (window win2):
 
55
  event_rep (ATTACH_WINDOW_EVENT), win (win2) {}
 
56
attach_window_event_rep::operator tree () { return "attach_window_event"; }
 
57
event emit_attach_window (window win) {
 
58
  return new attach_window_event_rep (win); }
 
59
 
 
60
position_event_rep::position_event_rep ():
 
61
  event_rep (POSITION_EVENT), flag (true),
 
62
  ox (0), oy (0), w (0), h (0), grav (north_west) {}
 
63
position_event_rep::position_event_rep (SI a, SI b, SI c, SI d, gravity grav2):
 
64
  event_rep (POSITION_EVENT), flag (false),
 
65
  ox (a), oy (b), w (c), h (d), grav (grav2) {}
 
66
position_event_rep::operator tree () {
 
67
  if (flag) return "reposition";
 
68
  return tree (TUPLE, "position_event", as_tree (grav),
 
69
               tree (TUPLE, as_string (ox/PIXEL), as_string (oy/PIXEL)),
 
70
               tree (TUPLE, as_string (w /PIXEL), as_string (h /PIXEL))); }
 
71
event emit_reposition () {
 
72
  return new position_event_rep (); }
 
73
event emit_position (SI ox, SI oy, SI w, SI h, gravity grav) {
 
74
  return new position_event_rep (ox, oy, w, h, grav); }
 
75
 
 
76
move_event_rep::move_event_rep ():
 
77
  event_rep (MOVE_EVENT) {}
 
78
move_event_rep::operator tree () { return "move_event"; }
 
79
event emit_move () {
 
80
  return new move_event_rep (); }
 
81
 
 
82
resize_event_rep::resize_event_rep ():
 
83
  event_rep (RESIZE_EVENT) {}
 
84
resize_event_rep::operator tree () { return "resize_event"; }
 
85
event emit_resize () {
 
86
  return new resize_event_rep (); }
 
87
 
 
88
destroy_event_rep::destroy_event_rep ():
 
89
  event_rep (DESTROY_EVENT) {}
 
90
destroy_event_rep::operator tree () { return "destroy_event"; }
 
91
event emit_destroy () {
 
92
  return new destroy_event_rep (); }
 
93
 
 
94
/******************************************************************************
 
95
* Input events
 
96
******************************************************************************/
 
97
 
 
98
keypress_event_rep::keypress_event_rep (string key2, time_t t2):
 
99
  event_rep (KEYPRESS_EVENT), key (key2), t (t2) {}
 
100
keypress_event_rep::operator tree () {
 
101
  return tree (TUPLE, "keypress_event", key); }
 
102
event emit_keypress (string key, time_t t) {
 
103
  return new keypress_event_rep (key, t); }
 
104
event emit_keypress (keypress_event ev, string key) {
 
105
  return new keypress_event_rep (key, ev->t); }
 
106
 
 
107
keyboard_focus_event_rep::keyboard_focus_event_rep (bool io, time_t t2):
 
108
  event_rep (KEYBOARD_FOCUS_EVENT), flag (io), t (t2) {}
 
109
keyboard_focus_event_rep::operator tree () {
 
110
  return tree (TUPLE, "keyboard_focus_event", (char*) (flag? "in": "out")); }
 
111
event emit_keyboard_focus (bool in_out_flag, time_t t) {
 
112
  return new keyboard_focus_event_rep (in_out_flag, t); }
 
113
 
 
114
mouse_event_rep::mouse_event_rep (string type2, SI x2, SI y2,
 
115
  time_t t2, int status2): event_rep (MOUSE_EVENT),
 
116
    type (type2), x (x2), y (y2), t (t2), status (status2) {}
 
117
mouse_event_rep::operator tree () {
 
118
  return tree (TUPLE, "mouse_event", type,
 
119
               tree (TUPLE, as_string (x/PIXEL), as_string (y/PIXEL))); }
 
120
bool
 
121
mouse_event_rep::pressed (string s) {
 
122
  if (s == "left") return (status&1) != 0;
 
123
  if (s == "middle") return (status&2) != 0;
 
124
  if (s == "right") return (status&4) != 0;
 
125
  if (s == "extra1") return (status&8) != 0;
 
126
  if (s == "extra2") return (status&16) != 0;
 
127
  return false; }
 
128
event emit_mouse (string type, SI x, SI y, time_t t, int status) {
 
129
  return new mouse_event_rep (type, x, y, t, status); }
 
130
event emit_mouse (mouse_event ev, string type, SI x, SI y) {
 
131
  return new mouse_event_rep (type, x, y, ev->t, ev->status); }
 
132
 
 
133
alarm_event_rep::alarm_event_rep (string message2, time_t t2):
 
134
  event_rep (ALARM_EVENT), message (message2), t (t2) {}
 
135
alarm_event_rep::operator tree () {
 
136
  return tree (TUPLE, "alarm_event", message); }
 
137
event emit_alarm (string message, time_t t) {
 
138
  return new alarm_event_rep (message, t); }
 
139
 
 
140
/******************************************************************************
 
141
* Output events
 
142
******************************************************************************/
 
143
 
 
144
clear_event_rep::clear_event_rep (SI x1b, SI y1b, SI x2b, SI y2b):
 
145
  event_rep (CLEAR_EVENT), x1 (x1b), y1 (y1b), x2 (x2b), y2 (y2b) {}
 
146
clear_event_rep::operator tree () {
 
147
  return tree (TUPLE, "clear event",
 
148
               tree (TUPLE, as_string (x1/PIXEL), as_string (y1/PIXEL)),
 
149
               tree (TUPLE, as_string (x2/PIXEL), as_string (y2/PIXEL))); }
 
150
event emit_clear (SI x1, SI y1, SI x2, SI y2) {
 
151
  return new clear_event_rep (x1, y1, x2, y2); }
 
152
 
 
153
repaint_event_rep::repaint_event_rep (SI x1b, SI y1b, SI x2b, SI y2b, bool& b):
 
154
  event_rep (REPAINT_EVENT), x1 (x1b), y1 (y1b), x2 (x2b), y2 (y2b), stop(b) {}
 
155
repaint_event_rep::operator tree () {
 
156
  return tree (TUPLE, "repaint event",
 
157
               tree (TUPLE, as_string (x1/PIXEL), as_string (y1/PIXEL)),
 
158
               tree (TUPLE, as_string (x2/PIXEL), as_string (y2/PIXEL))); }
 
159
event emit_repaint (SI x1, SI y1, SI x2, SI y2, bool& stop) {
 
160
  return new repaint_event_rep (x1, y1, x2, y2, stop); }
 
161
 
 
162
/******************************************************************************
 
163
* Request some action
 
164
******************************************************************************/
 
165
 
 
166
update_event_rep::update_event_rep ():
 
167
  event_rep (UPDATE_EVENT) {}
 
168
update_event_rep::operator tree () { return "update_event"; }
 
169
event emit_update () {
 
170
  return new update_event_rep (); }
 
171
 
 
172
invalidate_event_rep::invalidate_event_rep ():
 
173
  event_rep (INVALIDATE_EVENT), all_flag (true),
 
174
  x1 (0), y1 (0), x2 (0), y2 (0) {}
 
175
invalidate_event_rep::invalidate_event_rep (SI x1b, SI y1b, SI x2b, SI y2b):
 
176
  event_rep (INVALIDATE_EVENT), all_flag (false),
 
177
  x1 (x1b), y1 (y1b), x2 (x2b), y2 (y2b) {}
 
178
invalidate_event_rep::operator tree () {
 
179
  if (all_flag) return "invalidate_event";
 
180
  else return tree (TUPLE, "invalidate_event",
 
181
                    tree (TUPLE, as_string (x1/PIXEL),as_string (y1/PIXEL)),
 
182
                    tree (TUPLE, as_string (x2/PIXEL),as_string (y2/PIXEL))); }
 
183
event emit_invalidate_all () {
 
184
  return new invalidate_event_rep (); }
 
185
event emit_invalidate (SI x1, SI y1, SI x2, SI y2) {
 
186
  return new invalidate_event_rep (x1, y1, x2, y2); }
 
187
 
 
188
keyboard_grab_event_rep::keyboard_grab_event_rep (bool io, time_t t2):
 
189
  event_rep (KEYBOARD_GRAB_EVENT), flag (io), t (t2) {}
 
190
keyboard_grab_event_rep::operator tree () {
 
191
  return tree (TUPLE, "keyboard_grab_event", (char*) (flag? "in": "out")); }
 
192
event emit_keyboard_grab (bool in_out_flag, time_t t) {
 
193
  return new keyboard_grab_event_rep (in_out_flag, t); }
 
194
 
 
195
mouse_grab_event_rep::mouse_grab_event_rep (bool io, time_t t2):
 
196
  event_rep (MOUSE_GRAB_EVENT), flag (io), t (t2) {}
 
197
mouse_grab_event_rep::operator tree () {
 
198
  return tree (TUPLE, "mouse_grab_event", (char*) (flag? "in": "out")); }
 
199
event emit_mouse_grab (bool in_out_flag, time_t t) {
 
200
  return new mouse_grab_event_rep (in_out_flag, t); }
 
201
 
 
202
request_alarm_event_rep::request_alarm_event_rep (event ev2, time_t delay2):
 
203
  event_rep (REQUEST_ALARM_EVENT), ev (ev2), delay (delay2) {}
 
204
request_alarm_event_rep::operator tree () {
 
205
  return tree (TUPLE, "request_alarm_event",
 
206
               (tree) ev, as_string ((int) delay)); }
 
207
event emit_request_alarm (event ev, time_t delay) {
 
208
  return new request_alarm_event_rep (ev, delay); }
 
209
 
 
210
/******************************************************************************
 
211
* Miscellaneous events
 
212
******************************************************************************/
 
213
 
 
214
find_child_event_rep::find_child_event_rep (SI x2, SI y2, int& which2):
 
215
  event_rep (FIND_CHILD_EVENT), x (x2), y (y2), which (which2) {}
 
216
find_child_event_rep::operator tree () {
 
217
  return tree (TUPLE, "find_child_event",
 
218
               tree (TUPLE, as_string (x/PIXEL), as_string (y/PIXEL))); }
 
219
event emit_find_child (SI x, SI y, int& which) {
 
220
  return new find_child_event_rep (x, y, which); }
 
221
 
 
222
/******************************************************************************
 
223
* Output routines for the gravity class
 
224
******************************************************************************/
 
225
 
 
226
ostream&
 
227
operator << (ostream& out, gravity grav) {
 
228
  return out << as_tree (grav);
 
229
}
 
230
 
 
231
tree
 
232
as_tree (gravity grav) {
 
233
  switch (grav) {
 
234
  case north_west: return "north west";
 
235
  case north     : return "north";
 
236
  case north_east: return "north east";
 
237
  case west      : return "west";
 
238
  case center    : return "center";
 
239
  case east      : return "east";
 
240
  case south_west: return "south west";
 
241
  case south     : return "south";
 
242
  case south_east: return "south east";
 
243
  }
 
244
  fatal_error ("unknown gravity", "as_tree", "basic_event.cpp");
 
245
  return ""; // Because of bug in certain versions of g++
 
246
}