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

#include "objptr.h"

#include "stacksecurity.h"

#include "syntax.h"

#include "graphics_util.h"

MCClone::~MCClone()

{

delete source;

delete newname;

}

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;

}

}

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

void MCClone::exec_ctxt(MCExecContext& ctxt)

{

#ifdef /* MCClone */ LEGACY_EXEC

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

ep.getit()->set(ep);

MCdefaultstackptr = odefaultstackptr;

return ES_NORMAL;

#endif /* MCClone */

MCObject *optr = NULL;

uint4 parid;

if (!source->getobj(ctxt, optr, parid, True))

{

ctxt . LegacyThrow(EE_CLONE_NOTARGET);

return;

}

MCAutoStringRef t_new_name;

if (!ctxt . EvalOptionalExprAsNullableStringRef(newname, EE_CLONE_BADNAME, &t_new_name))

return;

MCInterfaceExecClone(ctxt, optr, *t_new_name, visible == False);

}

void MCClone::compile(MCSyntaxFactoryRef ctxt)

{

MCSyntaxFactoryBeginStatement(ctxt, line, pos);

source -> compile_object_ptr(ctxt);

if (newname != nil)

newname -> compile(ctxt);

else

MCSyntaxFactoryEvalConstantNil(ctxt);

MCSyntaxFactoryEvalConstantBool(ctxt, visible == False);

MCSyntaxFactoryExecMethod(ctxt, kMCInterfaceExecCloneMethodInfo);

MCSyntaxFactoryEndStatement(ctxt);

}

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

MCClipboardCmd::~MCClipboardCmd(void)

{

deletetargets(&targets);

delete dest;

}

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;

}

}

return PS_NORMAL;

}

void MCClipboardCmd::exec_ctxt(MCExecContext& ctxt)

{

#ifdef /* MCClipboardCmd */ LEGACY_EXEC

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

{

// MW-2013-11-08: [[ RefactorIt ]] Both 'processto' methods in theory need context so

// pass ep.

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

t_error = processtocontainer(ep, t_objects, t_object_count, t_dst_object);

else if (t_error == EE_UNDEFINED)

t_error = processtoclipboard(ep, 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;

#endif /* MCClipboardCmd */

if (targets == NULL)

{

// Implicit form - use current context

if (iscut())

MCPasteboardExecCut(ctxt);

else

MCPasteboardExecCopy(ctxt);

}

else if (targets -> istextchunk())

{

// Explicit form (1) - text chunk-

if (targets -> next != NULL)

{

ctxt . LegacyThrow(EE_CLIPBOARD_BADMIX);

return;

}

MCObjectChunkPtr t_obj_chunk;

if (!targets -> evalobjectchunk(ctxt, true, false, t_obj_chunk))

{

ctxt . LegacyThrow(EE_CLIPBOARD_BADTEXT);

return;

}

if (iscut())

MCPasteboardExecCutTextToClipboard(ctxt, t_obj_chunk);

else

MCPasteboardExecCopyTextToClipboard(ctxt, t_obj_chunk);

MCValueRelease(t_obj_chunk . mark . text);

}

else

{

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

MCChunk *chunkptr = targets;

MCObjectPtr t_object;

MCAutoArray<MCObjectPtr> t_objects;

while (chunkptr != NULL)

{

if (chunkptr -> istextchunk())

{

ctxt . LegacyThrow(EE_CLIPBOARD_BADMIX);

return;

}

if (!chunkptr -> getobj(ctxt, t_object, True))

{

ctxt . LegacyThrow(EE_CLIPBOARD_BADOBJ);

return;

}

if (!t_objects . Push(t_object))

{

ctxt . LegacyThrow(EE_NO_MEMORY);

break;

}

chunkptr = chunkptr->next;

}

// Calculate destination object (if applicable)

MCObjectPtr t_dst_object;

if (dest != NULL)

{

if (!dest -> getobj(ctxt, t_dst_object, True))

{

ctxt . LegacyThrow(EE_CLIPBOARD_BADOBJ);

return;

}

}

if (t_objects . Size() > 0)

{

if (dest != NULL)

{

if (iscut())

MCInterfaceExecCutObjectsToContainer(ctxt, t_objects . Ptr(), t_objects . Size(), t_dst_object);

else

MCInterfaceExecCopyObjectsToContainer(ctxt, t_objects . Ptr(), t_objects . Size(), t_dst_object);

}

else

{

if (iscut())

MCPasteboardExecCutObjectsToClipboard(ctxt, t_objects . Ptr(), t_objects . Size());

else

MCPasteboardExecCopyObjectsToClipboard(ctxt, t_objects . Ptr(), t_objects . Size());

}

}

}

}

void MCClipboardCmd::compile(MCSyntaxFactoryRef ctxt)

{

MCSyntaxFactoryBeginStatement(ctxt, line, pos);

if (targets == NULL)

{

if (iscut())

MCSyntaxFactoryExecMethod(ctxt, kMCPasteboardExecCutMethodInfo);

else

MCSyntaxFactoryExecMethod(ctxt, kMCPasteboardExecCopyMethodInfo);

}

else

{

uindex_t t_count;

t_count = 0;

for (MCChunk *chunkptr = targets; chunkptr != nil; chunkptr = chunkptr -> next)

{

chunkptr -> compile_object_ptr(ctxt);

t_count++;

}

if (dest != nil)

{

MCSyntaxFactoryEvalList(ctxt, t_count);

dest -> compile_object_ptr(ctxt);

if (iscut())

MCSyntaxFactoryExecMethod(ctxt, kMCInterfaceExecCutObjectsToContainerMethodInfo);

else

MCSyntaxFactoryExecMethod(ctxt, kMCInterfaceExecCopyObjectsToContainerMethodInfo);

}

else if (t_count > 1)

{

MCSyntaxFactoryEvalList(ctxt, t_count);

if (iscut())

MCSyntaxFactoryExecMethod(ctxt, kMCPasteboardExecCutObjectsToClipboardMethodInfo);

else

MCSyntaxFactoryExecMethod(ctxt, kMCPasteboardExecCopyObjectsToClipboardMethodInfo);

}

else

{

if (iscut())

{

MCSyntaxFactoryExecMethod(ctxt, kMCPasteboardExecCutTextToClipboardMethodInfo);

MCSyntaxFactoryExecMethod(ctxt, kMCPasteboardExecCutObjectsToClipboardMethodInfo);

}

else

{

MCSyntaxFactoryExecMethod(ctxt, kMCPasteboardExecCopyTextToClipboardMethodInfo);

MCSyntaxFactoryExecMethod(ctxt, kMCPasteboardExecCopyObjectsToClipboardMethodInfo);

}

}

}

MCSyntaxFactoryEndStatement(ctxt);

}

#ifdef LEGACY_EXEC

Exec_errors MCClipboardCmd::processtocontainer(MCExecPoint& ep, 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);

// SN-2014-12-08: [[ Bug 12726 ]] Avoid to dereference a nil pointer (and fall back

// to the default stack).

if (t_old_parent == NULL)

t_new_control -> resetfontindex(MCdefaultstackptr);

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

{

// MW-2013-11-08: [[ RefactorIt ]] Use a temp-ep for the value, but use the real ep for

// it setting.

MCExecPoint ep2(NULL, NULL, NULL);

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

ep.getit() -> set(ep2);

}

return EE_UNDEFINED;

}

#endif

#ifdef LEGACY_EXEC

Exec_errors MCClipboardCmd::processtoclipboard(MCExecPoint& ep, 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)

{

if (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;

}

#endif

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

//

// 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 kind;

delete newname;

delete file;

delete container;

}

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:

case CT_WIDGET:

otype = (Chunk_term)te->which;

break;

case CT_ALIAS:

alias = True;

break;

default:

MCperror->add

(PE_CREATE_BADTYPE, sp);

return PS_ERROR;

}

}

else if (te -> type == TT_PROPERTY && te -> which == P_SCRIPT)

{

// Accept 'create script only stack ... [ <name> ]'

if (sp . skip_token(SP_SUGAR, TT_UNDEFINED, SG_ONLY) != PS_NORMAL ||

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

{

MCperror -> add(PE_CREATE_BADTYPE, sp);

return PS_ERROR;

}

script_only_stack = True;

}

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

{

// AL-2015-05-21: [[ Bug 15405 ]] Allow 'create widget as ... in group ...'

if (otype == CT_WIDGET)

{

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

{

MCperror -> add(PE_CREATE_BADTYPE, sp);

return PS_ERROR;

}

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

{

MCperror -> add(PE_CREATE_BADTYPE, sp);