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

#include "parsedef.h"

#include "filedefs.h"

#include "mcio.h"

#include "scriptpt.h"

#include "execpt.h"

#include "handler.h"

#include "cmds.h"

#include "visual.h"

#include "chunk.h"

#include "mcerror.h"

#include "object.h"

#include "dispatch.h"

#include "stack.h"

#include "card.h"

#include "group.h"

#include "button.h"

#include "player.h"

#include "stacklst.h"

#include "cardlst.h"

#include "util.h"

#include "ans.h"

#include "debug.h"

#include "globals.h"

#include "securemode.h"

#include "redraw.h"

MCCompact::~MCCompact()

{

delete target;

}

Parse_stat MCCompact::parse(MCScriptPoint &sp)

{

initpoint(sp);

target = new MCChunk(False);

if (target->parse(sp, False) != PS_NORMAL)

{

MCperror->add

(PE_COMPACT_BADPARAM, sp);

return PS_ERROR;

}

return PS_NORMAL;

}

Exec_stat MCCompact::exec(MCExecPoint &ep)

{

#ifdef /* MCCompact */ LEGACY_EXEC

MCObject *optr;

uint4 parid;

if (target->getobj(ep, optr, parid, True) != ES_NORMAL)

{

MCeerror->add

(EE_COMPACT_NOTARGET, line, pos);

return ES_ERROR;

}

if (optr->gettype() != CT_STACK)

{

MCeerror->add

(EE_COMPACT_NOTASTACK, line, pos);

return ES_ERROR;

}

MCStack *sptr = (MCStack *)optr;

sptr->compact();

return ES_NORMAL;

#endif /* MCCompact */

}

MCGo::~MCGo()

{

while (stack != NULL)

{

MCCRef *tptr = stack;

stack = stack->next;

delete tptr;

}

delete stack;

delete background;

delete card;

delete window;

}

Parse_stat MCGo::parse(MCScriptPoint &sp)

{

Symbol_type type;

Boolean need_target = True;

const LT *te;

MCCRef *curref = NULL;

Chunk_term oterm = CT_UNDEFINED;

Chunk_term nterm = CT_UNDEFINED;

Chunk_term lterm = CT_UNDEFINED;

initpoint(sp);

if (sp.skip_token(SP_FACTOR, TT_PROPERTY, P_INVISIBLE) == PS_NORMAL)

visible = False;

while (True)

{

if (sp.next(type) != PS_NORMAL)

if (need_target)

{

if (ct_class(oterm) == CT_ORDINAL)

{

card = new MCCRef;

card->otype = CT_CARD;

card->etype = oterm;

return PS_NORMAL;

}

else

{

MCperror->add

(PE_GO_NOID, sp);

return PS_ERROR;

}

}

else

break;

if (type == ST_ID && (sp.lookup(SP_FACTOR, te) == PS_NORMAL

|| sp.lookup(SP_GO, te) == PS_NORMAL))

{

switch (te->type)

{

case TT_PREP:

if (need_target)

{

MCperror->add

(PE_GO_BADPREP, sp);

return PS_ERROR;

}

if (te->which == PT_AS)

{

if (sp.next(type) != PS_NORMAL

|| type != ST_ID

|| sp.lookup(SP_COMMAND, te) != PS_NORMAL

|| te->type != TT_STATEMENT)

{

uint2 newmode;

if (!MCU_stoui2(sp.gettoken(), newmode)

|| newmode < 1 || newmode >= WM_LAST)

{

MCperror->add

(PE_GO_NOMODE, sp);

return PS_ERROR;

}

mode = (Window_mode)newmode;

return PS_NORMAL;

}

switch (te->which)

{

case S_TOP_LEVEL:

mode = WM_TOP_LEVEL;

break;

case S_MODELESS:

mode = WM_MODELESS;

break;

case S_PALETTE:

mode = WM_PALETTE;

break;

case S_MODAL:

mode = WM_MODAL;

break;

case S_SHEET:

mode = WM_SHEET;

break;

case S_DRAWER:

mode = WM_DRAWER;

break;

case S_PULLDOWN:

mode = WM_PULLDOWN;

break;

case S_POPUP:

mode = WM_POPUP;

break;

case S_OPTION:

mode = WM_OPTION;

break;

default:

MCperror->add

(PE_GO_NOMODE, sp);

return PS_ERROR;

}

}

else

{

sp.backup();

sp.skip_token(SP_SUGAR, TT_PREP, PT_WITHOUT);

sp.skip_token(SP_LOCK, TT_UNDEFINED, LC_ERRORS);

}

return PS_NORMAL;

case TT_TO:

case TT_THE:

break;

case TT_IN:

sp.skip_token(SP_FACTOR, TT_THE);

if (sp.skip_token(SP_FACTOR, TT_CHUNK, CT_STACK) == PS_NORMAL)

{

sp.skip_token(SP_FACTOR, TT_OF);

if (sp.skip_token(SP_FACTOR, TT_CHUNK, CT_THIS) == PS_NORMAL)

{

sp.skip_token(SP_FACTOR, TT_CHUNK, CT_STACK);

thisstack = True;

return PS_NORMAL;

}

sp.skip_token(SP_FACTOR, TT_CHUNK, CT_STACK);

if (sp.parseexp(False, True, &window) != PS_NORMAL)

{

MCperror->add

(PE_GO_BADWINDOW, sp);

return PS_ERROR;

}

return PS_NORMAL;

}

sp.skip_token(SP_VALIDATION, TT_UNDEFINED, IV_UNDEFINED); // a

sp.skip_token(SP_SUGAR, TT_CHUNK, CT_UNDEFINED); // new

sp.skip_token(SP_FACTOR, TT_CHUNK, CT_STACK); // window

sp.skip_token(SP_SUGAR, TT_PREP, PT_WITHOUT); // without

sp.skip_token(SP_LOCK, TT_UNDEFINED, LC_ERRORS); // dialog

return PS_NORMAL;

case TT_OF:

need_target = True;

break;

case TT_CLASS:

if (te->which != CT_MARKED)

{

MCperror->add

(PE_GO_NODEST, sp);

return PS_ERROR;

}

marked = True;

break;

case TT_CHUNK:

nterm = (Chunk_term)te->which;

switch (ct_class(nterm))

{

case CT_DIRECT:

switch (nterm)

{

case CT_BACKWARD:

case CT_FORWARD:

{

card = new MCCRef;

card->etype = nterm;

MCScriptPoint oldsp(sp);

MCerrorlock++;

if (sp.parseexp(False, True, &card->startpos) != PS_NORMAL)

{

sp = oldsp;

delete card->startpos;

card->startpos = NULL;

}

MCerrorlock--;

}

break;

case CT_START:

case CT_FINISH:

card = new MCCRef;

card->etype = nterm;

sp.skip_token(SP_FACTOR, TT_CHUNK, CT_CARD);

break;

case CT_HOME:

case CT_HELP:

stack = new MCCRef;

stack->etype = nterm;

break;

default:

MCperror->add

(PE_GO_BADDIRECT, sp);

return PS_ERROR;

}

return PS_NORMAL;

case CT_ORDINAL:

oterm = nterm;

break;

case CT_TYPES:

if (lterm != CT_UNDEFINED && nterm > lterm)

{

MCperror->add

(PE_GO_BADCHUNKORDER, sp);

return PS_ERROR;

}

curref = new MCCRef;

if (oterm == CT_UNDEFINED)

{

if (nterm >= CT_FIELD || nterm == CT_URL)

{

sp.backup();

nterm = CT_CARD;

curref->etype = CT_EXPRESSION;

}

else

if (sp.skip_token(SP_FACTOR, TT_PROPERTY) == PS_NORMAL)

curref->etype = CT_ID;

else

curref->etype = CT_EXPRESSION;

if (sp.parseexp(False, True, &curref->startpos) != PS_NORMAL)

{

delete curref;

MCperror->add

(PE_GO_BADCHUNKEXP, sp);

return PS_ERROR;

}

}

else

{

curref->etype = oterm;

oterm = CT_UNDEFINED;

}

curref->otype = nterm;

switch (nterm)

{

case CT_STACK:

if (oterm > CT_STACK)

{

MCperror->add

(PE_GO_DUPCHUNK, sp);

delete curref;

return PS_ERROR;

}

curref->next = stack;

stack = curref;

break;

case CT_BACKGROUND:

background = curref;

break;

case CT_CARD:

card = curref;

break;

default: /* chunk type */

MCperror->add

(PE_GO_BADCHUNKDEST, sp);

delete curref;

return PS_ERROR;

}

lterm = nterm;

need_target = False;

break;

default: /* chunk class */

MCperror->add

(PE_GO_BADCHUNKTYPE, sp);

return PS_ERROR;

}

break;

default: /* factor */

if (need_target)

{

if (stack != NULL || card != NULL || background != NULL)

{

MCperror->add

(PE_GO_NODEST, sp);

return PS_ERROR;

}

sp.backup();

card = new MCCRef;

card->otype = CT_CARD;

card->etype = CT_EXPRESSION;

if (sp.parseexp(False, True, &card->startpos) != PS_NORMAL)

{

MCperror->add

(PE_GO_BADCHUNKEXP, sp);

return PS_ERROR;

}

}

else

sp.backup();

return PS_NORMAL;

}

}

else

{ /* not id token type */

if (need_target)

{

if (stack != NULL || card != NULL || background != NULL)

{

MCperror->add

(PE_GO_NODEST, sp);

return PS_ERROR;

}

sp.backup();

stack = new MCCRef;

stack->otype = CT_STACK;

stack->etype = CT_EXPRESSION;

if (sp.parseexp(False, True, &stack->startpos) != PS_NORMAL)

{

MCperror->add

(PE_GO_BADCHUNKEXP, sp);

return PS_ERROR;

}

need_target = False;

}

else

{

sp.backup();

break;

}

}

}

return PS_NORMAL;

}

#ifdef /* MCGo::findstack */ LEGACY_EXEC

MCStack *MCGo::findstack(MCExecPoint &ep, Chunk_term etype, MCCard *&cptr)

{

MCStack *sptr = NULL;

MCresult->clear(False);

uint4 offset;

if (MCU_offset(SIGNATURE, ep.getsvalue(), offset) || (ep . getsvalue() . getlength() > 8 && strncmp(ep . getsvalue() . getstring(), "REVO", 4) == 0))

{

IO_handle stream = MCS_fakeopen(ep.getsvalue());

if (MCdispatcher->readfile(NULL, NULL, stream, sptr) != IO_NORMAL)

{

MCS_close(stream);

if (MCresult->isclear())

MCresult->sets("can't build stack from string");

return NULL;

}

MCS_close(stream);

return sptr;

}

if (etype == CT_STACK)

return NULL;

if (etype == CT_ID)

sptr = MCdefaultstackptr->findstackid(ep.getuint4());

else

sptr = MCdefaultstackptr->findstackname(ep.getsvalue());

if (sptr != NULL)

return sptr;

MCObject *objptr;

MCChunk *tchunk = new MCChunk(False);

MCerrorlock++;

MCScriptPoint sp(ep);

Parse_stat stat = tchunk->parse(sp, False);

if (stat == PS_NORMAL)

{

uint4 parid;

if (tchunk->getobj(ep, objptr, parid, True) == ES_NORMAL)

stat = PS_NORMAL;

else

stat = PS_ERROR;

}

MCerrorlock--;

delete tchunk;

if (stat == PS_NORMAL)

{

switch (objptr->gettype())

{

case CT_STACK:

sptr = (MCStack *)objptr;

break;

case CT_CARD:

cptr = (MCCard *)objptr;

sptr = cptr->getstack();

break;

default:

break;

}

}

else

if (MCresult->isclear())

MCresult->sets("no such card");

return sptr;

}

#endif /* MCGo::findstack */

Exec_stat MCGo::exec(MCExecPoint &ep)

{

#ifdef /* MCGo */ LEGACY_EXEC

MCStack *sptr = MCdefaultstackptr;

MCControl *bptr = NULL;

MCCard *cptr = NULL;

MCRectangle rel;

MCStack *parentptr;

// MW-2011-02-27: [[ Bug ]] Make sure that if we open as a sheet, we have a parent pointer!

if (ep.getobj()->getstack()->getopened() || MCtopstackptr == NULL)

parentptr = ep.getobj() -> getstack();

else

parentptr = MCtopstackptr;

rel = parentptr -> getrect();

MCresult->clear(False);

MCString nc = "No such card";

if (stack == NULL && background == NULL && card == NULL)

{

MCeerror->add(EE_GO_NODEST, line, pos);

return ES_ERROR;

}

if (stack != NULL)

{

switch (stack->etype)

{

case CT_HELP:

sptr = MCdefaultstackptr->findstackname(MChelpnamestring);

if (sptr == NULL)

{

if (MCresult->isclear())

MCresult->sets(nc);

return ES_NORMAL;

}

break;

case CT_HOME:

sptr = MCdispatcher->gethome();

if (sptr != MCdefaultstackptr)

{

MCdefaultstackptr->close();

MCdefaultstackptr->checkdestroy();

}

break;

case CT_THIS:

case CT_EXPRESSION:

case CT_ID:

if (stack->etype == CT_THIS)

sptr = MCdefaultstackptr;

else

{

if (stack->startpos->eval(ep) != ES_NORMAL)

{

MCeerror->add(EE_GO_BADSTACKEXP, line, pos);

return ES_ERROR;

}

sptr = findstack(ep, stack->etype, cptr);

}

if (sptr != NULL && stack->next != NULL)

{

switch (stack->next->etype)

{

case CT_ID:

case CT_EXPRESSION:

if (stack->next->startpos->eval(ep) != ES_NORMAL)

{

MCeerror->add(EE_CHUNK_BADSTACKEXP, line, pos);

return ES_ERROR;

}

if (stack->next->etype == CT_ID)

sptr = sptr->findsubstackid(ep.getuint4());

else

sptr = sptr->findsubstackname(ep.getsvalue());

break;

default:

MCeerror->add(EE_CHUNK_BADSTACKEXP, line, pos);

return ES_ERROR;

}

}

if (sptr == NULL)

{

if (MCresult->isclear())

MCresult->sets(nc);

return ES_NORMAL;

}

break;

default:

return ES_ERROR;

}

if (mode == WM_PULLDOWN || mode == WM_POPUP || mode == WM_OPTION)

{

MCButton *bptr = (MCButton *)ep.getobj();

if (ep.getobj()->gettype() == CT_BUTTON && bptr->attachmenu(sptr))

rel = MCU_recttoroot(bptr->getstack(), bptr->getrect());

else

{

MCeerror->add(EE_GO_CANTATTACH, line, pos);

return ES_ERROR;

}

}

}

sptr->stopedit();

if (background != NULL)

{

switch (ct_class(background->etype))

{

case CT_ORDINAL:

bptr = sptr->getbackground(background->etype, MCnullmcstring, CT_GROUP);

break;

case CT_ID:

case CT_EXPRESSION:

if (background->startpos->eval(ep) != ES_NORMAL)

{

MCeerror->add(EE_GO_BADBACKGROUNDEXP, line, pos);

return ES_ERROR;

}

bptr = sptr->getbackground(background->etype, ep.getsvalue(), CT_GROUP);

break;

default:

break;

}

if (bptr == NULL)

{

if (MCresult->isclear())

MCresult->sets(nc);

return ES_NORMAL;

}

sptr->setbackground(bptr);

}

int2 i;

if (card != NULL)

switch (ct_class(card->etype))

{

case CT_DIRECT:

sptr->clearbackground();

switch (card->etype)

{

case CT_BACKWARD:

case CT_FORWARD:

real8 n;

if (card->startpos != NULL)

{

if (card->startpos->eval(ep) != ES_NORMAL || ep.ton() != ES_NORMAL)

{

sptr->clearbackground();

if (MCresult->isclear())

MCresult->sets(nc);

return ES_NORMAL;

}

n = ep.getnvalue();

}

else

n = 1.0;

i = (int2)(card->etype == CT_FORWARD ? n : -n);

MCrecent->gorel(i);

break;

case CT_START:

case CT_FINISH:

MCrecent->godirect(card->etype == CT_START);

break;

default:

return ES_ERROR;

}

return ES_NORMAL;

case CT_ORDINAL:

if (card->etype == CT_RECENT)

{

MCrecent->gorel(-1);

return ES_NORMAL;

}

else

{

if (marked)

sptr->setmark();

cptr = sptr->getchild(card->etype, MCnullmcstring, card->otype);

}

break;

case CT_ID:

case CT_EXPRESSION:

if (card->startpos->eval(ep) != ES_NORMAL)

{

sptr->clearbackground();

if (MCresult->isclear())

MCresult->sets(nc);

return ES_NORMAL;

}

if (marked)

sptr->setmark();

cptr = sptr->getchild(card->etype, ep.getsvalue(), card->otype);

if (cptr == NULL)

{

sptr = findstack(ep, CT_STACK, cptr);

if (sptr == NULL)

{

if (MCresult->isclear())

MCresult->sets(nc);

return ES_NORMAL;

}

cptr = (MCCard *)sptr->getchild(CT_THIS, MCnullmcstring, CT_CARD);

}

break;

default:

sptr->clearbackground();

fprintf(stderr, "Go: ERROR no card type %d\n", card->etype);

return ES_ERROR;

}

else

if (cptr == NULL)

cptr = (MCCard *)sptr->getchild(CT_THIS, MCnullmcstring, CT_CARD);

Window_mode wm = mode;

if (wm == WM_LAST && sptr->userlevel() != 0 && window == NULL && !thisstack)

wm = (Window_mode)(sptr->userlevel() + WM_TOP_LEVEL_LOCKED);

sptr->clearmark();

sptr->clearbackground();

uint2 oldw = sptr->getrect().width;

uint2 oldh = sptr->getrect().height;

if (cptr == NULL)

{

if (MCresult->isclear())

MCresult->sets(nc);

return ES_NORMAL;

}

// Here 'oldstack' is the pointer to the stack's window we are taking over.

// If it turns out NULL then we aren't subverting another stacks' window to

// our cause :o)

MCStack *oldstack = NULL;

if (window != NULL || thisstack)

{

Window w = DNULL;

if (thisstack)

{

oldstack = MCdefaultstackptr;

w = oldstack->getwindow();

}

else

{

if (window->eval(ep) != ES_NORMAL)

{

MCeerror->add(EE_GO_BADWINDOWEXP, line, pos);

return ES_ERROR;

}

if (ep.ton() == ES_NORMAL && MCscreen->uint4towindow(ep.getuint4(), w))

oldstack = MCdispatcher->findstackd(w);

else

oldstack = ep.getobj()->getstack()->findstackname(ep.getsvalue());

}

if (oldstack == NULL || !oldstack->getopened())

{

MCeerror->add(EE_GO_BADWINDOWEXP, line, pos);

return ES_ERROR;

}

if (oldstack == sptr)

oldstack = NULL;

else

{

// MW-2011-10-01: [[ Effects ]] Snapshot the old stack window.

if (!MCRedrawIsScreenLocked() && MCcur_effects != NULL)

oldstack -> snapshotwindow(oldstack -> getcurcard() -> getrect());

// MW-2011-10-01: [[ Redraw ]] Lock the screen until we are done.

MCRedrawLockScreen();

// MW-2012-09-19: [[ Bug 10383 ]] Use the 'real' mode - otherwise we get one

// modified for ICONIC or CLOSED states which screw things up a bit!

wm = oldstack->getrealmode();

if (wm == WM_MODAL || wm == WM_SHEET)

{

MCRedrawUnlockScreen();

MCeerror->add(EE_GO_BADWINDOWEXP, line, pos);

return ES_ERROR;

}

oldstack->kunfocus();

sptr->close();

MCPlayer *tptr = MCplayers;

while (tptr != NULL)

{

MCPlayer *oldptr = tptr;

tptr = tptr->getnextplayer();

if (oldptr->getstack() == oldstack)

oldptr->close();

}

if (!sptr->takewindow(oldstack))

{

MCRedrawUnlockScreen();

MCeerror->add(EE_GO_BADWINDOWEXP, line, pos);

return ES_ERROR;

}

}

}

else if (mode != WM_LAST && wm >= WM_MODELESS)

{

// MW-2011-08-18: [[ Redraw ]] Move to use redraw lock/unlock.

MCRedrawForceUnlockScreen();

}

Boolean oldtrace = MCtrace;

MCtrace = False;

// MW-2007-02-11: [[ Bug 4029 ]] - 'go invisible' fails to close stack window if window already open

if (!visible && sptr -> getflag(F_VISIBLE))

{

if (sptr -> getwindow() != NULL)

MCscreen -> closewindow(sptr -> getwindow());

sptr->setflag(False, F_VISIBLE);

}

// MW-2011-02-27: [[ Bug ]] Make sure that if we open as a sheet, we have a parent pointer!

if (wm != WM_SHEET && wm != WM_DRAWER)

parentptr = nil;

Exec_stat stat = ES_NORMAL;

Boolean added = False;

if (MCnexecutioncontexts < MAX_CONTEXTS)

{

ep.setline(line);

MCexecutioncontexts[MCnexecutioncontexts++] = &ep;

added = True;

}

#ifdef _MOBILE

// MW-2011-01-30: [[ Effects ]] On Mobile, we must twiddle with snapshots to

// ensure go stack with visual effect works.

if (oldstack == nil && MCcur_effects != nil && MCdefaultstackptr != sptr)

{

MCdefaultstackptr -> snapshotwindow(MCdefaultstackptr -> getcurcard() -> getrect());

sptr -> takewindowsnapshot(MCdefaultstackptr);

MCRedrawLockScreen();

}

#endif

if (sptr->setcard(cptr, True, True) == ES_ERROR

|| sptr->openrect(rel, wm, parentptr, WP_DEFAULT, OP_NONE) == ES_ERROR)

{

MCtrace = oldtrace;

stat = ES_ERROR;

}

if (oldstack != NULL)

{

MCRectangle trect = sptr->getcurcard()->getrect();

sptr->getcurcard()->message_with_args(MCM_resize_stack, trect.width, trect.height, oldw, oldh);

MCRedrawUnlockScreen();

if (MCcur_effects != nil)

{

Boolean t_abort;

sptr -> effectrect(sptr -> getcurcard() -> getrect(), t_abort);

}

Boolean oldlock = MClockmessages;

MClockmessages = True;

oldstack->close();

MClockmessages = oldlock;

sptr->kfocus();

}

#ifdef _MOBILE

// MW-2011-01-30: [[ Effects ]] Apply any stack level visual efect.

if (oldstack == nil && MCcur_effects != nil && MCdefaultstackptr != sptr)

{

MCRedrawUnlockScreen();

// MW-2011-10-17: [[ Bug 9811 ]] Make sure we configure the new card now.

MCRedrawDisableScreenUpdates();

sptr -> view_configure(True);

MCRedrawEnableScreenUpdates();

Boolean t_abort;

sptr -> effectrect(sptr -> getcurcard() -> getrect(), t_abort);

}

#endif

if (added)

MCnexecutioncontexts--;

MCtrace = oldtrace;

if (sptr->getmode() == WM_TOP_LEVEL || sptr->getmode() == WM_TOP_LEVEL_LOCKED)

MCdefaultstackptr = sptr;

if (MCmousestackptr != NULL)

MCmousestackptr->resetcursor(True);

if (MCabortscript)

return ES_ERROR;

return stat;

#endif /* MCGo */

}

MCHide::~MCHide()

{

delete object;

delete effect;

}

Parse_stat MCHide::parse(MCScriptPoint &sp)

{

initpoint(sp);

Symbol_type type;

const LT *te;

initpoint(sp);

if (sp.next(type) == PS_NORMAL)

if (sp.lookup(SP_SHOW, te) == PS_NORMAL)

{

if (te->which == SO_CARD || te->which == SO_BACKGROUND)

{

MCScriptPoint oldsp(sp);

if (sp.skip_token(SP_FACTOR, TT_CLASS, CT_CARD) == PS_NORMAL)

{

card = (Show_object)te->which == SO_CARD;

which = SO_PICTURE;

return PS_NORMAL;

}

if (sp.skip_token(SP_SHOW, TT_UNDEFINED, SO_WINDOW) == PS_NORMAL)

{

which = SO_PALETTE;

return PS_NORMAL;

}

sp = oldsp;

sp.backup();

}

else

{

which = (Show_object)te->which;

if (which == SO_GROUPS)

return PS_NORMAL;

if (which == SO_WINDOW)

{

sp.backup();

which = SO_OBJECT;

}

else

if (which == SO_PICTURE)

sp.skip_token(SP_FACTOR, TT_OF);

else

{

while (sp.skip_token(SP_SHOW, TT_UNDEFINED) == PS_NORMAL)

;

return PS_NORMAL;

}

}

}

else

sp.backup();

else

{

MCperror->add

(PE_HIDE_BADTARGET, sp);

return PS_ERROR;

}

object = new MCChunk(False);

if (object->parse(sp, False) != PS_NORMAL)

{

MCperror->add

(PE_HIDE_BADTARGET, sp);

return PS_ERROR;

}

if (sp.skip_token(SP_REPEAT, TT_UNDEFINED) == PS_NORMAL)

{

sp.skip_token(SP_COMMAND, TT_STATEMENT, S_VISUAL);

effect = new MCVisualEffect;

if (effect->parse(sp) != PS_NORMAL)

{

MCperror->add

(PE_HIDE_BADEFFECT, sp);

return PS_ERROR;

}

}

return PS_NORMAL;

}

Exec_stat MCHide::exec(MCExecPoint &ep)

{

#ifdef /* MCHide */ LEGACY_EXEC

switch (which)

{

case SO_GROUPS:

MClinkatts.underline = False;

// MW-2011-08-17: [[ Redraw ]] We've changed a global property that could

// affect the display of all stacks.

MCRedrawDirtyScreen();

break;

case SO_OBJECT:

MCObject *optr;

uint4 parid;

if (object->getobj(ep, optr, parid, True) != ES_NORMAL)

{

MCeerror->add(EE_HIDE_NOOBJ, line, pos);

return ES_ERROR;

}

// MW-2011-09-13: [[ Effects ]] Only apply the effect if the screen is not

// locked.

if (effect != NULL && !MCRedrawIsScreenLocked())

{

if (effect->exec(ep) != ES_NORMAL)

{

MCeerror->add(EE_HIDE_BADEFFECT, line, pos);

return ES_NORMAL;

}