← Back to branch summary

~kklimonda/ubuntu/lucid/rxvt-unicode/lp-514821

« back to all changes in this revision

Viewing changes to src/iom.h

  • Committer: Bazaar Package Importer
  • Author(s): Decklin Foster
  • Date: 2006-09-01 14:44:58 UTC
  • mfrom: (1.1.8 upstream) (3.1.1 etch)
  • Revision ID: james.westby@ubuntu.com-20060901144458-98hrz8zg01w8a3vy
Tags: 7.9-2
http://bugs.debian.org/385481
* Edit the comments in the app-defaults file, and disable all settings by
  default. If font autoselection fails, I would prefer to open a new bug
  specifically for that. (Closes: #385481)
* Reorganize and edit README.Debian, pushing as much as possible into FAQ
  format (with resource setting issues first).

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/iom.h
125
125
#if IOM_IO
126
126
enum { EVENT_UNDEF = -1, EVENT_NONE = 0, EVENT_READ = 1, EVENT_WRITE = 2 };
127
127
 
128
 
struct io_watcher : watcher, callback2<void, io_watcher &, short> {
 
128
struct io_watcher : watcher, callback<void (io_watcher &, short)> {
129
129
  int fd;
130
130
  short events;
131
131
 
136
136
  void start (int fd_, short events_) { set (fd_, events_); io_manager::reg (*this); }
137
137
  void stop () { io_manager::unreg (*this); }
138
138
 
139
 
  template<class O1, class O2>
140
 
  io_watcher (O1 *object, void (O2::*method) (io_watcher &, short))
141
 
  : callback2<void, io_watcher &, short> (object, method)
 
139
  template<class O, class M>
 
140
  io_watcher (O object, M method)
 
141
  : callback<void (io_watcher &, short)> (object, method)
142
142
  { }
143
143
  ~io_watcher () { stop (); }
144
144
};
145
145
#endif
146
146
 
147
147
#if IOM_TIME
148
 
struct time_watcher : watcher, callback1<void, time_watcher &> {
 
148
struct time_watcher : watcher, callback<void (time_watcher &)> {
149
149
  tstamp at;
150
150
 
151
151
  void trigger ();
156
156
  void start (tstamp when) { set (when); io_manager::reg (*this); }
157
157
  void stop () { io_manager::unreg (*this); }
158
158
 
159
 
  template<class O1, class O2>
160
 
  time_watcher (O1 *object, void (O2::*method) (time_watcher &))
161
 
  : callback1<void, time_watcher &> (object, method), at (0)
 
159
  template<class O, class M>
 
160
  time_watcher (O object, M method)
 
161
  : callback<void (time_watcher &)> (object, method), at (0)
162
162
  { }
163
163
  ~time_watcher () { stop (); }
164
164
};
166
166
 
167
167
#if IOM_CHECK
168
168
// run before checking for new events
169
 
struct check_watcher : watcher, callback1<void, check_watcher &> {
 
169
struct check_watcher : watcher, callback<void (check_watcher &)> {
170
170
  void start () { io_manager::reg (*this); }
171
171
  void stop () { io_manager::unreg (*this); }
172
172
 
173
 
  template<class O1, class O2>
174
 
  check_watcher (O1 *object, void (O2::*method) (check_watcher &))
175
 
  : callback1<void, check_watcher &> (object, method)
 
173
  template<class O, class M>
 
174
  check_watcher (O object, M method)
 
175
  : callback<void (check_watcher &)> (object, method)
176
176
  { }
177
177
  ~check_watcher () { stop (); }
178
178
};
180
180
 
181
181
#if IOM_IDLE
182
182
// run after checking for any i/o, but before waiting
183
 
struct idle_watcher : watcher, callback1<void, idle_watcher &> {
 
183
struct idle_watcher : watcher, callback<void (idle_watcher &)> {
184
184
  void start () { io_manager::reg (*this); }
185
185
  void stop () { io_manager::unreg (*this); }
186
186
 
187
 
  template<class O1, class O2>
188
 
  idle_watcher (O1 *object, void (O2::*method) (idle_watcher &))
189
 
    : callback1<void, idle_watcher &> (object, method)
 
187
  template<class O, class M>
 
188
  idle_watcher (O object, M method)
 
189
    : callback<void (idle_watcher &)> (object, method)
190
190
    { }
191
191
  ~idle_watcher () { stop (); }
192
192
};
193
193
#endif
194
194
 
195
195
#if IOM_SIG
196
 
struct sig_watcher : watcher, callback1<void, sig_watcher &> {
 
196
struct sig_watcher : watcher, callback<void (sig_watcher &)> {
197
197
  int signum;
198
198
 
199
199
  void start (int signum);
200
200
  void stop () { io_manager::unreg (*this); }
201
201
 
202
 
  template<class O1, class O2>
203
 
  sig_watcher (O1 *object, void (O2::*method) (sig_watcher &))
204
 
  : callback1<void, sig_watcher &> (object, method), signum (0)
 
202
  template<class O, class M>
 
203
  sig_watcher (O object, M method)
 
204
  : callback<void(sig_watcher &)> (object, method), signum (0)
205
205
  { }
206
206
  ~sig_watcher () { stop (); }
207
207
};
208
208
#endif
209
209
 
210
210
#if IOM_CHILD
211
 
struct child_watcher : watcher, callback2<void, child_watcher &, int> {
 
211
struct child_watcher : watcher, callback<void (child_watcher &, int)> {
212
212
  int /*pid_t*/ pid;
213
213
 
214
214
  void start (int pid) { this->pid = pid; io_manager::reg (*this); }
215
215
  void stop () { io_manager::unreg (*this); }
216
216
 
217
 
  template<class O1, class O2>
218
 
  child_watcher (O1 *object, void (O2::*method) (child_watcher &, int status))
219
 
  : callback2<void, child_watcher &, int> (object, method), pid (0)
 
217
  template<class O, class M>
 
218
  child_watcher (O object, M method)
 
219
  : callback<void (child_watcher &, int)> (object, method), pid (0)
220
220
  { }
221
221
  ~child_watcher () { stop (); }
222
222
};