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

MCRectangle MCCard::selrect;

int2 MCCard::startx;

int2 MCCard::starty;

MCObjptr *MCCard::removedcontrol;

#ifdef _MAC_DESKTOP

extern bool MCosxmenupoppedup;

#endif

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;

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

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

if (oldkfocused == NULL)

return False;

}

if (kfocused == NULL)

kfocused = tptr;

}

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

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

if (oldkfocused == NULL)

return False;

}

if (kfocused == NULL)

kfocused = tptr;

}

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;

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

}

else

{

message(MCM_focus_out);

oldkfocused = NULL;

}

}

Boolean MCCard::kdown(const char *string, KeySym key)

{

MCtooltip->closetip();

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

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

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

return True;

return False;

}

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

{

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

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

return MCObject::kup(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->settip(NULL);

// 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->settip(NULL);

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.

if (oldfocused -> handlesmessage(MCM_mouse_still_down))

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

// MW-2007-12-11: [[ Bug 5670 ]] Reset our notification var so we can check it after

#ifdef _MACOSX

MCosxmenupoppedup = false;

#endif

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

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

{

#ifdef _MACOSX

if (!MCosxmenupoppedup)

#endif

message_with_args(MCM_mouse_down, "1");

}

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

{

Boolean oldstate = MClockmessages;

MClockmessages = True;

if (!mup(which))

oldfocused->mup(which);

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_args(MCM_mouse_down, "1");

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

{

Boolean oldstate = MClockmessages;

MClockmessages = True;

mup(which);

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_args(MCM_mouse_down, "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)

{

if (state & CS_MENU_ATTACHED)

return MCObject::mup(which);

if (mfocused != NULL)

{

mgrabbed = False;

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

}

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

message_with_args(MCM_mouse_up, "1");

break;

case T_HELP:

help();

break;

default:

break;

}

break;

case Button2:

case Button3:

message_with_args(MCM_mouse_up, which);

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_args(MCM_mouse_double_down, "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_args(MCM_mouse_double_down, "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_args(MCM_mouse_double_up, "1");

break;

case T_POINTER:

getstack()->kfocusset(NULL);

if (MCmodifierstate & MS_MOD1)

editscript();

else

{

MCselected->replace(this);

message_with_args(MCM_mouse_double_up, "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)

if (message(MCM_idle) == ES_ERROR)

senderror();

else

again = True;

}

if (again)

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

}

}

else

MCObject::timer(mptr, params);

}

Exec_stat MCCard::getprop(uint4 parid, Properties which, MCExecPoint& ep, Boolean effective)

{

MCRectangle minrect;

uint2 num;

switch (which)

{

#ifdef /* MCCard::getprop */ LEGACY_EXEC

case P_NUMBER:

case P_LAYER:

getstack()->count(CT_CARD, CT_UNDEFINED, this, num);

ep.setint(num);

break;

case P_CANT_DELETE:

ep.setboolean(getflag(F_C_CANT_DELETE));

break;

case P_DONT_SEARCH:

ep.setboolean(getflag(F_C_DONT_SEARCH));

break;

case P_MARKED:

ep.setboolean(getflag(F_MARKED));

break;

case P_SHOW_PICT:

ep.setboolean(True);

break;

case P_FORMATTED_LEFT:

minrect = computecrect();

ep.setint(minrect.x);

break;

case P_FORMATTED_TOP:

minrect = computecrect();

ep.setint(minrect.y);

break;

case P_FORMATTED_HEIGHT:

minrect = computecrect();

ep.setint(minrect.height);

break;

case P_FORMATTED_WIDTH:

minrect = computecrect();

ep.setint(minrect.width);

break;

case P_FORMATTED_RECT:

minrect = computecrect();

ep.setrectangle(minrect);

break;

case P_BACKGROUND_NAMES:

case P_BACKGROUND_IDS:

case P_SHARED_GROUP_NAMES:

case P_SHARED_GROUP_IDS:

case P_GROUP_NAMES:

case P_GROUP_IDS:

case P_CONTROL_NAMES:

case P_CONTROL_IDS:

case P_CHILD_CONTROL_NAMES:

case P_CHILD_CONTROL_IDS:

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

// immediate and all descendent controls of a card.

ep.clear();

clean();

if (objptrs != NULL)

{

bool t_want_background;

t_want_background = which == P_BACKGROUND_NAMES || which == P_BACKGROUND_IDS;

bool t_want_shared;

t_want_shared = which == P_SHARED_GROUP_NAMES || which == P_SHARED_GROUP_IDS;

MCExecPoint t_other_ep(ep);

MCObjptr *optr = objptrs;

uint2 i = 0;

bool t_controls;

t_controls = which == P_CHILD_CONTROL_NAMES || which == P_CHILD_CONTROL_IDS || which == P_CONTROL_NAMES || which == P_CONTROL_IDS;

// MERG-2013-11-03: [[ ChildControlProps ]] No need to assign value to t_prop in each iteration

Properties t_prop;

if (which == P_BACKGROUND_NAMES || which == P_SHARED_GROUP_NAMES || which == P_GROUP_NAMES || which == P_CONTROL_NAMES || which == P_CHILD_CONTROL_NAMES)

t_prop = P_SHORT_NAME;

else

t_prop = P_SHORT_ID;

do

{

MCObject *t_object;

t_object = optr -> getref();

optr = optr -> next();

if (t_object->gettype() == CT_GROUP)

{