/* Synched up with: Not in FSF. */
-#ifndef _XEMACS_EVENTS_H_
-#define _XEMACS_EVENTS_H_
+#ifndef INCLUDED_events_h_
+#define INCLUDED_events_h_
#include "systime.h"
multiple heterogeneous machines, X11 and SunView, or X11 and NeXT, for
example, then it will be necessary to construct an event_stream structure
that can cope with the given types. Currently, the only implemented
- event_streams are for dumb-ttys, and for X11 plus dumb-ttys.
+ event_streams are for dumb-ttys, and for X11 plus dumb-ttys,
+ and for mswindows.
To implement this for one window system is relatively simple.
To implement this for multiple window systems is trickier and may
event_stream layer to translate to this format.
NOTE: #### All timestamps should be measured as milliseconds since XEmacs
- started. Currently many or most events have a 0 as their
- timestamp value, and for other timestamps, they are raw server
- timestamps. (The X protocol doesn't provide any easy way of
- translating between server time and real process time; yuck.)
+ started. Currently they are raw server timestamps. (The X protocol
+ doesn't provide any easy way of translating between server time and
+ real process time; yuck.)
Every event type has the following structures:
If this is an integer, it will be in the printing
ASCII range: >32 and <127.
modifiers Bucky-bits on that key: control, meta, etc.
+ Also includes buttons.
For many keys, Shift is not a bit; that is implicit
in the keyboard layout.
button_release_event
button What button went down or up.
modifiers Bucky-bits on that button: shift, control, meta, etc.
+ Also includes other buttons (not the one pressed).
x, y Where it was at the button-state-change (in pixels).
pointer_motion_event
x, y Where it was after it moved (in pixels).
modifiers Bucky-bits down when the motion was detected.
- (Possibly not all window systems will provide this?)
process_event
process the XEmacs "process" object in question
The Create stream pair function is passed two void* values, which identify
process-dependent 'handles'. The process implementation uses these handles
to communicate with child processes. The function must be prepared to receive
- handle types of any process implementation. Since there only one process
+ handle types of any process implementation. Since only one process
implementation exists in a particular XEmacs configuration, preprocessing
- is a mean of compiling in the support for the code which deals with particular
+ is a means of compiling in the support for the code which deals with particular
handle types.
For example, a unixoid type loop, which relies on file descriptors, may be
#define USID_DONTHASH ((USID)0)
\f
-struct Lisp_Event;
-struct Lisp_Process;
-
struct event_stream
{
int (*event_pending_p) (int);
- void (*next_event_cb) (struct Lisp_Event *);
- void (*handle_magic_event_cb) (struct Lisp_Event *);
+ void (*next_event_cb) (Lisp_Event *);
+ void (*handle_magic_event_cb) (Lisp_Event *);
int (*add_timeout_cb) (EMACS_TIME);
void (*remove_timeout_cb) (int);
void (*select_console_cb) (struct console *);
void (*unselect_console_cb) (struct console *);
- void (*select_process_cb) (struct Lisp_Process *);
- void (*unselect_process_cb) (struct Lisp_Process *);
+ void (*select_process_cb) (Lisp_Process *);
+ void (*unselect_process_cb) (Lisp_Process *);
void (*quit_p_cb) (void);
+ void (*force_event_pending) (struct frame* f);
USID (*create_stream_pair_cb) (void* /* inhandle*/, void* /*outhandle*/ ,
Lisp_Object* /* instream */,
Lisp_Object* /* outstream */,
int /* flags */);
USID (*delete_stream_pair_cb) (Lisp_Object /* instream */,
Lisp_Object /* outstream */);
+ int (*current_event_timestamp_cb) (struct console *);
};
/* Flags for create_stream_pair_cb() FLAGS parameter */
struct key_data
{
Lisp_Object keysym;
- unsigned char modifiers;
+ int modifiers;
};
struct button_data
{
int button;
- unsigned char modifiers;
+ int modifiers;
int x, y;
};
struct motion_data
{
int x, y;
- unsigned char modifiers;
+ int modifiers;
};
struct process_data
Lisp_Object function;
Lisp_Object object;
int button;
- unsigned char modifiers;
+ int modifiers;
int x, y;
};
# include <X11/Xlib.h>
#endif
+#ifdef HAVE_GTK
+#include <gdk/gdk.h>
+#endif
+
union magic_data
{
#ifdef HAVE_TTY
char underlying_tty_event;
#endif
+#ifdef HAVE_GTK
+ GdkEvent underlying_gdk_event;
+#endif
#ifdef HAVE_X_WINDOWS
XEvent underlying_x_event;
#endif
#endif
};
+struct Lisp_Timeout
+{
+ struct lcrecord_header header;
+ int id; /* Id we use to identify the timeout over its lifetime */
+ int interval_id; /* Id for this particular interval; this may
+ be different each time the timeout is
+ signalled.*/
+ Lisp_Object function, object; /* Function and object associated
+ with timeout. */
+ EMACS_TIME next_signal_time; /* Absolute time when the timeout
+ is next going to be signalled. */
+ unsigned int resignal_msecs; /* How far after the next timeout
+ should the one after that
+ occur? */
+};
+typedef struct Lisp_Timeout Lisp_Timeout;
+
+DECLARE_LRECORD (timeout, Lisp_Timeout);
+#define XTIMEOUT(x) XRECORD (x, timeout, Lisp_Timeout)
+#define XSETTIMEOUT(x, p) XSETRECORD (x, p, timeout)
+#define TIMEOUTP(x) RECORDP (x, timeout)
+#define CHECK_TIMEOUT(x) CHECK_RECORD (x, timeout)
+#define CONCHECK_TIMEOUT(x) CONCHECK_RECORD (x, timeout)
+
struct Lisp_Event
{
/* header->next (aka XEVENT_NEXT ()) is used as follows:
} event;
};
-DECLARE_LRECORD (event, struct Lisp_Event);
-#define XEVENT(x) XRECORD (x, event, struct Lisp_Event)
+DECLARE_LRECORD (event, Lisp_Event);
+#define XEVENT(x) XRECORD (x, event, Lisp_Event)
#define XSETEVENT(x, p) XSETRECORD (x, p, event)
#define EVENTP(x) RECORDP (x, event)
-#define GC_EVENTP(x) GC_RECORDP (x, event)
#define CHECK_EVENT(x) CHECK_RECORD (x, event)
#define CONCHECK_EVENT(x) CONCHECK_RECORD (x, event)
extern Lisp_Object QKbackspace, QKdelete, QKescape, QKlinefeed, QKreturn;
extern Lisp_Object QKspace, QKtab, Qmouse_event_p, Vcharacter_set_property;
extern Lisp_Object Qcancel_mode_internal;
+extern Lisp_Object Vmodifier_keys_sticky_time;
-/* Note: under X Windows, MOD_ALT is generated by the Alt key if there are
+/* Note: under X Windows, XEMACS_MOD_ALT is generated by the Alt key if there are
both Alt and Meta keys. If there are no Meta keys, then Alt generates
- MOD_META instead.
+ XEMACS_MOD_META instead.
*/
#ifdef emacs
#define KEYSYM(x) (intern (x))
/* from events.c */
-void format_event_object (char *buf, struct Lisp_Event *e, int brief);
-void character_to_event (Emchar c, struct Lisp_Event *event,
+void format_event_object (char *buf, Lisp_Event *e, int brief);
+void character_to_event (Emchar c, Lisp_Event *event,
struct console *con,
int use_console_meta_flag,
int do_backspace_mapping);
-void zero_event (struct Lisp_Event *e);
+void zero_event (Lisp_Event *e);
void deallocate_event_chain (Lisp_Object event);
Lisp_Object event_chain_tail (Lisp_Object event);
void enqueue_event (Lisp_Object event, Lisp_Object *head, Lisp_Object *tail);
/* True if this is a non-internal event
(keyboard press, menu, scrollbar, mouse button) */
int command_event_p (Lisp_Object event);
+void define_self_inserting_symbol (Lisp_Object, Lisp_Object);
+Emchar event_to_character (Lisp_Event *, int, int, int);
struct console *event_console_or_selected (Lisp_Object event);
/* from event-stream.c */
Lisp_Object allocate_command_builder (Lisp_Object console);
void enqueue_magic_eval_event (void (*fun) (Lisp_Object), Lisp_Object object);
-void event_stream_next_event (struct Lisp_Event *event);
-void event_stream_handle_magic_event (struct Lisp_Event *event);
+void event_stream_next_event (Lisp_Event *event);
+void event_stream_handle_magic_event (Lisp_Event *event);
void event_stream_select_console (struct console *con);
void event_stream_unselect_console (struct console *con);
-void event_stream_select_process (struct Lisp_Process *proc);
-void event_stream_unselect_process (struct Lisp_Process *proc);
+void event_stream_select_process (Lisp_Process *proc);
+void event_stream_unselect_process (Lisp_Process *proc);
USID event_stream_create_stream_pair (void* inhandle, void* outhandle,
Lisp_Object* instream, Lisp_Object* outstream, int flags);
USID event_stream_delete_stream_pair (Lisp_Object instream, Lisp_Object outstream);
int event_stream_unixoid_select_console (struct console *con);
int event_stream_unixoid_unselect_console (struct console *con);
-int event_stream_unixoid_select_process (struct Lisp_Process *proc);
-int event_stream_unixoid_unselect_process (struct Lisp_Process *proc);
-int read_event_from_tty_or_stream_desc (struct Lisp_Event *event,
+int event_stream_unixoid_select_process (Lisp_Process *proc);
+int event_stream_unixoid_unselect_process (Lisp_Process *proc);
+int read_event_from_tty_or_stream_desc (Lisp_Event *event,
struct console *con, int fd);
USID event_stream_unixoid_create_stream_pair (void* inhandle, void* outhandle,
Lisp_Object* instream,
#endif /* emacs */
-#endif /* _XEMACS_EVENTS_H_ */
+/* #### a hack, until accelerator shit is cleaned up */
+
+/* This structure is what we use to encapsulate the state of a command sequence
+ being composed; key events are executed by adding themselves to the command
+ builder; if the command builder is then complete (does not still represent
+ a prefix key sequence) it executes the corresponding command.
+ */
+struct command_builder
+{
+ struct lcrecord_header header;
+ Lisp_Object console; /* back pointer to the console this command
+ builder is for */
+ /* Qnil, or a Lisp_Event representing the first event read
+ * after the last command completed. Threaded. */
+ /* #### NYI */
+ Lisp_Object prefix_events;
+ /* Qnil, or a Lisp_Event representing event in the current
+ * keymap-lookup sequence. Subsequent events are threaded via
+ * the event's next slot */
+ Lisp_Object current_events;
+ /* Last elt of above */
+ Lisp_Object most_current_event;
+ /* Last elt before function map code took over. What this means is:
+ All prefixes up to (but not including) this event have non-nil
+ bindings, but the prefix including this event has a nil binding.
+ Any events in the chain after this one were read solely because
+ we're part of a possible function key. If we end up with
+ something that's not part of a possible function key, we have to
+ unread all of those events. */
+ Lisp_Object last_non_munged_event;
+ /* One set of values for function-key-map, one for key-translation-map */
+ struct munging_key_translation
+ {
+ /* First event that can begin a possible function key sequence
+ (to be translated according to function-key-map). Normally
+ this is the first event in the chain. However, once we've
+ translated a sequence through function-key-map, this will point
+ to the first event after the translated sequence: we don't ever
+ want to translate any events twice through function-key-map, or
+ things could get really screwed up (e.g. if the user created a
+ translation loop). If this is nil, then the next-read event is
+ the first that can begin a function key sequence. */
+ Lisp_Object first_mungeable_event;
+ } munge_me[2];
+
+ Bufbyte *echo_buf;
+ Bytecount echo_buf_length; /* size of echo_buf */
+ Bytecount echo_buf_index; /* index into echo_buf
+ * -1 before doing echoing for new cmd */
+ /* Self-insert-command is magic in that it doesn't always push an undo-
+ boundary: up to 20 consecutive self-inserts can happen before an undo-
+ boundary is pushed. This variable is that counter.
+ */
+ int self_insert_countdown;
+};
+
+#endif /* INCLUDED_events_h_ */
projects / chise / xemacs-chise.git.1 / blobdiff