15 #include "buttonThrower.h" 17 #include "buttonEvent.h" 18 #include "buttonEventList.h" 19 #include "dataNodeTransmit.h" 20 #include "throw_event.h" 34 ButtonThrower(
const string &name) :
37 _button_events_input = define_input(
"button_events", ButtonEventList::get_class_type());
38 _button_events_output = define_output(
"button_events", ButtonEventList::get_class_type());
42 _specific_flag =
true;
44 _throw_buttons_active =
false;
66 _parameters.push_back(obj);
79 return _parameters.size();
91 nassertr(n >= 0 && n < (
int)_parameters.size(),
EventParameter(0));
92 return _parameters[n];
121 ThrowButtonDef::iterator di;
122 for (di = def.begin(); di != def.end(); ++di) {
144 ThrowButtons::iterator ti = _throw_buttons.find(button);
145 if (ti == _throw_buttons.end()) {
154 ThrowButtonDef::iterator di;
155 for (di = def.begin(); di != def.end(); ++di) {
159 _throw_buttons.erase(ti);
179 ThrowButtons::const_iterator ti = _throw_buttons.find(button);
180 if (ti == _throw_buttons.end()) {
189 ThrowButtonDef::const_iterator di;
190 for (di = def.begin(); di != def.end(); ++di) {
214 ThrowButtons::const_iterator ti = _throw_buttons.find(button);
215 if (ti == _throw_buttons.end()) {
232 _throw_buttons.clear();
242 write(ostream &out,
int indent_level)
const {
243 DataNode::write(out, indent_level);
244 if (_throw_buttons_active) {
245 indent(out, indent_level)
246 <<
"Processing keys:\n";
248 ThrowButtons::const_iterator ti;
249 for (ti = _throw_buttons.begin(); ti != _throw_buttons.end(); ++ti) {
252 ThrowButtonDef::const_iterator di;
253 for (di = def.begin(); di != def.end(); ++di) {
254 indent(out, indent_level + 2)
255 << (*di).get_prefix() << button.
get_name() <<
"\n";
268 do_specific_event(
const string &event_name,
double time) {
269 if (_specific_flag) {
270 PT(
Event)
event =
new Event(_prefix + event_name);
273 event->add_parameter(time);
276 ParameterList::const_iterator pi;
277 for (pi = _parameters.begin(); pi != _parameters.end(); ++pi) {
278 event->add_parameter(*pi);
292 do_general_event(
const ButtonEvent &button_event,
const string &button_name) {
294 switch (button_event._type) {
295 case ButtonEvent::T_down:
296 event_name = _button_down_event;
299 case ButtonEvent::T_resume_down:
302 case ButtonEvent::T_up:
303 event_name = _button_up_event;
306 case ButtonEvent::T_repeat:
307 event_name = _button_repeat_event;
310 case ButtonEvent::T_keystroke:
311 event_name = _keystroke_event;
314 case ButtonEvent::T_candidate:
315 event_name = _candidate_event;
318 case ButtonEvent::T_move:
319 event_name = _move_event;
322 case ButtonEvent::T_raw_down:
323 event_name = _raw_button_down_event;
326 case ButtonEvent::T_raw_up:
327 event_name = _raw_button_up_event;
330 if (event_name.empty()) {
338 event->add_parameter(button_event._time);
342 switch (button_event._type) {
343 case ButtonEvent::T_down:
344 case ButtonEvent::T_resume_down:
345 case ButtonEvent::T_up:
346 case ButtonEvent::T_repeat:
347 case ButtonEvent::T_raw_down:
348 case ButtonEvent::T_raw_up:
349 event->add_parameter(button_name);
352 case ButtonEvent::T_keystroke:
353 event->add_parameter(wstring(1, button_event._keycode));
356 case ButtonEvent::T_candidate:
357 event->add_parameter(button_event._candidate_string);
360 case ButtonEvent::T_move:
361 event_name = _move_event;
365 ParameterList::const_iterator pi;
366 for (pi = _parameters.begin(); pi != _parameters.end(); ++pi) {
367 event->add_parameter(*pi);
391 _button_events->clear();
393 if (input.
has_data(_button_events_input)) {
395 DCAST_INTO_V(button_events, input.
get_data(_button_events_input).
get_ptr());
398 for (
int i = 0; i < num_events; i++) {
400 string event_name = be._button.
get_name();
402 if (be._type == ButtonEvent::T_down || be._type == ButtonEvent::T_repeat) {
412 if (be._type == ButtonEvent::T_repeat) {
413 do_specific_event(event_name +
"-repeat", be._time);
415 do_specific_event(event_name, be._time);
417 do_general_event(be, event_name);
422 _button_events->add_event(be);
425 }
else if (be._type == ButtonEvent::T_resume_down) {
432 }
else if (be._type == ButtonEvent::T_up) {
440 do_specific_event(event_name +
"-up", be._time);
441 do_general_event(be, event_name);
443 if (_throw_buttons_active) {
448 _button_events->add_event(be);
451 }
else if (be._type == ButtonEvent::T_raw_down) {
455 do_specific_event(
"raw-" + event_name, be._time);
456 do_general_event(be, event_name);
461 _button_events->add_event(be);
464 }
else if (be._type == ButtonEvent::T_raw_up) {
468 do_specific_event(
"raw-" + event_name +
"-up", be._time);
469 do_general_event(be, event_name);
471 if (_throw_buttons_active) {
476 _button_events->add_event(be);
482 _button_events->add_event(be);
483 do_general_event(be,
"");
The fundamental type of node for the data graph.
An optional parameter associated with an event.
bool has_data(int index) const
Returns true if the indicated parameter has been stored, false otherwise.
This is our own Panda specialization on the default STL vector.
void set_data(int index, const EventParameter &data)
Sets the data for the indicated parameter.
TypedWritableReferenceCount * get_ptr() const
Retrieves a pointer to the actual value stored in the parameter.
const EventParameter & get_data(int index) const
Extracts the data for the indicated index, if it has been stored, or the empty parameter if it has no...
A named event, possibly with parameters.
TypeHandle is the identifier used to differentiate C++ class types.
Encapsulates the data generated from (or sent into) any particular DataNode.
This object supervises the traversal of the data graph and the moving of data from one DataNode to it...