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

#include "globdefs.h"

#include "objdefs.h"

#include "parsedef.h"

#include "filedefs.h"

#include "mcio.h"

#include "scriptpt.h"

#include "execpt.h"

#include "param.h"

#include "handler.h"

#include "sellst.h"

#include "undolst.h"

#include "chunk.h"

#include "object.h"

#include "control.h"

#include "mcerror.h"

#include "dispatch.h"

#include "stack.h"

#include "stacklst.h"

#include "aclip.h"

#include "vclip.h"

#include "card.h"

#include "group.h"

#include "button.h"

#include "graphic.h"

#include "eps.h"

#include "scrolbar.h"

#include "player.h"

#include "image.h"

#include "field.h"

#include "util.h"

#include "globals.h"

#include "license.h"

#include "cmds.h"

#include "securemode.h"

#include "osspec.h"

#include "redraw.h"

#include "objptr.h"

MCClone::~MCClone()

{

delete source;

delete newname;

delete it;

}

Parse_stat MCClone::parse(MCScriptPoint &sp)

{

initpoint(sp);

// OK-2008-06-23: [[Bug 6590]] - Added [invisible] syntax to allow stacks to be cloned invisibly

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

visible = False;

source = new MCChunk(False);

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

{

MCperror->add

(PE_CLONE_BADCHUNK, sp);

return PS_ERROR;

}

if (sp.skip_token(SP_FACTOR, TT_PREP, PT_AS) == PS_NORMAL)

{

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

{

MCperror->add

(PE_CLONE_BADNAME, sp);

return PS_ERROR;

}

}

getit(sp, it);

return PS_NORMAL;

}

// MW-2004-11-17: New version is too restrictive. Semantics should be:

// clone a stack - always succeeds

// clone a card of stack -

// if target is this stack then only if not locked

// if target is not this stack then only if keyed and target valid

// clone an object of a stack - only if not locked

// where a target is valid only if it is not locked and not protected

Exec_stat MCClone::exec(MCExecPoint &ep)

{

MCStack *odefaultstackptr = MCdefaultstackptr;

MCObject *optr = NULL;

uint4 parid;

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

{

MCeerror->add

(EE_CLONE_NOTARGET, line, pos);

return ES_ERROR;

}

switch (optr->gettype())

{

case CT_STACK:

{

MCStack *sptr = (MCStack *)optr;

optr = sptr->clone();

if (newname == NULL)

{

sptr->getprop(0, P_SHORT_NAME, ep, False);

ep.insert(MCcopystring, 0, 0);

optr->setprop(0, P_NAME, ep, False);

}

MCdefaultstackptr = (MCStack *)optr;

// OK-2008-06-23: [[Bug 6590]]

if (!visible)

optr->setflag(visible, F_VISIBLE);

optr->open();

}

break;

case CT_CARD:

// MW-2005-03-10: Fix issue with card cloning which meant it wasn't working...

if ((optr -> getstack() -> islocked() && MCdefaultstackptr == optr -> getstack()) ||

(MCdefaultstackptr != optr -> getstack() && MCdefaultstackptr -> islocked()))

{

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

return ES_ERROR;

}

else if (MCdefaultstackptr != optr -> getstack() &&

(!optr -> getstack() -> iskeyed() || !MCdefaultstackptr -> iskeyed()))

{

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

return ES_ERROR;

}

else

{

MCCard *cptr = (MCCard *)optr;

cptr->getstack()->stopedit();

optr = cptr->clone(True, True);

}

break;

case CT_GROUP:

// MW-2010-10-12: [[ Bug 8494 ]] Surely its just the group being edited that you

// don't want to clone... Indeed, it shouldn't even be possible to reference

// that group since it 'doesn't exist' in group editing mode.

if (optr->getstack()->isediting() && optr->getstack()->getediting() == optr)

{

optr = NULL;

break;

}

case CT_BUTTON:

case CT_FIELD:

case CT_IMAGE:

case CT_SCROLLBAR:

case CT_PLAYER:

case CT_GRAPHIC:

case CT_EPS:

case CT_COLOR_PALETTE:

case CT_MAGNIFY:

if (optr -> getstack() -> islocked())

{

MCeerror -> add

(EE_CLONE_LOCKED, line, pos);

return ES_ERROR;

}

else

{

MCControl *coptr = (MCControl *)optr;

optr = coptr -> clone(True, OP_OFFSET, !visible);

}

break;

default:

break;

}

if (newname != NULL)

{

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

{

MCeerror->add

(EE_CLONE_BADNAME, line, pos);

return ES_ERROR;

}

optr->setprop(0, P_NAME, ep, False);

}

if (optr == NULL)

{

MCeerror->add

(EE_CLONE_CANTCLONE, line, pos);

return ES_ERROR;

}

optr->getprop(0, P_LONG_ID, ep, False);

it->set

(ep);

MCdefaultstackptr = odefaultstackptr;

return ES_NORMAL;

}

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

MCClipboardCmd::~MCClipboardCmd(void)

{

deletetargets(&targets);

delete dest;

delete it;

}

Parse_stat MCClipboardCmd::parse(MCScriptPoint& sp)

{

initpoint(sp);

MCScriptPoint oldsp(sp);

MCerrorlock++;

if (gettargets(sp, &targets, False) != PS_NORMAL)

{

deletetargets(&targets);

sp = oldsp;

}

MCerrorlock--;

if (sp.skip_token(SP_FACTOR, TT_TO, PT_TO) == PS_NORMAL)

{

dest = new MCChunk(False);

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

{

MCperror->add(PE_COPY_BADDEST, sp);

return PS_ERROR;

}

getit(sp, it);

}

return PS_NORMAL;

}

Exec_stat MCClipboardCmd::exec(MCExecPoint& ep)

{

// Implicit form - use current context

if (targets == NULL)

{

if (MCactivefield != NULL)

{

if (iscut())

MCactivefield -> cuttext();

else

MCactivefield -> copytext();

}

else if (MCactiveimage != NULL)

{

if (iscut())

MCactiveimage -> cutimage();

else

MCactiveimage -> copyimage();

}

else

{

if (iscut())

MCselected -> cut();

else

MCselected -> copy();

}

return ES_NORMAL;

}

// Explicit form (1) - text chunk

if (targets -> istextchunk())

{

if (targets -> next != NULL)

{

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

return ES_ERROR;

}

MCField* t_field;

uint4 t_part, t_start;

uint4 t_end;

if (targets -> marktextchunk(ep, t_field, t_part, t_start, t_end) != ES_NORMAL)

{

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

return ES_ERROR;

}

if (iscut())

t_field -> cuttextindex(t_part, t_start, t_end);

else

t_field -> copytextindex(t_part, t_start, t_end);

return ES_NORMAL;

}

// Explicit form (2)/(3) - object chunks

Exec_errors t_error;

t_error = EE_UNDEFINED;

MCObjectRef *t_objects;

uint4 t_object_count;

t_objects = NULL;

t_object_count = 0;

for(MCChunk *t_target = targets; t_target != NULL && t_error == EE_UNDEFINED; t_target = t_target -> next)

{

if (t_target -> istextchunk())

t_error = EE_CLIPBOARD_BADMIX;

MCObject *t_object;

uint4 t_part;

if (t_error == EE_UNDEFINED)

{

if (t_target -> getobj(ep, t_object, t_part, True) != ES_NORMAL)

t_error = EE_CLIPBOARD_BADOBJ;

}

if (t_error == EE_UNDEFINED)

{

if (!t_object -> getstack() -> iskeyed())

{

MCresult -> sets("can't cut object (stack is password protected)");

continue;

}

}

if (t_error == EE_UNDEFINED)

{

MCObjectRef *t_new_objects;

t_new_objects = (MCObjectRef *)realloc(t_objects, sizeof(MCObjectRef) * (t_object_count + 1));

if (t_new_objects == NULL)

t_error = EE_NO_MEMORY;

else

{

t_objects = t_new_objects;

t_objects[t_object_count] . object = t_object;

t_objects[t_object_count] . part = t_part;

t_object_count += 1;

}

}

}

// Calculate destination object (if applicable)

MCObject *t_dst_object;

t_dst_object = NULL;

if (t_error == EE_UNDEFINED && dest != NULL)

{

uint4 t_part;

if (dest -> getobj(ep, t_dst_object, t_part, True) != ES_NORMAL)

t_error = EE_CLIPBOARD_NODEST;

}

// Check destination compatibility

if (t_error == EE_UNDEFINED && dest != NULL)

{

Chunk_term t_dst_type;

t_dst_type = t_dst_object -> gettype();

for(uint4 i = 0; i < t_object_count; ++i)

{

Chunk_term t_src_type;

t_src_type = t_objects[i] . object -> gettype();

if (t_src_type <= CT_CARD && t_dst_type != CT_STACK)

t_error = EE_CLIPBOARD_BADDEST;

else if (t_dst_type != CT_STACK && t_dst_type != CT_CARD && t_dst_type != CT_GROUP)

t_error = EE_CLIPBOARD_BADDEST;

}

}

if (t_object_count > 0)

{

if (t_error == EE_UNDEFINED && dest != NULL)

t_error = processtocontainer(t_objects, t_object_count, t_dst_object);

else if (t_error == EE_UNDEFINED)

t_error = processtoclipboard(t_objects, t_object_count);

}

Exec_stat t_stat;

if (t_error == EE_UNDEFINED)

t_stat = ES_NORMAL;

else

{

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

t_stat = ES_ERROR;

}

if (t_objects != NULL)

free(t_objects);

return t_stat;

}

Exec_errors MCClipboardCmd::processtocontainer(MCObjectRef *p_objects, uint4 p_object_count, MCObject *p_dst)

{

bool t_cut;

t_cut = iscut();

MCObject *t_new_object;

for(uint4 i = 0; i < p_object_count; ++i)

{

MCObject *t_object;

t_object = p_objects[i] . object;

uint4 t_part;

t_part = p_objects[i] . part;

switch(t_object -> gettype())

{

case CT_AUDIO_CLIP:

{

MCAudioClip *t_aclip;

if (t_cut)

{

t_aclip = static_cast<MCAudioClip *>(t_object);

t_object -> getstack() -> removeaclip(t_aclip);

}

else

t_aclip = new MCAudioClip(*static_cast<MCAudioClip *>(t_object));

t_new_object = t_aclip;

p_dst -> getstack() -> appendaclip(t_aclip);

}

break;

case CT_VIDEO_CLIP:

{

MCVideoClip *t_aclip;

if (t_cut)

{

t_aclip = static_cast<MCVideoClip *>(t_object);

t_object -> getstack() -> removevclip(t_aclip);

}

else

t_aclip = new MCVideoClip(*static_cast<MCVideoClip *>(t_object));

t_new_object = t_aclip;

p_dst -> getstack() -> appendvclip(t_aclip);

}

break;

case CT_CARD:

{

if (!t_cut)

{

MCStack *t_old_default;

t_old_default = MCdefaultstackptr;

MCdefaultstackptr = static_cast<MCStack *>(p_dst);

MCdefaultstackptr -> stopedit();

MCCard *t_card;

t_card = static_cast<MCCard *>(t_object);

t_new_object = t_card -> clone(True, True);

MCdefaultstackptr = t_old_default;

}

}

break;

case CT_GROUP:

case CT_BUTTON:

case CT_SCROLLBAR:

case CT_PLAYER:

case CT_IMAGE:

case CT_GRAPHIC:

case CT_EPS:

case CT_COLOR_PALETTE:

case CT_FIELD:

{

if (p_dst -> gettype() == CT_STACK)

p_dst = static_cast<MCStack *>(p_dst) -> getcurcard();

if (!t_cut)

{

MCObject *t_old_parent;

t_old_parent = t_object -> getparent();

t_object -> setparent(p_dst);

MCControl *t_control;

t_control = static_cast<MCControl *>(t_object);

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

MCRedrawLockScreen();

t_new_object = t_control -> clone(True, OP_NONE, false);

MCControl *t_new_control;

t_new_control = static_cast<MCControl *>(t_new_object);

if (p_dst -> getstack() != t_old_parent -> getstack())

t_new_control -> resetfontindex(t_old_parent -> getstack());

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

t_new_control -> layer_redrawall();

MCRedrawUnlockScreen();

t_object -> setparent(t_old_parent);

}

}

break;

default:

return EE_CLIPBOARD_BADOBJ;

break;

}

}

if (t_new_object != NULL)

{

MCExecPoint ep(NULL, NULL, NULL);

t_new_object -> getprop(0, P_LONG_ID, ep, False);

it -> set(ep);

}

return EE_UNDEFINED;

}

Exec_errors MCClipboardCmd::processtoclipboard(MCObjectRef *p_objects, uint4 p_object_count)

{

// Pickle the list of objects. The only reason this could fail is due to lack of

// memory.

MCPickleContext *t_context;

// MW-2012-03-04: [[ StackFile5500 ]] When pickling for the clipboard, make sure it

// includes both 2.7 and 5.5 stackfile formats.

t_context = MCObject::startpickling(true);

if (t_context == NULL)

return EE_NO_MEMORY;

for(uint4 i = 0; i < p_object_count; ++i)

MCObject::continuepickling(t_context, p_objects[i] . object, p_objects[i] . part);

MCSharedString *t_pickle;

t_pickle = MCObject::stoppickling(t_context);

if (t_pickle == NULL)

return EE_NO_MEMORY;

bool t_success;

t_success = true;

// Open the clipboard ready for storing data

MCclipboarddata -> Open();

// Attempt to store the objects onto the clipboard

if (t_success)

if (!MCclipboarddata -> Store(TRANSFER_TYPE_OBJECTS, t_pickle))

t_success = false;

// If we've managed to store objects, and we are only copying/cutting one

// image object, attempt to copy the image data.

// Note that we don't care if this doesn't succeed as its not critical.

if (t_success)

if (p_object_count == 1 && p_objects[0] . object -> gettype() == CT_IMAGE)

{

// MW-2011-02-26: [[ Bug 9403 ]] If no image data is fetched, then don't try

// and store anything!

MCSharedString *t_image_data;

t_image_data = static_cast<MCImage *>(p_objects[0] . object) -> getclipboardtext();

if (t_image_data != nil)

{

MCclipboarddata -> Store(TRANSFER_TYPE_IMAGE, t_image_data);

t_image_data -> Release();

}

}

// Close the clipboard. If this returns false, then it means the

// writing was unsuccessful.

if (!MCclipboarddata -> Close())

t_success = false;

// If all is well, delete the original objects.

if (t_success)

{

if (iscut())

{

for(uint4 i = 0; i < p_object_count; ++i)

{

p_objects[i] . object -> del();

if (p_objects[i] . object -> gettype() == CT_STACK)

MCtodestroy -> remove(static_cast<MCStack *>(p_objects[i] . object));

p_objects[i] . object -> scheduledelete();

}

}

}

else

MCresult -> sets("unable to write to clipboard");

if (t_pickle != NULL)

t_pickle -> Release();

return EE_UNDEFINED;

}

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

//

// Primary Verb:

// copy

//

// Synonyms:

// <none>

//

//

// Syntactic Form 1: copy selection to clipboard

// copy

//

// Semantics:

// Copies the current selection to the clipboard. The current selection is

// determined by the current active object. The currently active object is

// a) MCactivefield (the field with insertion point) if not NULL

// b) MCactiveimage (the image being edited) if not NULL

// c) MCselected (the list of currently selected objects)

//

// Result:

// <none>

//

// Exceptions:

// <none>

//

//

// Syntactic Form 2: copy objects to clipboard

// copy { <Chunk> , and }

//

// Semantics:

// Copies the given chunks to the clipboard. The chunks can be:

// - an object

// - a text chunk of a field

// - the clickField

// - the selectedField

// - the mouseControl

// - the focusedObject

// - the selectedImage

//

// An object can only be copied from non-locked stacks.

//

// Result:

// empty if successful

// "can't cut object (stack is password protected)" if one of the objects

// resides on a locked stack.

//

// Exceptions:

// EE_CHUNK_CANTFINDOBJECT if one of the chunks cannot be found

// EE_CHUNK_BADCONTAINER if one of the chunks is not of an allowed type

//

//

// Syntactic Form 3: copy objects to container

// copy { <Chunk> , and } to <Chunk>

//

// Semantics:

// Copies the given object chunks to the target container. Compatibility

// of the source and target is checked - AudioClips, VideoClips and Cards

// can only be copied to a Stack. All other object types can only be

// copied to a Stack, Card or Group.

//

// An object can only be copied from non-locked stacks.

//

// If no exception occurs, the 'it' variable is filled in with the long id

// of the last object copied.

//

// Result:

// empty if successful

// "can't cut object (stack is password protected)" if one of the objects

// resides on a locked stack.

//

// Exceptions:

// EE_COPY_NODEST if the target object could not be found

// EE_COPY_NOOBJ if a source object could not be found

// EE_COPY_BADDEST if a source object is not compatible with the target

// EE_COPY_BADOBJ if the source object is not a type that can be copied

// EE_COPY_BADMIX if the collection of source objects is invalid

//

// Description:

// This class implements the 'copy' command.

//

// It has the following syntactic forms:

//

bool MCCopyCmd::iscut(void) const

{

return false;

}

MCCreate::~MCCreate()

{

delete newname;

delete file;

delete container;

delete it;

}

Parse_stat MCCreate::parse(MCScriptPoint &sp)

{

Symbol_type type;

const LT *te;

initpoint(sp);

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

visible = False;

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

{

MCperror->add

(PE_CREATE_NOTYPE, sp);

return PS_ERROR;

}

if (sp.lookup(SP_FACTOR, te) != PS_NORMAL)

{

MCperror->add

(PE_CREATE_NOTTYPE, sp);

return PS_ERROR;

}

if (te->type == TT_CHUNK)

{

switch (te->which)

{

case CT_STACK:

case CT_BACKGROUND:

case CT_CARD:

case CT_FIELD:

case CT_BUTTON:

case CT_MENU:

case CT_IMAGE:

case CT_GROUP:

case CT_SCROLLBAR:

case CT_PLAYER:

case CT_GRAPHIC:

case CT_EPS:

otype = (Chunk_term)te->which;

break;

case CT_ALIAS:

alias = True;

break;

default:

MCperror->add

(PE_CREATE_BADTYPE, sp);

return PS_ERROR;

}

getit(sp, it);

}

else

if (te->type == TT_PROPERTY && te->which == P_DIRECTORY)

directory = True;

MCerrorlock++;

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

{

if (directory || alias)

{

MCerrorlock--;

MCperror->add

(PE_CREATE_NONAME, sp);

return PS_ERROR;

}

delete newname;

newname = NULL;

}

MCerrorlock--;

if (alias)

{

if (sp.skip_token(SP_FACTOR, TT_TO, PT_TO) != PS_NORMAL)

{

MCperror->add

(PE_CREATE_NOFILENAME, sp);

return PS_ERROR;

}

if (sp.skip_token(SP_THERE, TT_UNDEFINED, TM_FILE) != PS_NORMAL)

sp.skip_token(SP_THERE, TT_UNDEFINED, TM_DIRECTORY);

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

{

MCperror->add

(PE_CREATE_BADFILENAME, sp);

return PS_ERROR;

}

}

else

if (sp.skip_token(SP_FACTOR, TT_IN) == PS_NORMAL || otype == CT_STACK

&& sp.skip_token(SP_REPEAT, TT_UNDEFINED, RF_WITH) == PS_NORMAL)

{

container = new MCChunk(False);

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

{

MCperror->add

(PE_CREATE_BADBGORCARD, sp);

return PS_ERROR;

}

}

return PS_NORMAL;

}

MCControl *MCCreate::getobject(MCObject *&parent)

{

switch (otype)

{

case CT_BACKGROUND:

case CT_GROUP:

return MCtemplategroup;

case CT_BUTTON:

return MCtemplatebutton;

case CT_MENU:

parent = MCmenubar != NULL ? MCmenubar : MCdefaultmenubar;

return MCtemplatebutton;

case CT_SCROLLBAR:

return MCtemplatescrollbar;

case CT_PLAYER:

return MCtemplateplayer;

case CT_IMAGE:

return MCtemplateimage;

case CT_GRAPHIC:

return MCtemplategraphic;

case CT_EPS:

return MCtemplateeps;

case CT_FIELD:

return MCtemplatefield;

default:

return NULL;

}

}

Exec_stat MCCreate::exec(MCExecPoint &ep)

{

if (directory)

{

if (MCsecuremode & MC_SECUREMODE_DISK)

{

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

return ES_ERROR;

}

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

{

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

return ES_ERROR;

}

char *fname = ep.getsvalue().clone();

if (!MCS_mkdir(fname))

MCresult->sets("can't create that directory");

else

MCresult->clear(False);

delete fname;

return ES_NORMAL;

}

if (alias)

{

if (MCsecuremode & MC_SECUREMODE_DISK)

{

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

return ES_ERROR;

}

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

{

MCeerror->add

(EE_CREATE_BADFILEEXP, line, pos);

return ES_ERROR;

}

char *aliasname = ep.getsvalue().clone();

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

{

delete aliasname;

MCeerror->add

(EE_CREATE_BADEXP, line, pos);

return ES_ERROR;

}

char *fname = ep.getsvalue().clone();

if (!MCS_createalias(fname, aliasname))

MCresult->sets("can't create that alias");

else

MCresult->clear(False);

delete fname;

delete aliasname;

return ES_NORMAL;

}

if (otype != CT_STACK && MCdefaultstackptr->islocked())

{

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

return ES_ERROR;

}

MCObject *optr;

if (otype == CT_STACK)

{

MCStack *odefaultstackptr = MCdefaultstackptr;

Boolean wasvisible = MCtemplatestack->isvisible();

if (!visible)

MCtemplatestack->setflag(visible, F_VISIBLE);

if (container != NULL)

{

MCObject *tptr;

uint4 parid;

if (container->getobj(ep, tptr, parid, True) != ES_NORMAL

|| tptr->gettype() != CT_GROUP && tptr->gettype() != CT_STACK)

{

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

return ES_ERROR;

}

MCdefaultstackptr = MCtemplatestack->clone();

MCdefaultstackptr->open();

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

{

MCGroup *gptr = (MCGroup *)tptr;

MCdefaultstackptr->setrect(gptr->getstack()->getrect());

gptr = (MCGroup *)gptr->clone(False, OP_NONE, false);

gptr->setparent(MCdefaultstackptr);

gptr->resetfontindex(tptr->getstack());

gptr->attach(OP_NONE, false);

}

else

{

tptr->getprop(0, P_NAME, ep, False);

if (MCdefaultstackptr->setprop(0, P_MAIN_STACK, ep, False) != ES_NORMAL)

{

delete MCdefaultstackptr;

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

return ES_ERROR;

}

}

}

else

{

MCdefaultstackptr = MCtemplatestack->clone();

MCdefaultstackptr->open();

}

MCtemplatestack->setflag(wasvisible, F_VISIBLE);

optr = MCdefaultstackptr;

MCdefaultstackptr = odefaultstackptr;

}

else

{

MCObject *parent = NULL;

if (container != NULL)

{

uint4 parid;

if (container->getobj(ep, parent, parid, True) != ES_NORMAL

|| parent->gettype() != CT_GROUP)

{

MCeerror->add

(EE_CREATE_BADBGORCARD, line, pos);

return ES_ERROR;

}

}

if (otype == CT_CARD)

{

MCdefaultstackptr->stopedit();

optr = MCtemplatecard->clone(True, False);

}

else

{

MCControl *cptr = getobject(parent);

if (cptr == NULL)

return ES_ERROR;

Boolean wasvisible = cptr->isvisible();

if (!visible)

cptr->setflag(visible, F_VISIBLE);

cptr->setparent(parent);

optr = cptr->clone(True, OP_CENTER, false);

if (cptr == getobject(parent))

{ // handle case where template reset

cptr->setparent(NULL);

if (!visible)

cptr->setflag(wasvisible, F_VISIBLE);

}

if (otype == CT_MENU)

{

MCButton *bptr = (MCButton *)optr;

bptr->setupmenu();

}

}

}

if (newname != NULL)

{

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

{

MCeerror->add

(EE_CREATE_BADEXP, line, pos);

return ES_ERROR;

}

optr->setprop(0, P_NAME, ep, False);

}

optr->getprop(0, P_LONG_ID, ep, False);

it->set(ep);

return ES_NORMAL;

}

MCCustomProp::~MCCustomProp()

{

delete prop;

delete target;

}

Parse_stat MCCustomProp::parse(MCScriptPoint &sp)

{

initpoint(sp);

Symbol_type type;

const LT *te;

sp.next(type);

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

{

MCperror->add

(PE_DEFINE_INVALIDNAME, sp);