{

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;

{

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;

{

if (optr == menu)

menu = NULL;

{

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

{

if (p_deleting)

icons->curicon = nil;

layer_redrawall();

return true;

}

return false;

{

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

}

{

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;

}

{

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

}

{

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;

{

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;

{

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

}

{

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;

{

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;

{

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

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