xemacs-beta: src/events.c comparison

comparison src/events.c @ 173:8eaf7971accc r20-3b13

Import from CVS: tag r20-3b13

author	cvs
date	Mon, 13 Aug 2007 09:49:09 +0200
parents	0132846995bd
children	e121b013d1f0

comparison

equal deleted inserted replaced

-:a38aed19690b
+:8eaf7971accc
 print_event (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
 {
 if (print_readably)
 error ("printing unreadable object #<event>");
 switch (XEVENT (obj)->event_type)
 {
 case key_press_event:
 print_event_1 ("#<keypress-event ", obj, printcharfun);
 break;
 case button_press_event:
 	write_c_string ("#<UNKNOWN-EVENT-TYPE", printcharfun);
 	break;
 }
 write_c_string (">", printcharfun);
 }
 static int
 event_equal (Lisp_Object o1, Lisp_Object o2, int depth)
 {
 struct Lisp_Event *e1 = XEVENT (o1);
 struct Lisp_Event *e2 = XEVENT (o2);
 /*  if (e1->timestamp != e2->timestamp) return 0; */
 switch (e1->event_type)
 {
 case process_event:
 return EQ (e1->event.process.process, e2->event.process.process);
 case timeout_event:
 return (!NILP (Fequal (e1->event.timeout.function,
 			     e2->event.timeout.function)) &&
 	      !NILP (Fequal (e1->event.timeout.object,
 			     e2->event.timeout.object)));
 case key_press_event:
 return (EQ (e1->event.key.keysym, e2->event.key.keysym) &&
 	      (e1->event.key.modifiers == e2->event.key.modifiers));
 case button_press_event:
 hash = HASH2 (e->event_type, LISP_HASH (e->channel));
 switch (e->event_type)
 {
 case process_event:
 return HASH2 (hash, LISP_HASH (e->event.process.process));
 case timeout_event:
 return HASH3 (hash, internal_hash (e->event.timeout.function, depth + 1),
 		    internal_hash (e->event.timeout.object, depth + 1));
 case key_press_event:
 return HASH3 (hash, LISP_HASH (e->event.key.keysym),
 		    e->event.key.modifiers);
 case button_press_event:
 error ("this event is already deallocated!");
 assert (XEVENT_TYPE (event) <= last_event_type);
 #if 0
 {
-int i;
+int i, len;
 extern Lisp_Object Vlast_command_event;
 extern Lisp_Object Vlast_input_event, Vunread_command_event;
 extern Lisp_Object Vthis_command_keys, Vrecent_keys_ring;
-if (EQ (event, Vlast_command_event))
+if (EQ (event, Vlast_command_event) ||
+	EQ (event, Vlast_input_event)   ||
+	EQ (event, Vunread_command_event))
 abort ();
-if (EQ (event, Vlast_input_event))
-abort ();
+len = XVECTOR_LENGTH (Vthis_command_keys);
-if (EQ (event, Vunread_command_event))
+for (i = 0; i < len; i++)
-abort ();
+if (EQ (event, XVECTOR_DATA (Vthis_command_keys) [i]))
-for (i = 0; i < XVECTOR (Vthis_command_keys)->size; i++)
-if (EQ (event, vector_data (XVECTOR (Vthis_command_keys)) [i]))
 	abort ();
 if (!NILP (Vrecent_keys_ring))
 {
-	for (i = 0; i < XVECTOR (Vrecent_keys_ring)->size; i++)
+	int recent_ring_len = XVECTOR_LENGTH (Vrecent_keys_ring);
-	  if (EQ (event, vector_data (XVECTOR (Vrecent_keys_ring)) [i]))
+	for (i = 0; i < recent_ring_len; i++)
+	  if (EQ (event, XVECTOR_DATA (Vrecent_keys_ring) [i]))
 	    abort ();
 }
 }
 #endif /* 0 */
 {
 Lisp_Object save_next = XEVENT_NEXT (event2);
 *XEVENT (event2) = *XEVENT (event1);
 XSET_EVENT_NEXT (event2, save_next);
-return (event2);
+return event2;
 }
 }
 assert (!EQ (event, XEVENT_NEXT (event)));
 }
 /* Remove an event off the head of a chain of events and return it.
 HEAD points to the first event in the chain, TAIL to the last event. */
 Lisp_Object
 dequeue_event (Lisp_Object *head, Lisp_Object *tail)
 {
 Lisp_Object event;
 {
 case key_press_event:
 case button_press_event:
 case button_release_event:
 case misc_user_event:
-return (1);
+return 1;
 default:
-return (0);
+return 0;
 }
 }
 void
 }
 else if (c == 127)
 k = QKdelete;
 else if (c == ' ')
 k = QKspace;
 event->event_type	     = key_press_event;
 event->timestamp	     = 0; /* #### */
 event->channel	     = make_console (con);
 event->event.key.keysym    = (!NILP (k) ? k : make_char (c));
 event->event.key.modifiers = m;
 	c -= ('a' - 'A');
 else
 	/* reject Control-Shift- keys */
 	if (c >= 'A' && c <= 'Z' && !allow_extra_modifiers)
 	  return -1;
 if (c >= '@' && c <= '_')
 	c -= '@';
 else if (c == ' ')  /* C-space and C-@ are the same. */
 	c = 0;
 else
 CHECK_LIVE_EVENT (event);
 c = event_to_character (XEVENT (event),
 			  !NILP (allow_extra_modifiers),
 			  !NILP (allow_meta),
 			  !NILP (allow_non_ascii));
-return (c < 0 ? Qnil : make_char (c));
+return c < 0 ? Qnil : make_char (c);
 }
 DEFUN ("character-to-event", Fcharacter_to_event, 1, 4, 0, /*
 Converts a keystroke specifier into an event structure, replete with
 bucky bits.  The keystroke is the first argument, and the event to fill
 Emchar ch = string_char (XSTRING (seq), n);
 Fcharacter_to_event (make_char (ch), event, Qnil, Qnil);
 }
 else
 {
-Lisp_Object keystroke = vector_data (XVECTOR (seq))[n];
+Lisp_Object keystroke = XVECTOR_DATA (seq)[n];
 if (EVENTP (keystroke))
 	Fcopy_event (keystroke, event);
 else
 	Fcharacter_to_event (keystroke, event, Qnil, Qnil);
 }
 CHECK_LIVE_EVENT (event);
 if (NILP (next_event))
 {
 XSET_EVENT_NEXT (event, Qnil);
-return (Qnil);
+return Qnil;
 }
 CHECK_LIVE_EVENT (next_event);
 EVENT_CHAIN_LOOP (ev, XEVENT_NEXT (event))
 {
 QUIT;
 if (EQ (ev, event))
 	signal_error (Qerror,
 		      list3 (build_string ("Cyclic event-next"),
 			     event,
 			     next_event));
 }
 XSET_EVENT_NEXT (event, next_event);
 return next_event;
 }
 The buffer position it's over in BUFP, if not a null pointer.
 The closest buffer position in CLOSEST, if not a null pointer.
 OBJ_X, OBJ_Y, OBJ1, and OBJ2 are as in pixel_to_glyph_translation().
 */
 static int
 event_pixel_translation (Lisp_Object event, int *char_x, int *char_y,
 			 int *obj_x, int *obj_y,
 			 struct window **w, Bufpos *bufp, Bufpos *closest,
 			 Charcount *modeline_closest,
 			 Lisp_Object *obj1, Lisp_Object *obj2)
 {
 int pix_x = 0;
 int pix_y = 0;
 int result;
-Lisp_Object frame;
+Lisp_Object frame = Qnil;
 int ret_x, ret_y, ret_obj_x, ret_obj_y;
 struct window *ret_w;
 Bufpos ret_bufp, ret_closest;
 Charcount ret_modeline_closest;
 Lisp_Object ret_obj1, ret_obj2;
 CHECK_LIVE_EVENT (event);
-if (XEVENT (event)->event_type == pointer_motion_event)
+frame = XEVENT (event)->channel;
-{
+switch (XEVENT (event)->event_type)
+{
+case pointer_motion_event :
 pix_x = XEVENT (event)->event.motion.x;
 pix_y = XEVENT (event)->event.motion.y;
-frame = XEVENT (event)->channel;
+break;
-}
+case button_press_event :
-else if (XEVENT (event)->event_type == button_press_event ||
+case button_release_event :
-	   XEVENT (event)->event_type == button_release_event)
-{
 pix_x = XEVENT (event)->event.button.x;
 pix_y = XEVENT (event)->event.button.y;
-frame = XEVENT (event)->channel;
+break;
-}
+default:
-else
+dead_wrong_type_argument (Qmouse_event_p, event);
-wrong_type_argument (Qmouse_event_p, event);
+}
 result = pixel_to_glyph_translation (XFRAME (frame), pix_x, pix_y,
 				       &ret_x, &ret_y, &ret_obj_x, &ret_obj_y,
 				       &ret_w, &ret_bufp, &ret_closest,
 				       &ret_modeline_closest,
 #ifdef HAVE_TOOLBARS
 			    || TOOLBAR_BUTTONP (ret_obj1)
 #endif
 ))
 abort ();
-if (!NILP (ret_obj2) && !(EXTENTP (ret_obj2)
+if (!NILP (ret_obj2) && !(EXTENTP (ret_obj2) || CONSP (ret_obj2)))
-			    || CONSP (ret_obj2)))
 abort ();
 if (char_x)
 *char_x = ret_x;
 if (char_y)
 {
 CHECK_LIVE_EVENT (event);
 switch (XEVENT (event)->event_type)
 {
 case timeout_event:
-return (XEVENT (event)->event.timeout.function);
+return XEVENT (event)->event.timeout.function;
 case misc_user_event:
 case eval_event:
-return (XEVENT (event)->event.eval.function);
+return XEVENT (event)->event.eval.function;
 default:
 return wrong_type_argument (intern ("timeout-or-eval-event-p"), event);
 }
 }
 again:
 CHECK_LIVE_EVENT (event);
 switch (XEVENT (event)->event_type)
 {
 case timeout_event:
-return (XEVENT (event)->event.timeout.object);
+return XEVENT (event)->event.timeout.object;
 case misc_user_event:
 case eval_event:
-return (XEVENT (event)->event.eval.object);
+return XEVENT (event)->event.eval.object;
 default:
 event = wrong_type_argument (intern ("timeout-or-eval-event-p"), event);
 goto again;
 }
 }
 switch (e->event_type)
 {
 case process_event:
 props = Fcons (Qprocess, Fcons (e->event.process.process, props));
 break;
 case timeout_event:
 props = Fcons (Qobject, Fcons (Fevent_object (event), props));
 props = Fcons (Qfunction, Fcons (Fevent_function (event), props));
 props = Fcons (Qid, Fcons (make_int (e->event.timeout.id_number),
 				 props));

Mercurial > hg > xemacs-beta

comparison src/events.c @ 173:8eaf7971accc r20-3b13