/* Copyright (C) 2003-2013 Runtime Revolution Ltd.

This file is part of LiveCode.

LiveCode is free software; you can redistribute it and/or modify it under

the terms of the GNU General Public License v3 as published by the Free

Software Foundation.

LiveCode is distributed in the hope that it will be useful, but WITHOUT ANY

WARRANTY; without even the implied warranty of MERCHANTABILITY or

FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License

for more details.

You should have received a copy of the GNU General Public License

along with LiveCode. If not see <http://www.gnu.org/licenses/>. */

#include "prefix.h"

#include "globdefs.h"

#include "filedefs.h"

#include "objdefs.h"

#include "parsedef.h"

#include "mcio.h"

//#include "execpt.h"

#include "sellst.h"

#include "util.h"

#include "font.h"

#include "date.h"

#include "dispatch.h"

#include "stack.h"

#include "card.h"

#include "group.h"

#include "cdata.h"

#include "image.h"

#include "button.h"

#include "field.h"

#include "stacklst.h"

#include "undolst.h"

#include "mcerror.h"

#include "param.h"

#include "objectstream.h"

#include "parentscript.h"

#include "mode.h"

#include "globals.h"

#include "mctheme.h"

#include "osspec.h"

#include "redraw.h"

#include "menuparse.h"

#include "objptr.h"

#include "stacksecurity.h"

#include "exec.h"

uint2 MCButton::mnemonicoffset = 2;

MCRectangle MCButton::optionrect = {0, 0, 12, 8};

uint4 MCButton::clicktime;

uint2 MCButton::menubuttonheight = 4;

Boolean MCButton::starthilite;

uint2 MCButton::starttab;

MCImage *MCButton::macrb = NULL;

MCImage *MCButton::macrbtrack = NULL;

MCImage *MCButton::macrbhilite = NULL;

MCImage *MCButton::macrbhilitetrack = NULL;

uint2 MCButton::focusedtab = MAXUINT2;

bool MCmenupoppedup = false;

Keynames MCButton::button_keys[] =

{

{XK_F1, "f1"},

{XK_F2, "f2"},

{XK_F3, "f3"},

{XK_F4, "f4"},

{XK_F5, "f5"},

{XK_F6, "f6"},

{XK_F7, "f7"},

{XK_F8, "f8"},

{XK_F9, "f9"},

{XK_F10, "f10"},

{XK_F11, "f11"},

{XK_L1, "l1"},

{XK_F12, "f12"},

{XK_L2, "l2"},

{XK_F13, "f13"},

{XK_L3, "l3"},

{XK_F14, "f14"},

{XK_L4, "l4"},

{XK_F15, "f15"},

{XK_L5, "l5"},

{XK_F16, "f16"},

{XK_L6, "l6"},

{XK_F17, "f17"},

{XK_L7, "l7"},

{XK_F18, "f18"},

{XK_L8, "l8"},

{XK_F19, "f19"},

{XK_L9, "l9"},

{XK_F20, "f20"},

{XK_L10, "l10"},

{XK_F21, "f21"},

{XK_R1, "r1"},

{XK_F22, "f22"},

{XK_R2, "r2"},

{XK_F23, "f23"},

{XK_R3, "r3"},

{XK_F24, "f24"},

{XK_R4, "r4"},

{XK_F25, "f25"},

{XK_R5, "r5"},

{XK_F26, "f26"},

{XK_R6, "r6"},

{XK_F27, "f27"},

{XK_R7, "r7"},

{XK_F28, "f28"},

{XK_R8, "r8"},

{XK_F29, "f29"},

{XK_R9, "r9"},

{XK_F30, "f30"},

{XK_R10, "r10"},

{XK_F31, "f31"},

{XK_R11, "r11"},

{XK_F32, "f32"},

{XK_R12, "r12"},

{XK_R13, "r13"},

{XK_F33, "f33"},

{XK_F34, "f34"},

{XK_R14, "r14"},

{XK_F35, "f35"},

{XK_R15, "r15"},

{XK_BackSpace, "backspace"},

{XK_Tab, "tab"},

{XK_Linefeed, "linefeed"},

{XK_Clear, "clear"},

{XK_Return, "return"},

{XK_Pause, "pause"},

{XK_Scroll_Lock, "scroll_lock"},

{XK_Sys_Req, "sys_req"},

{XK_Escape, "escape"},

{XK_Delete, "delete"},

{XK_Home, "home"},

{XK_Left, "left"},

{XK_Up, "up"},

{XK_Right, "right"},

{XK_Down, "down"},

{XK_End, "end"},

{XK_Prior, "page_up"},

{XK_Prior, "pgup"},

{XK_Next, "page_down"},

{XK_Next, "pgdown"},

{XK_Begin, "begin"},

{XK_Select, "select"},

{XK_Print, "print"},

{XK_Execute, "execute"},

{XK_Insert, "insert"},

{XK_Undo, "undo"},

{XK_Redo, "redo"},

{XK_Menu, "menu"},

{XK_Find, "find"},

{XK_Cancel, "cancel"},

{XK_Break, "break"},

{XK_Mode_switch, "mode_switch"},

{XK_script_switch, "script_switch"},

{XK_Num_Lock, "num_lock"},

{XK_osfHelp, "help"},

{XK_KP_Space, "kp_space"},

{XK_KP_Tab, "kp_tab"},

{XK_KP_Enter, "kp_enter"},

{XK_KP_Enter, "enter"},

{XK_KP_F1, "kp_f1"},

{XK_KP_F2, "kp_f2"},

{XK_KP_F3, "kp_f3"},

{XK_KP_F4, "kp_f4"},

{XK_KP_Begin, "kp_begin"},

{XK_KP_Home, "kp_home"},

{XK_KP_Left, "kp_left"},

{XK_KP_Up, "kp_up"},

{XK_KP_Right, "kp_right"},

{XK_KP_Down, "kp_down"},

{XK_KP_End, "kp_end"},

{XK_KP_Insert, "kp_insert"},

{XK_KP_Delete, "kp_delete"},

{XK_KP_Prior, "kp_page_up"},

{XK_KP_Next, "kp_page_down"},

{XK_KP_Equal, "kp_equal"},

{XK_KP_Multiply, "kp_multiply"},

{XK_KP_Add, "kp_add"},

{XK_KP_Separator, "kp_separator"},

{XK_KP_Subtract, "kp_subtract"},

{XK_KP_Decimal, "kp_decimal"},

{XK_KP_Divide, "kp_divide"},

{XK_KP_0, "kp_0"},

{XK_KP_1, "kp_1"},

{XK_KP_2, "kp_2"},

{XK_KP_3, "kp_3"},

{XK_KP_4, "kp_4"},

{XK_KP_5, "kp_5"},

{XK_KP_6, "kp_6"},

{XK_KP_7, "kp_7"},

{XK_KP_8, "kp_8"},

{XK_KP_9, "kp_9"},

{XK_space, "space"},

{0, ""},

};

typedef struct

{

uint1 modifier;

uint1 token_length;

const char *token;

} ModKeyToken;

static ModKeyToken modifier_tokens[] =

{

{MS_SHIFT, 5, "shift"},

{MS_SHIFT, 1, "@"},

{MS_ALT, 6, "option"},

{MS_ALT, 3, "opt"},

{MS_ALT, 3, "alt"},

{MS_ALT, 1, "#"},

{MS_MAC_CONTROL, 7, "control"},

{MS_MAC_CONTROL, 4, "ctrl"},

{MS_MAC_CONTROL, 1, "%"},

{MS_CONTROL, 7, "command"},

{MS_CONTROL, 3, "cmd"},

{MS_CONTROL, 1, "^"},

{0, 0, NULL}

};

////////////////////////////////////////////////////////////////////////////////

MCPropertyInfo MCButton::kProperties[] =

{

DEFINE_RW_OBJ_ENUM_PROPERTY(P_STYLE, InterfaceButtonStyle, MCButton, Style)

DEFINE_RW_OBJ_PROPERTY(P_AUTO_ARM, Bool, MCButton, AutoArm)

DEFINE_RW_OBJ_PROPERTY(P_AUTO_HILITE, Bool, MCButton, AutoHilite)

DEFINE_RW_OBJ_PROPERTY(P_ARM_BORDER, Bool, MCButton, ArmBorder)

DEFINE_RW_OBJ_PROPERTY(P_ARM_FILL, Bool, MCButton, ArmFill)

DEFINE_RW_OBJ_PROPERTY(P_HILITE_BORDER, Bool, MCButton, HiliteBorder)

DEFINE_RW_OBJ_PROPERTY(P_HILITE_FILL, Bool, MCButton, HiliteFill)

DEFINE_RW_OBJ_PROPERTY(P_SHOW_HILITE, Bool, MCButton, ShowHilite)

DEFINE_RW_OBJ_PROPERTY(P_ARM, Bool, MCButton, Arm)

DEFINE_RW_OBJ_PROPERTY(P_SHARED_HILITE, Bool, MCButton, SharedHilite)

DEFINE_RW_OBJ_PROPERTY(P_SHOW_ICON, Bool, MCButton, ShowIcon)

DEFINE_RW_OBJ_PROPERTY(P_SHOW_NAME, Bool, MCButton, ShowName)

DEFINE_RW_OBJ_NON_EFFECTIVE_PROPERTY(P_LABEL, String, MCButton, Label)

DEFINE_RO_OBJ_EFFECTIVE_PROPERTY(P_LABEL, String, MCButton, Label)

DEFINE_RW_OBJ_NON_EFFECTIVE_PROPERTY(P_UNICODE_LABEL, BinaryString, MCButton, UnicodeLabel)

DEFINE_RO_OBJ_EFFECTIVE_PROPERTY(P_UNICODE_LABEL, BinaryString, MCButton, UnicodeLabel)

DEFINE_RW_OBJ_PROPERTY(P_LABEL_WIDTH, UInt16, MCButton, LabelWidth)

DEFINE_RW_OBJ_PROPERTY(P_FAMILY, UInt16, MCButton, Family)

DEFINE_RW_OBJ_PROPERTY(P_VISITED, Bool, MCButton, Visited)

DEFINE_RW_OBJ_PROPERTY(P_MENU_HISTORY, UInt16, MCButton, MenuHistory)

DEFINE_RW_OBJ_PROPERTY(P_MENU_LINES, OptionalUInt16, MCButton, MenuLines)

DEFINE_RW_OBJ_PROPERTY(P_MENU_BUTTON, UInt16, MCButton, MenuButton)

DEFINE_RW_OBJ_PROPERTY(P_MENU_NAME, Name, MCButton, MenuName)

DEFINE_RW_OBJ_PROPERTY(P_ACCELERATOR_TEXT, String, MCButton, AcceleratorText)

DEFINE_RO_OBJ_PROPERTY(P_UNICODE_ACCELERATOR_TEXT, BinaryString, MCButton, UnicodeAcceleratorText)

DEFINE_RW_OBJ_PROPERTY(P_ACCELERATOR_KEY, OptionalString, MCButton, AcceleratorKey)

DEFINE_RW_OBJ_SET_PROPERTY(P_ACCELERATOR_MODIFIERS, InterfaceButtonAcceleratorModifiers, MCButton, AcceleratorModifiers)

DEFINE_RW_OBJ_PROPERTY(P_MNEMONIC, UInt16, MCButton, Mnemonic)

DEFINE_RO_OBJ_PROPERTY(P_FORMATTED_WIDTH, Int16, MCButton, FormattedWidth)

DEFINE_RO_OBJ_PROPERTY(P_FORMATTED_HEIGHT, Int16, MCButton, FormattedHeight)

DEFINE_RW_OBJ_PROPERTY(P_DEFAULT, Bool, MCButton, Default)

DEFINE_RW_OBJ_PROPERTY(P_TEXT, String, MCButton, Text)

DEFINE_RW_OBJ_PROPERTY(P_UNICODE_TEXT, BinaryString, MCButton, UnicodeText)

// SN-2014-06-25 [[ IconGravity ]]

DEFINE_RW_OBJ_ENUM_PROPERTY(P_ICON_GRAVITY, InterfaceButtonIconGravity, MCButton, IconGravity)

DEFINE_RW_OBJ_CUSTOM_PROPERTY(P_ICON, InterfaceButtonIcon, MCButton, Icon)

DEFINE_RW_OBJ_CUSTOM_PROPERTY(P_ARMED_ICON, InterfaceButtonIcon, MCButton, ArmedIcon)

DEFINE_RW_OBJ_CUSTOM_PROPERTY(P_DISABLED_ICON, InterfaceButtonIcon, MCButton, DisabledIcon)

DEFINE_RW_OBJ_CUSTOM_PROPERTY(P_HILITED_ICON, InterfaceButtonIcon, MCButton, HiliteIcon)

DEFINE_RW_OBJ_CUSTOM_PROPERTY(P_VISITED_ICON, InterfaceButtonIcon, MCButton, VisitedIcon)

DEFINE_RW_OBJ_CUSTOM_PROPERTY(P_HOVER_ICON, InterfaceButtonIcon, MCButton, HoverIcon)

DEFINE_RW_OBJ_PART_CUSTOM_PROPERTY(P_HILITE, InterfaceTriState, MCButton, Hilite)

DEFINE_RW_OBJ_ENUM_PROPERTY(P_MENU_MODE, InterfaceButtonMenuMode, MCButton, MenuMode)

DEFINE_WO_OBJ_CHAR_CHUNK_PROPERTY(P_HILITE, Bool, MCButton, Hilite)

DEFINE_WO_OBJ_CHAR_CHUNK_PROPERTY(P_DISABLED, Bool, MCButton, Disabled)

DEFINE_WO_OBJ_CHAR_CHUNK_PROPERTY(P_ENABLED, Bool, MCButton, Enabled)

};

MCObjectPropertyTable MCButton::kPropertyTable =

{

&MCControl::kPropertyTable,

sizeof(kProperties) / sizeof(kProperties[0]),

&kProperties[0],

};

////////////////////////////////////////////////////////////////////////////////

MCButton::MCButton()

{

flags |= F_STANDARD | F_TRAVERSAL_ON | F_HILITE_BORDER | F_HILITE_FILL

| F_SHOW_NAME | F_ALIGN_CENTER | F_AUTO_HILITE

| F_ARM_BORDER | F_SHARED_HILITE;

bdata = NULL;

icons = NULL;

label = MCValueRetain(kMCEmptyString);

labelwidth = 0;

menubutton = Button1;

menumode = WM_CLOSED;

menuname = MCValueRetain(kMCEmptyName);

menustring = MCValueRetain(kMCEmptyString);

menuhistory = 1;

menucontrol = MENUCONTROL_NONE;

menulines = DEFAULT_MENU_LINES;

menuhasitemtags = false;

menu = NULL; //stack based menu

m_system_menu = NULL;

entry = NULL;

tabs = MCValueRetain(kMCEmptyArray);

acceltext = MCValueRetain(kMCEmptyString);

accelkey = accelmods = 0;

mnemonic = 0;

family = 0;

ishovering = False;

// MW-2014-06-19: [[ IconGravity ]] By default buttons use legacy behavior.

m_icon_gravity = kMCGravityNone;

// MM-2014-07-31: [[ ThreadedRendering ]] Used to ensure the default button animate message is only posted from a single thread.

m_animate_posted = false;

m_menu_handler = nil;

}

MCButton::MCButton(const MCButton &bref) : MCControl(bref)

{

if (bref.icons != NULL)

{

icons = new iconlist;

memcpy(icons, bref.icons, sizeof(iconlist));

icons->curicon = NULL;

}

else

icons = NULL;

bdata = NULL;

label = MCValueRetain(bref.label);

labelwidth = bref.labelwidth;

menuhistory = bref.menuhistory;

menulines = bref.menulines;

menubutton = bref.menubutton;

menumode = bref.menumode;

menuname = MCValueRetain(bref.menuname);

menucontrol = bref.menucontrol;

menuhasitemtags = bref.menuhasitemtags;

menustring = MCValueRetain(bref.menustring);

menu = NULL;

m_system_menu = NULL;

entry = NULL;

tabs = MCValueRetain(kMCEmptyArray);

acceltext = MCValueRetain(bref.acceltext);

accelkey = bref.accelkey;

accelmods = bref.accelmods;

mnemonic = bref.mnemonic;

ishovering = False;

if (bref.bdata != NULL)

{

MCCdata *bptr = bref.bdata;

do

{

MCCdata *newbdata = new MCCdata(*bptr);

newbdata->appendto(bdata);

bptr = (MCCdata *)bptr->next();

}

while (bptr != bref.bdata);

}

family = bref.family;

// MW-2014-06-19: [[ IconGravity ]] Copy the other buttons gravity

m_icon_gravity = kMCGravityNone;

// MM-2014-07-31: [[ ThreadedRendering ]] Used to ensure the default button animate message is only posted from a single thread.

m_animate_posted = false;

m_menu_handler = nil;

}

MCButton::~MCButton()

{

// OK-2009-04-30: [[Bug 7517]] - Ensure the button is actually closed before deletion, otherwise dangling references may still exist,

// particuarly if the button had icons.

while (opened)

close();

delete icons;

freemenu(True);

MCValueRelease(acceltext);

MCValueRelease(label);

MCValueRelease(menuname);

MCValueRelease(menustring);

MCValueRelease(tabs);

if (accelkey != 0)

MCstacks->deleteaccelerator(this, NULL);

while (bdata != NULL)

{

MCCdata *bptr = (MCCdata *)bdata->remove

(bdata);

delete bptr;

}

}

void MCButton::removelink(MCObject *optr)

{

if (optr == menu)

menu = NULL;

}

bool MCButton::imagechanged(MCImage *p_image, bool p_deleting)

{

if (icons != nil && p_image == icons->curicon)

{

if (p_deleting)

icons->curicon = nil;

layer_redrawall();

return true;

}

return false;

}

Chunk_term MCButton::gettype() const

{

return CT_BUTTON;

}

const char *MCButton::gettypestring()

{

return MCbuttonstring;

}

bool MCButton::visit_self(MCObjectVisitor* p_visitor)

{

return p_visitor -> OnButton(this);

}

void MCButton::open()

{

MCControl::open();

// MW-2011-02-08: [[ Bug 9382 ]] Make sure we reset icons when opening and the state

// has changed (i.e. background transition has occured).

uint32_t t_old_state;

t_old_state = state;

switch(gethilite(0))

{

case True:

state |= CS_HILITED;

state &= ~CS_MIXED;

break;

case False:

state &= ~(CS_HILITED | CS_MIXED);

break;

case Mixed:

state &= ~CS_HILITED;

state |= CS_MIXED;

break;

}

if (opened == 1 || state != t_old_state)

reseticon();

if (opened == 1)

{

if (getflag(F_DEFAULT))

{

getcard() -> setdefbutton(this);

state |= CS_SHOW_DEFAULT;

}

setupmnemonic();

if (getstyleint(flags) == F_MENU)

{

// MW-2011-02-08:[[ Bug 9384 ]] Make sure we don't 'findmenu' for things that don't have them.

// i.e. popup/option/cascade types.

switch (menumode)

{

case WM_TOP_LEVEL:

MCValueRelease(tabs);

/* UNCHECKED */ MCStringSplit(menustring, MCSTR("\n"), nil, kMCStringOptionCompareExact, tabs);

break;

case WM_COMBO:

createentry();

break;

case WM_POPUP:

case WM_OPTION:

case WM_CASCADE:

break;

default:

findmenu(true);

if (!MCNameIsEmpty(menuname) && menu != NULL)

menu->installaccels(getstack());

break;

}

}

if (accelkey != 0)

MCstacks->addaccelerator(this, getstack(), accelkey, accelmods);

}

}

void MCButton::close()

{

MCControl::close();

if (opened == 0)

{

if (icons != NULL && icons->curicon != NULL)

{

icons->curicon->close();

icons->curicon = NULL;

}

// Always make sure we unlink ourselves from the default button

// points on card - just in case one isn't updated somewhere else.

state &= ~CS_SHOW_DEFAULT;

getcard()->freedefbutton(this);

clearmnemonic();

MCValueAssign(tabs, kMCEmptyArray);

// AL-2013-01-13 [[ Bug 11363 ]] Close menu on button close.

if (state & CS_SUBMENU)

closemenu(True, True);

freemenu(False);

if (entry != NULL)

{

MCundos->freestate();

deleteentry();

}

if (accelkey != 0)

MCstacks->deleteaccelerator(this, getstack());

ishovering = False;

}

}

void MCButton::kfocus()

{

if ((!IsMacLF() || state & CS_SHOW_DEFAULT

|| flags & F_AUTO_ARM || entry != NULL)

&& flags & F_TRAVERSAL_ON && !(state & CS_KFOCUSED))

{

// Get the current transient rect

uint2 t_old_trans;

t_old_trans = gettransient();

state |= CS_KFOCUSED | CS_ARMED;

reseticon();

bool t_need_redraw;

t_need_redraw = false;

if (entry != NULL)

{

entry->kfocus();

t_need_redraw = true;

}

else if (getstyleint(flags) == F_STANDARD && flags & F_SHOW_BORDER)

{

if (!getstate(CS_SHOW_DEFAULT) && getcard()->getodefbutton() != NULL)

state |= CS_SHOW_DEFAULT;

getcard()->setdefbutton(this);

t_need_redraw = true;

}

else if (getstyleint(flags) != F_MENU || menumode != WM_TOP_LEVEL)

t_need_redraw = true;

// MW-2011-08-18: [[ Layers ]] Invalidate the whole object, noting

// possible change in transient.

if (t_need_redraw)

layer_transientchangedandredrawall(t_old_trans);

message(MCM_focus_in);

}

}

Boolean MCButton::kfocusnext(Boolean top)

{

if (((IsMacLF() && !(state & CS_SHOW_DEFAULT))

&& !(flags & F_AUTO_ARM) && entry == NULL)

|| !(flags & F_VISIBLE || MCshowinvisibles)

|| !(flags & F_TRAVERSAL_ON) || state & CS_KFOCUSED || flags & F_DISABLED)

return False;

return True;

}

Boolean MCButton::kfocusprev(Boolean bottom)

{

if (((IsMacLF() && !(state & CS_SHOW_DEFAULT))

&& !(flags & F_AUTO_ARM) && entry == NULL)

|| !(flags & F_VISIBLE || MCshowinvisibles)

|| !(flags & F_TRAVERSAL_ON) || state & CS_KFOCUSED || flags & F_DISABLED)

return False;

return True;

}

void MCButton::kunfocus()

{

if (state & CS_SUBMENU && menumode == WM_CASCADE)

closemenu(True, True);

if (state & CS_KFOCUSED)

{

uint2 t_old_trans;

t_old_trans = gettransient();

if (flags & F_AUTO_ARM && state & CS_ARMED && !(state & CS_SUBMENU))

state &= ~CS_MFOCUSED;

state &= ~(CS_KFOCUSED | CS_ARMED);

reseticon();

bool t_need_redraw;

t_need_redraw = false;

if (entry != NULL)

{

entry->kfocus();

entry->kunfocus();

entry->unselect(True, True);

t_need_redraw = true;

}

if (getstyleint(flags) != F_MENU || menumode != WM_TOP_LEVEL)

{

if (getstate(CS_SHOW_DEFAULT) && !getflag(F_DEFAULT))

state &= ~CS_SHOW_DEFAULT;

t_need_redraw = true;

}

// MW-2011-08-18: [[ Layers ]] Invalidate the whole object, noting

// possible change in transient.

if (t_need_redraw)

layer_transientchangedandredrawall(t_old_trans);

message(MCM_focus_out);

}

}

Boolean MCButton::kdown(MCStringRef p_string, KeySym key)

{

codepoint_t t_char;

t_char = key & XK_Codepoint_mask;

if (state & CS_SUBMENU)

{

if (MCObject::kdown(p_string, key))

return True;

MCButton *bptr;

MCAutoStringRef t_pick;

switch (key)

{

case XK_Escape:

closemenu(True, True);

return True;

case XK_Tab:

case XK_Left:

case XK_Right:

if (menu->kdown(p_string, key))

return True;

if (menumode == WM_CASCADE)

{

closemenu(True, key != XK_Left);

return key == XK_Left;

}

if (menumode != WM_PULLDOWN)

return False;

uint2 tnum, newnum;

getcard()->count(CT_MENU, CT_UNDEFINED, NULL, tnum, True);

getcard()->count(CT_MENU, CT_UNDEFINED, this, newnum, True);

while (True)

{

if (key == XK_Left)

if (newnum == 1)

newnum = tnum;

else

newnum--;

else

if (newnum == tnum)

newnum = 1;

else

newnum++;

bptr = (MCButton *)getcard()->getnumberedchild(newnum, CT_MENU, CT_UNDEFINED);

if (bptr == this)

break;

if (bptr->menubutton == menubutton

&& bptr->isvisible() && !bptr->isdisabled())

{

closemenu(True, True);

bptr->message_with_args(MCM_mouse_down, menubutton);

if (bptr->findmenu())

{

bptr->openmenu(True);

return True;

}

}

}

break;

case XK_Down:

if (menu->kdown(p_string, key))

return True;

return menu->kfocusnext(False);

case XK_Up:

if (menu->kdown(p_string, key))

return True;

return menu->kfocusprev(False);

case XK_WheelDown:

case XK_WheelUp:

case XK_WheelLeft:

case XK_WheelRight:

if (menu -> getcontrols() -> gettype() == CT_FIELD)

if (menu -> getcontrols() -> kdown(p_string, key))

return True;

break;

case XK_space:

case XK_Return:

case XK_KP_Enter:

closemenu(False, True);

menu->menukdown(p_string, key, &t_pick, menuhistory);

// This check must be for null (not empty) because an empty pick

// indicates that the function succeeded while a null pick means

// that no menu responded to the event.

if (*t_pick != nil)

{

if (menumode == WM_OPTION || menumode == WM_COMBO)

{

MCValueAssign(label, *t_pick);

// SN-2014-08-05: [[ Bug 13100 ]] An empty label is not an issue,

// we need to rely on the F_LABEL flag

flags |= F_LABEL;

if (entry != NULL)

entry->settext(0, *t_pick, False);

Exec_stat es = handlemenupick(*t_pick, nil);

if (es == ES_NOT_HANDLED || es == ES_PASS)

message_with_args(MCM_mouse_up, menubutton);

// MW-2011-08-18: [[ Layers ]] Invalidate the whole object.

layer_redrawall();

}

else

{

if (!(state & CS_IGNORE_MENU))

docascade(*t_pick);

}

}

else

message_with_args(MCM_mouse_release, menubutton);

state &= ~CS_IGNORE_MENU;

if (MCmenuobjectptr == this)

MCmenuobjectptr = NULL;

return True;

default:

MCButton *mbptr = menu->findmnemonic(t_char);

if (mbptr != NULL)

{

closemenu(False, True);

if (!MCNameIsEmpty(menuname))

mbptr->activate(False, t_char);

else

{

MCStringRef t_label;

if (mbptr->getmenuhastags())

t_label = MCNameGetString(mbptr->getname());

else

t_label = mbptr->getlabeltext();

menu->menukdown(p_string, key, &t_pick, menuhistory);

Exec_stat es = handlemenupick(t_label, nil);

if (es == ES_NOT_HANDLED || es == ES_PASS)

message_with_args(MCM_mouse_up, menubutton);

}

if (MCmenuobjectptr == this)

MCmenuobjectptr = NULL;

return True;

}

else

{

if (MCmodifierstate & MS_MOD1)

{

mbptr = MCstacks->findmnemonic(t_char);

if (mbptr != NULL && mbptr->isvisible() && !mbptr->isdisabled())

{

closemenu(True, True);

mbptr->message_with_args(MCM_mouse_down, menubutton);

if (mbptr->findmenu())

{

mbptr->openmenu(True);

return True;

}

}

}

}

}

return True;

}

else

{

if (entry != NULL)

return entry->kdown(p_string, key);

if (MCObject::kdown(p_string, key))

return True;

if ((((key == XK_Right || key == XK_space

|| key == XK_Return || key == XK_KP_Enter)

&& (menumode == WM_CASCADE || menumode == WM_OPTION))

|| (key == XK_Down && menumode != WM_CASCADE))

&& state & CS_KFOCUSED && findmenu())

{

openmenu(True);

return True;

}

if ((key == XK_space || ((state & CS_SHOW_DEFAULT || state & CS_ARMED)

&& (key == XK_Return || key == XK_KP_Enter)))

&& !(MCmodifierstate & MS_MOD1))

{

activate(False, t_char);

return True;

}

}

return False;

}

Boolean MCButton::kup(MCStringRef p_string, KeySym key)

{

if (entry != NULL)

return entry->kup(p_string, key);

if (MCObject::kup(p_string, key))

return True;

if (state & CS_SUBMENU)

return menu->kup(p_string, key);

return False;

}

Boolean MCButton::mfocus(int2 x, int2 y)

{

// SMR 594 do menu stuff before visibility check

if (state & CS_MENU_ATTACHED)

return MCObject::mfocus(x, y);

if (state & CS_SUBMENU)

{

mx = x;

my = y;

int2 tx = x;

int2 ty = y;

MCStack *sptr = menumode == WM_CASCADE ? getstack() : MCmousestackptr;

//TS-2007-13-11 - [[Bug 5507]] - on linux it is possible to have sptr == NULL which causes a crash.

// This is only when you drag a menu really quickly so the MCmousestackptr == NULL.

if ( sptr == NULL)

return False;

sptr->translatecoords(menu, tx, ty);

MCRectangle trect = sptr->getrect();

Boolean handled = menu->mfocus(tx, ty);

tx = x + trect.x;

ty = y + trect.y;

if (!handled)

{

MCCard *cptr = getcard();

switch (menumode)

{

case WM_PULLDOWN:

uint2 i;

if (MCU_point_in_rect(menu->getrect(), tx, ty)

|| !MCU_point_in_rect(cptr->getrect(), x, y)

|| MCU_point_in_rect(rect, x, y))

return True;

for (cptr->count(CT_MENU, CT_UNDEFINED, NULL, i, True) ; i ; i--)

{

MCButton *bptr = (MCButton *)cptr->getnumberedchild(i, CT_MENU, CT_UNDEFINED);

if (bptr == this)

continue;

// OK-2010-02-24: [[Bug 8628]] - Added clause to prevent this menu switching happening when bptr is a

// normal mac pulldown menu.

if (bptr->menubutton == menubutton

&& bptr->parent == parent

&& bptr->isvisible() && !bptr->isdisabled()

&& MCU_point_in_rect(bptr->getrect(), x, y)

&& bptr->mfocus(x, y) && bptr->findmenu()

&& !(IsMacLFAM() && (bptr -> getflag(F_SHOW_BORDER)) != 0)

)

{

state &= ~(CS_MFOCUSED | CS_SUBMENU | CS_ARMED);

ishovering = False;

reseticon();

// MW-2011-08-18: [[ Layers ]] Invalidate the whole object.

layer_redrawall();

menu->setstate(True, CS_KFOCUSED); // override state

menu->kunfocus();

menu->close();

menudepth--;

MCdispatcher->addmenu(bptr);

// MW-2014-06-10: [[ Bug 12590 ]] Make sure we lock screen around the menu update message.

MCRedrawLockScreen();

bptr->state |= CS_MFOCUSED;

bptr->message_with_args(MCM_mouse_down, menubutton);

MCRedrawUnlockScreen();

bptr->findmenu();

bptr->openmenu(False);

return True;

}

}

break;

case WM_CASCADE:

// MW-2010-10-06: [[ Bug 9035 ]] We count the pointer as being inside the cascade button

// if its vertical position is when inside a menuwindow.

if (sptr -> menuwindow && y >= rect . y && y < rect . y + rect . height)

return True;

if (MCU_point_in_rect(rect, x, y))

return True;

if (flags & F_AUTO_ARM && MCU_point_in_rect(trect, tx, ty))

{

closemenu(False, True);

state &= ~(CS_MFOCUSED | CS_ARMED);

reseticon();

getcard()->ungrab();

return False;

}

break;

case WM_OPTION:

// OK-2007-08-07 : Bug 5287, a button with a menu name (stack panel) set will not have

// an associated field to contain items, so should break here to avoid crash.

if ((MClook != LF_WIN95) || !MCNameIsEmpty(menuname))

break;

case WM_COMBO:

// MW-2014-03-11: [[ Bug 11893 ]] Make sure we don't do anything to a stack panel.

if (state & CS_MFOCUSED && MCNameIsEmpty(menuname))

{

uint2 fheight;

fheight = gettextheight();

MCField *fptr = (MCField *)menu->getcontrols();

fptr->vscroll(my < rect.y + rect.height ? -fheight : fheight, True);

fptr->resetscrollbars(True);

}

break;

default:

break;

}

}

message_with_args(MCM_mouse_move, x, y);

/* This would prevent buttons that are under the menu of this one

from taking the focus away, but unfortunately this messes up

grab at the card level if (menumode == WM_CASCADE) return

handled; */

return True;

}

if (!(flags & F_VISIBLE || MCshowinvisibles)

|| (flags & F_DISABLED && getstack()->gettool(this) == T_BROWSE))

return False;

Tool tool = getstack()->gettool(this);

if (tool == T_BROWSE || tool == T_HELP)

{

mx = x;

my = y;

if (entry != NULL && entry->mfocus(x, y))

return True;

if (getstyleint(flags) == F_MENU && menumode == WM_TOP_LEVEL

&& IsMacLF() && state & CS_MFOCUSED)

{

// MW-2011-08-18: [[ Layers ]] Invalidate the whole object.

layer_redrawall();

}

else

{

if (flags & F_AUTO_ARM)

{

if (MCU_point_in_rect(rect, x, y)

&& MCU_point_in_rect(getcard()->getrect(), x, y))

{

if (!(state & CS_ARMED))

{

if (menumode == WM_CASCADE && findmenu())

{

getcard()->grab();

mdown(menubutton);

}

state |= CS_MFOCUSED | CS_ARMED;

getcard()->kfocusset(this);

}

message_with_args(MCM_mouse_move, x, y);

return True;

}

else

{

if (state & CS_ARMED)

{

uint2 t_old_trans;

t_old_trans = gettransient();

state &= ~(CS_MFOCUSED | CS_ARMED | CS_KFOCUSED);

ishovering = False;

reseticon();

getcard()->kfocusset(NULL);

// MW-2011-08-18: [[ Layers ]] Invalidate the whole object, noting