/* Generate a file notification event. */
static void
kqueue_generate_event (Lisp_Object watch_object, Lisp_Object actions,
Lisp_Object file, Lisp_Object file1)
{
Lisp_Object flags, action, entry;
struct input_event event;
/* Check, whether all actions shall be monitored. */
flags = Fnth (make_number (2), watch_object);
action = actions;
do {
if (NILP (action))
break;
entry = XCAR (action);
if (NILP (Fmember (entry, flags))) {
action = XCDR (action);
actions = Fdelq (entry, actions);
} else
action = XCDR (action);
} while (1);
/* Store it into the input event queue. */
if (! NILP (actions)) {
EVENT_INIT (event);
event.kind = FILE_NOTIFY_EVENT;
event.frame_or_window = Qnil;
event.arg = list2 (Fcons (XCAR (watch_object),
Fcons (actions,
NILP (file1)
? Fcons (file, Qnil)
: list2 (file, file1))),
Fnth (make_number (3), watch_object));
kbd_buffer_store_event (&event);
}
}
static void
store_config_changed_event (Lisp_Object arg, Lisp_Object display_name)
{
struct input_event event;
EVENT_INIT (event);
event.kind = CONFIG_CHANGED_EVENT;
event.frame_or_window = display_name;
event.arg = arg;
kbd_buffer_store_event (&event);
}
/* This callback is called when the FD is available for read. The inotify
events are read from FD and converted into input_events. */
static void
inotify_callback (int fd, void *_)
{
struct input_event event;
Lisp_Object watch_object;
int to_read;
char *buffer;
ssize_t n;
size_t i;
to_read = 0;
if (ioctl (fd, FIONREAD, &to_read) == -1)
report_file_notify_error ("Error while retrieving file system events",
Qnil);
buffer = xmalloc (to_read);
n = read (fd, buffer, to_read);
if (n < 0)
{
xfree (buffer);
report_file_notify_error ("Error while reading file system events", Qnil);
}
EVENT_INIT (event);
event.kind = FILE_NOTIFY_EVENT;
i = 0;
while (i < (size_t)n)
{
struct inotify_event *ev = (struct inotify_event*)&buffer[i];
watch_object = Fassoc (make_watch_descriptor (ev->wd), watch_list);
if (!NILP (watch_object))
{
event.arg = inotifyevent_to_event (watch_object, ev);
/* If event was removed automatically: Drop it from watch list. */
if (ev->mask & IN_IGNORED)
watch_list = Fdelete (watch_object, watch_list);
if (!NILP (event.arg))
kbd_buffer_store_event (&event);
}
i += sizeof (*ev) + ev->len;
}
xfree (buffer);
}
/* This callback is called when the FD is available for read. The inotify
events are read from FD and converted into input_events. */
static void
inotify_callback (int fd, void *_)
{
int to_read;
if (ioctl (fd, FIONREAD, &to_read) < 0)
report_file_notify_error ("Error while retrieving file system events",
Qnil);
USE_SAFE_ALLOCA;
char *buffer = SAFE_ALLOCA (to_read);
ssize_t n = read (fd, buffer, to_read);
if (n < 0)
report_file_notify_error ("Error while reading file system events", Qnil);
struct input_event event;
EVENT_INIT (event);
event.kind = FILE_NOTIFY_EVENT;
for (ssize_t i = 0; i < n; )
{
struct inotify_event *ev = (struct inotify_event *) &buffer[i];
Lisp_Object descriptor = INTEGER_TO_CONS (ev->wd);
Lisp_Object prevtail = find_descriptor (descriptor);
if (! NILP (prevtail))
{
Lisp_Object tail = CONSP (prevtail) ? XCDR (prevtail) : watch_list;
for (Lisp_Object watches = XCDR (XCAR (tail)); ! NILP (watches);
watches = XCDR (watches))
{
event.arg = inotifyevent_to_event (XCAR (watches), ev);
if (!NILP (event.arg))
kbd_buffer_store_event (&event);
}
/* If event was removed automatically: Drop it from watch list. */
if (ev->mask & IN_IGNORED)
remove_descriptor (prevtail, true);
}
i += sizeof (*ev) + ev->len;
}
SAFE_FREE ();
}
void
find_and_call_menu_selection (struct frame *f, int menu_bar_items_used,
Lisp_Object vector, void *client_data)
{
Lisp_Object prefix, entry;
Lisp_Object *subprefix_stack;
int submenu_depth = 0;
int i;
USE_SAFE_ALLOCA;
entry = Qnil;
SAFE_NALLOCA (subprefix_stack, 1, menu_bar_items_used);
prefix = Qnil;
i = 0;
while (i < menu_bar_items_used)
{
if (EQ (AREF (vector, i), Qnil))
{
subprefix_stack[submenu_depth++] = prefix;
prefix = entry;
i++;
}
else if (EQ (AREF (vector, i), Qlambda))
{
prefix = subprefix_stack[--submenu_depth];
i++;
}
else if (EQ (AREF (vector, i), Qt))
{
prefix = AREF (vector, i + MENU_ITEMS_PANE_PREFIX);
i += MENU_ITEMS_PANE_LENGTH;
}
else
{
entry = AREF (vector, i + MENU_ITEMS_ITEM_VALUE);
/* Treat the pointer as an integer. There's no problem
as long as pointers have enough bits to hold small integers. */
if ((intptr_t) client_data == i)
{
int j;
struct input_event buf;
Lisp_Object frame;
EVENT_INIT (buf);
XSETFRAME (frame, f);
buf.kind = MENU_BAR_EVENT;
buf.frame_or_window = frame;
buf.arg = frame;
kbd_buffer_store_event (&buf);
for (j = 0; j < submenu_depth; j++)
if (!NILP (subprefix_stack[j]))
{
buf.kind = MENU_BAR_EVENT;
buf.frame_or_window = frame;
buf.arg = subprefix_stack[j];
kbd_buffer_store_event (&buf);
}
if (!NILP (prefix))
{
buf.kind = MENU_BAR_EVENT;
buf.frame_or_window = frame;
buf.arg = prefix;
kbd_buffer_store_event (&buf);
}
buf.kind = MENU_BAR_EVENT;
buf.frame_or_window = frame;
buf.arg = entry;
kbd_buffer_store_event (&buf);
break;
}
i += MENU_ITEMS_ITEM_LENGTH;
}
}
SAFE_FREE ();
}
int
w32_console_read_socket (struct terminal *terminal,
struct input_event *hold_quit)
{
int nev, add;
int isdead;
block_input ();
for (;;)
{
int nfnotify = handle_file_notifications (hold_quit);
nev = fill_queue (0);
if (nev <= 0)
{
/* If nev == -1, there was some kind of error
If nev == 0 then no events were available
so return. */
if (nfnotify)
nev = 0;
break;
}
while (nev > 0)
{
struct input_event inev;
EVENT_INIT (inev);
inev.kind = NO_EVENT;
inev.arg = Qnil;
switch (queue_ptr->EventType)
{
case KEY_EVENT:
add = key_event (&queue_ptr->Event.KeyEvent, &inev, &isdead);
if (add == -1) /* 95.7.25 by himi */
{
queue_ptr--;
add = 1;
}
if (add)
kbd_buffer_store_event_hold (&inev, hold_quit);
break;
case MOUSE_EVENT:
add = do_mouse_event (&queue_ptr->Event.MouseEvent, &inev);
if (add)
kbd_buffer_store_event_hold (&inev, hold_quit);
break;
case WINDOW_BUFFER_SIZE_EVENT:
if (w32_use_full_screen_buffer)
resize_event (&queue_ptr->Event.WindowBufferSizeEvent);
break;
case MENU_EVENT:
case FOCUS_EVENT:
/* Internal event types, ignored. */
break;
}
queue_ptr++;
nev--;
}
}
/* We don't get told about changes in the window size (only the buffer
size, which we no longer care about), so we have to check it
periodically. */
if (!w32_use_full_screen_buffer)
maybe_generate_resize_event ();
unblock_input ();
return nev;
}
static int
handle_file_notifications (struct input_event *hold_quit)
{
BYTE *p = file_notifications;
FILE_NOTIFY_INFORMATION *fni = (PFILE_NOTIFY_INFORMATION)p;
const DWORD min_size
= offsetof (FILE_NOTIFY_INFORMATION, FileName) + sizeof(wchar_t);
struct input_event inev;
int nevents = 0;
/* We cannot process notification before Emacs is fully initialized,
since we need the UTF-16LE coding-system to be set up. */
if (!initialized)
{
notification_buffer_in_use = 0;
return nevents;
}
enter_crit ();
if (notification_buffer_in_use)
{
DWORD info_size = notifications_size;
Lisp_Object cs = intern ("utf-16le");
Lisp_Object obj = w32_get_watch_object (notifications_desc);
/* notifications_size could be zero when the buffer of
notifications overflowed on the OS level, or when the
directory being watched was itself deleted. Do nothing in
that case. */
if (info_size
&& !NILP (obj) && CONSP (obj))
{
Lisp_Object callback = XCDR (obj);
EVENT_INIT (inev);
while (info_size >= min_size)
{
Lisp_Object utf_16_fn
= make_unibyte_string ((char *)fni->FileName,
fni->FileNameLength);
/* Note: mule-conf is preloaded, so utf-16le must
already be defined at this point. */
Lisp_Object fname
= code_convert_string_norecord (utf_16_fn, cs, 0);
Lisp_Object action = lispy_file_action (fni->Action);
inev.kind = FILE_NOTIFY_EVENT;
inev.code = (ptrdiff_t)XINT (XIL ((EMACS_INT)notifications_desc));
inev.timestamp = GetTickCount ();
inev.modifiers = 0;
inev.frame_or_window = callback;
inev.arg = Fcons (action, fname);
kbd_buffer_store_event_hold (&inev, hold_quit);
if (!fni->NextEntryOffset)
break;
p += fni->NextEntryOffset;
fni = (PFILE_NOTIFY_INFORMATION)p;
info_size -= fni->NextEntryOffset;
}
}
notification_buffer_in_use = 0;
}
leave_crit ();
return nevents;
}
static int
do_mouse_event (MOUSE_EVENT_RECORD *event,
struct input_event *emacs_ev)
{
static DWORD button_state = 0;
static Lisp_Object last_mouse_window;
DWORD but_change, mask;
int i;
if (event->dwEventFlags == MOUSE_MOVED)
{
FRAME_PTR f = SELECTED_FRAME ();
Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
int mx = event->dwMousePosition.X, my = event->dwMousePosition.Y;
mouse_moved_to (mx, my);
if (f->mouse_moved)
{
if (hlinfo->mouse_face_hidden)
{
hlinfo->mouse_face_hidden = 0;
clear_mouse_face (hlinfo);
}
/* Generate SELECT_WINDOW_EVENTs when needed. */
if (!NILP (Vmouse_autoselect_window))
{
Lisp_Object mouse_window = window_from_coordinates (f, mx, my,
0, 0);
/* A window will be selected only when it is not
selected now, and the last mouse movement event was
not in it. A minibuffer window will be selected iff
it is active. */
if (WINDOWP (mouse_window)
&& !EQ (mouse_window, last_mouse_window)
&& !EQ (mouse_window, selected_window))
{
struct input_event event;
EVENT_INIT (event);
event.kind = SELECT_WINDOW_EVENT;
event.frame_or_window = mouse_window;
event.arg = Qnil;
event.timestamp = movement_time;
kbd_buffer_store_event (&event);
}
last_mouse_window = mouse_window;
}
else
last_mouse_window = Qnil;
previous_help_echo_string = help_echo_string;
help_echo_string = help_echo_object = help_echo_window = Qnil;
help_echo_pos = -1;
note_mouse_highlight (f, mx, my);
/* If the contents of the global variable help_echo has
changed (inside note_mouse_highlight), generate a HELP_EVENT. */
if (!NILP (help_echo_string) || !NILP (previous_help_echo_string))
gen_help_event (help_echo_string, selected_frame, help_echo_window,
help_echo_object, help_echo_pos);
}
return 0;
}
/* It looks like the console code sends us a mouse event with
dwButtonState == 0 when a window is activated. Ignore this case. */
if (event->dwButtonState == button_state)
return 0;
emacs_ev->kind = MOUSE_CLICK_EVENT;
/* Find out what button has changed state since the last button event. */
but_change = button_state ^ event->dwButtonState;
mask = 1;
for (i = 0; mask; i++, mask <<= 1)
if (but_change & mask)
{
if (i < NUM_TRANSLATED_MOUSE_BUTTONS)
emacs_ev->code = emacs_button_translation[i];
else
emacs_ev->code = i;
break;
}
button_state = event->dwButtonState;
emacs_ev->timestamp = GetTickCount ();
emacs_ev->modifiers = w32_kbd_mods_to_emacs (event->dwControlKeyState, 0) |
((event->dwButtonState & mask) ? down_modifier : up_modifier);
XSETFASTINT (emacs_ev->x, event->dwMousePosition.X);
XSETFASTINT (emacs_ev->y, event->dwMousePosition.Y);
/* for Mule 2.2 (Based on Emacs 19.28 */
#ifdef MULE
XSET (emacs_ev->frame_or_window, Lisp_Frame, get_frame ());
#else
XSETFRAME (emacs_ev->frame_or_window, get_frame ());
#endif
return 1;
}
static int
do_mouse_event (MOUSE_EVENT_RECORD *event,
struct input_event *emacs_ev)
{
static DWORD button_state = 0;
static Lisp_Object last_mouse_window;
DWORD but_change, mask, flags = event->dwEventFlags;
int i;
switch (flags)
{
case MOUSE_MOVED:
{
struct frame *f = get_frame ();
Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
int mx = event->dwMousePosition.X, my = event->dwMousePosition.Y;
mouse_moved_to (mx, my);
if (f->mouse_moved)
{
if (hlinfo->mouse_face_hidden)
{
hlinfo->mouse_face_hidden = 0;
clear_mouse_face (hlinfo);
}
/* Generate SELECT_WINDOW_EVENTs when needed. */
if (!NILP (Vmouse_autoselect_window))
{
Lisp_Object mouse_window = window_from_coordinates (f, mx, my,
0, 0);
/* A window will be selected only when it is not
selected now, and the last mouse movement event was
not in it. A minibuffer window will be selected iff
it is active. */
if (WINDOWP (mouse_window)
&& !EQ (mouse_window, last_mouse_window)
&& !EQ (mouse_window, selected_window))
{
struct input_event event;
EVENT_INIT (event);
event.kind = SELECT_WINDOW_EVENT;
event.frame_or_window = mouse_window;
event.arg = Qnil;
event.timestamp = movement_time;
kbd_buffer_store_event (&event);
}
last_mouse_window = mouse_window;
}
else
last_mouse_window = Qnil;
previous_help_echo_string = help_echo_string;
help_echo_string = help_echo_object = help_echo_window = Qnil;
help_echo_pos = -1;
note_mouse_highlight (f, mx, my);
/* If the contents of the global variable help_echo has
changed (inside note_mouse_highlight), generate a HELP_EVENT. */
if (!NILP (help_echo_string) || !NILP (previous_help_echo_string))
gen_help_event (help_echo_string, selected_frame,
help_echo_window, help_echo_object,
help_echo_pos);
}
/* We already called kbd_buffer_store_event, so indicate the
the caller it shouldn't. */
return 0;
}
case MOUSE_WHEELED:
case MOUSE_HWHEELED:
{
struct frame *f = get_frame ();
int mx = event->dwMousePosition.X, my = event->dwMousePosition.Y;
bool down_p = (event->dwButtonState & 0x10000000) != 0;
emacs_ev->kind =
flags == MOUSE_HWHEELED ? HORIZ_WHEEL_EVENT : WHEEL_EVENT;
emacs_ev->code = 0;
emacs_ev->modifiers = down_p ? down_modifier : up_modifier;
emacs_ev->modifiers |=
w32_kbd_mods_to_emacs (event->dwControlKeyState, 0);
XSETINT (emacs_ev->x, mx);
XSETINT (emacs_ev->y, my);
XSETFRAME (emacs_ev->frame_or_window, f);
emacs_ev->arg = Qnil;
emacs_ev->timestamp = GetTickCount ();
return 1;
}
case DOUBLE_CLICK:
default: /* mouse pressed or released */
/* It looks like the console code sends us a button-release
mouse event with dwButtonState == 0 when a window is
activated and when the mouse is first clicked. Ignore this
case. */
if (event->dwButtonState == button_state)
return 0;
emacs_ev->kind = MOUSE_CLICK_EVENT;
/* Find out what button has changed state since the last button
event. */
but_change = button_state ^ event->dwButtonState;
mask = 1;
for (i = 0; mask; i++, mask <<= 1)
if (but_change & mask)
{
if (i < NUM_TRANSLATED_MOUSE_BUTTONS)
emacs_ev->code = emacs_button_translation[i];
else
emacs_ev->code = i;
break;
}
button_state = event->dwButtonState;
emacs_ev->modifiers =
w32_kbd_mods_to_emacs (event->dwControlKeyState, 0)
| ((event->dwButtonState & mask) ? down_modifier : up_modifier);
XSETFASTINT (emacs_ev->x, event->dwMousePosition.X);
XSETFASTINT (emacs_ev->y, event->dwMousePosition.Y);
XSETFRAME (emacs_ev->frame_or_window, get_frame ());
emacs_ev->arg = Qnil;
emacs_ev->timestamp = GetTickCount ();
return 1;
}
}
void
menubar_selection_callback (struct frame *f, void * client_data)
{
Lisp_Object prefix, entry;
Lisp_Object vector;
Lisp_Object *subprefix_stack;
int submenu_depth = 0;
int i;
if (!f)
return;
entry = Qnil;
subprefix_stack = (Lisp_Object *) alloca (f->menu_bar_items_used * word_size);
vector = f->menu_bar_vector;
prefix = Qnil;
i = 0;
while (i < f->menu_bar_items_used)
{
if (EQ (AREF (vector, i), Qnil))
{
subprefix_stack[submenu_depth++] = prefix;
prefix = entry;
i++;
}
else if (EQ (AREF (vector, i), Qlambda))
{
prefix = subprefix_stack[--submenu_depth];
i++;
}
else if (EQ (AREF (vector, i), Qt))
{
prefix = AREF (vector, i + MENU_ITEMS_PANE_PREFIX);
i += MENU_ITEMS_PANE_LENGTH;
}
else
{
entry = AREF (vector, i + MENU_ITEMS_ITEM_VALUE);
/* The UINT_PTR cast avoids a warning. There's no problem
as long as pointers have enough bits to hold small integers. */
if ((int) (UINT_PTR) client_data == i)
{
int j;
struct input_event buf;
Lisp_Object frame;
EVENT_INIT (buf);
XSETFRAME (frame, f);
buf.kind = MENU_BAR_EVENT;
buf.frame_or_window = frame;
buf.arg = frame;
kbd_buffer_store_event (&buf);
for (j = 0; j < submenu_depth; j++)
if (!NILP (subprefix_stack[j]))
{
buf.kind = MENU_BAR_EVENT;
buf.frame_or_window = frame;
buf.arg = subprefix_stack[j];
kbd_buffer_store_event (&buf);
}
if (!NILP (prefix))
{
buf.kind = MENU_BAR_EVENT;
buf.frame_or_window = frame;
buf.arg = prefix;
kbd_buffer_store_event (&buf);
}
buf.kind = MENU_BAR_EVENT;
buf.frame_or_window = frame;
buf.arg = entry;
/* Free memory used by owner-drawn and help-echo strings. */
w32_free_menu_strings (FRAME_W32_WINDOW (f));
kbd_buffer_store_event (&buf);
f->output_data.w32->menubar_active = 0;
return;
}
i += MENU_ITEMS_ITEM_LENGTH;
}
}
/* Free memory used by owner-drawn and help-echo strings. */
w32_free_menu_strings (FRAME_W32_WINDOW (f));
f->output_data.w32->menubar_active = 0;
}
/* This is the callback function for arriving signals from
g_file_monitor. It shall create a Lisp event, and put it into
Emacs input queue. */
static gboolean
dir_monitor_callback (GFileMonitor *monitor,
GFile *file,
GFile *other_file,
GFileMonitorEvent event_type,
gpointer user_data)
{
Lisp_Object symbol, monitor_object, watch_object;
char *name = g_file_get_parse_name (file);
char *oname = other_file ? g_file_get_parse_name (other_file) : NULL;
/* Determine event symbol. */
switch (event_type)
{
case G_FILE_MONITOR_EVENT_CHANGED:
symbol = Qchanged;
break;
case G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT:
symbol = Qchanges_done_hint;
break;
case G_FILE_MONITOR_EVENT_DELETED:
symbol = Qdeleted;
break;
case G_FILE_MONITOR_EVENT_CREATED:
symbol = Qcreated;
break;
case G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED:
symbol = Qattribute_changed;
break;
case G_FILE_MONITOR_EVENT_PRE_UNMOUNT:
symbol = Qpre_unmount;
break;
case G_FILE_MONITOR_EVENT_UNMOUNTED:
symbol = Qunmounted;
break;
case G_FILE_MONITOR_EVENT_MOVED:
symbol = Qmoved;
break;
default:
goto cleanup;
}
/* Determine callback function. */
monitor_object = XIL ((intptr_t) monitor);
eassert (INTEGERP (monitor_object));
watch_object = assq_no_quit (monitor_object, watch_list);
if (CONSP (watch_object))
{
/* Construct an event. */
struct input_event event;
Lisp_Object otail = oname ? list1 (build_string (oname)) : Qnil;
EVENT_INIT (event);
event.kind = FILE_NOTIFY_EVENT;
event.frame_or_window = Qnil;
event.arg = list2 (Fcons (monitor_object,
Fcons (symbol,
Fcons (build_string (name),
otail))),
XCDR (watch_object));
/* Store it into the input event queue. */
kbd_buffer_store_event (&event);
}
/* Cleanup. */
cleanup:
g_free (name);
g_free (oname);
return TRUE;
}
void
find_and_call_menu_selection (FRAME_PTR f, int menu_bar_items_used, Lisp_Object vector, void *client_data)
{
Lisp_Object prefix, entry;
Lisp_Object *subprefix_stack;
int submenu_depth = 0;
int i;
entry = Qnil;
subprefix_stack = (Lisp_Object *) alloca (menu_bar_items_used * sizeof (Lisp_Object));
prefix = Qnil;
i = 0;
while (i < menu_bar_items_used)
{
if (EQ (XVECTOR (vector)->contents[i], Qnil))
{
subprefix_stack[submenu_depth++] = prefix;
prefix = entry;
i++;
}
else if (EQ (XVECTOR (vector)->contents[i], Qlambda))
{
prefix = subprefix_stack[--submenu_depth];
i++;
}
else if (EQ (XVECTOR (vector)->contents[i], Qt))
{
prefix = XVECTOR (vector)->contents[i + MENU_ITEMS_PANE_PREFIX];
i += MENU_ITEMS_PANE_LENGTH;
}
else
{
entry = XVECTOR (vector)->contents[i + MENU_ITEMS_ITEM_VALUE];
/* The EMACS_INT cast avoids a warning. There's no problem
as long as pointers have enough bits to hold small integers. */
if ((int) (EMACS_INT) client_data == i)
{
int j;
struct input_event buf;
Lisp_Object frame;
EVENT_INIT (buf);
XSETFRAME (frame, f);
buf.kind = MENU_BAR_EVENT;
buf.frame_or_window = frame;
buf.arg = frame;
kbd_buffer_store_event (&buf);
for (j = 0; j < submenu_depth; j++)
if (!NILP (subprefix_stack[j]))
{
buf.kind = MENU_BAR_EVENT;
buf.frame_or_window = frame;
buf.arg = subprefix_stack[j];
kbd_buffer_store_event (&buf);
}
if (!NILP (prefix))
{
buf.kind = MENU_BAR_EVENT;
buf.frame_or_window = frame;
buf.arg = prefix;
kbd_buffer_store_event (&buf);
}
buf.kind = MENU_BAR_EVENT;
buf.frame_or_window = frame;
buf.arg = entry;
kbd_buffer_store_event (&buf);
return;
}
i += MENU_ITEMS_ITEM_LENGTH;
}
}
}
/* This is the callback function for arriving signals from
g_file_monitor. It shall create a Lisp event, and put it into
Emacs input queue. */
static gboolean
dir_monitor_callback (GFileMonitor *monitor,
GFile *file,
GFile *other_file,
GFileMonitorEvent event_type,
gpointer user_data)
{
Lisp_Object symbol, monitor_object, watch_object, flags;
char *name = g_file_get_parse_name (file);
char *oname = other_file ? g_file_get_parse_name (other_file) : NULL;
/* Determine event symbol. */
switch (event_type)
{
case G_FILE_MONITOR_EVENT_CHANGED:
symbol = Qchanged;
break;
case G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT:
symbol = Qchanges_done_hint;
break;
case G_FILE_MONITOR_EVENT_DELETED:
symbol = Qdeleted;
break;
case G_FILE_MONITOR_EVENT_CREATED:
symbol = Qcreated;
break;
case G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED:
symbol = Qattribute_changed;
break;
case G_FILE_MONITOR_EVENT_PRE_UNMOUNT:
symbol = Qpre_unmount;
break;
case G_FILE_MONITOR_EVENT_UNMOUNTED:
symbol = Qunmounted;
break;
case G_FILE_MONITOR_EVENT_MOVED:
symbol = Qmoved;
break;
default:
goto cleanup;
}
/* Determine callback function. */
monitor_object = make_pointer_integer (monitor);
eassert (INTEGERP (monitor_object));
watch_object = assq_no_quit (monitor_object, watch_list);
if (CONSP (watch_object))
{
struct input_event event;
Lisp_Object otail = oname ? list1 (build_string (oname)) : Qnil;
/* Check, whether event_type is expected. */
flags = XCAR (XCDR (XCDR (watch_object)));
if ((!NILP (Fmember (Qchange, flags)) &&
!NILP (Fmember (symbol, list5 (Qchanged, Qchanges_done_hint,
Qdeleted, Qcreated, Qmoved)))) ||
(!NILP (Fmember (Qattribute_change, flags)) &&
((EQ (symbol, Qattribute_changed)))))
{
/* Construct an event. */
EVENT_INIT (event);
event.kind = FILE_NOTIFY_EVENT;
event.frame_or_window = Qnil;
event.arg = list2 (Fcons (monitor_object,
Fcons (symbol,
Fcons (build_string (name),
otail))),
XCAR (XCDR (XCDR (XCDR (watch_object)))));
/* Store it into the input event queue. */
kbd_buffer_store_event (&event);
// XD_DEBUG_MESSAGE ("%s", XD_OBJECT_TO_STRING (event.arg));
}
/* Cancel monitor if file or directory is deleted. */
if (!NILP (Fmember (symbol, list2 (Qdeleted, Qmoved))) &&
!g_file_monitor_is_cancelled (monitor))
g_file_monitor_cancel (monitor);
}
/* Cleanup. */
cleanup:
g_free (name);
g_free (oname);
return TRUE;
}
int
w32_console_read_socket (struct terminal *terminal,
int expected,
struct input_event *hold_quit)
{
BOOL no_events = TRUE;
int nev, ret = 0, add;
int isdead;
if (interrupt_input_blocked)
{
interrupt_input_pending = 1;
return -1;
}
interrupt_input_pending = 0;
BLOCK_INPUT;
for (;;)
{
nev = fill_queue (0);
if (nev <= 0)
{
/* If nev == -1, there was some kind of error
If nev == 0 then waitp must be zero and no events were available
so return. */
UNBLOCK_INPUT;
return nev;
}
while (nev > 0)
{
struct input_event inev;
EVENT_INIT (inev);
inev.kind = NO_EVENT;
inev.arg = Qnil;
switch (queue_ptr->EventType)
{
case KEY_EVENT:
add = key_event (&queue_ptr->Event.KeyEvent, &inev, &isdead);
if (add == -1) /* 95.7.25 by himi */
{
queue_ptr--;
add = 1;
}
if (add)
kbd_buffer_store_event_hold (&inev, hold_quit);
break;
case MOUSE_EVENT:
add = do_mouse_event (&queue_ptr->Event.MouseEvent, &inev);
if (add)
kbd_buffer_store_event_hold (&inev, hold_quit);
break;
case WINDOW_BUFFER_SIZE_EVENT:
if (w32_use_full_screen_buffer)
resize_event (&queue_ptr->Event.WindowBufferSizeEvent);
break;
case MENU_EVENT:
case FOCUS_EVENT:
/* Internal event types, ignored. */
break;
}
queue_ptr++;
nev--;
}
if (ret > 0 || expected == 0)
break;
}
/* We don't get told about changes in the window size (only the buffer
size, which we no longer care about), so we have to check it
periodically. */
if (!w32_use_full_screen_buffer)
maybe_generate_resize_event ();
UNBLOCK_INPUT;
return ret;
}
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License version 2 for more details.
*
* You should have received a copy of the GNU General Public License
* version 2 along with this program; if not, write to the Free
* Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
* MA 02110-1301, USA.
*
*/
#include <stdio.h>
#include "status.h"
struct event status_changed = EVENT_INIT(status_changed);
static const char *message = "";
static int level = 0;
/*
* Return: current status string
*/
const char* status(void)
{
return message;
}
int status_level(void)
{
int
handle_file_notifications (struct input_event *hold_quit)
{
struct notifications_set *ns = NULL;
int nevents = 0;
int done = 0;
/* We cannot process notification before Emacs is fully initialized,
since we need the UTF-16LE coding-system to be set up. */
if (!initialized)
{
return nevents;
}
while (!done)
{
ns = NULL;
/* Find out if there is a record available in the linked list of
notifications sets. If so, unlink te set from the linked list.
Use the critical section. */
enter_crit ();
if (notifications_set_head->next != notifications_set_head)
{
ns = notifications_set_head->next;
ns->prev->next = ns->next;
ns->next->prev = ns->prev;
}
else
done = 1;
leave_crit();
if (ns)
{
BYTE *p = ns->notifications;
FILE_NOTIFY_INFORMATION *fni = (PFILE_NOTIFY_INFORMATION)p;
const DWORD min_size
= offsetof (FILE_NOTIFY_INFORMATION, FileName) + sizeof(wchar_t);
struct input_event inev;
DWORD info_size = ns->size;
Lisp_Object cs = Qutf_16le;
Lisp_Object obj = w32_get_watch_object (ns->desc);
/* notifications size could be zero when the buffer of
notifications overflowed on the OS level, or when the
directory being watched was itself deleted. Do nothing in
that case. */
if (info_size
&& !NILP (obj) && CONSP (obj))
{
Lisp_Object callback = XCDR (obj);
EVENT_INIT (inev);
while (info_size >= min_size)
{
Lisp_Object utf_16_fn
= make_unibyte_string ((char *)fni->FileName,
fni->FileNameLength);
/* Note: mule-conf is preloaded, so utf-16le must
already be defined at this point. */
Lisp_Object fname
= code_convert_string_norecord (utf_16_fn, cs, 0);
Lisp_Object action = lispy_file_action (fni->Action);
inev.kind = FILE_NOTIFY_EVENT;
inev.timestamp = GetTickCount ();
inev.modifiers = 0;
inev.frame_or_window = callback;
inev.arg = Fcons (action, fname);
inev.arg = list3 (make_pointer_integer (ns->desc),
action, fname);
kbd_buffer_store_event_hold (&inev, hold_quit);
nevents++;
if (!fni->NextEntryOffset)
break;
p += fni->NextEntryOffset;
fni = (PFILE_NOTIFY_INFORMATION)p;
info_size -= fni->NextEntryOffset;
}
}
/* Free this notification set. */
free (ns->notifications);
free (ns);
}
}
return nevents;
}