/* 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 "scriptpt.h"
//#include "execpt.h"
#include "cmds.h"
#include "chunk.h"
#include "mcerror.h"
#include "object.h"
#include "stack.h"
#include "card.h"
#include "printer.h"
#include "util.h"
#include "globals.h"
#include "securemode.h"
#include "exec.h"

#include "syntax.h"
#include "graphics_util.h"

MCPrint::MCPrint()
{
	mode = PM_CARD;
	target = NULL;
	from = NULL;
	to = NULL;
	rect = NULL;
	initial_state = NULL;
	bookmark_closed = false;
}

MCPrint::~MCPrint()
{
	delete target;
	delete from;
	delete to;
	delete rect;
	delete initial_state;
}

// This parses the following forms:
//   print break
//   print ( all | marked ) cards [ of <chunk> ] [ from <expr> to <expr> ] [ into <expr> ]
//   print <chunk> [ from <expr> to <expr> ] [ into <expr> ]
//   print <chunk> cards [ from <expr> to <expr> ] [ into <expr> ]
//
// New interactivity related print syntax:
//   print anchor <name> at <position>
//   print link to <anchor or url> with rect[angle] <rect>
//
Parse_stat MCPrint::parse(MCScriptPoint &sp)
{
	Symbol_type type;
	const LT *te;
	Boolean single = False;

	initpoint(sp);

	// print anchor <name> at <position>
	//   <name> -> from
	//   <position> -> rect
	//
	if (sp . skip_token(SP_SUGAR, TT_UNDEFINED, SG_ANCHOR) == PS_NORMAL)
	{
		mode = PM_ANCHOR;

		if (sp . parseexp(False, True, &from) != PS_NORMAL)
		{
			MCperror -> add(PE_PRINTANCHOR_BADNAMEEXP, sp);
			return PS_ERROR;
		}

		if (sp . skip_token(SP_FACTOR, TT_PREP, PT_AT) != PS_NORMAL)
		{
			MCperror -> add(PE_PRINTANCHOR_NOATEXP, sp);
			return PS_ERROR;
		}

		if (sp . parseexp(False, True, &rect) != PS_NORMAL)
		{
			MCperror -> add(PE_PRINTANCHOR_BADTOEXP, sp);
			return PS_ERROR;
		}

		return PS_NORMAL;
	}

	// print link to [ url | anchor ] <anchor or url> with rect[angle] <rect>
	//   <anchor or url> -> to
	//   <rect> -> rect
	//
	if (sp . skip_token(SP_SUGAR, TT_UNDEFINED, SG_LINK) == PS_NORMAL)
	{
		mode = PM_LINK;

		if (sp . skip_token(SP_FACTOR, TT_TO, PT_TO) != PS_NORMAL)
		{
			MCperror -> add(PE_PRINTLINK_NOTOEXP, sp);
			return PS_ERROR;
		}

		if (sp.skip_token(SP_SUGAR, TT_UNDEFINED, SG_ANCHOR) == PS_NORMAL)
			mode = PM_LINK_ANCHOR;
		else if (sp.skip_token(SP_SUGAR, TT_UNDEFINED, SG_URL) == PS_NORMAL)
			mode = PM_LINK_URL;

		if (sp . parseexp(False, True, &to) != PS_NORMAL)
		{
			MCperror -> add(PE_PRINTLINK_BADTOEXP, sp);
			return PS_ERROR;
		}
		
		if (sp . skip_token(SP_REPEAT, TT_UNDEFINED, RF_WITH) != PS_NORMAL ||
			sp . skip_token(SP_FACTOR, TT_PROPERTY, P_RECTANGLE) != PS_NORMAL)
		{
			MCperror -> add(PE_PRINTLINK_NOAREAEXP, sp);
			return PS_ERROR;
		}

		if (sp . parseexp(False, True, &rect) != PS_NORMAL)
		{
			MCperror -> add(PE_PRINTLINK_BADAREAEXP, sp);
			return PS_ERROR;
		}

		return PS_NORMAL;
	}

	// print [unicode] bookmark <title> [with level <level>] [at <position>]
	//   <title> -> from
	//   <level> -> to
	//   <position> -> rect
	if (sp.skip_token(SP_SUGAR, TT_UNDEFINED, SG_UNICODE) == PS_NORMAL)
		mode = PM_UNICODE_BOOKMARK;
	if (sp . skip_token(SP_SUGAR, TT_UNDEFINED, SG_BOOKMARK) != PS_NORMAL)
	{
		if (mode == PM_UNICODE_BOOKMARK)
		{
			MCperror->add(PE_PRINTBOOKMARK_NOBOOKMARK, sp);
			return PS_ERROR;
		}
	}
	else
	{
		if (mode != PM_UNICODE_BOOKMARK)
			mode = PM_BOOKMARK;

		if (sp.parseexp(False, True, &from) != PS_NORMAL)
		{
			MCperror->add(PE_PRINTBOOKMARK_BADTITLEEXP, sp);
			return PS_ERROR;
		}
		if (sp.skip_token(SP_REPEAT, TT_UNDEFINED, RF_WITH) == PS_NORMAL)
		{
			if (sp.skip_token(SP_SUGAR, TT_UNDEFINED, SG_LEVEL) != PS_NORMAL)
			{
				MCperror->add(PE_PRINTBOOKMARK_NOLEVEL, sp);
				return PS_ERROR;
			}
			if (sp.parseexp(False, True, &to) != PS_NORMAL)
			{
				MCperror->add(PE_PRINTBOOKMARK_BADLEVELEXP, sp);
				return PS_ERROR;
			}
		}
		if (sp.skip_token(SP_FACTOR, TT_PREP, PT_AT) == PS_NORMAL)
		{
			if (sp.parseexp(False, True, &rect) != PS_NORMAL)
			{
				MCperror->add(PE_PRINTBOOKMARK_BADATEXP, sp);
				return PS_ERROR;
			}
		}
		if (sp.skip_token(SP_SUGAR, TT_UNDEFINED, SG_INITIALLY) == PS_NORMAL)
		{
			if (sp.skip_token(SP_SUGAR, TT_UNDEFINED, SG_OPEN) == PS_NORMAL)
				bookmark_closed = false;
			else if (sp.skip_token(SP_SUGAR, TT_UNDEFINED, SG_CLOSED) == PS_NORMAL)
				bookmark_closed = true;
			else if (sp.parseexp(False, True, &initial_state) != PS_NORMAL)
			{
				MCperror->add(PE_PRINTBOOKMARK_BADINITIALEXP, sp);
				return PS_ERROR;
			}
		}

		return PS_NORMAL;
	}

	// Rest of the print syntax
	if (sp.next(type) == PS_NORMAL)
	{
		if (sp.lookup(SP_SHOW, te) == PS_NORMAL)
		{
			if (te->which == SO_ALL || te->which == SO_MARKED)
			{
				mode = (Show_object)te->which == SO_ALL ? PM_ALL : PM_MARKED;
				if (sp.skip_token(SP_FACTOR, TT_CLASS, CT_CARD) != PS_NORMAL)
				{
					MCperror->add(PE_PRINT_BADTARGET, sp);
					return PS_ERROR;
				}
			}
			else if (te->which == SO_BREAK)
			{
				sp.skip_token(SP_SHOW, TT_UNDEFINED, SO_BREAK);
				mode = PM_BREAK;
				return PS_NORMAL;
			}
			else if (te->which == SO_CARD)
			{
				MCScriptPoint oldsp(sp);
				sp.backup();
				target = new MCChunk(False);
				MCerrorlock++;
				if (target->parse(sp, False) != PS_NORMAL)
				{
					sp = oldsp;
					delete target;
					target = NULL;
					single = True;
				}
				MCerrorlock--;
			}
		}
		else
			sp . backup();
	}
	if ((mode != PM_CARD && sp . skip_token(SP_FACTOR, TT_OF) == PS_NORMAL) ||
		(mode == PM_CARD && !single && target == NULL))
	{
		target = new MCChunk(False);
		if (target->parse(sp, False) != PS_NORMAL)
		{
			MCperror->add(PE_PRINT_BADTARGET, sp);
			return PS_ERROR;
		}
	}
	if (sp.skip_token(SP_FACTOR, TT_CLASS, CT_CARD) == PS_NORMAL)
		mode = PM_SOME;
	if (sp.skip_token(SP_FACTOR, TT_FROM, PT_FROM) == PS_NORMAL)
	{
		if (sp.parseexp(False, True, &from) != PS_NORMAL)
		{
			MCperror->add(PE_PRINT_BADFROMEXP, sp);
			return PS_ERROR;
		}
		if (sp.skip_token(SP_FACTOR, TT_TO) != PS_NORMAL)
		{
			MCperror->add(PE_PRINT_NOTO, sp);
			return PS_ERROR;
		}
		if (sp.parseexp(False, True, &to) != PS_NORMAL)
		{
			MCperror->add(PE_PRINT_BADTOEXP, sp);
			return PS_ERROR;
		}
	}
	if (sp.skip_token(SP_FACTOR, TT_PREP, PT_INTO) == PS_NORMAL)
	{
		sp.skip_token(SP_FACTOR, TT_PROPERTY, P_RECTANGLE);
		if (sp.parseexp(False, True, &rect) != PS_NORMAL)
		{
			MCperror->add(PE_PRINT_BADRECTEXP, sp);
			return PS_ERROR;
		}
	}
	return PS_NORMAL;
}

bool MCPrint::evaluate_src_rect(MCExecContext& ctxt, MCPoint& r_from, MCPoint& r_to)
{
    MCPoint t_from, t_to;
    if (!ctxt . EvalExprAsPoint(from, EE_PRINT_CANTGETCOORD, t_from))
        return false;

    if (!ctxt . EvalExprAsPoint(to, EE_PRINT_CANTGETCOORD, t_to))
        return false;

    r_from = t_from;
    r_to = t_to;

    return true;
}

void MCPrint::exec_ctxt(MCExecContext &ctxt)
{
#ifdef /* MCPrint */ LEGACY_EXEC
	if (MCsecuremode & MC_SECUREMODE_PRINT)
	{
		MCeerror->add(EE_PRINT_NOPERM, line, pos);
		return ES_ERROR;
	}

	if (mode == PM_ANCHOR)
	{
		char *t_name;
		t_name = nil;
		if (from -> eval(ep) != ES_NORMAL)
		{
			MCeerror -> add(EE_PRINTANCHOR_BADNAME, line, pos);
			return ES_ERROR;
		}

		t_name = ep . getsvalue() . clone();

		int2 t_at_x, t_at_y;
		if (rect -> eval(ep) != ES_NORMAL)
		{
			MCeerror -> add(EE_PRINTANCHOR_BADLOCATION, line, pos);
			delete t_name;
			return ES_ERROR;
		}

		if (!MCU_stoi2x2(ep . getsvalue(), t_at_x, t_at_y))
		{
			MCeerror -> add(EE_PRINTANCHOR_LOCATIONNAP, line, pos, ep . getsvalue());
			delete t_name;
			return ES_ERROR;
		}

		MCprinter -> MakeAnchor(t_name, t_at_x, t_at_y);

		delete t_name;

		return ES_NORMAL;
	}
	else if (mode == PM_LINK || mode == PM_LINK_ANCHOR || mode == PM_LINK_URL)
	{
		MCPrinterLinkType t_type = kMCPrinterLinkUnspecified;
		if (mode == PM_LINK_ANCHOR)
			t_type = kMCPrinterLinkAnchor;
		else if (mode == PM_LINK_URL)
			t_type = kMCPrinterLinkURI;
		char *t_dest;
		t_dest = nil;
		if (to -> eval(ep) != ES_NORMAL)
		{
			MCeerror -> add(EE_PRINTLINK_BADDEST, line, pos);
			return ES_ERROR;
		}

		t_dest = ep . getsvalue() . clone();

		if (rect -> eval(ep) != ES_NORMAL)
		{
			MCeerror -> add(EE_PRINTLINK_BADAREA, line, pos);
			return ES_ERROR;
		}

		int2 i1, i2, i3, i4;
		if (!MCU_stoi2x4(ep . getsvalue(), i1, i2, i3, i4))
		{
			MCeerror->add(EE_PRINTLINK_AREANAR, line, pos, ep . getsvalue());
			return ES_ERROR;
		}

		MCRectangle t_area_rect;
		t_area_rect . x = i1;
		t_area_rect . y = i2;
		t_area_rect . width = MCU_max(i3 - i1, 1);
		t_area_rect . height = MCU_max(i4 - i2, 1);

		MCprinter -> MakeLink(t_dest, t_area_rect, t_type);

		delete t_dest;

		return ES_NORMAL;
	}
	else if (mode == PM_BOOKMARK || mode == PM_UNICODE_BOOKMARK)
	{
		char *t_title = nil;
		uint32_t t_level = 0;
		int16_t t_x = 0, t_y = 0;
		bool t_success = true;

		if (from->eval(ep) != ES_NORMAL)
		{
			MCeerror->add(EE_PRINTBOOKMARK_BADTITLE, line, pos, ep.getsvalue());
			t_success = false;
		}

		if (t_success)
		{
			if (mode == PM_UNICODE_BOOKMARK)
				ep.utf16toutf8();
			else
				ep.nativetoutf8();
			t_title = ep.getsvalue().clone();
		}

		if (t_success && to != NULL)
		{
			if (to->eval(ep) != ES_NORMAL ||
				ep.ton() != ES_NORMAL)
			{
				MCeerror->add(EE_PRINTBOOKMARK_BADLEVEL, line, pos, ep.getsvalue());
				t_success = false;
			}
			else
				t_level = ep.getint4();
		}

		if (t_success && rect != NULL)
		{
			if (rect->eval(ep) != ES_NORMAL ||
				!MCU_stoi2x2(ep.getsvalue(), t_x, t_y))
			{
				MCeerror->add(EE_PRINTBOOKMARK_BADAT, line, pos, ep.getsvalue());
				t_success = false;
			}
		}

		if (t_success && initial_state != NULL)
		{
			if (initial_state->eval(ep) != ES_NORMAL)
				t_success = false;
			if (t_success)
			{
				if (ep.getsvalue() == "closed")
					bookmark_closed = true;
				else if (ep.getsvalue() == "open")
					bookmark_closed = false;
				else
					t_success = false;
			}
			if (!t_success)
				MCeerror->add(EE_PRINTBOOKMARK_BADINITIAL, line, pos, ep.getsvalue());
		}

		if (t_success)
			MCprinter->MakeBookmark(t_title, t_x, t_y, t_level, bookmark_closed);
		delete t_title;

		return t_success ? ES_NORMAL : ES_ERROR;
	}

	MCObject *optr;
	uint4 parid;
	MCStack *stack = MCdefaultstackptr;
	
	MCCard *t_card;
	t_card  = NULL;
	
	uint2 count = 1;

	MCresult -> clear(False);
	
	// Syntax: print .. from .. to ..
	MCRectangle t_src_rect;
	bool t_src_rect_required;
	t_src_rect_required = true;
	if (from != NULL)
	{
		int2 lrx, lry;
		if (from -> eval(ep) != ES_NORMAL)
		{
			MCeerror -> add(EE_PRINT_CANTGETCOORD, line, pos);
			return ES_ERROR;
		}
		if (!MCU_stoi2x2(ep.getsvalue(), t_src_rect . x, t_src_rect . y))
		{
			MCeerror -> add(EE_PRINT_NAP, line, pos, ep.getsvalue());
			return ES_ERROR;
		}
		if (to -> eval(ep) != ES_NORMAL)
		{
			MCeerror -> add(EE_PRINT_CANTGETCOORD, line, pos);
			return ES_ERROR;
		}
		if (!MCU_stoi2x2(ep . getsvalue(), lrx, lry))
		{
			MCeerror -> add(EE_PRINT_NAP, line, pos, ep . getsvalue());
			return ES_ERROR;
		}
		// MJ: the old printing added 1 to both width and height below.
		// This indeed caused rectangles to look 1 pixel too large on either sides. Removing this solves this problem.
		t_src_rect . width = lrx - t_src_rect . x;//  + 1;
		t_src_rect . height = lry - t_src_rect . y; // + 1;
		
		t_src_rect_required = false;
	}
	//else the source rectangle will be the rect of the target.
	
	// Syntax: print .. into ..
	MCRectangle t_dst_rect;
	bool t_dst_rect_defined;
	t_dst_rect_defined = false;
	if (rect != NULL)
	{
		if (rect -> eval(ep) != ES_NORMAL)
		{
			MCeerror -> add(EE_PRINT_CANTGETRECT, line, pos);
			return ES_ERROR;
		}
		int2 i1, i2, i3, i4;
		if (!MCU_stoi2x4(ep . getsvalue(), i1, i2, i3, i4))
		{
			MCeerror->add(EE_PRINT_NAR, line, pos, ep . getsvalue());
			return ES_ERROR;
		}
		t_dst_rect . x = i1;
		t_dst_rect . y = i2;
		t_dst_rect . width = MCU_max(i3 - i1, 1);
		t_dst_rect . height = MCU_max(i4 - i2, 1);
		
		t_dst_rect_defined = true; // could use rect != NULL or whatever..
	}
	
	switch (mode)
	{
	case PM_ALL:
	case PM_MARKED:
		if (target != NULL)
		{
			if (target -> getobj(ep, optr, parid, True) != ES_NORMAL || optr -> gettype() != CT_STACK)
			{
				MCeerror -> add(EE_PRINT_NOTARGET, line, pos);
				return ES_ERROR;
			}
			stack = (MCStack *)optr;
		}
	break;
		
	case PM_SOME:
		if (target -> eval(ep) != ES_NORMAL || ep . ton() != ES_NORMAL)
		{
			MCeerror -> add(EE_PRINT_CANTGETCOUNT, line, pos);
			return ES_ERROR;
		}
		count = ep . getuint2();
	break;
		
	case PM_CARD:
		if (target != NULL)
		{
			if (target -> getobj(ep, optr, parid, True) != ES_NORMAL)
			{
				MCeerror -> add(EE_PRINT_NOTARGET, line, pos);
				return ES_ERROR;
			}
			if (optr->gettype() == CT_CARD)
			{
				t_card = (MCCard *)optr;
				stack = t_card -> getstack();
			}
			else
			{
				if (optr -> gettype() != CT_STACK)
				{
					MCeerror -> add(EE_PRINT_NOTACARD, line, pos);
					return ES_ERROR;
				}
				mode = PM_ALL;
				stack = (MCStack *)optr;
			}
		}
	break;
		
	default:
	break;
	}
	
	if (stack -> getopened() == 0)
	{
		MCeerror -> add(EE_PRINT_NOTOPEN, line, pos);
		return ES_ERROR;
	}
	
	MCU_watchcursor(NULL, True);
	
	Exec_stat t_exec_stat;
	t_exec_stat = ES_NORMAL;
	switch (mode)
	{
	case PM_BREAK: // syntax: print break
		MCprinter -> Break();
	break;
	
	case PM_MARKED:
		MCprinter -> LayoutStack(stack, true, t_src_rect_required ? NULL : &t_src_rect); // extend this with a stack pointer
	break;
	
	case PM_ALL:
		MCprinter -> LayoutStack(stack, false, t_src_rect_required ? NULL : &t_src_rect);
	break;
	
	case PM_CARD:
	{
		// If no t_card specified, then we get the current t_card of the default stack.
		if (t_card == NULL)
			t_card = stack -> getcurcard();
		
		if (t_src_rect_required)
			t_src_rect = t_card -> getrect();
			
		if (t_dst_rect_defined) // we have a destination rect, this is where it will go
			MCprinter -> Render(t_card, t_src_rect, t_dst_rect);
		else // the card is laid out in the current layout
			MCprinter -> LayoutCard(t_card, &t_src_rect);
	}
	break;
	
	case PM_SOME:
	{
		if (t_src_rect_required)
			t_src_rect = MCdefaultstackptr -> getcurcard() -> getrect();
		
		MCprinter -> LayoutCardSequence(MCdefaultstackptr, count, &t_src_rect);
	}
	break;
	
	default:
		// What do we do here? Could get here if mode == PM_UNDEFINED, however, for now
		// let's just put an assertion here.
		assert(false);
	break;
	}
	
	// MW-2007-12-17: [[ Bug 266 ]] The watch cursor must be reset before we
	//   return back to the caller.
	MCU_unwatchcursor(ep.getobj()->getstack(), True);
	
	return t_exec_stat;
#endif /* MCPrint */

	if (mode == PM_ANCHOR)
    {
        MCAutoStringRef t_name;
        if (!ctxt . EvalExprAsStringRef(from, EE_DO_BADEXP, &t_name))
            return;
		
		MCPoint t_location;
        if (!ctxt . EvalExprAsPoint(rect, EE_PRINTANCHOR_BADLOCATION, t_location))
            return;

		MCPrintingExecPrintAnchor(ctxt, *t_name, t_location);
	}
	else if (mode == PM_LINK || mode == PM_LINK_ANCHOR || mode == PM_LINK_URL)
	{
		MCPrinterLinkType t_type;
		if (mode == PM_LINK_ANCHOR)
			t_type = kMCPrinterLinkAnchor;
		else if (mode == PM_LINK_URL)
			t_type = kMCPrinterLinkURI;
		else
            t_type = kMCPrinterLinkUnspecified;

		MCAutoStringRef t_target;
        if (!ctxt . EvalExprAsStringRef(to, EE_PRINTLINK_BADDEST, &t_target))
            return;

		MCRectangle t_area;
        if (!ctxt . EvalExprAsRectangle(rect, EE_PRINTLINK_BADAREA, t_area))
            return;

		MCPrintingExecPrintLink(ctxt, (int)t_type, *t_target, t_area);
	}
	else if (mode == PM_BOOKMARK || mode == PM_UNICODE_BOOKMARK)
    {
		MCAutoValueRef t_title;
        if (mode != PM_UNICODE_BOOKMARK)
        {
            if (!ctxt . EvalExprAsStringRef(from, EE_PRINTBOOKMARK_BADTITLE, (MCStringRef&)&t_title))
                return;
        }
        else
        {
            if (!ctxt . EvalExprAsDataRef(from, EE_PRINTBOOKMARK_BADTITLE, (MCDataRef&)&t_title))
                return;
        }

		uint32_t t_level;
        if (!ctxt . EvalOptionalExprAsUInt(to, 0, EE_PRINTBOOKMARK_BADLEVEL, t_level))
            return;

		MCPoint t_location;
        t_location . x = t_location . y = 0;

        MCPoint *t_location_ptr;
        t_location_ptr = &t_location;
        if (!ctxt . EvalOptionalExprAsPoint(rect, t_location_ptr, EE_PRINTBOOKMARK_BADAT, t_location_ptr))
            return;

		bool t_initially_closed;
		t_initially_closed = false;
		if (initial_state != nil)
		{
            MCAutoStringRef t_state;
            if (!ctxt . EvalExprAsStringRef(initial_state, EE_PRINTBOOKMARK_BADINITIAL, &t_state))
                return;

            if (MCStringIsEqualToCString(*t_state, "closed", kMCCompareExact))
				t_initially_closed = true;
            else if (MCStringIsEqualToCString(*t_state, "open", kMCCompareExact))
				t_initially_closed = false;
			else
			{
                ctxt . LegacyThrow(EE_PRINTBOOKMARK_BADINITIAL);
                return;
			}
		}
		else
			t_initially_closed = bookmark_closed;


		if (mode != PM_UNICODE_BOOKMARK)
            MCPrintingExecPrintBookmark(ctxt, (MCStringRef)*t_title, t_location, t_level, t_initially_closed);
		else
            MCPrintingExecPrintUnicodeBookmark(ctxt, (MCDataRef)*t_title, t_location, t_level, t_initially_closed);
	}
	else if (mode == PM_BREAK)
	{
		MCPrintingExecPrintBreak(ctxt);
	}
	else if (mode == PM_MARKED || mode == PM_ALL)
	{
		MCStack *t_stack;
		t_stack = nil;
		if (target != nil)
		{
			MCObject *optr;
			uint32_t parid;
            if (!target -> getobj(ctxt, optr, parid, True)
                    || optr -> gettype() != CT_STACK)
			{
                ctxt . LegacyThrow(EE_PRINT_NOTARGET);
                return;
			}

			t_stack = (MCStack *)optr;
		}

		MCPoint t_area_from, t_area_to;
		if (from != nil &&
                !evaluate_src_rect(ctxt, t_area_from, t_area_to))
            return;

		if (from == nil)
			MCPrintingExecPrintAllCards(ctxt, t_stack, mode == PM_MARKED);
		else
			MCPrintingExecPrintRectOfAllCards(ctxt, t_stack, mode == PM_MARKED, t_area_from, t_area_to);
	}
	else if (mode == PM_CARD)
	{
		MCObject *t_object;
		if (target != NULL)
		{
			uint32_t parid;
            if (!target -> getobj(ctxt, t_object, parid, True))
			{
                ctxt . LegacyThrow(EE_PRINT_NOTARGET);
                return;
			}
			if (t_object -> gettype() != CT_CARD && t_object -> gettype() != CT_STACK)
			{
                ctxt . LegacyThrow(EE_PRINT_NOTACARD);
                return;
			}
		}
		else
			t_object = MCdefaultstackptr -> getcurcard();

		MCPoint t_from, t_to;
		if (from != nil &&
                !evaluate_src_rect(ctxt, t_from, t_to))
            return;

		if (t_object -> gettype() == CT_STACK)
		{
			if (from == nil)
				MCPrintingExecPrintAllCards(ctxt, (MCStack *)t_object, mode == PM_MARKED);
			else
				MCPrintingExecPrintRectOfAllCards(ctxt, (MCStack *)t_object, mode == PM_MARKED, t_from, t_to);
		}
		else if (rect == nil)
		{
			if (from == nil)
				MCPrintingExecPrintCard(ctxt, (MCCard *)t_object);
			else
				MCPrintingExecPrintRectOfCard(ctxt, (MCCard *)t_object, t_from, t_to);
		}
		else
		{
            MCRectangle t_dst_area;
            if (!ctxt . EvalExprAsRectangle(rect, EE_PRINT_CANTGETRECT, t_dst_area))
                return;

			if (from == nil)
				MCPrintingExecPrintCardIntoRect(ctxt, (MCCard *)t_object, t_dst_area);
			else
				MCPrintingExecPrintRectOfCardIntoRect(ctxt, (MCCard *)t_object, t_from, t_to, t_dst_area);
		}
	}
	else if (mode == PM_SOME)
	{
        integer_t t_count;
        if (!ctxt . EvalExprAsInt(target, EE_PRINT_CANTGETCOUNT, t_count))
            return;

		MCPoint t_from, t_to;
		if (from != nil &&
            !evaluate_src_rect(ctxt, t_from, t_to))
            return;

		if (from == nil)
			MCPrintingExecPrintSomeCards(ctxt, t_count);
		else
			MCPrintingExecPrintRectOfSomeCards(ctxt, t_count, t_from, t_to);
    }
}

void MCPrint::compile(MCSyntaxFactoryRef ctxt)
{
	MCSyntaxFactoryBeginStatement(ctxt, line, pos);
	
	if (mode == PM_ANCHOR)
	{		
		from -> compile(ctxt); // anchor name (string)
		rect -> compile(ctxt); // anchor location (point)
		
		MCSyntaxFactoryExecMethod(ctxt, kMCPrintingExecPrintAnchorMethodInfo);
	}
	else if (mode == PM_LINK || mode == PM_LINK_ANCHOR || mode == PM_LINK_URL)
	{
		MCPrinterLinkType t_type;
		if (mode == PM_LINK_ANCHOR)
			t_type = kMCPrinterLinkAnchor;
		else if (mode == PM_LINK_URL)
			t_type = kMCPrinterLinkURI;
		else
			t_type = kMCPrinterLinkUnspecified;
		
		MCSyntaxFactoryEvalConstantEnum(ctxt, kMCPrintingPrinterLinkTypeInfo, (int)t_type); // link type (MCPrinterLinkType)
		
		to -> compile(ctxt); // link target (string)
		
		rect -> compile(ctxt); // link area (rectangle)
		
		MCSyntaxFactoryExecMethod(ctxt, kMCPrintingExecPrintLinkMethodInfo);
	}
	else if (mode == PM_BOOKMARK || mode == PM_UNICODE_BOOKMARK)
	{
		from -> compile(ctxt); // bookmark title (string)
		
		if (rect != nil)
			rect -> compile(ctxt); // bookmark location (point)
		else
			MCSyntaxFactoryEvalConstantLegacyPoint(ctxt, MCPointMake(0, 0)); // bookmark location (point - 0,0)
		
		if (to != nil)
			to -> compile(ctxt);
		else
			MCSyntaxFactoryEvalConstantUInt(ctxt, 0);
		
		if (initial_state != nil)
			initial_state -> compile(ctxt); // bookmark initial state (MCPrinterBookmarkInitialState)
		else
			MCSyntaxFactoryEvalConstantEnum(ctxt, kMCPrintingPrinterBookmarkInitialStateTypeInfo, bookmark_closed ? 1 : 0); // bookmark initial state 
		
		MCSyntaxFactoryExecMethod(ctxt, mode != PM_UNICODE_BOOKMARK ? kMCPrintingExecPrintNativeBookmarkMethodInfo : kMCPrintingExecPrintUnicodeBookmarkMethodInfo);
	}
	else if (mode == PM_BREAK)
	{
		MCSyntaxFactoryExecMethod(ctxt, kMCPrintingExecPrintBreakMethodInfo);
	}
	else if (mode == PM_MARKED || mode == PM_ALL)
	{
		if (target != nil)
			target -> compile_object_ptr(ctxt);
		else
			MCSyntaxFactoryEvalConstantNil(ctxt);
		
		MCSyntaxFactoryEvalConstantBool(ctxt, mode == PM_MARKED);
		
		if (from != nil)
		{
			from -> compile(ctxt);
			to -> compile(ctxt);
			MCSyntaxFactoryExecMethod(ctxt, kMCPrintingExecPrintRectOfAllCardsMethodInfo);
		}
		else
			MCSyntaxFactoryExecMethod(ctxt, kMCPrintingExecPrintAllCardsMethodInfo);
	}
	else if (mode == PM_CARD)
	{
		if (target != nil)
			target -> compile_object_ptr(ctxt);
		else
			MCSyntaxFactoryEvalConstantNil(ctxt);
		
		if (rect == nil)
		{
			if (from != nil)
			{
				MCSyntaxFactoryEvalConstantBool(ctxt, mode == PM_MARKED);
				from -> compile(ctxt);
				to -> compile(ctxt);
				
				if (mode == PM_MARKED)
					MCSyntaxFactoryExecMethod(ctxt, kMCPrintingExecPrintRectOfAllCardsMethodInfo);
				else
				{
					MCSyntaxFactoryExecMethod(ctxt, kMCPrintingExecPrintRectOfAllCardsMethodInfo);
					MCSyntaxFactoryExecMethodWithArgs(ctxt, kMCPrintingExecPrintRectOfCardMethodInfo, 0, 2, 3);
				}
			}
			else
			{
				MCSyntaxFactoryEvalConstantBool(ctxt, mode == PM_MARKED);
				
				if (mode == PM_MARKED)
					MCSyntaxFactoryExecMethod(ctxt, kMCPrintingExecPrintAllCardsMethodInfo);
				else
				{
					MCSyntaxFactoryExecMethod(ctxt, kMCPrintingExecPrintAllCardsMethodInfo);
					MCSyntaxFactoryExecMethodWithArgs(ctxt, kMCPrintingExecPrintCardMethodInfo, 0);
				}
			}
		}
		else
		{
			if (from != nil)
			{
				from -> compile(ctxt);
				to -> compile(ctxt);
			}
			
			rect -> compile(ctxt);
			
			if (from != nil)
				MCSyntaxFactoryExecMethod(ctxt, kMCPrintingExecPrintCardIntoRectMethodInfo);
			else
				MCSyntaxFactoryExecMethod(ctxt, kMCPrintingExecPrintRectOfCardIntoRectMethodInfo);
		}
	}
	else if (mode == PM_SOME)
	{
		target -> compile(ctxt);
		if (from != nil)
		{
			from -> compile(ctxt);
			to -> compile(ctxt);

			MCSyntaxFactoryExecMethod(ctxt, kMCPrintingExecPrintRectOfSomeCardsMethodInfo);
		}
		else
			MCSyntaxFactoryExecMethod(ctxt, kMCPrintingExecPrintSomeCardsMethodInfo);
	}
	
	MCSyntaxFactoryEndStatement(ctxt);
}