{

while(!MCquit)

X_main_loop_iteration();

{

if (X_init(p_argc, p_argv, p_envp))

{

r_error_code = 0;

r_error_message = nil;

return;

}

r_error_code = -1;

if (MCValueGetTypeCode(MCresult -> getvalueref()) == kMCValueTypeCodeString)

r_error_message = (MCStringRef)MCValueRetain(MCresult->getvalueref());

{

switch(MCdefaultstackptr->getcard()->message(MCM_shut_down_request))

{

case ES_PASS:

case ES_NOT_HANDLED:

MCdefaultstackptr->getcard()->message(MCM_shut_down);

MCquit = True;

MCexitall = True;

MCtracestackptr = NULL;

MCtraceabort = True;

MCtracereturn = True;

r_terminate = true;

break;

default:

r_terminate = false;

break;

}

{

// FG-2014-09-22: [[ Bugfix 13480 ]] May have no default stack on startup

if (MCdefaultstackptr)

MCdefaultstackptr -> getcard() -> message(MCM_suspend);

MCappisactive = False;

{

// FG-2014-09-22: [[ Bugfix 13480 ]] May have no default stack on startup

MCappisactive = True;

if (MCdefaultstackptr)

MCdefaultstackptr -> getcard() -> message(MCM_resume);

{

X_main_loop_iteration();

r_continue = !MCquit;

{

// IM-2014-01-28: [[ HiDPI ]] Use updatedisplayinfo() method to update & compare display details

bool t_changed;

t_changed = false;

MCscreen->updatedisplayinfo(t_changed);

// Post a desktop changed message.

MCscreen -> delaymessage(MCdefaultstackptr -> getcurcard(), MCM_desktop_changed);

{

MCStack *t_stack;

t_stack = MCdispatcher -> findstackd(p_window);

if (t_stack == nil)

return;

else

{

t_stack -> kunfocus();

t_stack -> close();

t_stack -> checkdestroy();

}

{

MCStack *t_stack;

t_stack = MCdispatcher -> findstackd(p_window);

if (t_stack == nil)

return;

// Handle any cancelled popup menus.

MCdispatcher -> closemenus();

// Now make sure the stack is indeed closed, it might be a transient.

if (t_stack -> getopened() != 0)

{

t_stack -> kunfocus();

t_stack -> close();

t_stack -> checkdestroy();

}

{

MCStack *t_stack;

t_stack = MCdispatcher -> findstackd(p_window);

if (t_stack == nil)

{

r_wanted_size = p_proposed_size;

return;

}

t_stack -> constrain(p_proposed_size, r_wanted_size);

{

if (((MCScreenDC *)MCscreen) -> isbackdrop(p_window))

{

((MCScreenDC *)MCscreen) -> redrawbackdrop(p_surface, p_region);

return;

}

MCdispatcher -> wredraw(p_window, p_surface, p_region);

{

MCStack *t_stack;

t_stack = MCdispatcher -> findstackd(p_window);

if (t_stack == nil)

return;

if (p_view_id == 0)

t_stack -> getcard() -> kfocus();

else

{

MCControl *t_control;

MCAutoStringRef t_id;

/* UNCHECKED */ MCStringFormat(&t_id, "%d", p_view_id);

t_control = t_stack -> getcard() -> getchild(CT_ID, *t_id, CT_LAYER, CT_UNDEFINED);

if (t_control != nil)

t_stack -> kfocusset(t_control);

else

t_stack -> getcard() -> kunfocus();

}

{

MCStack *t_stack;

t_stack = MCdispatcher -> findstackd(p_window);

if (t_stack == nil)

return;

if (t_stack != MCmousestackptr)

{

MCmousestackptr = t_stack;

MCmousestackptr -> enter();

}

// MW-2014-06-23: [[ Bug 12670 ]] This shouldn't be necessary as mouseEnter

// is followed immediately by a mouseMove after the mouseLoc has been

// updated.

/*MCObject *t_menu;

{

MCStack *t_stack;

t_stack = MCdispatcher -> findstackd(p_window);

if (t_stack == nil)

return;

if (t_stack == MCmousestackptr)

{

MCmousestackptr -> munfocus();

MCmousestackptr = nil;

}

{

MCStack *t_stack;

t_stack = MCdispatcher -> findstackd(p_window);

if (t_stack == nil)

return;

MCObject *t_menu;

t_menu = MCdispatcher -> getmenu();

if (MCmousestackptr == t_stack || t_menu != nil)

{

MCeventtime = MCPlatformGetEventTime();

MCObject *t_target;

t_target = t_menu != nil ? t_menu : MCmousestackptr;

// IM-2014-02-12: [[ StackScale ]] mfocus will translate target stack to menu stack coords

// so in both cases we pass target stack coords.

// IM-2014-02-14: [[ StackScale ]] Don't try to convert if target is null

MCPoint t_mouseloc;

if (t_stack != nil)

t_mouseloc = t_stack->windowtostackloc(p_location);

MCmousex = t_mouseloc.x;

MCmousey = t_mouseloc.y;

//MCLog("MouseMove(%p, %d, %d)", t_target, t_mouseloc . x, t_mouseloc . y);

t_target -> mfocus(t_mouseloc . x, t_mouseloc . y);

}

{

if (((MCScreenDC *)MCscreen) -> isbackdrop(p_window))

{

((MCScreenDC *)MCscreen) -> mousedowninbackdrop(p_button, p_count);

return;

}

MCStack *t_stack;

t_stack = MCdispatcher -> findstackd(p_window);

if (t_stack == nil)

return;

MCObject *t_menu;

t_menu = MCdispatcher -> getmenu();

if (MCmousestackptr == t_stack || t_menu != nil)

{

MCbuttonstate |= (1 << p_button);

MCeventtime = MCPlatformGetEventTime();

MCclicklocx = MCmousex;

MCclicklocy = MCmousey;

MCclickstackptr = MCmousestackptr;

MCObject *t_target;

t_target = t_menu != nil ? t_menu : MCclickstackptr;

tripleclick = p_count == 2;

//MCLog("MouseDown(%p, %d, %d)", t_target, p_button, p_count);

if (p_count != 1)

{

if (p_count == 0 && !MCdispatcher -> isdragsource())

{

MCallowabledragactions = DRAG_ACTION_COPY;

MCdragaction = DRAG_ACTION_NONE;

MCdragimageid = 0;

MCdragimageoffset . x = 0;

MCdragimageoffset . y = 0;

MCdragboard->Clear();

}

t_target -> mdown(p_button + 1);

}

else

t_target -> doubledown(p_button + 1);

}

{

if (((MCScreenDC *)MCscreen) -> isbackdrop(p_window))

{

((MCScreenDC *)MCscreen) -> mouseupinbackdrop(p_button, p_count);

return;

}

MCStack *t_stack;

t_stack = MCdispatcher -> findstackd(p_window);

if (t_stack == nil)

return;

MCObject *t_menu;

t_menu = MCdispatcher -> getmenu();

if (MCmousestackptr == t_stack || t_menu != nil)

{

MCbuttonstate &= ~(1 << p_button);

MCeventtime = MCPlatformGetEventTime();

// PM-2015-03-30: [[ Bug 15091 ]] When we "go to card X" on mouseDown, MCclickstackptr becomes nil because of MCStack::close().

if (MCclickstackptr == nil)

MCclickstackptr = MCmousestackptr;

MCObject *t_target;

t_target = t_menu != nil ? t_menu : MCclickstackptr;

//MCLog("MouseUp(%p, %d, %d)", t_target, p_button, p_count);

if (p_count != 1)

t_target -> mup(p_button + 1, false);

else

t_target -> doubleup(p_button + 1);

}

{

if (((MCScreenDC *)MCscreen) -> isbackdrop(p_window))

{

((MCScreenDC *)MCscreen) -> mousereleaseinbackdrop(p_button);

return;

}

MCStack *t_stack;

t_stack = MCdispatcher -> findstackd(p_window);

if (t_stack == nil)

return;

MCObject *t_menu;

t_menu = MCdispatcher -> getmenu();

if (MCmousestackptr == t_stack || t_menu != nil)

{

tripleclick = False;

MCbuttonstate &= ~(1 << p_button);

// If the press was 'released' i.e. cancelled then we stop messages, mup then

// dispatch a mouseRelease message ourselves.

// FG-2013-10-09 [[ Bugfix 11208 ]]

// CS_NO_MESSAGES only applies to the target and not the controls it contains

// so the mouse up message (on mouseUp) gets sent when it isn't desired

// Hopefully nobody depends on the old behaviour...

// FG-2014-06-27 [[ Bugfix 12705 ]]

// Turns out that sending a release message directly to the stack won't

// work because it will never get delivered to the control with mouse

// focus. Instead, the mup handler has been changed to accept a second

// parameter that, when true, indicates that this is a release event.

MCObject *t_target;

t_target = t_menu != nil ? t_menu : MCclickstackptr;

// MW-2014-06-11: [[ Bug 12339 ]] Only send a mouseRelease message if this wasn't the result of a popup menu.

if (!p_was_menu)

t_target -> mup(p_button + 1, true);

else

{

bool old_lock = MClockmessages;

MClockmessages = true;

t_target -> mup(p_button + 1, true);

MClockmessages = old_lock;

}

//MCLog("MouseRelease(%p, %d)", t_target, p_button);

}

{

MCStack *t_stack;

t_stack = MCdispatcher -> findstackd(p_window);

if (t_stack == nil)

return;

if (MCmousestackptr != t_stack)

return;

MCObject *mfocused;

mfocused = MCmousestackptr->getcard()->getmfocused();

if (mfocused == NULL)

mfocused = MCmousestackptr -> getcard();

if (mfocused == NULL)

mfocused = MCmousestackptr;

if (p_dy != 0)

mfocused -> kdown(kMCEmptyString, p_dy < 0 ? XK_WheelUp : XK_WheelDown);

mfocused = MCmousestackptr->getcard()->getmfocused();

if (mfocused == NULL)

mfocused = MCmousestackptr -> getcard();

if (mfocused == NULL)

mfocused = MCmousestackptr;

if (p_dx != 0)

mfocused -> kdown(kMCEmptyString, p_dx < 0 ? XK_WheelLeft : XK_WheelRight);

{

switch(p_action)

{

case DRAG_ACTION_NONE:

return kMCPlatformDragOperationNone;

case DRAG_ACTION_MOVE:

return kMCPlatformDragOperationMove;

case DRAG_ACTION_COPY:

return kMCPlatformDragOperationCopy;

case DRAG_ACTION_LINK:

return kMCPlatformDragOperationLink;

}

assert(false);

return kMCPlatformDragOperationNone;

{

// On some platforms (Mac and iOS), the drag board used for drag-and-drop

// operations may not be the main drag board. If a non-NULL clipboard was

// supplied for this operation, tell the engine drag board to re-bind to it.

if (p_dragboard != NULL)

MCdragboard->Rebind(p_dragboard);

MCdispatcher->wmdragenter(p_window);

r_operation = dragaction_to_dragoperation(MCdragaction);

{

MCdispatcher -> wmdragmove(p_window, p_location . x, p_location . y);

r_operation = dragaction_to_dragoperation(MCdragaction);

{

// On some platforms (Mac and iOS), the drag board used for drag-and-drop

// operations may not be the main drag board. Reset the drag board back to

// the main one after the drag has left.

MCAutoRefcounted<MCRawClipboard> t_dragboard(MCRawClipboard::CreateSystemDragboard());

MCdragboard->Rebind(t_dragboard);

MCdispatcher -> wmdragleave(p_window);

{

MCdispatcher -> wmdragdrop(p_window);

// PLATFORM-TODO: Should we do more than this? i.e. Should the dragDrop

// message be able to signal refusal?

r_accepted = true;

{

MCPlatformKeyCode key_code;

codepoint_t mapped_codepoint;

codepoint_t unmapped_codepoint;

bool needs_mapping;

struct MCKeyMessage* next;

{

MCKeyMessage *t_next;

t_next = p_message_queue;

while (t_next != nil)

{

p_message_queue = p_message_queue -> next;

delete t_next;

t_next = p_message_queue;

}

p_message_queue = nil;

{

MCKeyMessage *t_new;

t_new = new MCKeyMessage;

t_new -> key_code = p_key_code;

t_new -> mapped_codepoint = p_mapped_codepoint;

t_new -> unmapped_codepoint = p_unmapped_codepoint;

t_new -> needs_mapping = p_needs_mapping;

t_new -> next = nil;

if (p_message_queue != nil)

{

MCKeyMessage *t_ptr;

t_ptr = p_message_queue;

while (t_ptr -> next != nil)

t_ptr = t_ptr -> next;

t_ptr -> next = t_new;

}

else

p_message_queue = t_new;

{

if (p_message_queue)

{

MCKeyMessage *t_old;

t_old = p_message_queue;

p_message_queue = p_message_queue -> next;

delete t_old;

}

{

if (p_mapped_codepoint <= 0xffff)

{

uint16_t t_unicode_char;

char_t t_native_char;

// MW-2014-08-05: [[ Bug 13042 ]] This was a mis-merge from an updated fix to bug 12747

// (the code previously was using unmapped codepoint).

t_unicode_char = p_mapped_codepoint & 0xffff;

if (MCUnicodeMapToNative(&t_unicode_char, 1, t_native_char))

{

/* UNCHECKED */ MCStringCreateWithNativeChars(&t_native_char, 1, r_native_char);

// MW-2014-06-25: [[ Bug 12370 ]] The engine expects keyCode to be the mapped key whenever

// the mapped key is ASCII. If the mapped key is not ASCII then the keyCode reflects

// the raw (US English) keycode.

// SN-2014-12-08: [[ Bug 14067 ]] Avoid to use the native char instead of the key code

// the numeric keypad keys.

if (isascii(t_native_char) && (p_key_code < kMCPlatformKeyCodeKeypadSpace || p_key_code > kMCPlatformKeyCodeKeypadEqual))

r_key_code = t_native_char;

else

r_key_code = p_key_code;

return;

}

// SN-2014-12-05: [[ Bug 14162 ]] We can have unicode chars being typed.

// We keep the given keycode (the codepoint) as the key code in these conditions.

else

{

/* UNCHECKED */ MCStringCreateWithChars(&t_unicode_char, 1, r_native_char);

r_key_code = p_key_code;

return;

}

}

r_native_char = MCValueRetain(kMCEmptyString);

r_key_code = p_key_code;

{

MCmodifierstate = 0;

if ((p_modifiers & kMCPlatformModifierShift) != 0)

MCmodifierstate |= MS_SHIFT;

if ((p_modifiers & kMCPlatformModifierControl) != 0)

MCmodifierstate |= MS_CONTROL;

if ((p_modifiers & kMCPlatformModifierAlt) != 0)

MCmodifierstate |= MS_MOD1;

if ((p_modifiers & kMCPlatformModifierMeta) != 0)

MCmodifierstate |= MS_MOD2;

if ((p_modifiers & kMCPlatformModifierCapsLock) != 0)

MCmodifierstate |= MS_CAPS_LOCK;

{

int32_t si, ei;

// SN-2014-09-15: [[ Bug 13423 ]] Clear the key sequence if needed, then append

// the new key typed.

if (!MCactivefield -> getcompositionrange(si, ei))

MCKeyMessageClear(s_pending_key_down);

MCKeyMessageAppend(s_pending_key_down, p_key_code, p_mapped_codepoint, p_unmapped_codepoint);

{

MCPlatformKeyCode t_mapped_key_code;

MCAutoStringRef t_mapped_char;

map_key_to_engine(p_key_code, p_mapped_codepoint, p_unmapped_codepoint, t_mapped_key_code, &t_mapped_char);

MCdispatcher -> wkdown(p_window, *t_mapped_char, t_mapped_key_code);

// SN-2014-11-03: [[ Bug 13832]] Enqueue the event instead of firing it now (we are still in the NSApplication's keyDown)

MCKeyMessageAppend(s_pending_key_up, p_key_code, p_mapped_codepoint, p_unmapped_codepoint);

{

// SN-2014-10-31: [[ Bug 13832 ]] We now output all the key messages that have been queued

// (by either MCPlatformHandleKeyDown, or MCPlatformHandleTextInputInsertText)

while (s_pending_key_up != nil)

{

MCPlatformKeyCode t_mapped_key_code;

MCAutoStringRef t_mapped_char;

// SN-2015-06-23: [[ Bug 3537 ]] We don't want to map a nativised char -

// but we want to map key strokes like F1 and such

// This is intended to mimic the behaviour of the key down process,

// in which MCDispatcher::wkdown is called with the nativised char

if (s_pending_key_up -> needs_mapping)

map_key_to_engine(s_pending_key_up -> key_code, s_pending_key_up -> mapped_codepoint, s_pending_key_up -> unmapped_codepoint, t_mapped_key_code, &t_mapped_char);

else

{

/* UNCHECKED */ MCStringCreateWithNativeChars((const char_t*)&(s_pending_key_up -> mapped_codepoint), 1, &t_mapped_char);

t_mapped_key_code = s_pending_key_up -> key_code;

}

MCdispatcher -> wkup(p_window, *t_mapped_char, t_mapped_key_code);

MCKeyMessageNext(s_pending_key_up);

}

{

if (MCactivefield == nil)

{

r_marked_range = MCRangeMake(UINDEX_MAX, 0);

r_selected_range = MCRangeMake(UINDEX_MAX, 0);

return;

}

int4 si, ei;

MCactivefield -> selectedmark(False, si, ei, False);

MCactivefield -> unresolvechars(0, si, ei);

r_selected_range = MCRangeMake(si, ei - si);

if (MCactivefield -> getcompositionrange(si, ei))

{

MCactivefield -> unresolvechars(0, si, ei);

r_marked_range = MCRangeMake(si, ei - si);

}

else

r_marked_range = MCRangeMake(UINDEX_MAX, 0);

{

if (MCactivefield == nil)

{

r_index = 0;

return;

}

MCPoint t_location;

t_location = MCactivefield -> getstack() -> windowtostackloc(p_location);

int32_t si, ei;

if (MCactivefield -> locmarkpoint(p_location, False, False, False, False, si, ei))

MCactivefield -> unresolvechars(0, si, ei);

else

si = 0;

r_index = si;

{

if (MCactivefield == nil)

{

r_first_line_rect = MCRectangleMake(0, 0, 0, 0);

r_actual_range = MCRangeMake(UINDEX_MAX, 0);

return;

}

int32_t t_si, t_ei;

t_si = 0;

t_ei = INT32_MAX;

MCactivefield -> resolvechars(0, t_si, t_ei, p_range . offset, p_range . length);

MCRectangle t_rect;

t_rect = MCactivefield -> firstRectForCharacterRange(t_si, t_ei);

MCactivefield -> unresolvechars(0, t_si, t_ei);

MCPoint t_top_left, t_bottom_right;

t_top_left = MCactivefield -> getstack() -> stacktowindowloc(MCPointMake(t_rect . x, t_rect . y));

t_bottom_right = MCactivefield -> getstack() -> stacktowindowloc(MCPointMake(t_rect . x + t_rect . width, t_rect . y + t_rect . height));

r_first_line_rect = MCRectangleMake(t_top_left . x, t_top_left . y, t_bottom_right . x - t_top_left . x, t_bottom_right . y - t_top_left . y);

r_actual_range = MCRangeMake(t_si, t_ei - t_si);

{

if (MCactivefield == nil)

{

r_chars = nil;

r_char_count = 0;

r_actual_range = MCRangeMake(p_range . offset, 0);

return;

}

int32_t t_si, t_ei;

MCAutoStringRef t_text;

t_si = 0;

t_ei = INT32_MAX;

MCactivefield -> resolvechars(0, t_si, t_ei, p_range . offset, p_range . length);

MCactivefield -> exportastext(0, t_si, t_ei, &t_text);

MCactivefield -> unresolvechars(0, t_si, t_ei);

/* UNCHECKED */ MCStringConvertToUnicode(*t_text, r_chars, r_char_count);

r_actual_range = MCRangeMake(t_si, t_ei - t_si);

{

if (MCactivefield == nil)

return;

// SN-2014-12-04: [[ Bug 14152 ]] Locking the screen here doesn't allow the screen to refresh after

// text input, inside an MCWait loop

int32_t t_r_si, t_r_ei;

t_r_si = 0;

t_r_ei = INT32_MAX;

MCactivefield -> resolvechars(0, t_r_si, t_r_ei, p_replace_range . offset, p_replace_range . length);

// SN-2014-09-15: [[ Bug 13423 ]] t_was_compositing now used further in the function

bool t_was_compositing;

t_was_compositing = false;

if (!p_mark)

{

// MW-2014-08-05: [[ Bug 13098 ]] If we have been compositing, then don't synthesise a

// keyDown / keyUp.

int4 si, ei;

if (MCactivefield -> getcompositionrange(si, ei))

{

if (si < t_r_si)

t_r_si -= MCMin(t_r_si - si, ei - si);

if (si < t_r_ei)

t_r_ei -= MCMin(t_r_ei - si, ei - si);

MCactivefield -> stopcomposition(True, False);

t_was_compositing = true;

}

else

t_was_compositing = false;

// If the char count is 1 and the replacement range matches the current selection,

// the char is native and the requested selection is after the char, then synthesis a

// keydown/up pair.

// MW-2014-06-25: [[ Bug 12370 ]] If the char is ascii then map appropriately so we get

// the keycodes the engine expects.

char_t t_char;

if (!t_was_compositing &&

p_char_count == 1 &&

MCUnicodeMapToNative(p_chars, 1, t_char) &&

p_selection_range . offset == p_replace_range . offset + 1 &&

p_selection_range . length == 0)

{

int32_t t_s_si, t_s_ei;

MCactivefield -> selectedmark(False, t_s_si, t_s_ei, False);

if (t_s_si == t_r_si &&

t_s_ei == t_r_ei)

{

// SN-2014-09-15: [[ Bug 13423 ]] Send the messages for all the characters typed

while (s_pending_key_down != nil)

{

// MW-2014-04-15: [[ Bug 12086 ]] Pass the keycode from the last event that was

// passed to the IME.

MCAutoStringRef t_mapped_char;

MCPlatformKeyCode t_mapped_key_code;

map_key_to_engine(s_pending_key_down -> key_code, s_pending_key_down -> mapped_codepoint, s_pending_key_down -> unmapped_codepoint, t_mapped_key_code, &t_mapped_char);

// SN-2014-11-03: [[ Bug 13832 ]] Enqueue the event, instead of firing it now (we are still in the NSApplication's keyDown).

// PM-2015-05-15: [[ Bug 15372]] call MCKeyMessageAppend before wkdown to prevent a crash if 'wait with messages' is used (since s_pending_key_down might become nil after wkdown

MCKeyMessageAppend(s_pending_key_up, s_pending_key_down -> key_code, s_pending_key_down -> mapped_codepoint, s_pending_key_down -> unmapped_codepoint);

MCdispatcher -> wkdown(p_window, *t_mapped_char, t_mapped_key_code);

MCKeyMessageNext(s_pending_key_down);

}

return;

}

}

}

else

{

if (p_char_count == 0)

MCactivefield -> stopcomposition(True, False);

else

{

int4 si, ei;

if (MCactivefield -> getcompositionrange(si, ei))

{

if (si < t_r_si)

t_r_si -= MCMin(t_r_si - si, ei - si);

if (si < t_r_ei)

t_r_ei -= MCMin(t_r_ei - si, ei - si);

MCactivefield -> stopcomposition(True, False);

}

}

}

// SN-2014-09-14: [[ Bug 13423 ]] MCPlatformHandleRawKeyDown gets the US mac layout key, without any modifier included.

// We need to update the elements:

// if the key pressed leads to an actual char:

// this wrong key is replaced by this new 'combined' char

// if the key pressed fails to generate a char:

// this wrong key is replaced by the dead-key char

// SN-2015-04-10: [[ Bug 14205 ]] When using the dictation, there is no

// pending key down, but the composition was still on though.

// SN-2015-06-23: [[ Bug 3537 ]] We should not cast p_char as a uint1 if it

// is not a native char.

uint1 t_char[2];

bool t_is_native_char;

t_is_native_char = MCUnicodeMapToNative(p_chars, 1, t_char[0]);

t_char[1] = 0;

if (t_was_compositing && s_pending_key_down && t_is_native_char)

{

s_pending_key_down -> key_code = (uint1)*t_char;

s_pending_key_down -> mapped_codepoint = (uint1)*t_char;

s_pending_key_down -> unmapped_codepoint = (uint1)*t_char;

// SN-2015-05-18: [[ Bug 15385 ]] Enqueue the first char in the sequence

// here - that will be the same as keyDown.

// SN-2015-06-23: [[ Bug 3537 ]] In this only case, we don't want this

// nativised char to be mapped again in MCPlatformHandleKeyUp.

MCKeyMessageAppend(s_pending_key_up, (uint1)*t_char, (uint1)*t_char, (uint1)*t_char, false);

}

// Set the text.

MCactivefield -> seltext(t_r_si, t_r_ei, False);

if (p_mark)

MCactivefield -> startcomposition();

// SN-2014-09-15: [[ Bug 13423 ]] If the character typed is not Unicode and follows a dead key character, then we send

// [Raw]KeyDown/Up and remove the first character from the sequence of keys typed.

// If the character successfully combined with the dead char before it in a native char, we don't use finsert

// Otherwise, we have the dead char in p_chars, we need to remove the one stored first in the sequence

MCAutoStringRef t_string;

// SN-2015-01-20: [[ Bug 14406 ]] If we have a series of pending keys, we have two possibilities:

// - typing IME characters: the characters are native, so we use the finsertnew

// - typing dead characters: the character, if we arrive here, is > 127

// SN-2015-04-13: [[ Bug 14205 ]] Ensure that s_pending_key_down is not nil

if (*p_chars > 127 && s_pending_key_down && s_pending_key_down -> next

&& t_is_native_char)

{

MCStringCreateWithNativeChars((const char_t *)t_char, 1, &t_string);

MCdispatcher -> wkdown(p_window, *t_string, *t_char);

MCKeyMessageNext(s_pending_key_down);

}

else

{

MCStringCreateWithChars(p_chars, p_char_count, &t_string);

// SN-2014-12-05: [[ Bug 14162 ]] In case the character is a Unicode alphanumeric char,

// then that's not a combining char - and it deserves its (raw)Key(Down|Up) messages

uint32_t t_codepoint;

t_codepoint = MCStringGetCodepointAtIndex(*t_string, 0);