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

#include "util.h"

#include "sellst.h"

#include "stack.h"

#include "tooltip.h"

#include "card.h"

#include "control.h"

#include "group.h"

#include "field.h"

#include "scrolbar.h"

#include "mcerror.h"

#include "hndlrlst.h"

#include "stacklst.h"

#include "undolst.h"

#include "mctheme.h"

#include "dispatch.h"

#include "parentscript.h"

#include "globals.h"

#include "context.h"

#include "bitmapeffect.h"

#include "graphicscontext.h"

#include "graphics_util.h"

#include "exec.h"

MCControl *MCControl::focused;

int2 MCControl::defaultmargin = 4;

int2 MCControl::xoffset;

int2 MCControl::yoffset;

double MCControl::aspect;

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

MCPropertyInfo MCControl::kProperties[] =

{

DEFINE_RW_OBJ_PROPERTY(P_LEFT_MARGIN, Int16, MCControl, LeftMargin)

DEFINE_RW_OBJ_PROPERTY(P_RIGHT_MARGIN, Int16, MCControl, RightMargin)

DEFINE_RW_OBJ_PROPERTY(P_TOP_MARGIN, Int16, MCControl, TopMargin)

DEFINE_RW_OBJ_PROPERTY(P_BOTTOM_MARGIN, Int16, MCControl, BottomMargin)

DEFINE_RW_OBJ_CUSTOM_PROPERTY(P_MARGINS, InterfaceMargins, MCControl, Margins)

DEFINE_RW_OBJ_PROPERTY(P_TOOL_TIP, String, MCControl, ToolTip)

DEFINE_RW_OBJ_PROPERTY(P_UNICODE_TOOL_TIP, BinaryString, MCControl, UnicodeToolTip)

DEFINE_RW_OBJ_NON_EFFECTIVE_ENUM_PROPERTY(P_LAYER_MODE, InterfaceLayerMode, MCControl, LayerMode)

DEFINE_RO_OBJ_EFFECTIVE_ENUM_PROPERTY(P_LAYER_MODE, InterfaceLayerMode, MCControl, LayerMode)

DEFINE_RW_OBJ_RECORD_PROPERTY(P_BITMAP_EFFECT_DROP_SHADOW, MCControl, DropShadow)

DEFINE_RW_OBJ_RECORD_PROPERTY(P_BITMAP_EFFECT_OUTER_GLOW, MCControl, OuterGlow)

DEFINE_RW_OBJ_RECORD_PROPERTY(P_BITMAP_EFFECT_INNER_GLOW, MCControl, InnerGlow)

DEFINE_RW_OBJ_RECORD_PROPERTY(P_BITMAP_EFFECT_COLOR_OVERLAY, MCControl, ColorOverlay)

DEFINE_RW_OBJ_RECORD_PROPERTY(P_BITMAP_EFFECT_INNER_SHADOW, MCControl, InnerShadow)

};

MCObjectPropertyTable MCControl::kPropertyTable =

{

&MCObject::kPropertyTable,

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

&kProperties[0],

};

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

MCControl::MCControl()

{

rect.x = rect.y = -1;

rect.width = MCminsize << 4;

rect.height = MCminsize << 2;

leftmargin = rightmargin = topmargin = bottommargin = defaultmargin;

// MW-2004-11-26: Initialise mx and my (VG)

mx = my = 0;

// MW-2009-06-09: [[ Bitmap Effects ]]

MCBitmapEffectsInitialize(m_bitmap_effects);

// MW-2011-09-21: [[ Layers ]] Clear the layer attrs.

layer_resetattrs();

// MW-2011-09-21: [[ Layers ]] The layer starts off as static.

m_layer_mode_hint = kMCLayerModeHintStatic;

}

MCControl::MCControl(const MCControl &cref) : MCObject(cref)

{

leftmargin = cref.leftmargin;

rightmargin = cref.rightmargin;

topmargin = cref.topmargin;

bottommargin = cref.bottommargin;

state &= ~CS_KFOCUSED;

// MW-2006-04-21: [[ Purify ]] Need to initialise mx and my here too

mx = my = 0;

// MW-2009-06-09: [[ Bitmap Effects ]] Note that this is not currently robust

// as the copy could silently fail.

MCBitmapEffectsInitialize(m_bitmap_effects);

MCBitmapEffectsAssign(m_bitmap_effects, cref . m_bitmap_effects);

// MW-2011-09-21: [[ Layers ]] Clear the layer attrs.

layer_resetattrs();

// MW-2011-09-21: [[ Layers ]] The layer takes its layer hint from the source.

m_layer_mode_hint = cref . m_layer_mode_hint;

}

MCControl::~MCControl()

{

if (focused == this)

focused = NULL;

MCscreen->stopmove(this, False);

// MW-2009-06-11: [[ Bitmap Effects ]] Destroy the bitmap effects

MCBitmapEffectsFinalize(m_bitmap_effects);

}

void MCControl::open()

{

if (opened == 0)

{

// MW-2011-10-01: [[ Bug 9777 ]] Special case for when 'open' / 'close' used to

// reinitialize object (i.e. MCImage::reopen) - don't update layer attrs if

// KEEP_LAYER is set.

if (!getstate(CS_KEEP_LAYER))

layer_resetattrs();

// Make sure we keep state which should be preserved across open.

state = (state & (CS_NO_MESSAGES | CS_NO_FILE | CS_SELECTED)) | (state & CS_KEEP_LAYER);

}

MCObject::open();

}

void MCControl::close()

{

// MW-2008-01-09: [[ Bug 5739 ]] Changing group layer cancels mousedown

if (opened == 1)

if (focused == this)

focused = NULL;

MCObject::close();

}

void MCControl::kfocus()

{

if (flags & F_TRAVERSAL_ON)

{

uint2 t_old_trans;

t_old_trans = gettransient();

state |= CS_KFOCUSED;

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

// possible change in transient.

layer_transientchangedandredrawall(t_old_trans);;

message(MCM_focus_in);

}

}

void MCControl::kunfocus()

{

if (state & CS_KFOCUSED)

{

uint2 t_old_trans;

t_old_trans = gettransient();

state &= ~CS_KFOCUSED;

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

// possible change in transient.

layer_transientchangedandredrawall(t_old_trans);

message(MCM_focus_out);

}

}

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

{

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

return True;

switch (key)

{

case XK_space:

case XK_Return:

case XK_KP_Enter:

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

return True;

default:

break;

}

return False;

}

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

{

// SMR 594 do menu stuff before visibility check

if (state & CS_MENU_ATTACHED)

return MCObject::mfocus(x, y);

if (!(flags & F_VISIBLE || MCshowinvisibles)

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

return False;

if (state & CS_GRAB)

{

MCRectangle newrect = rect;

newrect.x = x - xoffset;

newrect.y = y - yoffset;

mx = x;

my = y;

// MW-2011-08-18: [[ Layers ]] Set the rect.

if (newrect.x != rect.x || newrect.y != rect.y)

layer_setrect(newrect, false);

message_with_args(MCM_mouse_move, x, y);

return True;

}

if (state & CS_MOVE)

{

mx = x;

my = y;

MCselected->continuemove(x, y);

// MM-2012-09-05: [[ Property Listener ]] Moving object using IDE. Make sure location property is flagged as changed.

signallisteners(P_LOCATION);

message_with_args(MCM_mouse_move, x, y);

return True;

}

if (state & CS_SIZE)

{

continuesize(x, y);

// MM-2012-09-05: [[ Property Listener ]] Resizing object using IDE. Make sure rect property is flagged as changed.

signallisteners(P_RECTANGLE);

message_with_args(MCM_mouse_move, x, y);

return True;

}

MCRectangle srect;

MCU_set_rect(srect, x, y, 1, 1);

Boolean is = maskrect(srect) || (state & CS_SELECTED

&& MCU_point_in_rect(rect, x, y)

&& sizehandles() != 0);

mx = x;

my = y;

if (is || state & CS_MFOCUSED)

{

if (focused == this || getstack() -> gettool(this) == T_POINTER)

{

if (MCdispatcher -> isdragtarget())

message_with_args(MCM_drag_move, x, y);

else

message_with_args(MCM_mouse_move, x, y);

}

}

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

{

case T_BROWSE:

case T_HELP:

case T_POINTER:

if (state & CS_MFOCUSED)

return True;

break;

case T_BUTTON:

case T_SCROLLBAR:

case T_PLAYER:

case T_FIELD:

case T_IMAGE:

case T_GRAPHIC:

if ((is && state & CS_SELECTED) || state & CS_MFOCUSED)

return True;

else

return False;

break;

default:

is = False;

break;

}

return is;

}

void MCControl::munfocus()

{

if (focused == this)

{

if (state & CS_MFOCUSED)

{

mfocus(mx, my);

// IM-2013-08-07: [[ Bug 10671 ]] Release grabbed controls when removing focus

state &= ~(CS_MFOCUSED | CS_GRAB);

message(MCM_mouse_release);

}

else

leave();

}

mx = rect.x - 1;

my = rect.y - 1;

}

Boolean MCControl::doubledown(uint2 which)

{

switch (which)

{

case Button1:

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

{

case T_BROWSE:

case T_BUTTON:

case T_FIELD:

case T_SCROLLBAR:

case T_PLAYER:

case T_IMAGE:

case T_GRAPHIC:

case T_POINTER:

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

break;

default:

return False;

}

break;

case Button2:

case Button3:

message_with_args(MCM_mouse_double_down, which);

break;

}

return True;

}

Boolean MCControl::doubleup(uint2 which)

{

switch (which)

{

case Button1:

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

{

case T_BUTTON:

case T_FIELD:

case T_SCROLLBAR:

case T_PLAYER:

case T_IMAGE:

case T_GRAPHIC:

case T_POINTER:

// MW-2010-10-15: [[ Bug 9055 ]] Pass false here to prevent 'mouseUp' being sent.

end(false, false);

case T_BROWSE:

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

break;

default:

return False;

}

break;

case Button2:

case Button3:

message_with_args(MCM_mouse_double_up, which);

break;

}

return True;

}

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

{

if (MCNameIsEqualTo(mptr, MCM_idle, kMCCompareCaseless))

{

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

{

Boolean again = False;

MCRectangle srect;

MCU_set_rect(srect, mx, my, 1, 1);

if (maskrect(srect))

{

if (conditionalmessage(HH_MOUSE_WITHIN, MCM_mouse_within) == ES_ERROR)

senderror();

else

again = True;

}

if (state & CS_MFOCUSED)

{

if (conditionalmessage(HH_MOUSE_STILL_DOWN, MCM_mouse_still_down) == ES_ERROR)

senderror();

else

again = True;

}

if (hashandlers & HH_IDLE)

{

if (message(MCM_idle) == ES_ERROR)

senderror();

else

again = True;

}

if (again)

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

}

}

else

MCObject::timer(mptr, params);

}

uint2 MCControl::gettransient() const

{

if (state & CS_KFOCUSED && MClook == LF_MOTIF

&& !(extraflags & EF_NO_FOCUS_BORDER))

return MCfocuswidth;

return 0;

}

#ifdef LEGACY_EXEC

Exec_stat MCControl::getprop_legacy(uint4 parid, Properties which, MCExecPoint& ep, Boolean effective, bool recursive = false)

{

switch (which)

{

#ifdef /* MCControl::getprop */ LEGACY_EXEC

case P_MARGINS:

if (leftmargin == rightmargin && leftmargin == topmargin && leftmargin == bottommargin)

ep.setint(leftmargin);

else

ep.setrectangle(leftmargin, topmargin, rightmargin, bottommargin);

break;

case P_LEFT_MARGIN:

ep.setint(leftmargin);

break;

case P_RIGHT_MARGIN:

ep.setint(rightmargin);

break;

case P_TOP_MARGIN:

ep.setint(topmargin);

break;

case P_BOTTOM_MARGIN:

ep.setint(bottommargin);

break;

// MW-2012-03-013: [[ UnicodeToolTip ]] If normal tool tip is requested convert to

// native.

case P_TOOL_TIP:

ep.setsvalue(tooltip);

ep.utf8tonative();

break;

// MW-2012-03-013: [[ UnicodeToolTip ]] If unicode tool tip is requested convert to

// UTF-16.

case P_UNICODE_TOOL_TIP:

ep.setsvalue(tooltip);

ep.utf8toutf16();

break;

// MW-2011-08-25: [[ Layers ]] Handle layerMode property fetch.

case P_LAYER_MODE:

{

// MW-2011-09-21: [[ Layers ]] Updated to use layerMode hint system.

MCLayerModeHint t_mode;

if (effective)

t_mode = layer_geteffectivemode();

else

t_mode = m_layer_mode_hint;

const char *t_value;

switch(t_mode)

{

case kMCLayerModeHintStatic:

t_value = "static";

break;

case kMCLayerModeHintDynamic:

t_value = "dynamic";

break;

case kMCLayerModeHintScrolling:

t_value = "scrolling";

break;

case kMCLayerModeHintContainer:

t_value = "container";

break;

}

ep.setstaticcstring(t_value);

}

break;

#endif /* MCControl::getprop */

default:

return MCObject::getprop_legacy(parid, which, ep, effective, recursive);

}

return ES_NORMAL;

}

// MW-2011-11-23: [[ Array Chunk Props ]] Add 'effective' param to arrayprop access.

Exec_stat MCControl::getarrayprop_legacy(uint4 parid, Properties which, MCExecPoint& ep, MCNameRef key, Boolean effective)

{

switch(which)

{

#ifdef /* MCControl::getarrayprop */ LEGACY_EXEC

// MW-2009-06-09: [[ Bitmap Effects ]]

case P_BITMAP_EFFECT_DROP_SHADOW:

case P_BITMAP_EFFECT_INNER_SHADOW:

case P_BITMAP_EFFECT_OUTER_GLOW:

case P_BITMAP_EFFECT_INNER_GLOW:

case P_BITMAP_EFFECT_COLOR_OVERLAY:

return MCBitmapEffectsGetProperties(m_bitmap_effects, which, ep, key);

#endif /* MCControl::getarrayprop */

default:

return MCObject::getarrayprop_legacy(parid, which, ep, key, effective);

}

return ES_NORMAL;

}

Exec_stat MCControl::setprop_legacy(uint4 parid, Properties which, MCExecPoint &ep, Boolean effective)

{

Boolean dirty = True;

int2 i1, i2, i3, i4;

MCString data = ep.getsvalue();

switch (which)

{

#ifdef /* MCControl::setprop */ LEGACY_EXEC

case P_MARGINS:

if (MCU_stoi2(data, i1))

leftmargin = rightmargin = topmargin = bottommargin = i1;

else

{

if (!MCU_stoi2x4(data, i1, i2, i3, i4))

{

MCeerror->add(EE_OBJECT_MARGINNAN, 0, 0, data);

return ES_ERROR;

}

leftmargin = i1;

topmargin = i2;

rightmargin = i3;

bottommargin = i4;

}

break;

case P_LEFT_MARGIN:

if (!MCU_stoi2(data, i1))

{

MCeerror->add(EE_OBJECT_MARGINNAN, 0, 0, data);

return ES_ERROR;

}

leftmargin = i1;

break;

case P_RIGHT_MARGIN:

if (!MCU_stoi2(data, i1))

{

MCeerror->add(EE_OBJECT_MARGINNAN, 0, 0, data);

return ES_ERROR;

}

rightmargin = i1;

break;

case P_TOP_MARGIN:

if (!MCU_stoi2(data, i1))

{

MCeerror->add(EE_OBJECT_MARGINNAN, 0, 0, data);

return ES_ERROR;

}

topmargin = i1;

break;

case P_BOTTOM_MARGIN:

if (!MCU_stoi2(data, i1))

{

MCeerror->add(EE_OBJECT_MARGINNAN, 0, 0, data);

return ES_ERROR;

}

bottommargin = i1;

break;

// MW-2012-03-13: [[ UnicodeToolTip ]] Handle the unicodeToolTip property - same

// as tooltip except expects UTF-16 encoded string, rather than native.

case P_TOOL_TIP:

case P_UNICODE_TOOL_TIP:

if (tooltip != MCtooltip->gettip())

dirty = False;

delete tooltip;

// MW-2012-03-13: [[ UnicodeToolTip ]] Convert the value to UTF-8 - either

// from native or UTF-16 depending on what prop was set.

if (which == P_TOOL_TIP)

ep.nativetoutf8();

else

ep.utf16toutf8();

data = ep . getsvalue();

if (data != MCnullmcstring)

tooltip = data.clone();

else

tooltip = NULL;

if (dirty && focused == this)

{

MCtooltip->settip(tooltip);

dirty = False;

}

break;

// MW-2011-08-25: [[ TileCache ]] Handle layerMode property store.

case P_LAYER_MODE:

{

// MW-2011-09-21: [[ Layers ]] Updated to use new layermode hint system.

MCLayerModeHint t_mode;

if (data == "static")

t_mode = kMCLayerModeHintStatic;

else if (data == "dynamic")

t_mode = kMCLayerModeHintDynamic;

else if (data == "scrolling")

t_mode = kMCLayerModeHintScrolling;

#if NOT_YET_IMPLEMENTED

else if (data == "container")

t_mode = kMCLayerModeHintContainer;

#endif

else

{

MCeerror -> add(EE_CONTROL_BADLAYERMODE, 0, 0, data);

return ES_ERROR;

}

// If the layer mode hint has changed, update and mark the attrs

// for recompute. If the hint hasn't changed, then there's no need

// to redraw.

if (t_mode != m_layer_mode_hint)

{

m_layer_attr_changed = true;

m_layer_mode_hint = t_mode;

}

else

dirty = False;

}

break;

// MW-2011-09-21: [[ Layers ]] There are numerous properties which

// can affect the layer attributes, thus in those cases we pass back

// the handling and then mark the attrs for a recompute.

// The 'ink' property affects whether a layer can be static.

case P_INK:

// The border, focus border and shadow properties can affect whether the layer

// is direct.

case P_SHOW_BORDER:

case P_SHOW_FOCUS_BORDER:

case P_SHADOW:

// The opaque property can affect the layer's opaqueness.

case P_FILLED:

case P_OPAQUE:

if (MCObject::setprop(parid, which, ep, effective) != ES_NORMAL)

return ES_ERROR;

// Mark the layer attrs for recompute.

m_layer_attr_changed = true;

return ES_NORMAL;

#endif /* MCControl::setprop */

default:

return MCObject::setprop_legacy(parid, which, ep, effective);

}

if (dirty && opened)

{

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

layer_redrawall();

}

return ES_NORMAL;

}

Exec_stat MCControl::setarrayprop_legacy(uint4 parid, Properties which, MCExecPoint& ep, MCNameRef key, Boolean effective)

{

Boolean dirty;

dirty = False;

switch(which)

{

#ifdef /* MCControl::setarrayprop */ LEGACY_EXEC

case P_BITMAP_EFFECT_DROP_SHADOW:

case P_BITMAP_EFFECT_INNER_SHADOW:

case P_BITMAP_EFFECT_OUTER_GLOW:

case P_BITMAP_EFFECT_INNER_GLOW:

case P_BITMAP_EFFECT_COLOR_OVERLAY:

{

MCRectangle t_old_effective_rect = geteffectiverect();

if (MCBitmapEffectsSetProperties(m_bitmap_effects, which, ep, key, dirty) != ES_NORMAL)

return ES_ERROR;

if (dirty && opened)

{

// MW-2011-09-21: [[ Layers ]] Mark the attrs as needing redrawn.

m_layer_attr_changed = true;

// MW-2011-08-17: [[ Layers ]] Make sure any redraw needed due to effects

// changing occur.

layer_effectschanged(t_old_effective_rect);

}

}

return ES_NORMAL;

#endif /* MCControl::setarrayprop */

default:

break;

}

return MCObject::setarrayprop_legacy(parid, which, ep, key, effective);

}

#endif

void MCControl::select()

{

state |= CS_SELECTED;

kunfocus();

// MW-2011-09-23: [[ Layers ]] Mark the layer attrs as having changed - the selection

// setting can influence the layer type.

m_layer_attr_changed = true;

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

layer_redrawall();

}

void MCControl::deselect()

{

if (state & CS_SELECTED)

{

state &= ~(CS_SELECTED | CS_MOVE | CS_SIZE | CS_CREATE);

// MW-2011-09-23: [[ Layers ]] Mark the layer attrs as having changed - the selection

// setting can influence the layer type.

m_layer_attr_changed = true;

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

layer_redrawall();

}

}

Boolean MCControl::del()

{

if (parent == NULL || scriptdepth != 0 || getstack()->islocked())

{

MCeerror->add(EE_OBJECT_CANTREMOVE, 0, 0);

return False;

}

switch (gettype())

{

case CT_BUTTON:

message(MCM_delete_button);

break;

case CT_EPS:

message(MCM_delete_eps);

break;

case CT_FIELD:

message(MCM_delete_field);

break;

case CT_IMAGE:

message(MCM_delete_image);

break;

case CT_SCROLLBAR:

message(MCM_delete_scrollbar);

break;

case CT_PLAYER:

message(MCM_delete_player);

break;

case CT_GRAPHIC:

message(MCM_delete_graphic);

break;

case CT_GROUP:

message(MCM_delete_group);

message(MCM_delete_background);

break;

case CT_WIDGET:

message(MCM_delete_widget);

break;

default:

break;

}

uint2 num = 0;

getcard()->count(CT_LAYER, CT_UNDEFINED, this, num, True);

switch (parent->gettype())

{

case CT_CARD:

{

MCCard *cptr = (MCCard *)parent;

if (!cptr->removecontrol(this, False, True))

return False;

getstack()->removecontrol(this);

break;

}

case CT_GROUP:

{

MCGroup *gptr = (MCGroup *)parent;

gptr->removecontrol(this, True);

break;

}

default:

{ //stack

MCStack *sptr = (MCStack *)parent;

sptr->removecontrol(this);

}

}

// IM-2012-05-16 [[ BZ 10212 ]] deleting the dragtarget control in response

// to a 'dragdrop' message would leave these globals pointing to the deleted

// object, leading to an infinite loop if the target was a field

if (MCdragdest == this)

{

MCdragdest = nil;

MCdropfield = nil;

}

if (MCdragsource == this)

MCdragsource = nil;

// MCObject now does things on del(), so we must make sure we finish by

// calling its implementation.

return MCObject::del();

}

void MCControl::paste(void)

{

if (MCdefaultstackptr->getmode() != WM_TOP_LEVEL)

return;

parent = MCdefaultstackptr->getchild(CT_THIS, kMCEmptyString, CT_CARD);

MCCard *cptr = (MCCard *)parent;

obj_id = 0;

//newcontrol->resetfontindex(oldstack);

if (!MCU_point_in_rect(cptr->getrect(), rect.x + (rect.width >> 1),

rect.y + (rect.height >> 1)))

setrect(MCU_center_rect(cptr->getrect(), rect));

attach(OP_NONE, false);

if (getstack()->gettool(this) == T_POINTER && opened)

{

state |= CS_SELECTED;

MCselected->clear(False);

MCselected->add(this);

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

layer_redrawall();

}

}

void MCControl::undo(Ustruct *us)

{

MCRectangle newrect = rect;

switch (us->type)

{

case UT_MOVE:

if (!(flags & F_LOCK_LOCATION))

{

newrect.x -= us->ud.deltas.x;

newrect.y -= us->ud.deltas.y;

us->ud.deltas.x = -us->ud.deltas.x;

us->ud.deltas.y = -us->ud.deltas.y;

}

break;

case UT_SIZE:

newrect = us->ud.rect;

us->ud.rect = rect;

break;

case UT_DELETE:

{

MCCard *card = (MCCard *)parent->getcard();

getstack()->appendcontrol(this);

card->newcontrol(this, False);

Boolean oldrlg = MCrelayergrouped;

MCrelayergrouped = True;

card->relayer(this, us->ud.layer);

MCrelayergrouped = oldrlg;

Boolean oldlock = MClockmessages;

MClockmessages = True;

MCselected->add(this);

MClockmessages = oldlock;

MCscreen->delaymessage(this, MCM_selected_object_changed);

us->type = UT_REPLACE;

}

return;

case UT_REPLACE:

del();

us->type = UT_DELETE;

return;

default:

break;

}

// MW-2011-08-18: [[ Layers ]] Set the rect.

layer_setrect(newrect, false);

// MW-2011-10-03: [[ Scrolling ]] Make sure the parent is notified.

resizeparent();

}

// MW-2011-09-06: [[ Redraw ]] Added 'sprite' option - if true, ink and opacity are not set.

void MCControl::draw(MCDC *dc, const MCRectangle &dirty, bool p_isolated, bool p_sprite)

{

fprintf(stderr, "Control: ERROR tried to draw control id %d\n", obj_id);

}

IO_stat MCControl::save(IO_handle stream, uint4 p_part, bool p_force_ext)

{

return MCObject::save(stream, p_part, p_force_ext);

}

Boolean MCControl::kfocusset(MCControl *target)

{

if (target == this)

return True;

return False;

}

MCControl *MCControl::clone(Boolean attach, Object_pos p, bool invisible)

{

fprintf(stderr, "Control: ERROR tried to clone control id %d\n", obj_id);

return NULL;

}

MCControl *MCControl::findnum(Chunk_term type, uint2 &num)

{

if ((type == gettype() || type == CT_LAYER) && num-- == 0)

return this;

else

return NULL;

}

MCControl *MCControl::findname(Chunk_term type, MCNameRef p_name)

{

if ((type == gettype() || type == CT_LAYER)

&& MCU_matchname(p_name, gettype(), getname()))

return this;

else

return NULL;

}

MCControl *MCControl::findid(Chunk_term type, uint4 inid, Boolean alt)

{

if ((type == gettype() || type == CT_LAYER)

&& (inid == obj_id || (alt && inid == altid)))

return this;

else

return NULL;

}

Boolean MCControl::count(Chunk_term type, MCObject *stop, uint2 &num)

{

if (type == gettype() || type == CT_LAYER)

num++;

if (stop == this)

return True;

return False;

}

Boolean MCControl::maskrect(const MCRectangle &srect)

{

if (!(flags & F_VISIBLE || MCshowinvisibles))

return False;

MCRectangle drect = MCU_intersect_rect(srect, rect);

return drect.width != 0 && drect.height != 0;

}

void MCControl::installaccels(MCStack *stack)

{ }

void MCControl::removeaccels(MCStack *stack)

{ }

MCCdata *MCControl::getdata(uint4 cardid, Boolean clone)

{

return NULL;

}

void MCControl::replacedata(MCCdata *&data, uint4 newid)

{ }

void MCControl::compactdata()

{ }

void MCControl::resetfontindex(MCStack *oldstack)

{

}

Exec_stat MCControl::hscroll(int4 offset, Boolean doredraw)

{

return ES_NORMAL;

}

Exec_stat MCControl::vscroll(int4 offset, Boolean doredraw)

{

return ES_NORMAL;

}

void MCControl::readscrollbars()

{ }

void MCControl::setsbrects()

{ }

void MCControl::resetscrollbars(Boolean move)

{ }

void MCControl::fliph()

{ }

void MCControl::flipv()

{ }

void MCControl::attach(Object_pos p, bool invisible)

{

int2 v1 = rect.x;

int2 v2 = rect.y;

if (p == OP_CENTER && v1 == -1 && v2 == -1)

positionrel(getcard()->getrect(), OP_CENTER, OP_MIDDLE);

else

if (p == OP_OFFSET)