/* Copyright (C) 2003-2015 LiveCode 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 "util.h"

#include "stack.h"

#include "tooltip.h"

#include "card.h"

#include "cdata.h"

#include "objptr.h"

#include "sellst.h"

#include "stacklst.h"

#include "undolst.h"

#include "group.h"

#include "button.h"

#include "graphic.h"

#include "scrolbar.h"

#include "player.h"

#include "image.h"

#include "field.h"

#include "vclip.h"

#include "hndlrlst.h"

#include "handler.h"

#include "mcerror.h"

#include "debug.h"

#include "dispatch.h"

#include "field.h"

#include "scrolbar.h"

#include "graphic.h"

#include "player.h"

#include "eps.h"

#include "magnify.h"

#include "aclip.h"

#include "cpalette.h"

#include "vclip.h"

#include "redraw.h"

#include "globals.h"

#include "mctheme.h"

#include "context.h"

#include "exec.h"

MCRectangle MCCard::selrect;

int2 MCCard::startx;

int2 MCCard::starty;

MCObjptr *MCCard::removedcontrol;

#ifdef _MAC_DESKTOP

extern bool MCosxmenupoppedup;

#endif

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

MCPropertyInfo MCCard::kProperties[] =

{

DEFINE_RW_OBJ_CUSTOM_PROPERTY(P_LAYER, InterfaceLayer, MCCard, Layer)

DEFINE_RW_OBJ_CUSTOM_PROPERTY(P_NUMBER, InterfaceLayer, MCCard, Layer)

DEFINE_RW_OBJ_PROPERTY(P_CANT_DELETE, Bool, MCCard, CantDelete)

DEFINE_RW_OBJ_PROPERTY(P_DONT_SEARCH, Bool, MCCard, DontSearch)

DEFINE_RW_OBJ_PROPERTY(P_MARKED, Bool, MCCard, Marked)

DEFINE_RW_OBJ_PROPERTY(P_SHOW_PICT, Bool, MCCard, ShowPict)

DEFINE_RO_OBJ_PROPERTY(P_FORMATTED_LEFT, Int16, MCCard, FormattedLeft)

DEFINE_RO_OBJ_PROPERTY(P_FORMATTED_TOP, Int16, MCCard, FormattedTop)

DEFINE_RO_OBJ_PROPERTY(P_FORMATTED_HEIGHT, Int16, MCCard, FormattedHeight)

DEFINE_RO_OBJ_PROPERTY(P_FORMATTED_WIDTH, Int16, MCCard, FormattedWidth)

DEFINE_RO_OBJ_PROPERTY(P_FORMATTED_RECT, Rectangle, MCCard, FormattedRect)

DEFINE_RO_OBJ_PROPERTY(P_BACKGROUND_NAMES, String, MCCard, BackgroundNames)

DEFINE_RO_OBJ_PROPERTY(P_BACKGROUND_IDS, String, MCCard, BackgroundIds)

DEFINE_RO_OBJ_PROPERTY(P_SHARED_GROUP_NAMES, String, MCCard, SharedGroupNames)

DEFINE_RO_OBJ_PROPERTY(P_SHARED_GROUP_IDS, String, MCCard, SharedGroupIds)

DEFINE_RO_OBJ_PROPERTY(P_GROUP_IDS, String, MCCard, GroupIds)

DEFINE_RO_OBJ_PROPERTY(P_GROUP_NAMES, String, MCCard, GroupNames)

// MERG-2015-05-01: [[ ChildControlProps ]] Add ability to list both

// immediate and all descendent controls of a card.

DEFINE_RO_OBJ_PART_PROPERTY(P_CONTROL_IDS, String, MCCard, ControlIds)

DEFINE_RO_OBJ_PART_PROPERTY(P_CONTROL_NAMES, String, MCCard, ControlNames)

DEFINE_RO_OBJ_PROPERTY(P_CHILD_CONTROL_IDS, String, MCCard, ChildControlIds)

DEFINE_RO_OBJ_PROPERTY(P_CHILD_CONTROL_NAMES, String, MCCard, ChildControlNames)

DEFINE_RO_OBJ_PROPERTY(P_DEFAULT_BUTTON, OptionalString, MCCard, DefaultButton)

DEFINE_UNAVAILABLE_OBJ_PROPERTY(P_VISIBLE)

DEFINE_UNAVAILABLE_OBJ_PROPERTY(P_INVISIBLE)

DEFINE_UNAVAILABLE_OBJ_PROPERTY(P_ENABLED)

DEFINE_UNAVAILABLE_OBJ_PROPERTY(P_DISABLED)

DEFINE_UNAVAILABLE_OBJ_PROPERTY(P_TRAVERSAL_ON)

DEFINE_UNAVAILABLE_OBJ_PROPERTY(P_SHADOW)

DEFINE_UNAVAILABLE_OBJ_PROPERTY(P_LOCK_LOCATION)

DEFINE_UNAVAILABLE_OBJ_PROPERTY(P_TOOL_TIP)

// MW-2012-03-13: [[ UnicodeToolTip ]] Cards don't have tooltips.

DEFINE_UNAVAILABLE_OBJ_PROPERTY(P_UNICODE_TOOL_TIP)

DEFINE_RO_OBJ_NON_EFFECTIVE_PROPERTY(P_RECTANGLE, Rectangle, MCObject, Rectangle)

DEFINE_RO_OBJ_EFFECTIVE_PROPERTY(P_RECTANGLE, Rectangle, MCObject, Rectangle)

DEFINE_RO_OBJ_NON_EFFECTIVE_PROPERTY(P_WIDTH, UInt16, MCObject, Width)

DEFINE_RO_OBJ_EFFECTIVE_PROPERTY(P_WIDTH, UInt16, MCObject, Width)

DEFINE_RO_OBJ_NON_EFFECTIVE_PROPERTY(P_HEIGHT, UInt16, MCObject, Height)

DEFINE_RO_OBJ_EFFECTIVE_PROPERTY(P_HEIGHT, UInt16, MCObject, Height)

DEFINE_RO_OBJ_NON_EFFECTIVE_PROPERTY(P_LEFT, Int16, MCObject, Left)

DEFINE_RO_OBJ_NON_EFFECTIVE_PROPERTY(P_RIGHT, Int16, MCObject, Right)

DEFINE_RO_OBJ_NON_EFFECTIVE_PROPERTY(P_BOTTOM, Int16, MCObject, Bottom)

DEFINE_RO_OBJ_NON_EFFECTIVE_PROPERTY(P_TOP, Int16, MCObject, Top)

DEFINE_RO_OBJ_NON_EFFECTIVE_PROPERTY(P_TOP_LEFT, Point, MCObject, TopLeft)

DEFINE_RO_OBJ_NON_EFFECTIVE_PROPERTY(P_TOP_RIGHT, Point, MCObject, TopRight)

DEFINE_RO_OBJ_NON_EFFECTIVE_PROPERTY(P_BOTTOM_LEFT, Point, MCObject, BottomLeft)

DEFINE_RO_OBJ_NON_EFFECTIVE_PROPERTY(P_BOTTOM_RIGHT, Point, MCObject, BottomRight)

DEFINE_RO_OBJ_EFFECTIVE_PROPERTY(P_LEFT, Int16, MCObject, Left)

DEFINE_RO_OBJ_EFFECTIVE_PROPERTY(P_RIGHT, Int16, MCObject, Right)

DEFINE_RO_OBJ_EFFECTIVE_PROPERTY(P_BOTTOM, Int16, MCObject, Bottom)

DEFINE_RO_OBJ_EFFECTIVE_PROPERTY(P_TOP, Int16, MCObject, Top)

DEFINE_RO_OBJ_EFFECTIVE_PROPERTY(P_TOP_LEFT, Point, MCObject, TopLeft)

DEFINE_RO_OBJ_EFFECTIVE_PROPERTY(P_TOP_RIGHT, Point, MCObject, TopRight)

DEFINE_RO_OBJ_EFFECTIVE_PROPERTY(P_BOTTOM_LEFT, Point, MCObject, BottomLeft)

DEFINE_RO_OBJ_EFFECTIVE_PROPERTY(P_BOTTOM_RIGHT, Point, MCObject, BottomRight)

};

MCObjectPropertyTable MCCard::kPropertyTable =

{

&MCObject::kPropertyTable,

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

&kProperties[0],

};

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

MCCard::MCCard()

{

objptrs = NULL;

flags &= ~F_SHOW_BORDER;

savedata = NULL;

mfocused = kfocused = oldkfocused = NULL;

defbutton = odefbutton = NULL;

// MW-2011-09-23: [[ TileCache ]] Make sure the card layer ids are zero.

m_bg_layer_id = 0;

m_fg_layer_id = 0;

// MM-2012-11-05: [[ Object selection started/ended message ]]

m_selecting_objects = false;

}

MCCard::MCCard(const MCCard &cref) : MCObject(cref)

{

objptrs = NULL;

if (cref.objptrs != NULL)

{

MCObjptr *tptr = cref.objptrs;

do

{

MCObjptr *newoptr = new MCObjptr;

newoptr->setparent(this);

newoptr->setid(tptr->getid());

newoptr->appendto(objptrs);

tptr = (MCObjptr *)tptr->next();

}

while (tptr != cref.objptrs);

}

savedata = NULL;

mfocused = kfocused = oldkfocused = NULL;

defbutton = odefbutton = NULL;

// MW-2011-09-23: [[ TileCache ]] Make sure the card layer ids are zero.

m_bg_layer_id = 0;

m_fg_layer_id = 0;

// MM-2012-11-05: [[ Object selection started/ended message ]]

m_selecting_objects = false;

}

MCCard::~MCCard()

{

while (opened)

close();

while (objptrs != NULL)

{

if (state & CS_OWN_CONTROLS)

{

MCControl *cptr = objptrs->getref();

// MW-2011-08-09: [[ Groups ]] We mustn't delete a shared group even

// if the card owns the controls.

if (cptr->gettype() != CT_GROUP || !static_cast<MCGroup *>(cptr)->isshared())

delete cptr;

}

MCObjptr *optr = objptrs->remove(objptrs);

delete optr;

}

while (savedata != NULL)

{

MCDLlist *optr = savedata->remove(savedata);

delete optr;

}

}

Chunk_term MCCard::gettype() const

{

return CT_CARD;

}

const char *MCCard::gettypestring()

{

return MCcardstring;

}

bool MCCard::visit(MCVisitStyle p_style, uint32_t p_part, MCObjectVisitor *p_visitor)

{

bool t_continue;

t_continue = true;

// If the card doesn't match the part number, we do nothing.

if (p_part != 0 && getid() != p_part)

return true;

if (p_style == VISIT_STYLE_DEPTH_LAST)

t_continue = p_visitor -> OnCard(this);

if (t_continue && objptrs != NULL)

{

MCObjptr *t_objptr;

t_objptr = objptrs;

do

{

t_continue = t_objptr -> visit(p_style, p_part, p_visitor);

t_objptr = t_objptr -> next();

}

while(t_continue && t_objptr != objptrs);

}

if (t_continue && p_style == VISIT_STYLE_DEPTH_FIRST)

t_continue = p_visitor -> OnCard(this);

return t_continue;

}

void MCCard::open()

{

clean();

MCObject::open();

if (objptrs != NULL)

{

MCObjptr *tptr = objptrs;

do

{

MCControl *control = tptr->getref();

control->setparent(this);

control->open();

// MW-2013-03-21: [[ Bug ]] If we are opening a shared group for

// the second time it means we are switching between cards sharing

// it. Therefore, we make sure we recompute fonts and recompute it

// (This ensures correct inherited fonts and such are used).

if (control -> gettype() == CT_GROUP &&

static_cast<MCGroup *>(control) -> isshared() &&

control -> getopened() > 1)

if (control -> recomputefonts(m_font))

control -> recompute();

tptr = tptr->next();

}

while (tptr != objptrs);

}

odefbutton = defbutton;

mgrabbed = False;

mfocused = kfocused = oldkfocused = NULL;

}

void MCCard::close()

{

if (!opened)

return;

if (getstack()->getmode() <= WM_SHEET)

kunfocus();

MCObject::close();

if (objptrs != NULL)

{

MCObjptr *tptr = objptrs;

do

{

tptr->getref()->close();

tptr = tptr->next();

}

while (tptr != objptrs);

clear();

}

defbutton = odefbutton = NULL;

MCtooltip->clearmatch(this);

}

void MCCard::kfocus()

{

if (oldkfocused != NULL && kfocused == NULL)

{

kfocused = oldkfocused;

// MW-2014-08-12: [[ Bug 13167 ]] Sync the view focus before the engine state

// (otherwise the engine state can change due to script).

MCscreen -> controlgainedfocus(getstack(), kfocused -> getid());

kfocused->getref()->kfocus();

}

if (kfocused == NULL)

kfocusnext(True);

}

Boolean MCCard::kfocusnext(Boolean top)

{

if (!opened)

return False;

if (objptrs == NULL)

{

kfocused = oldkfocused = NULL;

return False;

}

MCObjptr *startptr;

if (kfocused == NULL || top)

startptr = objptrs;

else

startptr = kfocused;

Boolean done = False;

defbutton = NULL;

MCObjptr *tptr = startptr;

do

{

if (tptr->getref()->kfocusnext(top))

{

if (kfocused != tptr)

{

oldkfocused = kfocused;

kfocused = NULL;

if (oldkfocused != NULL)

{

if (oldkfocused->getref() == MCactivefield

&& !MCactivefield->getflag(F_LIST_BEHAVIOR))

MCactivefield->unselect(False, True);

// MW-2014-08-12: [[ Bug 13167 ]] Sync the view focus before the engine state

// (otherwise the engine state can change due to script).

MCscreen -> controllostfocus(getstack(), oldkfocused -> getid());

oldkfocused->getref()->kunfocus();

if (oldkfocused == NULL)

return False;

}

if (kfocused == NULL)

kfocused = tptr;

}

// MW-2014-07-29: [[ Bug 13001 ]] Sync the view focus before the engine state

// (otherwise the engine state can change due to script).

MCscreen -> controlgainedfocus(getstack(), kfocused -> getid());

kfocused->getref()->kfocus();

done = True;

break;

}

tptr = tptr->next();

}

while (tptr != startptr);

if (!done && kfocused != NULL)

done = kfocused->getref()->kfocusnext(True);

if (done && odefbutton != NULL && defbutton != odefbutton)

odefbutton->setdefault(defbutton == NULL);

if (!done)

message(MCM_focus_in);

return True;

}

Boolean MCCard::kfocusprev(Boolean bottom)

{

if (!opened)

return False;

if (objptrs == NULL)

{

kfocused = oldkfocused = NULL;

return False;

}

MCObjptr *startptr;

if (kfocused == NULL || bottom)

startptr = objptrs->prev();

else

startptr = kfocused;

Boolean done = False;

defbutton = NULL;

MCObjptr *tptr = startptr;

do

{

if (tptr->getref()->kfocusprev(bottom))

{

if (kfocused != tptr)

{

oldkfocused = kfocused;

kfocused = NULL;

if (oldkfocused != NULL)

{

if (oldkfocused->getref() == MCactivefield

&& !MCactivefield->getflag(F_LIST_BEHAVIOR))

MCactivefield->unselect(False, True);

// MW-2014-08-12: [[ Bug 13167 ]] Sync the view focus before the engine state

// (otherwise the engine state can change due to script).

MCscreen -> controllostfocus(getstack(), oldkfocused -> getid());

oldkfocused->getref()->kunfocus();

if (oldkfocused == NULL)

return False;

}

if (kfocused == NULL)

kfocused = tptr;

}

// MW-2014-07-29: [[ Bug 13001 ]] Sync the view focus before the engine state

// (otherwise the engine state can change due to script).

MCscreen -> controlgainedfocus(getstack(), kfocused -> getid());

kfocused->getref()->kfocus();

done = True;

break;

}

tptr = tptr->prev();

}

while (tptr != startptr);

if (!done && kfocused != NULL)

done = kfocused->getref()->kfocusprev(True);

if (done && odefbutton != NULL && defbutton != odefbutton)

odefbutton->setdefault(defbutton == NULL);

return True;

}

void MCCard::kunfocus()

{

if (kfocused != NULL)

{

oldkfocused = kfocused;

kfocused = NULL;

// MW-2014-08-12: [[ Bug 13167 ]] Sync the view focus before the engine state

// (otherwise the engine state can change due to script).

MCscreen -> controllostfocus(getstack(), oldkfocused -> getid());

oldkfocused->getref()->kunfocus();

}

else

{

message(MCM_focus_out);

oldkfocused = NULL;

}

}

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

{

MCtooltip->closetip();

if (kfocused != NULL && getstack()->gettool(this) == T_BROWSE)

return kfocused->getref()->kdown(p_string, key);

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

return True;

return False;

}

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

{

if (kfocused != NULL && getstack()->gettool(this) == T_BROWSE)

return kfocused->getref()->kup(p_string, key);

return MCObject::kup(p_string, key);

}

void MCCard::mdrag(void)

{

if (!mgrabbed)

return;

if (getstack() -> gettool(this) != T_BROWSE)

return;

if (mfocused != NULL)

{

mfocused -> getref() -> mdrag();

//MCdragtargetptr = mfocused -> getref();

}

else

{

message(MCM_drag_start);

MCdragtargetptr = this;

}

}

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

{

if (state & CS_MENU_ATTACHED)

return MCObject::mfocus(x, y);

if (!mgrabbed)

MCtooltip->mousemove(x, y, this);

if (mgrabbed || MCU_point_in_rect(rect, x, y))

state |= CS_INSIDE;

else

state &= ~CS_INSIDE;

if (objptrs == NULL)

{

// MW-2007-10-29: [[ Bug 3726 ]] dragMove is not sent to a card during

// a drag-drop operation.

if (MCdispatcher -> isdragtarget())

message_with_args(MCM_drag_move, x, y);

else

message_with_args(MCM_mouse_move, x, y);

mfocused = NULL;

return False;

}

if (mfocused == NULL || !(mgrabbed && mfocused->getref()->mfocus(x, y)))

{

if (mfocused == NULL && mgrabbed)

{

if (state & CS_SIZE)

{

MCRedrawLockScreen();

MCRectangle oldrect = selrect;

selrect = MCU_compute_rect(startx, starty, x, y);

MCRectangle drect = MCU_union_rect(oldrect, selrect);

if (objptrs != NULL)

{

MCObjptr *optr = objptrs;

do

{

MCControl *cptr = optr->getref();

updateselection(cptr, oldrect, selrect, drect);

optr = optr->next();

}

while (optr != objptrs);

}

MCRedrawUnlockScreen();

// MW-2011-08-19: [[ Layers ]] Ensure the selection rect is updated.

layer_selectedrectchanged(oldrect, selrect);

}

message_with_args(MCM_mouse_move, x, y);

return True;

}

if (mgrabbed)

mfocused->getref()->mfocus(x, y);

mgrabbed = False;

MCObjptr *tptr = objptrs->prev();

Boolean freed;

do

{

MCObject *t_tptr_object;

t_tptr_object = tptr -> getref();

freed = False;

if (t_tptr_object->mfocus(x, y))

{

// MW-2010-10-28: If mfocus calls relayer, then the objptrs can get changed.

// Reloop to find the correct one.

MCObjptr *tptr = objptrs -> prev();

while(tptr -> getref() != t_tptr_object)

tptr = tptr -> prev();

Boolean newfocused = tptr != mfocused;

if (newfocused && mfocused != NULL)

{

MCControl *oldfocused = mfocused->getref();

mfocused = tptr;

oldfocused->munfocus();

}

else

mfocused = tptr;

if (newfocused && mfocused != NULL && mfocused -> getref() -> gettype() != CT_GROUP)

{

mfocused->getref()->enter();

// MW-2007-10-31: mouseMove sent before mouseEnter - make sure we send an mouseMove

// It is possible for mfocused to become NULL if its deleted in mouseEnter so

// we check first.

if (mfocused != NULL)

mfocused->getref()->mfocus(x, y);

}

return True;

}

if (tptr == mfocused)

{

// MW-2012-02-22: [[ Bug 10018 ]] Previously, if a group was hidden and it had

// mouse focus, then it wouldn't unmfocus as there was an explicit check to

// stop this (for groups) here.

// MW-2012-03-13: [[ Bug 10074 ]] Invoke the control's munfocus() method for groups

// if the group has an mfocused control.

if (mfocused -> getref() -> gettype() != CT_GROUP || static_cast<MCGroup *>(mfocused -> getref()) -> getmfocused() != nil)

{

MCControl *oldfocused = mfocused->getref();

mfocused = NULL;

oldfocused->munfocus();

}

else

{

static_cast<MCGroup *>(mfocused -> getref()) -> clearmfocus();

mfocused = nil;

}

freed = True;

tptr = objptrs->prev();

}

else

tptr = tptr->prev();

}

while (freed || tptr != objptrs->prev());

MCtooltip->cleartip();

// MW-2007-07-09: [[ Bug 3726 ]] dragMove is not sent to a card during

// a drag-drop operation.

if (MCdispatcher -> isdragtarget())

message_with_args(MCM_drag_move, x, y);

else

message_with_args(MCM_mouse_move, x, y);

return False;

}

else

return True;

}

void MCCard::mfocustake(MCControl *target)

{

MCObjptr *newmfocused = objptrs;

do

{

if (newmfocused->getref() == target)

{

if (newmfocused != mfocused)

{

munfocus();

mfocused = newmfocused;

}

mfocused->getref()->mfocus(MCmousex, MCmousey);

return;

}

newmfocused = newmfocused->next();

}

while (newmfocused != objptrs);

munfocus();

}

void MCCard::munfocus()

{

MCtooltip->cleartip();

state &= ~CS_INSIDE;

if (mfocused != NULL && !mgrabbed)

{

MCControl *oldfocused = mfocused->getref();

mfocused = NULL;

oldfocused->munfocus();

}

else

{

if (MCdispatcher -> isdragtarget())

message(MCM_drag_leave);

else

message(MCM_mouse_leave);

}

}

Boolean MCCard::mdown(uint2 which)

{

if (state & CS_MENU_ATTACHED)

return MCObject::mdown(which);

MCtooltip->closetip();

MCControl *cptr = NULL;

MCclickfield = NULL;

mgrabbed = True;

if (mfocused != NULL)

{

MCControl *oldfocused = mfocused->getref();

// AL-2013-01-14: [[ Bug 11343 ]] Add timer if the object handles mouseStillDown in the behavior chain.

// MW-2014-07-29: [[ Bug 13010 ]] Make sure we use the deepest mfocused child.

MCControl *t_child_oldfocused = getmfocused();

if (t_child_oldfocused != NULL &&

t_child_oldfocused -> handlesmessage(MCM_mouse_still_down))

MCscreen->addtimer(t_child_oldfocused, MCM_idle, MCidleRate);

if (!mfocused->getref()->mdown(which)

&& getstack()->gettool(this) == T_BROWSE)

{

message_with_valueref_args(MCM_mouse_down, MCSTR("1"));

}

if (!(MCbuttonstate & (0x1L << (which - 1))))

{

Boolean oldstate = MClockmessages;

MClockmessages = True;

if (!mup(which, false))

oldfocused->mup(which, false);

MClockmessages = oldstate;

}

return True;

}

else

{

// AL-2013-01-14: [[ Bug 11343 ]] Add timer to the card if it handles mouseStillDown in the behavior chain.

if (handlesmessage(MCM_mouse_still_down))

MCscreen->addtimer(this, MCM_idle, MCidleRate);

switch (which)

{

case Button1:

switch (getstack()->gettool(this))

{

case T_BROWSE:

// The following we do to ensure that a click on the card unfocuses any browsers

// on OS X - what should really happen here is that the *card* should be focused

// but things aren't currently engineered this way

MCstacks -> ensureinputfocus(getstack() -> getwindow());

kunfocus();

#ifdef _MOBILE

// Make sure the IME has gone away on mobile if due to an explicit card

// click.

MCscreen -> closeIME();

#endif

message_with_valueref_args(MCM_mouse_down, MCSTR("1"));

if (!(MCbuttonstate & (0x1L << (which - 1))))

{

Boolean oldstate = MClockmessages;

MClockmessages = True;

mup(which, false);

MClockmessages = oldstate;

}

break;

case T_POINTER:

// MW-2010-10-15: [[ Bug 9055 ]] Make sure the card script gets a chance to cancel selection handling

if (message_with_valueref_args(MCM_mouse_down, MCSTR("1")) == ES_NORMAL && !MCexitall)

return True;

// MW-2010-11-24: [[ Bug 9194 ]] Make sure we reset exitall, otherwise the selectedObjectChanged message

// won't be sent.

MCexitall = False;

if (!(MCmodifierstate & MS_SHIFT))

MCselected->clear(True);

state |= CS_SIZE;

startx = MCmousex;

starty = MCmousey;

MCU_set_rect(selrect, startx, starty, 1, 1);

break;

case T_HELP:

break;

case T_BUTTON:

cptr = new MCButton(*MCtemplatebutton);

break;

case T_SCROLLBAR:

cptr = new MCScrollbar(*MCtemplatescrollbar);

break;

case T_PLAYER:

cptr = new MCPlayer(*MCtemplateplayer);

break;

case T_GRAPHIC:

cptr = new MCGraphic(*MCtemplategraphic);

break;

case T_FIELD:

cptr = new MCField(*MCtemplatefield);

break;

case T_IMAGE:

cptr = new MCImage(*MCtemplateimage);

break;

case T_DROPPER:

// IM-2013-09-23: [[ FullscreenMode ]] Get mouse loc in view coordinates

MCStack *t_mousestack;

MCPoint t_mouseloc;

MCscreen->getmouseloc(t_mousestack, t_mouseloc);

MCscreen->dropper(getw(), t_mouseloc.x, t_mouseloc.y, NULL);

message(MCM_color_changed);

break;

case T_BRUSH:

case T_BUCKET:

case T_CURVE:

case T_LINE:

case T_OVAL:

case T_PENCIL:

case T_POLYGON:

case T_RECTANGLE:

case T_REGULAR_POLYGON:

case T_ROUND_RECT:

case T_SPRAY:

case T_TEXT:

{

if (objptrs != NULL)

{

MCObjptr *optr = objptrs;

do

{

if (optr->getref()->gettype() == CT_IMAGE)

return False;

optr = optr->next();

}

while (optr != objptrs);

}

MCImage *iptr = createimage();

iptr->mfocus(MCmousex, MCmousey);

iptr->mdown(which);

}

break;

default:

return False;

}

break;

case Button2:

case Button3:

message_with_args(MCM_mouse_down, which);

return False;

}

}

if (cptr != NULL)

{

getstack()->appendcontrol(cptr);

mfocused = newcontrol(cptr, False);

cptr->create(MCmousex, MCmousey);

}

return True;

}

Boolean MCCard::mup(uint2 which, bool p_release)

{

if (state & CS_MENU_ATTACHED)

return MCObject::mup(which, p_release);

if (mfocused != NULL)

{

mgrabbed = False;

return mfocused->getref()->mup(which, p_release);

}

else

{

if (state & (CS_INSIDE | CS_SIZE))

{

switch (which)

{

case Button1:

if (state & CS_SIZE)

{

state &= ~CS_SIZE;

// MW-2011-08-18: // MW-2011-08-19: [[ Layers ]] Ensure the selection rect is updated.

layer_dirtyrect(selrect);

// MM-2012-11-05: [[ Object selection started/ended message ]]

if (m_selecting_objects)

{

m_selecting_objects = false;

message(MCM_object_selection_ended);

}

}

switch (getstack()->gettool(this))

{

case T_POINTER:

case T_BROWSE:

// MW-2010-10-15: [[ Bug 9055 ]] Mouse message consistency improvement

if (p_release)

message_with_valueref_args(MCM_mouse_release, MCSTR("1"));

else

message_with_valueref_args(MCM_mouse_up, MCSTR("1"));

break;

case T_HELP:

help();

break;

default:

break;

}

break;

case Button2:

case Button3:

// MW-2014-07-24: [[ Bug 12882 ]] Make sure we pass through correct button number.

if (p_release)

message_with_valueref_args(MCM_mouse_release, which == Button2 ? MCSTR("2") : MCSTR("3"));

else

message_with_valueref_args(MCM_mouse_up, which == Button2 ? MCSTR("2") : MCSTR("3"));

break;

}

mgrabbed = False;

return True;

}

mgrabbed = False;

}

return False;

}

Boolean MCCard::doubledown(uint2 which)

{

if (mfocused != NULL)

{

mgrabbed = True;

MCControl *oldfocused = mfocused->getref();

if (!mfocused->getref()->doubledown(which)

&& getstack()->gettool(this) == T_BROWSE)

message_with_valueref_args(MCM_mouse_double_down, MCSTR("1"));

if (!(MCbuttonstate & (0x1L << (which - 1))))

{

Boolean oldstate = MClockmessages;

MClockmessages = True;

if (!doubleup(which))

oldfocused->doubleup(which);

MClockmessages = oldstate;

}

}

else

{

// MW-2010-10-15: [[ Bug 9055 ]] Don't send messages to the card, if they were sent to the control

switch (which)

{

case Button1:

switch (getstack()->gettool(this))

{

case T_BROWSE:

case T_POINTER:

message_with_valueref_args(MCM_mouse_double_down, MCSTR("1"));

break;

default:

break;

}

break;

case Button2:

case Button3:

message_with_args(MCM_mouse_double_down, which);

break;

}

}

return True;

}

Boolean MCCard::doubleup(uint2 which)

{

if (mfocused != NULL)

{

mgrabbed = False;

return mfocused->getref()->doubleup(which);

}

else

{

// MW-2010-10-15: [[ Bug 9055 ]] Don't send messages to the card, if they were sent to the control

switch (which)

{

case Button1:

switch (getstack()->gettool(this))

{

case T_BROWSE:

message_with_valueref_args(MCM_mouse_double_up, MCSTR("1"));

break;

case T_POINTER:

getstack()->kfocusset(NULL);

if (MCmodifierstate & MS_MOD1)

editscript();

else

{

MCselected->replace(this);

message_with_valueref_args(MCM_mouse_double_up, MCSTR("1"));

}

break;

default:

break;

}

break;

case Button2:

case Button3:

message_with_args(MCM_mouse_double_up, which);

break;

}

}

return True;

}

void MCCard::timer(MCNameRef mptr, MCParameter *params)

{

if (MCNameIsEqualTo(mptr, MCM_idle, kMCCompareCaseless))

{

if (opened)

{

Boolean again = False;

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

if (mfocused == NULL && MCbuttonstate)

{

if (tool == T_BROWSE)

if (message(MCM_mouse_still_down) == ES_ERROR)

senderror();

else

again = True;

}

if (hashandlers & HH_IDLE)

{

if (tool == T_BROWSE)