static int
do_mouse_event (MOUSE_EVENT_RECORD *event,
struct input_event *emacs_ev)
{
static DWORD button_state = 0;
DWORD but_change, mask;
int i;
if (event->dwEventFlags == MOUSE_MOVED)
{
/* For movement events we just note that the mouse has moved
so that emacs will generate drag events. */
mouse_moved_to (event->dwMousePosition.X, event->dwMousePosition.Y);
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;
}
void
record_insert (ptrdiff_t beg, ptrdiff_t length)
{
Lisp_Object lbeg, lend;
if (EQ (BVAR (current_buffer, undo_list), Qt))
return;
record_point (beg);
/* If this is following another insertion and consecutive with it
in the buffer, combine the two. */
if (CONSP (BVAR (current_buffer, undo_list)))
{
Lisp_Object elt;
elt = XCAR (BVAR (current_buffer, undo_list));
if (CONSP (elt)
&& INTEGERP (XCAR (elt))
&& INTEGERP (XCDR (elt))
&& XINT (XCDR (elt)) == beg)
{
XSETCDR (elt, make_number (beg + length));
return;
}
}
XSETFASTINT (lbeg, beg);
XSETINT (lend, beg + length);
bset_undo_list (current_buffer,
Fcons (Fcons (lbeg, lend), BVAR (current_buffer, undo_list)));
}
void
record_delete (ptrdiff_t beg, Lisp_Object string, bool record_markers)
{
Lisp_Object sbeg;
if (EQ (BVAR (current_buffer, undo_list), Qt))
return;
if (PT == beg + SCHARS (string))
{
XSETINT (sbeg, -beg);
record_point (PT);
}
else
{
XSETFASTINT (sbeg, beg);
record_point (beg);
}
/* primitive-undo assumes marker adjustments are recorded
immediately before the deletion is recorded. See bug 16818
discussion. */
if (record_markers)
record_marker_adjustments (beg, beg + SCHARS (string));
bset_undo_list
(current_buffer,
Fcons (Fcons (string, sbeg), BVAR (current_buffer, undo_list)));
}
void
record_delete (EMACS_INT beg, Lisp_Object string)
{
Lisp_Object sbeg;
if (EQ (BVAR (current_buffer, undo_list), Qt))
return;
if (PT == beg + SCHARS (string))
{
XSETINT (sbeg, -beg);
record_point (PT);
}
else
{
XSETFASTINT (sbeg, beg);
record_point (beg);
}
BVAR (current_buffer, undo_list)
= Fcons (Fcons (string, sbeg), BVAR (current_buffer, undo_list));
}
static Lisp_Object
move_point (Lisp_Object n, bool forward)
{
EMACS_INT new_point;
if (NILP (n))
XSETFASTINT (n, 1);
new_point = PT + (forward ? XINT(n) : - XINT(n));
if (new_point < BEGV)
{
SET_PT (BEGV);
//xsignal0
}
if (new_point > ZV)
{
SET_PT (ZV);
//xsignal0
}
SET_PT (new_point);
return Qnil;
}
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;
}
}
static Lisp_Object
casify_object (enum case_action flag, Lisp_Object obj)
{
register int c, c1;
register int inword = flag == CASE_DOWN;
/* If the case table is flagged as modified, rescan it. */
if (NILP (XCHAR_TABLE (BVAR (current_buffer, downcase_table))->extras[1]))
Fset_case_table (BVAR (current_buffer, downcase_table));
if (INTEGERP (obj))
{
int flagbits = (CHAR_ALT | CHAR_SUPER | CHAR_HYPER
| CHAR_SHIFT | CHAR_CTL | CHAR_META);
int flags = XINT (obj) & flagbits;
int multibyte = ! NILP (BVAR (current_buffer, enable_multibyte_characters));
/* If the character has higher bits set
above the flags, return it unchanged.
It is not a real character. */
if ((unsigned) XFASTINT (obj) > (unsigned) flagbits)
return obj;
c1 = XFASTINT (obj) & ~flagbits;
/* FIXME: Even if enable-multibyte-characters is nil, we may
manipulate multibyte chars. This means we have a bug for latin-1
chars since when we receive an int 128-255 we can't tell whether
it's an eight-bit byte or a latin-1 char. */
if (c1 >= 256)
multibyte = 1;
if (! multibyte)
MAKE_CHAR_MULTIBYTE (c1);
c = downcase (c1);
if (inword)
XSETFASTINT (obj, c | flags);
else if (c == (XFASTINT (obj) & ~flagbits))
{
if (! inword)
c = upcase1 (c1);
if (! multibyte)
MAKE_CHAR_UNIBYTE (c);
XSETFASTINT (obj, c | flags);
}
return obj;
}
if (!STRINGP (obj))
wrong_type_argument (Qchar_or_string_p, obj);
else if (!STRING_MULTIBYTE (obj))
{
EMACS_INT i;
EMACS_INT size = SCHARS (obj);
obj = Fcopy_sequence (obj);
for (i = 0; i < size; i++)
{
c = SREF (obj, i);
MAKE_CHAR_MULTIBYTE (c);
c1 = c;
if (inword && flag != CASE_CAPITALIZE_UP)
c = downcase (c);
else if (!uppercasep (c)
&& (!inword || flag != CASE_CAPITALIZE_UP))
c = upcase1 (c1);
if ((int) flag >= (int) CASE_CAPITALIZE)
inword = (SYNTAX (c) == Sword);
if (c != c1)
{
MAKE_CHAR_UNIBYTE (c);
/* If the char can't be converted to a valid byte, just don't
change it. */
if (c >= 0 && c < 256)
SSET (obj, i, c);
}
}
return obj;
}
else
{
EMACS_INT i, i_byte, size = SCHARS (obj);
int len;
USE_SAFE_ALLOCA;
unsigned char *dst, *o;
/* Over-allocate by 12%: this is a minor overhead, but should be
sufficient in 99.999% of the cases to avoid a reallocation. */
EMACS_INT o_size = SBYTES (obj) + SBYTES (obj) / 8 + MAX_MULTIBYTE_LENGTH;
SAFE_ALLOCA (dst, void *, o_size);
o = dst;
for (i = i_byte = 0; i < size; i++, i_byte += len)
{
if ((o - dst) + MAX_MULTIBYTE_LENGTH > o_size)
{ /* Not enough space for the next char: grow the destination. */
unsigned char *old_dst = dst;
o_size += o_size; /* Probably overkill, but extremely rare. */
SAFE_ALLOCA (dst, void *, o_size);
memcpy (dst, old_dst, o - old_dst);
o = dst + (o - old_dst);
}
c = STRING_CHAR_AND_LENGTH (SDATA (obj) + i_byte, len);
if (inword && flag != CASE_CAPITALIZE_UP)
c = downcase (c);
else if (!uppercasep (c)
&& (!inword || flag != CASE_CAPITALIZE_UP))
c = upcase1 (c);
if ((int) flag >= (int) CASE_CAPITALIZE)
inword = (SYNTAX (c) == Sword);
o += CHAR_STRING (c, o);
}
eassert (o - dst <= o_size);
obj = make_multibyte_string ((char *) dst, size, o - dst);
SAFE_FREE ();
return obj;
}
}
