/* 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 "core.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"

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;

// MW-2007-12-11: [[ Bug 5670 ]] This global is set to false before a card issues an

// mdown to its focused control. If the mdown resulted in a popup being shown on OS X, then it will be

// set to true. This is to work around the problem with the mouse down message being 'cancelled' on a

// popup-menu action resulting in the group mdown not returning true, and thus causing the card to

// send an errant mdown message to the script.

bool MCosxmenupoppedup = false;

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}

};

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 = NULL;

labelsize = 0;

labelwidth = 0;

menubutton = Button1;

menumode = WM_CLOSED;

menuname = NULL;

menustring = NULL;

menusize = 0;

menuhistory = 1;

menucontrol = MENUCONTROL_NONE;

menulines = DEFAULT_MENU_LINES;

menuhasitemtags = false;

menu = NULL; //stack based menu

#ifdef _MAC_DESKTOP

bMenuID = 0; //for button/object based menus

#endif

entry = NULL;

tabs = NULL;

ntabs = 0;

acceltext = NULL;

acceltextsize = 0;

accelkey = accelmods = 0;

mnemonic = 0;

family = 0;

ishovering = False;

}

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;

if (bref.labelsize)

{

labelsize = bref.labelsize;

label = new char[labelsize];

memcpy(label, bref.label, labelsize);

}

else

{

label = NULL;

labelsize = 0;

}

labelwidth = bref.labelwidth;

menuhistory = bref.menuhistory;

menulines = bref.menulines;

menubutton = bref.menubutton;

menumode = bref.menumode;

menuname = strclone(bref.menuname);

menucontrol = bref.menucontrol;

menuhasitemtags = bref.menuhasitemtags;

menustring = NULL;

menusize = 0;

if (bref.menustring)

{

menusize = bref.menusize;

menustring = new char[menusize];

memcpy(menustring, bref.menustring, menusize);

}

menu = NULL;

entry = NULL;

tabs = NULL;

ntabs = 0;

acceltext = NULL;

acceltextsize = 0;

if (bref.acceltext)

{

acceltextsize = bref.acceltextsize;

acceltext = new char[acceltextsize];

memcpy(acceltext, bref.acceltext, acceltextsize);

}

accelkey = bref.accelkey;

accelmods = bref.accelmods;

mnemonic = bref.mnemonic;

ishovering = False;

#ifdef _MAC_DESKTOP

bMenuID = 0;

#endif

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;

}

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();

// MW-2008-10-28: [[ ParentScripts ]] Flush the parent scripts table if

// tsub has the state flag marked.

if (getstate(CS_IS_PARENTSCRIPT))

MCParentScript::FlushObject(this);

delete icons;

freemenu(True);

delete label;

delete acceltext;

delete menuname;

delete menustring;

delete 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(MCVisitStyle p_style, uint32_t p_part, MCObjectVisitor* p_visitor)

{

return p_visitor -> OnButton(this);

}

void MCButton::open()

{

// MW-2008-10-28: [[ ParentScripts ]] We have to preserve the setting of the

// CS_IS_PARENTSCRIPT state.

if (!getstate(CS_IS_PARENTSCRIPT))

MCControl::open();

else

{

MCControl::open();

setstate(True, CS_IS_PARENTSCRIPT);

}

// 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:

MCU_break_string(MCString(menustring, menusize), tabs, ntabs, hasunicode());

break;

case WM_COMBO:

createentry();

break;

case WM_POPUP:

case WM_OPTION:

case WM_CASCADE:

break;

default:

findmenu(true);

if (menuname != NULL && 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();

if (tabs != NULL)

{

delete tabs;

tabs = NULL;

ntabs = 0;

}

// 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(const char *string, KeySym key)

{

if (state & CS_SUBMENU)

{

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

return True;

MCButton *bptr;

MCString pick;

switch (key)

{

case XK_Escape:

closemenu(True, True);

return True;

case XK_Tab:

case XK_Left:

case XK_Right:

if (menu->kdown(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++;

char exp[U2L];

sprintf(exp, "%d", newnum);

bptr = (MCButton *)getcard()->getchild(CT_EXPRESSION, exp,

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(string, key))

return True;

return menu->kfocusnext(False);

case XK_Up:

if (menu->kdown(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(string, key))

return True;

break;

case XK_space:

case XK_Return:

case XK_KP_Enter:

closemenu(False, True);

menu->menukdown(string, key, pick, menuhistory);

if (pick.getstring() != NULL)

{

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

{

delete label;

label = (char *)pick.getstring();

labelsize = pick.getlength();

flags |= F_LABEL;

if (entry != NULL)

entry->settext(0, pick, False, hasunicode());

Exec_stat es = message_with_args(MCM_menu_pick, pick);

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(pick);

delete (char *)pick.getstring();

}

}

else

message_with_args(MCM_mouse_release, menubutton);

state &= ~CS_IGNORE_MENU;

if (MCmenuobjectptr == this)

MCmenuobjectptr = NULL;

return True;

default:

MCButton *mbptr = menu->findmnemonic(string[0]);

if (mbptr != NULL)

{

closemenu(False, True);

if (menuname != NULL)

mbptr->activate(False, string[0]);

else

{

MCString slabel;

bool t_is_unicode;

if (mbptr->getmenuhastags())

slabel = mbptr -> getname_oldstring(), t_is_unicode = false;

else

mbptr->getlabeltext(slabel, t_is_unicode);

menu->menukdown(string, key, pick, menuhistory);

Exec_stat es = message_with_args(MCM_menu_pick, slabel);

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

message_with_args(MCM_mouse_up, menubutton);

delete (char *)pick.getstring();

}

if (MCmenuobjectptr == this)

MCmenuobjectptr = NULL;

return True;

}

else

{

if (MCmodifierstate & MS_MOD1)

{

mbptr = MCstacks->findmnemonic(string[0]);

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(string, key);

if (MCObject::kdown(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, string[0]);

return True;

}

}

return False;

}

Boolean MCButton::kup(const char *string, KeySym key)

{

if (entry != NULL)

return entry->kup(string, key);

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

return True;

if (state & CS_SUBMENU)

return menu->kup(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--)

{

char string[U2L];

sprintf(string, "%d", i);

MCButton *bptr = (MCButton *)cptr->getchild(CT_EXPRESSION, string,

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);

bptr->state |= CS_MFOCUSED;

bptr->message_with_args(MCM_mouse_down, menubutton);

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) || menuname != NULL)

break;

case WM_COMBO:

if (state & CS_MFOCUSED)

{

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)

{

MCRectangle trect = rect;

trect.height = 8 + MCFontGetAscent(m_font);

// 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

// possible change in transient.

layer_transientchangedandredrawall(t_old_trans);

}

return False;

}

}

if (MCbuttonstate & Button1 && flags & F_AUTO_HILITE

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

&& state & CS_MFOCUSED && !(state & CS_SELECTED))

{

if (MClook == LF_MOTIF || flags & F_SHOW_ICON

|| getstyleint(flags) != F_RADIO

&& getstyleint(flags) != F_CHECK)

{

if (MCU_point_in_rect(rect, x, y))

{

if ((state & CS_HILITED) != starthilite

&& (starthilite || getstyleint(flags) != F_RADIO))

{

state ^= CS_HILITED;

reseticon();

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

layer_redrawall();

}

}