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

#include "objdefs.h"

#include "parsedef.h"

#include "mcio.h"

#include "execpt.h"

#include "dispatch.h"

#include "stack.h"

#include "tooltip.h"

#include "card.h"

#include "field.h"

#include "button.h"

#include "image.h"

#include "aclip.h"

#include "vclip.h"

#include "stacklst.h"

#include "mcerror.h"

#include "hc.h"

#include "util.h"

#include "param.h"

#include "debug.h"

#include "statemnt.h"

#include "funcs.h"

#include "magnify.h"

#include "sellst.h"

#include "undolst.h"

#include "styledtext.h"

#include "external.h"

#include "osspec.h"

#include "flst.h"

#include "globals.h"

#include "license.h"

#include "mode.h"

#include "redraw.h"

#include "printer.h"

#include "font.h"

#include "stacksecurity.h"

#define UNLICENSED_TIME 6.0

#ifdef _DEBUG_MALLOC_INC

#define LICENSED_TIME 1.0

#else

#define LICENSED_TIME 3.0

#endif

MCImage *MCDispatch::imagecache;

#define VERSION_OFFSET 11

#define HEADERSIZE 255

static char header[HEADERSIZE] = "#!/bin/sh\n# MetaCard 2.4 stack\n# The following is not ASCII text,\n# so now would be a good time to q out of more\f\nexec mc $0 \"$@\"\n";

#define NEWHEADERSIZE 8

static const char *newheader = "REVO2700";

static const char *newheader5500 = "REVO5500";

MCDispatch::MCDispatch()

{

license = NULL;

stacks = NULL;

fonts = NULL;

setname_cstring("dispatch");

handling = False;

menu = NULL;

panels = NULL;

startdir = NULL;

enginedir = NULL;

flags = 0;

m_drag_source = false;

m_drag_target = false;

m_drag_end_sent = false;

m_externals = nil;

}

MCDispatch::~MCDispatch()

{

delete license;

while (stacks != NULL)

{

MCStack *sptr = stacks->prev()->remove(stacks);

delete sptr;

}

while (imagecache != NULL)

{

MCImage *iptr = imagecache->remove(imagecache);

delete iptr;

}

delete fonts;

delete startdir;

delete enginedir;

delete m_externals;

}

bool MCDispatch::isdragsource(void)

{

return m_drag_source;

}

bool MCDispatch::isdragtarget(void)

{

return m_drag_target;

}

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

{

switch (which)

{

case P_BACK_PIXEL:

ep.setint(MCscreen->background_pixel.pixel & 0xFFFFFF);

return ES_NORMAL;

case P_TOP_PIXEL:

ep.setint(MCscreen->white_pixel.pixel & 0xFFFFFF);

return ES_NORMAL;

case P_HILITE_PIXEL:

case P_FORE_PIXEL:

case P_BORDER_PIXEL:

case P_BOTTOM_PIXEL:

case P_SHADOW_PIXEL:

case P_FOCUS_PIXEL:

ep.setint(MCscreen->black_pixel.pixel & 0xFFFFFF);

return ES_NORMAL;

case P_BACK_COLOR:

case P_HILITE_COLOR:

ep.setstaticcstring("white");

return ES_NORMAL;

case P_FORE_COLOR:

case P_BORDER_COLOR:

case P_TOP_COLOR:

case P_BOTTOM_COLOR:

case P_SHADOW_COLOR:

case P_FOCUS_COLOR:

ep.setstaticcstring("black");

return ES_NORMAL;

case P_FORE_PATTERN:

case P_BACK_PATTERN:

case P_HILITE_PATTERN:

case P_BORDER_PATTERN:

case P_TOP_PATTERN:

case P_BOTTOM_PATTERN:

case P_SHADOW_PATTERN:

case P_FOCUS_PATTERN:

ep.clear();

return ES_NORMAL;

case P_TEXT_ALIGN:

ep.setstaticcstring(MCleftstring);

return ES_NORMAL;

case P_TEXT_FONT:

ep.setstaticcstring(DEFAULT_TEXT_FONT);

return ES_NORMAL;

case P_TEXT_HEIGHT:

ep.setint(heightfromsize(DEFAULT_TEXT_SIZE));

return ES_NORMAL;

case P_TEXT_SIZE:

ep.setint(DEFAULT_TEXT_SIZE);

return ES_NORMAL;

case P_TEXT_STYLE:

ep.setstaticcstring(MCplainstring);

return ES_NORMAL;

default:

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

return ES_ERROR;

}

}

Exec_stat MCDispatch::setprop(uint4 parid, Properties which, MCExecPoint &ep, Boolean effective)

{

return ES_NORMAL;

}

// bogus "cut" call actually checks license

Boolean MCDispatch::cut(Boolean home)

{

if (home)

return True;

return MCnoui || (flags & F_WAS_LICENSED) != 0;

}

extern Exec_stat MCHandlePlatformMessage(Handler_type htype, const MCString& mess, MCParameter *params);

Exec_stat MCDispatch::handle(Handler_type htype, MCNameRef mess, MCParameter *params, MCObject *pass_from)

{

Exec_stat stat = ES_NOT_HANDLED;

bool t_has_passed;

t_has_passed = false;

if (MCcheckstack && MCU_abs(MCstackbottom - (char *)&stat) > MCrecursionlimit)

{

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

MCerrorptr = stacks;

return ES_ERROR;

}

// MW-2011-06-30: Move handling of library stacks from MCStack::handle.

if (MCnusing > 0)

{

for (uint32_t i = MCnusing; i > 0 && (stat == ES_PASS || stat == ES_NOT_HANDLED); i -= 1)

{

stat = MCusing[i - 1]->handle(htype, mess, params, nil);

// MW-2011-08-22: [[ Bug 9686 ]] Make sure we exit as soon as the

// message is handled.

if (stat != ES_NOT_HANDLED && stat != ES_PASS)

return stat;

if (stat == ES_PASS)

t_has_passed = true;

}

if (t_has_passed && stat == ES_NOT_HANDLED)

stat = ES_PASS;

}

if ((stat == ES_NOT_HANDLED || stat == ES_PASS) && MCbackscripts != NULL)

{

MCObjectList *optr = MCbackscripts;

do

{

if (!optr->getremoved())

{

stat = optr->getobject()->handle(htype, mess, params, nil);

if (stat != ES_NOT_HANDLED && stat != ES_PASS)

return stat;

if (stat == ES_PASS)

t_has_passed = true;

}

optr = optr->next();

}

while (optr != MCbackscripts);

}

if ((stat == ES_NOT_HANDLED || stat == ES_PASS) && m_externals != nil)

{

Exec_stat oldstat = stat;

stat = m_externals -> Handle(this, htype, mess, params);

// MW-2011-08-22: [[ Bug 9686 ]] Make sure we exit as soon as the

// message is handled.

if (stat != ES_NOT_HANDLED && stat != ES_PASS)

return stat;

if (oldstat == ES_PASS && stat == ES_NOT_HANDLED)

stat = ES_PASS;

}

#ifdef TARGET_SUBPLATFORM_IPHONE

extern Exec_stat MCIPhoneHandleMessage(MCNameRef message, MCParameter *params);

if (stat == ES_NOT_HANDLED || stat == ES_PASS)

{

stat = MCIPhoneHandleMessage(mess, params);

if (stat != ES_NOT_HANDLED && stat != ES_PASS)

return stat;

}

#endif

#ifdef _MOBILE

if (stat == ES_NOT_HANDLED || stat == ES_PASS)

{

stat = MCHandlePlatformMessage(htype, MCNameGetOldString(mess), params);

// MW-2011-08-22: [[ Bug 9686 ]] Make sure we exit as soon as the

// message is handled.

if (stat != ES_NOT_HANDLED && stat != ES_PASS)

return stat;

}

#endif

if (MCmessagemessages && stat != ES_PASS)

MCtargetptr->sendmessage(htype, mess, False);

if (t_has_passed)

return ES_PASS;

return stat;

}

void MCDispatch::getmainstacknames(MCExecPoint &ep)

{

ep.clear();

MCExecPoint ep2(ep);

MCStack *tstk = stacks;

bool first;

first = true;

do

{

tstk->getprop(0, P_SHORT_NAME, ep2, False);

ep.concatmcstring(ep2.getsvalue(), EC_RETURN, first);

first = false;

tstk = (MCStack *)tstk->next();

}

while (tstk != stacks);

}

void MCDispatch::appendstack(MCStack *sptr)

{

sptr->appendto(stacks);

// MW-2013-03-20: [[ MainStacksChanged ]]

MCmainstackschanged = True;

}

void MCDispatch::removestack(MCStack *sptr)

{

sptr->remove(stacks);

// MW-2013-03-20: [[ MainStacksChanged ]]

MCmainstackschanged = True;

}

void MCDispatch::destroystack(MCStack *sptr, Boolean needremove)

{

if (needremove)

removestack(sptr);

if (sptr == MCstaticdefaultstackptr)

MCstaticdefaultstackptr = stacks;

if (sptr == MCdefaultstackptr)

MCdefaultstackptr = MCstaticdefaultstackptr;

if (MCacptr != NULL && MCacptr->getmessagestack() == sptr)

MCacptr->setmessagestack(NULL);

Boolean oldstate = MClockmessages;

MClockmessages = True;

delete sptr;

MClockmessages = oldstate;

}

Boolean MCDispatch::openstartup(const char *sname,

char **outpath, IO_handle &stream)

{

if (enginedir == nil)

return False;

uint4 l = MCU_max((uint4)strlen(enginedir), (uint4)strlen(startdir)) + strlen(sname) + 11;

char *fullpath = new char[l];

sprintf(fullpath, "%s/%s", startdir, sname);

if ((stream = MCS_open(fullpath, IO_READ_MODE, True, False, 0)) != NULL)

{

*outpath = fullpath;

return True;

}

sprintf(fullpath, "%s/%s", enginedir, sname);

if ((stream = MCS_open(fullpath, IO_READ_MODE, True, False, 0)) != NULL)

{

*outpath = fullpath;

return True;

}

delete fullpath;

return False;

}

Boolean MCDispatch::openenv(const char *sname, const char *env,

char **outpath, IO_handle &stream, uint4 offset)

{

if ((env = MCS_getenv(env)) != NULL)

{

char *pathstring = strclone(env);

char *fullpath = new char[strlen(env) + strlen(sname) + 2];

char *eptr = pathstring;

while (eptr != NULL)

{

char *path = eptr;

eptr = strchr(eptr, ENV_SEPARATOR);

if (eptr != NULL)

*eptr++ = '\0';

#ifdef _WIN32

sprintf(fullpath, "%s\\%s", path, sname);

#else

sprintf(fullpath, "%s/%s", path, sname);

#endif

if ((stream = MCS_open(fullpath, IO_READ_MODE, True, False,

offset)) != NULL)

{

delete pathstring;

*outpath = fullpath;

return True;

}

}

delete pathstring;

delete fullpath;

}

return False;

}

IO_stat readheader(IO_handle& stream, char *version)

{

char tnewheader[NEWHEADERSIZE];

uint4 size = NEWHEADERSIZE;

if (IO_read(tnewheader, sizeof(char), size, stream) == IO_NORMAL)

{

// MW-2012-03-04: [[ StackFile5500 ]] Check for either the 2.7 or 5.5 header.

if (strncmp(tnewheader, newheader, NEWHEADERSIZE) == 0 ||

strncmp(tnewheader, newheader5500, NEWHEADERSIZE) == 0)

{

sprintf(version, "%c.%c.%c.%c", tnewheader[4], tnewheader[5], tnewheader[6], tnewheader[7]);

if (tnewheader[7] == '0')

{

version[5] = '\0';

if (tnewheader[6] == '0')

version[3] = '\0';

}

}

else

{

char theader[HEADERSIZE + 1];

uint4 size = HEADERSIZE - NEWHEADERSIZE;

theader[HEADERSIZE] = '\0';

uint4 offset;

strncpy(theader, tnewheader, NEWHEADERSIZE);

if (IO_read(theader + NEWHEADERSIZE, sizeof(char), size, stream) == IO_NORMAL

&& MCU_offset(SIGNATURE, theader, offset))

{

if (theader[offset - 1] != '\n' || theader[offset - 2] == '\r')

{

MCresult->sets("stack was corrupted by a non-binary file transfer");

return IO_ERROR;

}

strncpy(version, &theader[offset + VERSION_OFFSET], 3);

version[3] = '\0';

}

else

return IO_ERROR;

}

}

return IO_NORMAL;

}

// This method reads a stack from the given stream. The stack is set to

// have parent MCDispatch, and filename MCcmd. It is designed to be used

// for embedded stacks/deployed stacks/revlet stacks.

IO_stat MCDispatch::readstartupstack(IO_handle stream, MCStack*& r_stack)

{

char version[8];

uint1 charset, type;

char *newsf;

if (readheader(stream, version) != IO_NORMAL

|| IO_read_uint1(&charset, stream) != IO_NORMAL

|| IO_read_uint1(&type, stream) != IO_NORMAL

|| IO_read_string(newsf, stream) != IO_NORMAL)

return IO_ERROR;

// MW-2008-10-20: [[ ParentScripts ]] Set the boolean flag that tells us whether

// parentscript resolution is required to false.

s_loaded_parent_script_reference = false;

MCtranslatechars = charset != CHARSET;

delete newsf; // stackfiles is obsolete

MCStack *t_stack = nil;

/* UNCHECKED */ MCStackSecurityCreateStack(t_stack);

t_stack -> setparent(this);

t_stack -> setfilename(strclone(MCcmd));

if (IO_read_uint1(&type, stream) != IO_NORMAL

|| type != OT_STACK && type != OT_ENCRYPT_STACK

|| t_stack->load(stream, version, type) != IO_NORMAL)

{

delete t_stack;

return IO_ERROR;

}

if (t_stack->load_substacks(stream, version) != IO_NORMAL

|| IO_read_uint1(&type, stream) != IO_NORMAL

|| type != OT_END)

{

delete t_stack;

return IO_ERROR;

}

// We are reading the startup stack, so this becomes the root of the

// stack list.

stacks = t_stack;

r_stack = t_stack;

#ifndef _MOBILE

// Make sure parent script references are up to date.

if (s_loaded_parent_script_reference)

t_stack -> resolveparentscripts();

#else

// Mark the stack as needed parentscript resolution. This is done after

// aux stacks have been loaded.

if (s_loaded_parent_script_reference)

t_stack -> setextendedstate(True, ECS_USES_PARENTSCRIPTS);

#endif

return IO_NORMAL;

}

// MW-2012-02-17: [[ LogFonts ]] Load a stack file, ensuring we clear up any

// font table afterwards - regardless of errors.

IO_stat MCDispatch::readfile(const char *openpath, const char *inname, IO_handle &stream, MCStack *&sptr)

{

IO_stat stat;

stat = doreadfile(openpath, inname, stream, sptr);

MCLogicalFontTableFinish();

return stat;

}

// MW-2012-02-17: [[ LogFonts ]] Actually load the stack file (wrapped by readfile

// to handle font table cleanup).

IO_stat MCDispatch::doreadfile(const char *openpath, const char *inname, IO_handle &stream, MCStack *&sptr)

{

Boolean loadhome = False;

char version[8];

if (readheader(stream, version) == IO_NORMAL)

{

if (strcmp(version, MCversionstring) > 0)

{

MCresult->sets("stack was produced by a newer version");

return IO_ERROR;

}

// MW-2008-10-20: [[ ParentScripts ]] Set the boolean flag that tells us whether

// parentscript resolution is required to false.

s_loaded_parent_script_reference = false;

uint1 charset, type;

char *newsf;

if (IO_read_uint1(&charset, stream) != IO_NORMAL

|| IO_read_uint1(&type, stream) != IO_NORMAL

|| IO_read_string(newsf, stream) != IO_NORMAL)

{

MCresult->sets("stack is corrupted, check for ~ backup file");

return IO_ERROR;

}

delete newsf; // stackfiles is obsolete

MCtranslatechars = charset != CHARSET;

sptr = nil;

/* UNCHECKED */ MCStackSecurityCreateStack(sptr);

if (stacks == NULL)

sptr->setparent(this);

else

sptr->setparent(stacks);

sptr->setfilename(strclone(openpath));

if (MCModeCanLoadHome() && type == OT_HOME)

{

char *lstring = NULL;

char *cstring = NULL;

IO_read_string(lstring, stream);

IO_read_string(cstring, stream);

delete lstring;

delete cstring;

}

MCresult -> clear();

if (IO_read_uint1(&type, stream) != IO_NORMAL

|| type != OT_STACK && type != OT_ENCRYPT_STACK

|| sptr->load(stream, version, type) != IO_NORMAL)

{

if (MCresult -> isclear())

MCresult->sets("stack is corrupted, check for ~ backup file");

destroystack(sptr, False);

sptr = NULL;

return IO_ERROR;

}

// MW-2011-08-09: [[ Groups ]] Make sure F_GROUP_SHARED is set

// appropriately.

sptr -> checksharedgroups();

if (sptr->load_substacks(stream, version) != IO_NORMAL

|| IO_read_uint1(&type, stream) != IO_NORMAL

|| type != OT_END)

{

if (MCresult -> isclear())

MCresult->sets("stack is corrupted, check for ~ backup file");

destroystack(sptr, False);

sptr = NULL;

return IO_ERROR;

}

if (stacks != NULL)

{

MCStack *tstk = stacks;

do

{

if (sptr->hasname(tstk->getname()))

{

MCAutoNameRef t_stack_name;

/* UNCHECKED */ t_stack_name . Clone(sptr -> getname());

delete sptr;

sptr = NULL;

if (strequal(tstk->getfilename(), openpath))

sptr = tstk;

else

{

MCdefaultstackptr->getcard()->message_with_args(MCM_reload_stack, MCNameGetOldString(tstk->getname()), openpath);

tstk = stacks;

do

{

if (MCNameIsEqualTo(t_stack_name, tstk->getname(), kMCCompareCaseless))

{

sptr = tstk;

break;

}

tstk = (MCStack *)tstk->next();

}

while (tstk != stacks);

}

return IO_NORMAL;

}

tstk = (MCStack *)tstk->next();

}

while (tstk != stacks);

}

appendstack(sptr);

sptr->extraopen(false);

// MW-2008-10-28: [[ ParentScript ]]

// We just loaded a stackfile, so check to see if parentScript resolution

// is required and if so do it.

// MW-2009-01-28: [[ Inherited parentScripts ]]

// Resolving parentScripts may allocate memory, so 'resolveparentscripts'

// will return false if it fails to allocate what it needs. At some point

// this needs to be dealt with by deleting the stack and returning an error,

// *However* at the time of writing, 'readfile' isn't designed to handle

// this - so we just ignore the result for now (note that all the 'load'

// methods *fail* to check for no-memory errors!).

if (s_loaded_parent_script_reference)

sptr -> resolveparentscripts();

}

else

{

MCS_seek_set(stream, 0);

if (stacks == NULL)

{

MCnoui = True;

MCscreen = new MCUIDC;

/* UNCHECKED */ MCStackSecurityCreateStack(stacks);

MCdefaultstackptr = MCstaticdefaultstackptr = stacks;

stacks->setparent(this);

stacks->setname_cstring("revScript");

uint4 size = (uint4)MCS_fsize(stream);

char *script = new char[size + 2];

script[size] = '\n';

script[size + 1] = '\0';

if (IO_read(script, sizeof(char), size, stream) != IO_NORMAL

|| !stacks->setscript(script))

{

delete script;

return IO_ERROR;

}

}

else

{

char *tname = strclone(inname);

// MW-2008-06-12: [[ Bug 6476 ]] Media won't open HC stacks

if (!MCdispatcher->cut(True) || hc_import(tname, stream, sptr) != IO_NORMAL)

{

MCresult->sets("file is not a stack");

delete tname;

return IO_ERROR;

}

}

}

return IO_NORMAL;

}

IO_stat MCDispatch::loadfile(const char *inname, MCStack *&sptr)

{

IO_handle stream;

char *openpath = NULL;

char *fname = strclone(inname);

if ((stream = MCS_open(fname, IO_READ_MODE, True, False, 0)) != NULL)

if (fname[0] != PATH_SEPARATOR && fname[1] != ':')

{

char *curpath = MCS_getcurdir();

if (curpath[strlen(curpath) - 1] == '/')

curpath[strlen(curpath) - 1] = '\0';

openpath = new char[strlen(curpath) + strlen(fname) + 2];

sprintf(openpath, "%s/%s", curpath, fname);

delete curpath;

}

else

openpath = strclone(fname);

else

{

char *tmparray = new char[strlen(fname) + 1];

strcpy(tmparray, fname);

char *tname = strrchr(tmparray, PATH_SEPARATOR);

if (tname == NULL)

tname = tmparray;

else

tname++;

if ((stream = MCS_open(tname, IO_READ_MODE, True, False, 0)) != NULL)

{

char *curpath = MCS_getcurdir();

openpath = new char[strlen(curpath) + strlen(tname) + 2];

sprintf(openpath, "%s/%s", curpath, tname);

delete curpath;

}

else

{

if (!openstartup(tname, &openpath, stream)

&& !openenv(tname, "MCPATH", &openpath, stream, 0)

&& !openenv(tname, "PATH", &openpath, stream, 0))

{

char *homename;

if ((homename = MCS_getenv("HOME")) != NULL)

{

openpath = new char[strlen(homename) + strlen(tname) + 13];

if (homename[strlen(homename) - 1] == '/')

homename[strlen(homename) - 1] = '\0';

sprintf(openpath, "%s/%s", homename, tname);

if ((stream = MCS_open(openpath, IO_READ_MODE, True,

False, 0)) == NULL)

{

sprintf(openpath, "%s/stacks/%s", homename, tname);

if ((stream = MCS_open(openpath, IO_READ_MODE, True,

False, 0)) == NULL)

{

sprintf(openpath, "%s/components/%s", homename, tname);

if ((stream = MCS_open(openpath, IO_READ_MODE, True,

False, 0)) == NULL)

{

delete openpath;

openpath = NULL;

}

}

}

}

}

}

delete tmparray;

}

if (stream == NULL)

{

if (openpath != NULL)

delete openpath;

delete fname;

return IO_ERROR;

}

delete fname;

IO_stat stat = readfile(openpath, inname, stream, sptr);

delete openpath;

MCS_close(stream);

return stat;

}

void MCDispatch::cleanup(IO_handle stream, char *linkname, char *bname)

{

if (stream != NULL)

MCS_close(stream);

MCS_unlink(linkname);

if (bname != NULL)

MCS_unbackup(bname, linkname);

delete linkname;

delete bname;

}

IO_stat MCDispatch::savestack(MCStack *sptr, const MCString& fname)

{

IO_stat stat;

stat = dosavestack(sptr, fname);

MCLogicalFontTableFinish();

return stat;

}

IO_stat MCDispatch::dosavestack(MCStack *sptr, const MCString &fname)

{

if (MCModeCheckSaveStack(sptr, fname) != IO_NORMAL)

return IO_ERROR;

char *linkname;

if (fname.getlength() != 0)

linkname = fname.clone();

else

if ((linkname = strclone(sptr->getfilename())) == NULL)

{

MCresult->sets("stack does not have a filename");

return IO_ERROR;

}

if (linkname == NULL)

{

MCresult->sets("can't open stack file, bad path");

return IO_ERROR;

}

if (MCS_noperm(linkname))

{

MCresult->sets("can't open stack file, no permission");

delete linkname;

return IO_ERROR;

}

char *oldfiletype = MCfiletype;

MCfiletype = MCstackfiletype;

char *backup = new char[strlen(linkname) + 2];

strcpy(backup, linkname);

strcat(backup, "~");

MCS_unlink(backup);

if (MCS_exists(linkname, True) && !MCS_backup(linkname, backup))

{

MCresult->sets("can't open stack backup file");

MCfiletype = oldfiletype;

delete linkname;

delete backup;

return IO_ERROR;

}

IO_handle stream;

if ((stream = MCS_open(linkname, IO_WRITE_MODE, True, False, 0)) == NULL)

{

MCresult->sets("can't open stack file");

cleanup(stream, linkname, backup);

MCfiletype = oldfiletype;

return IO_ERROR;

}

MCfiletype = oldfiletype;

MCString errstring = "Error writing stack (disk full?)";

// MW-2012-03-04: [[ StackFile5500 ]] Work out what header to emit, and the size.

const char *t_header;

uint32_t t_header_size;

if (MCstackfileversion >= 5500)

t_header = newheader5500, t_header_size = 8;

else if (MCstackfileversion >= 2700)

t_header = newheader, t_header_size = 8;

else

t_header = header, t_header_size = HEADERSIZE;

if (IO_write(t_header, sizeof(char), t_header_size, stream) != IO_NORMAL

|| IO_write_uint1(CHARSET, stream) != IO_NORMAL)

{

MCresult->sets(errstring);

cleanup(stream, linkname, backup);

return IO_ERROR;

}

if (IO_write_uint1(OT_NOTHOME, stream) != IO_NORMAL

|| IO_write_string(NULL, stream) != IO_NORMAL)

{ // was stackfiles

MCresult->sets(errstring);

cleanup(stream, linkname, backup);

return IO_ERROR;

}

// MW-2012-02-22; [[ NoScrollSave ]] Adjust the rect by the current group offset.

MCgroupedobjectoffset . x = 0;

MCgroupedobjectoffset . y = 0;

MCresult -> clear();

if (sptr->save(stream, 0, false) != IO_NORMAL

|| IO_write_uint1(OT_END, stream) != IO_NORMAL)

{

if (MCresult -> isclear())

MCresult->sets(errstring);

cleanup(stream, linkname, backup);

return IO_ERROR;

}

MCS_close(stream);

uint2 oldmask = MCS_umask(0);

uint2 newmask = ~oldmask & 00777;

if (oldmask & 00400)

newmask &= ~00100;

if (oldmask & 00040)

newmask &= ~00010;

if (oldmask & 00004)

newmask &= ~00001;

MCS_umask(oldmask);

MCS_chmod(linkname, newmask);

if (sptr->getfilename() != NULL && !strequal(linkname, sptr->getfilename()))

MCS_copyresourcefork(sptr->getfilename(), linkname);

else if (sptr -> getfilename() != NULL)

MCS_copyresourcefork(backup, linkname);

sptr->setfilename(linkname);

if (backup != NULL)

{

MCS_unlink(backup);

delete backup;

}

return IO_NORMAL;

}

#ifdef FEATURE_RELAUNCH_SUPPORT

extern bool relaunch_startup(const char *p_id);

#endif

void send_relaunch(void)

{

#ifdef FEATURE_RELAUNCH_SUPPORT

bool t_do_relaunch;

t_do_relaunch = false;

const char *t_id;

t_do_relaunch = MCModeHandleRelaunch(t_id);

if (t_do_relaunch)

if (relaunch_startup(t_id))

exit(0);

#endif

}

void send_startup_message(bool p_do_relaunch = true)

{

if (p_do_relaunch)

send_relaunch();

MCdefaultstackptr -> setextendedstate(true, ECS_DURING_STARTUP);

MCdefaultstackptr -> getcard() -> message(MCM_start_up);

MCdefaultstackptr -> setextendedstate(false, ECS_DURING_STARTUP);

}

void MCDispatch::wclose(Window w)

{

MCStack *target = findstackd(w);

if (target != NULL && !target -> getextendedstate(ECS_DISABLED_FOR_MODAL))

{

Exec_stat stat = target->getcurcard()->message(MCM_close_stack_request);

if (stat == ES_NOT_HANDLED || stat == ES_PASS)

{

target->kunfocus();

target->close();

target->checkdestroy();

}

}

}

void MCDispatch::wkfocus(Window w)

{

MCStack *target = findstackd(w);

if (target != NULL)

target->kfocus();

}

void MCDispatch::wkunfocus(Window w)

{

MCStack *target = findstackd(w);

if (target != NULL)

target->kunfocus();

}

Boolean MCDispatch::wkdown(Window w, const char *string, KeySym key)

{

if (menu != NULL)

return menu->kdown(string, key);

MCStack *target = findstackd(w);

if (target == NULL || !target->kdown(string, key))

{

if (MCmodifierstate & MS_MOD1)

{

MCButton *bptr = MCstacks->findmnemonic(MCS_tolower(string[0]));

if (bptr != NULL)

{

bptr->activate(True, (uint2)key);

return True;

}

}

}

else

if (target != NULL)

return True;

return False;

}

void MCDispatch::wkup(Window w, const char *string, KeySym key)

{

if (menu != NULL)

menu->kup(string, key);

else