Mercurial > hg > xemacs-beta

comparison src/events.c @ 282:c42ec1d1cded r21-0b39

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Import from CVS: tag r21-0b39
author cvs
date Mon, 13 Aug 2007 10:33:18 +0200
parents 7df0dd720c89
children 558f606b08ae
comparison
equal deleted inserted replaced
281:090b52736db2 282:c42ec1d1cded
64 Lisp_Object Qprocess_event_p; 64 Lisp_Object Qprocess_event_p;
65 65
66 Lisp_Object Qkey_press, Qbutton_press, Qbutton_release, Qmisc_user; 66 Lisp_Object Qkey_press, Qbutton_press, Qbutton_release, Qmisc_user;
67 Lisp_Object Qascii_character; 67 Lisp_Object Qascii_character;
68 68
69 #if defined(HAVE_OFFIX_DND) || defined(HAVE_MS_WINDOWS)
70 Lisp_Object Qdnd_drop_event_p;
71 Lisp_Object Qdnd_drop;
72 #endif
73
74 EXFUN (Fevent_x_pixel, 1); 69 EXFUN (Fevent_x_pixel, 1);
75 EXFUN (Fevent_y_pixel, 1); 70 EXFUN (Fevent_y_pixel, 1);
76 71
77 /* #### Ad-hoc hack. Should be part of define_lrecord_implementation */ 72 /* #### Ad-hoc hack. Should be part of define_lrecord_implementation */
78 void 73 void
136 case button_release_event: 131 case button_release_event:
137 case pointer_motion_event: 132 case pointer_motion_event:
138 case magic_event: 133 case magic_event:
139 case empty_event: 134 case empty_event:
140 case dead_event: 135 case dead_event:
141 #if defined(HAVE_OFFIX_DND) || defined(HAVE_MS_WINDOWS)
142 case dnd_drop_event:
143 #endif
144 break; 136 break;
145 default: 137 default:
146 abort (); 138 abort ();
147 } 139 }
148 ((markobj) (event->channel)); 140 ((markobj) (event->channel));
201 break; 193 break;
202 case empty_event: 194 case empty_event:
203 write_c_string ("#<empty-event", printcharfun); 195 write_c_string ("#<empty-event", printcharfun);
204 break; 196 break;
205 case misc_user_event: 197 case misc_user_event:
198 write_c_string ("#<misc-user-event (", printcharfun);
199 print_internal (XEVENT (obj)->event.misc.function, printcharfun, 1);
200 write_c_string (" ", printcharfun);
201 print_internal (XEVENT (obj)->event.misc.object, printcharfun, 1);
202 write_c_string (")", printcharfun);
203 break;
206 case eval_event: 204 case eval_event:
207 write_c_string ("#<", printcharfun); 205 write_c_string ("#<eval-event (", printcharfun);
208 if (XEVENT (obj)->event_type == misc_user_event)
209 write_c_string ("misc-user", printcharfun);
210 else
211 write_c_string ("eval", printcharfun);
212 write_c_string ("-event (", printcharfun);
213 print_internal (XEVENT (obj)->event.eval.function, printcharfun, 1); 206 print_internal (XEVENT (obj)->event.eval.function, printcharfun, 1);
214 write_c_string (" ", printcharfun); 207 write_c_string (" ", printcharfun);
215 print_internal (XEVENT (obj)->event.eval.object, printcharfun, 1); 208 print_internal (XEVENT (obj)->event.eval.object, printcharfun, 1);
216 write_c_string (")", printcharfun); 209 write_c_string (")", printcharfun);
217 break; 210 break;
218 case dead_event: 211 case dead_event:
219 write_c_string ("#<DEALLOCATED-EVENT", printcharfun); 212 write_c_string ("#<DEALLOCATED-EVENT", printcharfun);
220 break; 213 break;
221 #if defined(HAVE_OFFIX_DND) || defined(HAVE_MS_WINDOWS)
222 case dnd_drop_event:
223 print_event_1 ("#<dnd-drop-event ", obj, printcharfun);
224 break;
225 #endif
226 default: 214 default:
227 write_c_string ("#<UNKNOWN-EVENT-TYPE", printcharfun); 215 write_c_string ("#<UNKNOWN-EVENT-TYPE", printcharfun);
228 break; 216 break;
229 } 217 }
230 write_c_string (">", printcharfun); 218 write_c_string (">", printcharfun);
262 case pointer_motion_event: 250 case pointer_motion_event:
263 return (e1->event.motion.x == e2->event.motion.x && 251 return (e1->event.motion.x == e2->event.motion.x &&
264 e1->event.motion.y == e2->event.motion.y); 252 e1->event.motion.y == e2->event.motion.y);
265 253
266 case misc_user_event: 254 case misc_user_event:
255 return (internal_equal (e1->event.eval.function,
256 e2->event.eval.function, 0) &&
257 internal_equal (e1->event.eval.object,
258 e2->event.eval.object, 0) &&
259 /* is this really needed for equality
260 or is x and y also important? */
261 e1->event.misc.button == e2->event.misc.button &&
262 e1->event.misc.modifiers == e2->event.misc.modifiers);
263
267 case eval_event: 264 case eval_event:
268 return (internal_equal (e1->event.eval.function, 265 return (internal_equal (e1->event.eval.function,
269 e2->event.eval.function, 0) && 266 e2->event.eval.function, 0) &&
270 internal_equal (e1->event.eval.object, 267 internal_equal (e1->event.eval.object,
271 e2->event.eval.object, 0)); 268 e2->event.eval.object, 0));
273 case magic_eval_event: 270 case magic_eval_event:
274 return (e1->event.magic_eval.internal_function == 271 return (e1->event.magic_eval.internal_function ==
275 e2->event.magic_eval.internal_function && 272 e2->event.magic_eval.internal_function &&
276 internal_equal (e1->event.magic_eval.object, 273 internal_equal (e1->event.magic_eval.object,
277 e2->event.magic_eval.object, 0)); 274 e2->event.magic_eval.object, 0));
278
279 #if defined(HAVE_OFFIX_DND) || defined(HAVE_MS_WINDOWS)
280 case dnd_drop_event:
281 return (e1->event.dnd_drop.button == e2->event.dnd_drop.button &&
282 e1->event.dnd_drop.modifiers == e2->event.dnd_drop.modifiers &&
283 EQ (e1->event.dnd_drop.data, e2->event.dnd_drop.data));
284 #endif
285 275
286 case magic_event: 276 case magic_event:
287 { 277 {
288 struct console *con = XCONSOLE (CDFW_CONSOLE (e1->channel)); 278 struct console *con = XCONSOLE (CDFW_CONSOLE (e1->channel));
289 279
342 332
343 case pointer_motion_event: 333 case pointer_motion_event:
344 return HASH3 (hash, e->event.motion.x, e->event.motion.y); 334 return HASH3 (hash, e->event.motion.x, e->event.motion.y);
345 335
346 case misc_user_event: 336 case misc_user_event:
337 return HASH5 (hash, internal_hash (e->event.misc.function, depth + 1),
338 internal_hash (e->event.misc.object, depth + 1),
339 e->event.misc.button, e->event.misc.modifiers);
340
347 case eval_event: 341 case eval_event:
348 return HASH3 (hash, internal_hash (e->event.eval.function, depth + 1), 342 return HASH3 (hash, internal_hash (e->event.eval.function, depth + 1),
349 internal_hash (e->event.eval.object, depth + 1)); 343 internal_hash (e->event.eval.object, depth + 1));
350 344
351 case magic_eval_event: 345 case magic_eval_event:
352 return HASH3 (hash, 346 return HASH3 (hash,
353 (unsigned long) e->event.magic_eval.internal_function, 347 (unsigned long) e->event.magic_eval.internal_function,
354 internal_hash (e->event.magic_eval.object, depth + 1)); 348 internal_hash (e->event.magic_eval.object, depth + 1));
355
356 #if defined(HAVE_OFFIX_DND) || defined(HAVE_MS_WINDOWS)
357 case dnd_drop_event:
358 return HASH4 (hash, e->event.dnd_drop.button, e->event.dnd_drop.modifiers,
359 LISP_HASH(e->event.dnd_drop.data));
360 #endif
361 349
362 case magic_event: 350 case magic_event:
363 { 351 {
364 struct console *con = XCONSOLE (CDFW_CONSOLE (EVENT_CHANNEL (e))); 352 struct console *con = XCONSOLE (CDFW_CONSOLE (EVENT_CHANNEL (e)));
365 #ifdef HAVE_X_WINDOWS 353 #ifdef HAVE_X_WINDOWS
394 382
395 DEFUN ("make-event", Fmake_event, 0, 2, 0, /* 383 DEFUN ("make-event", Fmake_event, 0, 2, 0, /*
396 Return a new event of type TYPE, with properties described by PLIST. 384 Return a new event of type TYPE, with properties described by PLIST.
397 385
398 TYPE is a symbol, either `empty', `key-press', `button-press', 386 TYPE is a symbol, either `empty', `key-press', `button-press',
399 `button-release', `motion' or `dnd-drop'. If TYPE is nil, it 387 `button-release', or `motion'. If TYPE is nil, it
400 defaults to `empty'. 388 defaults to `empty'.
401 389
402 PLIST is a property list, the properties being compatible to those 390 PLIST is a property list, the properties being compatible to those
403 returned by `event-properties'. The following properties are 391 returned by `event-properties'. The following properties are
404 allowed: 392 allowed:
405 393
406 channel -- The event channel, a frame or a console. For 394 channel -- The event channel, a frame or a console. For
407 button-press, button-release, motion and dnd-drop 395 button-press, button-release, motion events,
408 events, this must be a frame. For key-press 396 this must be a frame. For key-press
409 events, it must be a console. If channel is 397 events, it must be a console. If channel is
410 unspecified, it will be set to the selected frame 398 unspecified, it will be set to the selected frame
411 or selected console, as appropriate. 399 or selected console, as appropriate.
412 key -- The event key, a symbol or character. Allowed only for 400 key -- The event key, a symbol or character. Allowed only for
413 keypress events. 401 keypress events.
414 button -- The event button, integer 1, 2 or 3. Allowed for 402 button -- The event button, integer 1, 2 or 3. Allowed for
415 button-press, button-release and dnd-drag events. 403 button-press, button-release and misc-user events.
416 modifiers -- The event modifiers, a list of modifier symbols. Allowed 404 modifiers -- The event modifiers, a list of modifier symbols. Allowed
417 for key-press, button-press, button-release, motion and 405 for key-press, button-press, button-release, motion and
418 dnd-drop events. 406 misc-user events.
419 x -- The event X coordinate, an integer. This is relative 407 x -- The event X coordinate, an integer. This is relative
420 to the left of CHANNEL's root window. Allowed for 408 to the left of CHANNEL's root window. Allowed for
421 motion, button-press, button-release and dnd-drop events. 409 motion, button-press, button-release and misc-user events.
422 y -- The event Y coordinate, an integer. This is relative 410 y -- The event Y coordinate, an integer. This is relative
423 to the top of CHANNEL's root window. Allowed for 411 to the top of CHANNEL's root window. Allowed for
424 motion, button-press, button-release and dnd-drop events. 412 motion, button-press, button-release and misc-user events.
425 dnd-data -- The event DND data, a list of (INTEGER DATA). Allowed
426 for dnd-drop events, if support for DND has been
427 compiled into XEmacs.
428 timestamp -- The event timestamp, a non-negative integer. Allowed for 413 timestamp -- The event timestamp, a non-negative integer. Allowed for
429 all types of events. If unspecified, it will be set to 0 414 all types of events. If unspecified, it will be set to 0
430 by default. 415 by default.
431 416
432 For event type `empty', PLIST must be nil. 417 For event type `empty', PLIST must be nil.
441 */ 426 */
442 (type, plist)) 427 (type, plist))
443 { 428 {
444 Lisp_Object tail, keyword, value; 429 Lisp_Object tail, keyword, value;
445 Lisp_Object event = Qnil; 430 Lisp_Object event = Qnil;
446 Lisp_Object dnd_data = Qnil;
447 struct Lisp_Event *e; 431 struct Lisp_Event *e;
448 EMACS_INT coord_x = 0, coord_y = 0; 432 EMACS_INT coord_x = 0, coord_y = 0;
449 struct gcpro gcpro1, gcpro2; 433 struct gcpro gcpro1;
450 434
451 GCPRO2 (event, dnd_data); 435 GCPRO1 (event);
452 436
453 if (NILP (type)) 437 if (NILP (type))
454 type = Qempty; 438 type = Qempty;
455 439
456 if (!NILP (Vevent_resource)) 440 if (!NILP (Vevent_resource))
491 else if (EQ (type, Qmisc_user)) 475 else if (EQ (type, Qmisc_user))
492 { 476 {
493 e->event_type = misc_user_event; 477 e->event_type = misc_user_event;
494 e->event.eval.function = e->event.eval.object = Qnil; 478 e->event.eval.function = e->event.eval.object = Qnil;
495 } 479 }
496 #if defined(HAVE_OFFIX_DND) || defined(HAVE_MS_WINDOWS)
497 else if (EQ (type, Qdnd_drop))
498 {
499 e->event_type = dnd_drop_event;
500 e->event.dnd_drop.data = Qnil;
501 }
502 #endif
503 else 480 else
504 { 481 {
505 /* Not allowed: Qprocess, Qtimeout, Qmagic, Qeval, Qmagic_eval. */ 482 /* Not allowed: Qprocess, Qtimeout, Qmagic, Qeval, Qmagic_eval. */
506 signal_simple_error ("Invalid event type", type); 483 signal_simple_error ("Invalid event type", type);
507 } 484 }
540 e->event.key.keysym = value; 517 e->event.key.keysym = value;
541 } 518 }
542 else if (EQ (keyword, Qbutton)) 519 else if (EQ (keyword, Qbutton))
543 { 520 {
544 if (e->event_type != button_press_event 521 if (e->event_type != button_press_event
545 && e->event_type != button_release_event) 522 && e->event_type != button_release_event
523 && e->event_type != misc_user_event)
546 { 524 {
547 WRONG_EVENT_TYPE_FOR_PROPERTY (type, keyword); 525 WRONG_EVENT_TYPE_FOR_PROPERTY (type, keyword);
548 } 526 }
549 CHECK_NATNUM (value); 527 CHECK_NATNUM (value);
550 check_int_range (XINT (value), 0, 7); 528 check_int_range (XINT (value), 0, 7);
551 e->event.button.button = XINT (value); 529 if (e->event_type == misc_user_event)
530 e->event.misc.button = XINT (value);
531 else
532 e->event.button.button = XINT (value);
552 } 533 }
553 else if (EQ (keyword, Qmodifiers)) 534 else if (EQ (keyword, Qmodifiers))
554 { 535 {
555 Lisp_Object modtail; 536 Lisp_Object modtail;
556 int modifiers = 0; 537 int modifiers = 0;
557 538
558 if (e->event_type != key_press_event 539 if (e->event_type != key_press_event
559 && e->event_type != button_press_event 540 && e->event_type != button_press_event
560 && e->event_type != button_release_event 541 && e->event_type != button_release_event
561 && e->event_type != pointer_motion_event) 542 && e->event_type != pointer_motion_event
543 && e->event_type != misc_user_event)
562 { 544 {
563 WRONG_EVENT_TYPE_FOR_PROPERTY (type, keyword); 545 WRONG_EVENT_TYPE_FOR_PROPERTY (type, keyword);
564 } 546 }
565 547
566 EXTERNAL_LIST_LOOP (modtail, value) 548 EXTERNAL_LIST_LOOP (modtail, value)
579 if (e->event_type == key_press_event) 561 if (e->event_type == key_press_event)
580 e->event.key.modifiers = modifiers; 562 e->event.key.modifiers = modifiers;
581 else if (e->event_type == button_press_event 563 else if (e->event_type == button_press_event
582 || e->event_type == button_release_event) 564 || e->event_type == button_release_event)
583 e->event.button.modifiers = modifiers; 565 e->event.button.modifiers = modifiers;
584 else /* pointer_motion_event */ 566 else if (e->event_type == pointer_motion_event)
585 e->event.motion.modifiers = modifiers; 567 e->event.motion.modifiers = modifiers;
568 else /* misc_user_event */
569 e->event.misc.modifiers = modifiers;
586 } 570 }
587 else if (EQ (keyword, Qx)) 571 else if (EQ (keyword, Qx))
588 { 572 {
589 if (e->event_type != pointer_motion_event 573 if (e->event_type != pointer_motion_event
590 && e->event_type != button_press_event 574 && e->event_type != button_press_event
591 && e->event_type != button_release_event) 575 && e->event_type != button_release_event
576 && e->event_type != misc_user_event)
592 { 577 {
593 WRONG_EVENT_TYPE_FOR_PROPERTY (type, keyword); 578 WRONG_EVENT_TYPE_FOR_PROPERTY (type, keyword);
594 } 579 }
595 /* Allow negative values, so we can specify toolbar 580 /* Allow negative values, so we can specify toolbar
596 positions. */ 581 positions. */
599 } 584 }
600 else if (EQ (keyword, Qy)) 585 else if (EQ (keyword, Qy))
601 { 586 {
602 if (e->event_type != pointer_motion_event 587 if (e->event_type != pointer_motion_event
603 && e->event_type != button_press_event 588 && e->event_type != button_press_event
604 && e->event_type != button_release_event) 589 && e->event_type != button_release_event
590 && e->event_type != misc_user_event)
605 { 591 {
606 WRONG_EVENT_TYPE_FOR_PROPERTY (type, keyword); 592 WRONG_EVENT_TYPE_FOR_PROPERTY (type, keyword);
607 } 593 }
608 /* Allow negative values; see above. */ 594 /* Allow negative values; see above. */
609 CHECK_INT (value); 595 CHECK_INT (value);
624 { 610 {
625 if (e->event_type != misc_user_event) 611 if (e->event_type != misc_user_event)
626 WRONG_EVENT_TYPE_FOR_PROPERTY (type, keyword); 612 WRONG_EVENT_TYPE_FOR_PROPERTY (type, keyword);
627 e->event.eval.object = value; 613 e->event.eval.object = value;
628 } 614 }
629 #if defined(HAVE_OFFIX_DND) || defined(HAVE_MS_WINDOWS)
630 else if (EQ (keyword, Qdnd_data))
631 {
632 if (e->event_type != dnd_drop_event)
633 WRONG_EVENT_TYPE_FOR_PROPERTY (type, keyword);
634
635 /* Value is either nil, or a list of (TYPE DATA). TYPE is
636 an integer. DATA is a list. */
637 if (!NILP (value))
638 {
639 Lisp_Object dnd_tail;
640 CHECK_CONS (value);
641 /* To be changed to CHECK_SYMBOL. */
642 CHECK_NATNUM (XCAR (value));
643 CHECK_CONS (XCDR (value));
644 if (XINT (Flength (value)) != 2)
645 signal_simple_error ("Data should be a two-element list", value);
646 /* Check validity of DATA. */
647 EXTERNAL_LIST_LOOP (dnd_tail, XCAR (XCDR (value)))
648 {
649 /* Every element must be a string. */
650 CHECK_STRING (XCAR (dnd_tail));
651 }
652 /* And now, copy it all to avoid corruption later. */
653 e->event.dnd_drop.data = Fcopy_tree (value, Qnil);
654 }
655 }
656 #endif /* HAVE_OFFIX_DND || HAVE_MS_WINDOWS */
657 else 615 else
658 signal_simple_error_2 ("Invalid property", keyword, value); 616 signal_simple_error_2 ("Invalid property", keyword, value);
659 } 617 }
660 618
661 /* Insert the channel, if missing. */ 619 /* Insert the channel, if missing. */
670 /* Fevent_properties, Fevent_x_pixel, etc. work with pixels relative 628 /* Fevent_properties, Fevent_x_pixel, etc. work with pixels relative
671 to the frame, so we must adjust accordingly. */ 629 to the frame, so we must adjust accordingly. */
672 if (e->event_type == pointer_motion_event 630 if (e->event_type == pointer_motion_event
673 || e->event_type == button_press_event 631 || e->event_type == button_press_event
674 || e->event_type == button_release_event 632 || e->event_type == button_release_event
675 #if defined(HAVE_OFFIX_DND) || defined(HAVE_MS_WINDOWS) 633 || e->event_type == misc_user_event)
676 || e->event_type == dnd_drop_event
677 #endif
678 )
679 { 634 {
680 struct frame *f = XFRAME (EVENT_CHANNEL (e)); 635 struct frame *f = XFRAME (EVENT_CHANNEL (e));
681 636
682 coord_x += FRAME_REAL_LEFT_TOOLBAR_WIDTH (f); 637 coord_x += FRAME_REAL_LEFT_TOOLBAR_WIDTH (f);
683 coord_y += FRAME_REAL_TOP_TOOLBAR_HEIGHT (f); 638 coord_y += FRAME_REAL_TOP_TOOLBAR_HEIGHT (f);
686 { 641 {
687 e->event.motion.x = coord_x; 642 e->event.motion.x = coord_x;
688 e->event.motion.y = coord_y; 643 e->event.motion.y = coord_y;
689 } 644 }
690 else if (e->event_type == button_press_event 645 else if (e->event_type == button_press_event
691 || e->event_type == button_release_event 646 || e->event_type == button_release_event)
692 #if defined(HAVE_OFFIX_DND) || defined(HAVE_MS_WINDOWS)
693 || e->event_type == dnd_drop_event
694 #endif
695 )
696 { 647 {
697 e->event.button.x = coord_x; 648 e->event.button.x = coord_x;
698 e->event.button.y = coord_y; 649 e->event.button.y = coord_y;
699 } 650 }
651 else if (e->event_type == misc_user_event)
652 {
653 e->event.misc.x = coord_x;
654 e->event.misc.y = coord_y;
655 }
700 } 656 }
701 657
702 /* Finally, do some more validation. */ 658 /* Finally, do some more validation. */
703 switch (e->event_type) 659 switch (e->event_type)
704 { 660 {
707 || !(SYMBOLP (e->event.key.keysym) || CHARP (e->event.key.keysym))) 663 || !(SYMBOLP (e->event.key.keysym) || CHARP (e->event.key.keysym)))
708 error ("Undefined key for keypress event"); 664 error ("Undefined key for keypress event");
709 break; 665 break;
710 case button_press_event: 666 case button_press_event:
711 case button_release_event: 667 case button_release_event:
712 #if defined(HAVE_OFFIX_DND) || defined(HAVE_MS_WINDOWS)
713 case dnd_drop_event:
714 #endif
715 if (!e->event.button.button) 668 if (!e->event.button.button)
716 error ("Undefined button for %s event", 669 error ("Undefined button for %s event",
717 e->event_type == button_press_event 670 e->event_type == button_press_event
718 ? "buton-press" : 671 ? "buton-press" : "button-release");
719 #if defined(HAVE_OFFIX_DND) || defined(HAVE_MS_WINDOWS) 672 break;
720 e->event_type == button_release_event 673 case misc_user_event:
721 ? "button-release" : "dnd-drop" 674 if (!e->event.misc.button)
722 #else 675 error ("Undefined button for misc-user event");
723 "button-release"
724 #endif
725 );
726 break; 676 break;
727 default: 677 default:
728 break; 678 break;
729 } 679 }
730 680
975 { 925 {
976 case key_press_event: 926 case key_press_event:
977 case button_press_event: 927 case button_press_event:
978 case button_release_event: 928 case button_release_event:
979 case misc_user_event: 929 case misc_user_event:
980 #if defined(HAVE_OFFIX_DND) || defined(HAVE_MS_WINDOWS)
981 case dnd_drop_event:
982 #endif
983 return 1; 930 return 1;
984 default: 931 default:
985 return 0; 932 return 0;
986 } 933 }
987 } 934 }
1247 format_event_object (char *buf, struct Lisp_Event *event, int brief) 1194 format_event_object (char *buf, struct Lisp_Event *event, int brief)
1248 { 1195 {
1249 int mouse_p = 0; 1196 int mouse_p = 0;
1250 int mod = 0; 1197 int mod = 0;
1251 Lisp_Object key; 1198 Lisp_Object key;
1252 #if defined(HAVE_OFFIX_DND) || defined(HAVE_MS_WINDOWS)
1253 int dnd_p = 0;
1254 #endif
1255 1199
1256 switch (event->event_type) 1200 switch (event->event_type)
1257 { 1201 {
1258 case key_press_event: 1202 case key_press_event:
1259 { 1203 {
1294 #endif /* HAVE_X_WINDOWS */ 1238 #endif /* HAVE_X_WINDOWS */
1295 if (name) strcpy (buf, name); 1239 if (name) strcpy (buf, name);
1296 else strcpy (buf, "???"); 1240 else strcpy (buf, "???");
1297 return; 1241 return;
1298 } 1242 }
1299 #if defined(HAVE_OFFIX_DND) || defined(HAVE_MS_WINDOWS)
1300 case dnd_drop_event:
1301 {
1302 dnd_p++;
1303 mod = event->event.dnd_drop.modifiers;
1304 key = make_char (event->event.dnd_drop.button + '0');
1305 break;
1306 }
1307 #endif
1308 case magic_eval_event: strcpy (buf, "magic-eval"); return; 1243 case magic_eval_event: strcpy (buf, "magic-eval"); return;
1309 case pointer_motion_event: strcpy (buf, "motion"); return; 1244 case pointer_motion_event: strcpy (buf, "motion"); return;
1310 case misc_user_event: strcpy (buf, "misc-user"); return; 1245 case misc_user_event: strcpy (buf, "misc-user"); return;
1311 case eval_event: strcpy (buf, "eval"); return; 1246 case eval_event: strcpy (buf, "eval"); return;
1312 case process_event: strcpy (buf, "process"); return; 1247 case process_event: strcpy (buf, "process"); return;
1327 if (mouse_p) 1262 if (mouse_p)
1328 { 1263 {
1329 modprint1 ("button"); 1264 modprint1 ("button");
1330 --mouse_p; 1265 --mouse_p;
1331 } 1266 }
1332
1333 #if defined(HAVE_OFFIX_DND) || defined(HAVE_MS_WINDOWS)
1334 switch (dnd_p)
1335 {
1336 case 1:
1337 modprint1 ("drop");
1338 }
1339 #endif
1340 1267
1341 #undef modprint 1268 #undef modprint
1342 #undef modprint1 1269 #undef modprint1
1343 1270
1344 if (CHARP (key)) 1271 if (CHARP (key))
1471 case misc_user_event: return Qmisc_user; 1398 case misc_user_event: return Qmisc_user;
1472 case pointer_motion_event: return Qmotion; 1399 case pointer_motion_event: return Qmotion;
1473 case process_event: return Qprocess; 1400 case process_event: return Qprocess;
1474 case timeout_event: return Qtimeout; 1401 case timeout_event: return Qtimeout;
1475 case eval_event: return Qeval; 1402 case eval_event: return Qeval;
1476 #if defined(HAVE_OFFIX_DND) || defined(HAVE_MS_WINDOWS)
1477 case dnd_drop_event: return Qdnd_drop;
1478 #endif
1479 case magic_event: 1403 case magic_event:
1480 case magic_eval_event: 1404 case magic_eval_event:
1481 return Qmagic; 1405 return Qmagic;
1482 1406
1483 case empty_event: 1407 case empty_event:
1513 if (XEVENT(e)->event_type != (t1) && \ 1437 if (XEVENT(e)->event_type != (t1) && \
1514 XEVENT(e)->event_type != (t2)) \ 1438 XEVENT(e)->event_type != (t2)) \
1515 e = wrong_type_argument ((sym),(e)); \ 1439 e = wrong_type_argument ((sym),(e)); \
1516 } while (0) 1440 } while (0)
1517 1441
1442 #define CHECK_EVENT_TYPE3(e,t1,t2,t3,sym) do { \
1443 CHECK_LIVE_EVENT (e); \
1444 if (XEVENT(e)->event_type != (t1) && \
1445 XEVENT(e)->event_type != (t2) && \
1446 XEVENT(e)->event_type != (t3)) \
1447 e = wrong_type_argument ((sym),(e)); \
1448 } while (0)
1449
1518 DEFUN ("event-key", Fevent_key, 1, 1, 0, /* 1450 DEFUN ("event-key", Fevent_key, 1, 1, 0, /*
1519 Return the Keysym of the key-press event EVENT. 1451 Return the Keysym of the key-press event EVENT.
1520 This will be a character if the event is associated with one, else a symbol. 1452 This will be a character if the event is associated with one, else a symbol.
1521 */ 1453 */
1522 (event)) 1454 (event))
1528 DEFUN ("event-button", Fevent_button, 1, 1, 0, /* 1460 DEFUN ("event-button", Fevent_button, 1, 1, 0, /*
1529 Return the button-number of the given button-press or button-release event. 1461 Return the button-number of the given button-press or button-release event.
1530 */ 1462 */
1531 (event)) 1463 (event))
1532 { 1464 {
1533 #if !defined(HAVE_OFFIX_DND) && !defined(HAVE_MS_WINDOWS) 1465
1534 1466 CHECK_EVENT_TYPE3 (event, button_press_event, button_release_event,
1535 CHECK_EVENT_TYPE2 (event, button_press_event, button_release_event, 1467 misc_user_event, Qbutton_event_p);
1536 Qbutton_event_p);
1537 #ifdef HAVE_WINDOW_SYSTEM 1468 #ifdef HAVE_WINDOW_SYSTEM
1538 return make_int (XEVENT (event)->event.button.button); 1469 if ( XEVENT (event)->event_type == misc_user_event)
1470 return make_int (XEVENT (event)->event.misc.button);
1471 else
1472 return make_int (XEVENT (event)->event.button.button);
1539 #else /* !HAVE_WINDOW_SYSTEM */ 1473 #else /* !HAVE_WINDOW_SYSTEM */
1540 return Qzero; 1474 return Qzero;
1541 #endif /* !HAVE_WINDOW_SYSTEM */ 1475 #endif /* !HAVE_WINDOW_SYSTEM */
1542 1476
1543 #else /* HAVE_OFFIX_DND || HAVE_MS_WINDOWS */
1544
1545 CHECK_LIVE_EVENT (event);
1546 if (XEVENT(event)->event_type == (button_press_event) ||
1547 XEVENT(event)->event_type == (button_release_event))
1548 /* we always have X if we have OffiX !! */
1549 return make_int (XEVENT (event)->event.button.button);
1550 else if (XEVENT(event)->event_type == (dnd_drop_event))
1551 /* we always have X if we have OffiX !! */
1552 return make_int (XEVENT (event)->event.button.button);
1553 else
1554 return wrong_type_argument ((Qbutton_event_p),(event));
1555
1556 #endif
1557 } 1477 }
1558 1478
1559 DEFUN ("event-modifier-bits", Fevent_modifier_bits, 1, 1, 0, /* 1479 DEFUN ("event-modifier-bits", Fevent_modifier_bits, 1, 1, 0, /*
1560 Return a number representing the modifier keys which were down 1480 Return a number representing the modifier keys which were down
1561 when the given mouse or keyboard event was produced. 1481 when the given mouse or keyboard event was produced.
1572 case button_press_event: 1492 case button_press_event:
1573 case button_release_event: 1493 case button_release_event:
1574 return make_int (XEVENT (event)->event.button.modifiers); 1494 return make_int (XEVENT (event)->event.button.modifiers);
1575 case pointer_motion_event: 1495 case pointer_motion_event:
1576 return make_int (XEVENT (event)->event.motion.modifiers); 1496 return make_int (XEVENT (event)->event.motion.modifiers);
1577 #if defined(HAVE_OFFIX_DND) || defined(HAVE_MS_WINDOWS) 1497 case misc_user_event:
1578 case dnd_drop_event: 1498 return make_int (XEVENT (event)->event.misc.modifiers);
1579 return make_int (XEVENT (event)->event.dnd_drop.modifiers);
1580 #endif
1581 default: 1499 default:
1582 event = wrong_type_argument (intern ("key-or-mouse-event-p"), event); 1500 event = wrong_type_argument (intern ("key-or-mouse-event-p"), event);
1583 goto again; 1501 goto again;
1584 } 1502 }
1585 } 1503 }
1617 XEVENT (event)->event_type == button_release_event) 1535 XEVENT (event)->event_type == button_release_event)
1618 { 1536 {
1619 *x = XEVENT (event)->event.button.x; 1537 *x = XEVENT (event)->event.button.x;
1620 *y = XEVENT (event)->event.button.y; 1538 *y = XEVENT (event)->event.button.y;
1621 } 1539 }
1622 #if defined(HAVE_OFFIX_DND) || defined(HAVE_MS_WINDOWS) 1540 else if (XEVENT (event)->event_type == misc_user_event)
1623 else if (XEVENT (event)->event_type == dnd_drop_event) 1541 {
1624 { 1542 *x = XEVENT (event)->event.misc.x;
1625 *x = XEVENT (event)->event.dnd_drop.x; 1543 *y = XEVENT (event)->event.misc.y;
1626 *y = XEVENT (event)->event.dnd_drop.y; 1544 }
1627 }
1628 #endif
1629 else 1545 else
1630 return 0; 1546 return 0;
1631 1547
1632 f = XFRAME (EVENT_CHANNEL (XEVENT (event))); 1548 f = XFRAME (EVENT_CHANNEL (XEVENT (event)));
1633 1549
1774 case button_press_event : 1690 case button_press_event :
1775 case button_release_event : 1691 case button_release_event :
1776 pix_x = XEVENT (event)->event.button.x; 1692 pix_x = XEVENT (event)->event.button.x;
1777 pix_y = XEVENT (event)->event.button.y; 1693 pix_y = XEVENT (event)->event.button.y;
1778 break; 1694 break;
1779 #if defined(HAVE_OFFIX_DND) || defined(HAVE_MS_WINDOWS) 1695 case misc_user_event :
1780 case dnd_drop_event : 1696 pix_x = XEVENT (event)->event.misc.x;
1781 pix_x = XEVENT (event)->event.dnd_drop.x; 1697 pix_y = XEVENT (event)->event.misc.y;
1782 pix_y = XEVENT (event)->event.dnd_drop.y; 1698 break;
1783 break;
1784 #endif
1785 default: 1699 default:
1786 dead_wrong_type_argument (Qmouse_event_p, event); 1700 dead_wrong_type_argument (Qmouse_event_p, event);
1787 } 1701 }
1788 1702
1789 result = pixel_to_glyph_translation (XFRAME (frame), pix_x, pix_y, 1703 result = pixel_to_glyph_translation (XFRAME (frame), pix_x, pix_y,
2101 switch (XEVENT (event)->event_type) 2015 switch (XEVENT (event)->event_type)
2102 { 2016 {
2103 case timeout_event: 2017 case timeout_event:
2104 return XEVENT (event)->event.timeout.function; 2018 return XEVENT (event)->event.timeout.function;
2105 case misc_user_event: 2019 case misc_user_event:
2020 return XEVENT (event)->event.misc.function;
2106 case eval_event: 2021 case eval_event:
2107 return XEVENT (event)->event.eval.function; 2022 return XEVENT (event)->event.eval.function;
2108 default: 2023 default:
2109 event = wrong_type_argument (intern ("timeout-or-eval-event-p"), event); 2024 event = wrong_type_argument (intern ("timeout-or-eval-event-p"), event);
2110 goto again; 2025 goto again;
2122 switch (XEVENT (event)->event_type) 2037 switch (XEVENT (event)->event_type)
2123 { 2038 {
2124 case timeout_event: 2039 case timeout_event:
2125 return XEVENT (event)->event.timeout.object; 2040 return XEVENT (event)->event.timeout.object;
2126 case misc_user_event: 2041 case misc_user_event:
2042 return XEVENT (event)->event.misc.object;
2127 case eval_event: 2043 case eval_event:
2128 return XEVENT (event)->event.eval.object; 2044 return XEVENT (event)->event.eval.object;
2129 default: 2045 default:
2130 event = wrong_type_argument (intern ("timeout-or-eval-event-p"), event); 2046 event = wrong_type_argument (intern ("timeout-or-eval-event-p"), event);
2131 goto again; 2047 goto again;
2132 } 2048 }
2133 }
2134
2135 DEFUN ("event-drag-and-drop-data", Fevent_drag_and_drop_data, 1, 1, 0, /*
2136 Return the Dnd data list of EVENT.
2137 EVENT should be a dnd_drop event.
2138 */
2139 (event))
2140 {
2141 #if defined(HAVE_OFFIX_DND) || defined(HAVE_MS_WINDOWS)
2142 again:
2143 CHECK_LIVE_EVENT (event);
2144 switch (XEVENT (event)->event_type)
2145 {
2146 case dnd_drop_event:
2147 return XEVENT (event)->event.dnd_drop.data;
2148 default:
2149 event = wrong_type_argument (Qdnd_drop_event_p, event);
2150 goto again;
2151 }
2152 #else /* !(HAVE_OFFIX_DND || HAVE_MS_WINDOWS) */
2153 return Qnil;
2154 #endif /* HAVE_OFFIX_DND || HAVE_MS_WINDOWS */
2155 } 2049 }
2156 2050
2157 DEFUN ("event-properties", Fevent_properties, 1, 1, 0, /* 2051 DEFUN ("event-properties", Fevent_properties, 1, 1, 0, /*
2158 Return a list of all of the properties of EVENT. 2052 Return a list of all of the properties of EVENT.
2159 This is in the form of a property list (alternating keyword/value pairs). 2053 This is in the form of a property list (alternating keyword/value pairs).
2200 props = cons3 (Qy, Fevent_y_pixel (event), props); 2094 props = cons3 (Qy, Fevent_y_pixel (event), props);
2201 props = cons3 (Qx, Fevent_x_pixel (event), props); 2095 props = cons3 (Qx, Fevent_x_pixel (event), props);
2202 break; 2096 break;
2203 2097
2204 case misc_user_event: 2098 case misc_user_event:
2099 props = cons3 (Qobject, Fevent_object (event), props);
2100 props = cons3 (Qfunction, Fevent_function (event), props);
2101 props = cons3 (Qy, Fevent_y_pixel (event), props);
2102 props = cons3 (Qx, Fevent_x_pixel (event), props);
2103 props = cons3 (Qmodifiers, Fevent_modifiers (event), props);
2104 props = cons3 (Qbutton, Fevent_button (event), props);
2105 break;
2106
2205 case eval_event: 2107 case eval_event:
2206 props = cons3 (Qobject, Fevent_object (event), props); 2108 props = cons3 (Qobject, Fevent_object (event), props);
2207 props = cons3 (Qfunction, Fevent_function (event), props); 2109 props = cons3 (Qfunction, Fevent_function (event), props);
2208 break; 2110 break;
2209
2210 #if defined(HAVE_OFFIX_DND) || defined(HAVE_MS_WINDOWS)
2211 case dnd_drop_event:
2212 props = cons3 (Qy, Fevent_y_pixel (event), props);
2213 props = cons3 (Qx, Fevent_x_pixel (event), props);
2214 props = cons3 (Qmodifiers, Fevent_modifiers (event), props);
2215 props = cons3 (Qbutton, Fevent_button (event), props);
2216 props = cons3 (Qdnd_data, Fevent_drag_and_drop_data (event), props);
2217 break;
2218 #endif
2219 2111
2220 case magic_eval_event: 2112 case magic_eval_event:
2221 case magic_event: 2113 case magic_event:
2222 break; 2114 break;
2223 2115
2281 DEFSUBR (Fevent_glyph_y_pixel); 2173 DEFSUBR (Fevent_glyph_y_pixel);
2282 DEFSUBR (Fevent_toolbar_button); 2174 DEFSUBR (Fevent_toolbar_button);
2283 DEFSUBR (Fevent_process); 2175 DEFSUBR (Fevent_process);
2284 DEFSUBR (Fevent_function); 2176 DEFSUBR (Fevent_function);
2285 DEFSUBR (Fevent_object); 2177 DEFSUBR (Fevent_object);
2286 DEFSUBR (Fevent_drag_and_drop_data);
2287 2178
2288 defsymbol (&Qeventp, "eventp"); 2179 defsymbol (&Qeventp, "eventp");
2289 defsymbol (&Qevent_live_p, "event-live-p"); 2180 defsymbol (&Qevent_live_p, "event-live-p");
2290 defsymbol (&Qkey_press_event_p, "key-press-event-p"); 2181 defsymbol (&Qkey_press_event_p, "key-press-event-p");
2291 defsymbol (&Qbutton_event_p, "button-event-p"); 2182 defsymbol (&Qbutton_event_p, "button-event-p");
2294 defsymbol (&Qkey_press, "key-press"); 2185 defsymbol (&Qkey_press, "key-press");
2295 defsymbol (&Qbutton_press, "button-press"); 2186 defsymbol (&Qbutton_press, "button-press");
2296 defsymbol (&Qbutton_release, "button-release"); 2187 defsymbol (&Qbutton_release, "button-release");
2297 defsymbol (&Qmisc_user, "misc-user"); 2188 defsymbol (&Qmisc_user, "misc-user");
2298 defsymbol (&Qascii_character, "ascii-character"); 2189 defsymbol (&Qascii_character, "ascii-character");
2299 #if defined(HAVE_OFFIX_DND) || defined(HAVE_MS_WINDOWS)
2300 defsymbol (&Qdnd_drop_event_p, "dnd-drop-event-p");
2301 defsymbol (&Qdnd_drop, "dnd-drop");
2302 #endif
2303 } 2190 }
2304 2191
2305 void 2192 void
2306 vars_of_events (void) 2193 vars_of_events (void)
2307 { 2194 {