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

#include "stack.h"

#include "card.h"

#include "cdata.h"

#include "scrolbar.h"

#include "field.h"

#include "block.h"

#include "paragraf.h"

#include "mcerror.h"

#include "util.h"

#include "undolst.h"

#include "debug.h"

#include "mctheme.h"

#include "stacklst.h"

#include "dispatch.h"

#include "mode.h"

#include "globals.h"

#include "context.h"

#include "redraw.h"

int2 MCField::clickx;

int2 MCField::clicky;

int2 MCField::goalx;

MCRectangle MCField::cursorrect;

Boolean MCField::cursoron = False;

MCField *MCField::cursorfield = NULL;

Boolean MCField::extend;

Boolean MCField::extendwords;

Boolean MCField::extendlines;

Boolean MCField::contiguous = True;

int2 MCField::widemargin = 14;

int2 MCField::narrowmargin = 8;

MCRectangle MCField::linkrect;

MCBlock *MCField::linkstart;

MCBlock *MCField::linkend;

int4 MCField::linksi;

int4 MCField::linkei;

int4 MCField::composeoffset = 0;

uint2 MCField::composelength = 0;

uint1 MCField::composeconvertingsi = 0;

uint1 MCField::composeconvertingei = 0;

Boolean MCField::composing = False;

uint2 MCField::composecursorindex = 0;

MCField::MCField()

{

flags |= F_FIXED_HEIGHT | F_TRAVERSAL_ON;

fdata = oldfdata = scrolls = NULL;

oldparagraphs = paragraphs = NULL;

curparagraph = focusedparagraph = NULL;

textx = texty = 0;

textheight = textwidth = 0;

fixeda = fixedd = fixedheight = 0;

leftmargin = rightmargin = topmargin = bottommargin = narrowmargin;

indent = 0;

cury = focusedy = firsty = topmargin;

firstparagraph = lastparagraph = NULL;

foundlength = 0;

vscrollbar = hscrollbar = NULL;

scrollbarwidth = MCscrollbarwidth;

tabs = NULL;

ntabs = 0;

label = NULL;

}

MCField::MCField(const MCField &fref) : MCControl(fref)

{

fdata = oldfdata = scrolls = NULL;

oldparagraphs = paragraphs = NULL;

curparagraph = focusedparagraph = NULL;

textx = texty = 0;

textheight = textwidth = 0;

fixeda = fixedd = fixedheight = 0;

indent = fref.indent;

cury = focusedy = firsty = topmargin;

firstparagraph = lastparagraph = NULL;

foundlength = 0;

if (fref.vscrollbar != NULL)

{

vscrollbar = new MCScrollbar(*fref.vscrollbar);

vscrollbar->setparent(this);

vscrollbar->allowmessages(False);

vscrollbar->setflag(flags & F_3D, F_3D);

vscrollbar->setflag(flags & F_OPAQUE, F_OPAQUE);

vscrollbar->setflag(flags & F_DISABLED, F_DISABLED);

vscrollbar->setembedded();

}

else

vscrollbar = NULL;

if (fref.hscrollbar != NULL)

{

hscrollbar = new MCScrollbar(*fref.hscrollbar);

hscrollbar->setparent(this);

hscrollbar->allowmessages(False);

hscrollbar->setflag(flags & F_3D, F_3D);

hscrollbar->setflag(flags & F_OPAQUE, F_OPAQUE);

hscrollbar->setflag(flags & F_DISABLED, F_DISABLED);

hscrollbar->setembedded();

}

else

hscrollbar = NULL;

scrollbarwidth = fref.scrollbarwidth;

ntabs = fref.ntabs;

if (ntabs)

{

tabs = new uint2[ntabs];

uint2 i;

for (i = 0 ; i < ntabs ; i++)

tabs[i] = fref.tabs[i];

}

else

tabs = NULL;

if (fref.fdata != NULL)

{

MCCdata *fptr = fref.fdata;

do

{

MCCdata *newfdata = new MCCdata(*fptr);

newfdata->appendto(fdata);

fptr = fptr->next();

}

while (fptr != fref.fdata);

}

label = strclone(fref.label);

state &= ~CS_KFOCUSED;

}

MCField::~MCField()

{

// OK-2009-04-30: [[Bug 7517]] - Ensure the field is actually closed before deletion, otherwise dangling references may still exist,

// particuarly if the field had image source characters.

while (opened)

close();

if (opened && paragraphs != NULL)

{

closeparagraphs(paragraphs);

fdata->setparagraphs(paragraphs);

}

while (fdata != NULL)

{

MCCdata *fptr = fdata->remove

(fdata);

delete fptr;

}

while (scrolls != NULL)

{

MCCdata *fptr = scrolls->remove

(scrolls);

fptr->setdata(0);

delete fptr;

}

if (getstate(CS_FOREIGN_HSCROLLBAR))

hscrollbar -> link(NULL);

else

delete hscrollbar;

if (getstate(CS_FOREIGN_VSCROLLBAR))

vscrollbar -> link(NULL);

else

delete vscrollbar;

delete tabs;

delete label;

}

Chunk_term MCField::gettype() const

{

return CT_FIELD;

}

const char *MCField::gettypestring()

{

return MCfieldstring;

}

bool MCField::visit(MCVisitStyle p_style, uint32_t p_part, MCObjectVisitor *p_visitor)

{

bool t_continue;

t_continue = true;

if (p_style == VISIT_STYLE_DEPTH_LAST)

t_continue = p_visitor -> OnField(this);

if (t_continue && fdata != NULL)

{

// Loop through all the field data attached to this field.

MCCdata *t_fdata;

t_fdata = fdata;

do

{

// We include this field data in the following cases:

// 1) it is shared and its id is 0

// 2) the requested part is non-zero and the fdata's id matches it

// 3) the requested part is zero.

bool t_include;

if (getflag(F_SHARED_TEXT))

t_include = fdata -> getid() == 0;

else if (p_part != 0)

t_include = fdata -> getid() == p_part;

else

t_include = true;

// If we are including this field data, then loop through its

// paragraphs.

if (t_include)

{

// MW-2012-11-22: [[ Bug 10558 ]] Make sure we visit the correct fdata!

MCParagraph *pgptr = t_fdata -> getparagraphs();

MCParagraph *tpgptr = pgptr;

do

{

t_continue = tpgptr -> visit(p_style, p_part, p_visitor);

tpgptr = tpgptr->next();

}

while(t_continue && tpgptr != pgptr);

}

t_fdata = t_fdata -> next();

}

while(t_fdata != fdata);

}

if (t_continue && p_style == VISIT_STYLE_DEPTH_FIRST)

t_continue = p_visitor -> OnField(this);

return t_continue;

}

void MCField::open()

{

// MW-2008-03-14: [[ Bug 5750 ]] Fix to focus border problem in fields used as menu lists in

// (for example) option menus. Make sure the CS_MENUFIELD state persists.

bool t_is_menu_field;

t_is_menu_field = getstate(CS_MENUFIELD) == True;

MCControl::open();

if (t_is_menu_field)

setstate(True, CS_MENUFIELD);

if (hscrollbar != NULL && !getstate(CS_FOREIGN_HSCROLLBAR))

hscrollbar->open();

if (vscrollbar != NULL && !getstate(CS_FOREIGN_VSCROLLBAR))

vscrollbar->open();

if (opened > 1)

{

oldparagraphs = paragraphs;

oldfdata = fdata;

if (vscrollbar != NULL)

{

MCCdata *scrollptr = getcarddata(scrolls, fdata->getid(), False);

if (scrollptr != NULL)

scrollptr->setdata(texty);

else

if (texty != 0)

getcarddata(scrolls, fdata->getid(), True)->setdata(texty);

}

if (this == MCfoundfield)

{

foundoffset = 0;

foundlength = 0;

MCfoundfield = NULL;

}

}

else

{

oldparagraphs = NULL;

setsbrects();

}

paragraphs = NULL;

uint4 parentid;

if (flags & F_SHARED_TEXT)

parentid = 0;

else

parentid = getcard()->getid();

MCCdata *foundptr = getcarddata(fdata, parentid, True);

paragraphs = foundptr->getparagraphs();

foundptr->totop(fdata);

if (paragraphs == oldparagraphs)

oldparagraphs = NULL;

else

{

openparagraphs();

recompute();

if (vscrollbar != NULL)

{

MCCdata *scrollptr = getcarddata(scrolls, parentid, False);

if (scrollptr != NULL)

{

texty = scrollptr->getdata();

cury = focusedy = topmargin - texty;

resetscrollbars(True);

}

}

}

}

void MCField::close()

{

MCControl::close();

if (oldparagraphs != NULL)

MCundos->freeobject(this);

if (opened)

{

if (oldparagraphs != NULL)

{

closeparagraphs(oldparagraphs);

oldfdata->setparagraphs(oldparagraphs);

}

}

else

{

// MW-2007-12-18: [[ Bug 5497 ]] If a field is not truly closed, then we

// shouldn't reset all the dependent pointers. Only when it is closed

// once and for all do we reset click and active field pointers.

// MW-2005-12-01: [[Bug]] I-Beam cursor does not reset on field close

if ((state & CS_IBEAM) != 0)

getstack() -> clearibeam();

if (MCclickfield == this)

MCclickfield = NULL;

if (MCactivefield == this)

MCactivefield = NULL;

if (MCfoundfield == this)

{

foundoffset = 0;

foundlength = 0;

MCfoundfield = NULL;

}

if (paragraphs != NULL)

{

closeparagraphs(paragraphs);

fdata->setparagraphs(paragraphs);

if (vscrollbar != NULL)

{

MCCdata *scrollptr = getcarddata(scrolls, fdata->getid(), False);

if (scrollptr != NULL)

scrollptr->setdata(texty);

else

if (texty != 0)

getcarddata(scrolls, fdata->getid(), True)->setdata(texty);

}

}

curparagraph = focusedparagraph = NULL;

}

if (vscrollbar != NULL && vscrollbar->getopened() > opened)

vscrollbar->close();

if (hscrollbar != NULL && hscrollbar->getopened() > opened)

hscrollbar->close();

}

void MCField::kfocus()

{

if (opened && !(state & CS_KFOCUSED) && flags & F_TRAVERSAL_ON)

{

uint2 t_old_trans;

t_old_trans = gettransient();

state |= CS_KFOCUSED;

if (flags & F_LIST_BEHAVIOR)

{

if (!(flags & F_TOGGLE_HILITE))

if (!focusedparagraph->isselection()

&& focusedparagraph->gettextsize()

|| focusedparagraph->next() != focusedparagraph)

{

focusedparagraph->sethilite(True);

updateparagraph(False, False);

}

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

// possible change in transient.

layer_transientchangedandredrawall(t_old_trans);

replacecursor(False, False);

message(MCM_focus_in);

}

else

{

if (MCactivefield != NULL && MCactivefield != this)

MCactivefield->unselect(True, True);

MCactivefield = this;

clearfound();

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

// possible change in transient.

layer_transientchangedandredrawall(t_old_trans);

replacecursor(False, False);

MCscreen->addtimer(this, MCM_internal, MCblinkrate);

if (!(state & CS_MFOCUSED) && flags & F_AUTO_TAB)

seltext(0, getpgsize(paragraphs), True);

if (flags & F_TRAVERSAL_ON && !(flags & F_LOCK_TEXT))

message(MCM_open_field);

else

message(MCM_focus_in);

}

if (!(flags & F_LOCK_TEXT))

MCModeActivateIme(getstack(), true);

MCstacks -> ensureinputfocus(getstack() -> getwindow());

}

}

void MCField::kunfocus()

{

if (state & CS_KFOCUSED)

{

getstack() -> resetcursor(True);

stopcomposition(False, True);

MCModeActivateIme(getstack(), false);

uint2 t_old_trans;

t_old_trans = gettransient();

state &= ~CS_KFOCUSED;

if (flags & F_LIST_BEHAVIOR)

{

if (MCactivefield == this)

unselect(True, True);

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

// possible change in transient.

layer_transientchangedandredrawall(t_old_trans);

removecursor();

message(MCM_focus_out);

}

else

{

MCscreen->cancelmessageobject(this, MCM_internal);

removecursor();

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

// possible change in transient.

layer_transientchangedandredrawall(t_old_trans);

if (flags & F_LOCK_TEXT)

message(MCM_focus_out);

else

if (state & CS_CHANGED)

{

message(MCM_close_field);

if (!(state & CS_KFOCUSED))

state &= ~CS_CHANGED;

}

else

message(MCM_exit_field);

if (!(state & CS_KFOCUSED) && MCactivefield == this

&& !focusedparagraph->isselection()

&& firstparagraph == lastparagraph)

MCactivefield = NULL;

}

}

}

Boolean MCField::kdown(const char *string, KeySym key)

{

if (state & CS_NO_FILE)

return False;

if (key == XK_Return || key == XK_KP_Enter || key == XK_Tab)

{

char kstring[U4L];

sprintf(kstring, "%d", (int)key);

if (message_with_args(MCM_raw_key_down, kstring) == ES_NORMAL)

return True;

}

Exec_stat stat;

switch (key)

{

case XK_Return:

stat = message(MCM_return_in_field);

if (stat == ES_NORMAL || stat == ES_ERROR)

return True;

break;

case XK_KP_Enter:

stat = message(MCM_enter_in_field);

if (stat == ES_NORMAL || stat == ES_ERROR)

return True;

break;

case XK_Tab:

break;

case XK_Up:

case XK_Down:

case XK_Left:

case XK_Right:

if (!MCtextarrows)

return MCObject::kdown(string, key);

default:

if (MCObject::kdown(string, key))

return True;

break;

}

// MW-2008-01-11: [[ Bug 4360 ]] Hilite remains after removing focus in arrowKey handler.

// We must not only check that the focused paragraph is NULL, but also whether the

// activefield is us....

// MW-2008-02-13: ... unless we are doing a mousewheely thing - in which case the currently

// non-active field can scroll

// MW-2008-03-14: [[ Bug 5750 ]] ... or we are a menufield

// MW-2008-03-18: [[ Bug 6156 ]] ... or a field with list behaviour set

if (key != XK_WheelDown && key != XK_WheelUp && key != XK_WheelLeft && key != XK_WheelRight && (focusedparagraph == NULL || MCactivefield != this) && !getstate(CS_MENUFIELD) && !getflag(F_LIST_BEHAVIOR))

return False;

//windows likes to echo keydowns

#ifdef _MACOSX

/*uint2 mods = (MCmodifierstate & MS_CONTROL) >> 1 & 0x3;

Field_translations function;

if (MCmodifierstate & MS_MAC_CONTROL)

{

mods |= MS_CONTROL >> 1;

function = trans_lookup(emacs_keys, key, mods);

}

else

function = trans_lookup(std_keys, key, mods);*/

Field_translations function;

function = lookup_mac_keybinding(key, MCmodifierstate);

if (function == FT_UNDEFINED && MCmodifierstate & (MS_CONTROL | MS_MAC_CONTROL))

return False;

#else

uint2 mods = (MCmodifierstate >> 1) & 0x3;

Field_translations function;

if (key == XK_Insert && (MCmodifierstate & MS_SHIFT) != 0)

function = FT_PASTE;

else

function = trans_lookup(MCemacskeys ? emacs_keys : std_keys, key, mods);

if (function == FT_UNDEFINED && MCmodifierstate & (MS_CONTROL | MS_MOD1))

return False;

if (function != FT_UNDEFINED || strlen(string))

stopcomposition(False, True);

#endif

// MW-2008-02-26: [[ Bug 5939 ]] 'Escape' key inserts characters into fields

if (key == XK_Escape)

return False;

switch (function)

{

case FT_UNDEFINED:

if (!getflag(F_LOCK_TEXT))

{

if (MCnullmcstring == string)

return False;

getstack()->hidecursor();

// MW-2012-02-13: [[ Block Unicode ]] Use the new 'finsert' method in

// native mode.

finsertnew(function, string, key, false);

}

break;

case FT_DELBCHAR:

case FT_DELBWORD:

case FT_DELFCHAR:

case FT_DELFWORD:

case FT_DELBOL: // Not implemented yet

case FT_DELEOL: // Not implemented yet

case FT_DELBOP: // Not implemented yet

case FT_DELEOP:

if (!getflag(F_LOCK_TEXT))

fdel(function, string, key);

break;

case FT_HELP:

fhelp(function, string, key);

break;

case FT_UNDO:

if (!getflag(F_LOCK_TEXT))

fundo(function, string, key);

break;

case FT_CUT:

if (!getflag(F_LOCK_TEXT))

fcut(function, string, key);

break;

case FT_CUTLINE:

if (!getflag(F_LOCK_TEXT))

fcutline(function, string, key);

break;

case FT_COPY:

if (!getflag(F_LOCK_TEXT))

fcopy(function, string, key);

break;

case FT_PASTE:

if (!getflag(F_LOCK_TEXT))

fpaste(function, string, key);

break;

case FT_TAB:

ftab(function, string, key);

break;

case FT_FOCUSFIRST:

case FT_FOCUSLAST:

case FT_FOCUSNEXT:

case FT_FOCUSPREV:

ffocus(function, string, key);

break;

case FT_PARAGRAPHAFTER:

if (!getflag(F_LOCK_TEXT))

{

freturn(function, string, key);

fmove(FT_LEFTCHAR, string, key);

}

break;

case FT_PARAGRAPH:

if (!getflag(F_LOCK_TEXT))

freturn(function, string, key);

break;

case FT_CENTER:

fcenter(function, string, key);

break;

case FT_SCROLLUP:

case FT_SCROLLDOWN:

case FT_SCROLLLEFT:

case FT_SCROLLRIGHT:

case FT_SCROLLPAGEUP:

case FT_SCROLLPAGEDOWN:

case FT_SCROLLTOP:

case FT_SCROLLBOTTOM:

fscroll(function, string, key);

break;

default:

fmove(function, string, key);

break;

}

return True;

}

Boolean MCField::mfocus(int2 x, int2 y)

{

Tool tool = getstack()->gettool(this);

if (!(flags & F_VISIBLE || MCshowinvisibles)

|| flags & F_DISABLED && tool == T_BROWSE || state & CS_NO_FILE)

return False;

if (sbfocus(x, y, hscrollbar, vscrollbar))

{

if (state & CS_IBEAM)

{

state &= ~CS_IBEAM;

getstack()->clearibeam();

}

return True;

}

if (flags & F_F_AUTO_ARM && flags & F_LOCK_TEXT && flags & F_LIST_BEHAVIOR)

{

if (x != mx || y != my)

hiliteline(x, y);

return MCControl::mfocus(x, y);

}

if (state & CS_SELECTING)

{

if (x != mx || y != my)

{

// MW-2012-01-25: [[ FieldMetrics ]] Co-ordinates are now card-based.

extendselection(x, y);

mx = x;

my = y;

}

if (flags & F_LOCK_TEXT)

return MCControl::mfocus(x, y);

return True;

}

Boolean oldstate = True;

if (linkstart != NULL)

oldstate = MCU_point_in_rect(linkrect, mx, my);

Boolean getfocus = MCControl::mfocus(x, y);

if (getfocus && tool == T_BROWSE && hscrollbar != NULL && vscrollbar != NULL

&& x > rect.x + rect.width - scrollbarwidth

&& y > rect.y + rect.height - scrollbarwidth)

getfocus = False;

if (!(flags & F_LOCK_TEXT))

{

// Some control paths here do not explicitly set the cursor, so we take

// note of this and reset the stack's cursor if nothing else does. This

// is needed to ensure that a hidden cursor doesn't stick in some difficult

// to locate circumstances...

bool t_cursor_set;

t_cursor_set = false;

// MW-2008-03-18: [[ Bug 6106 ]] Cursor changes to i-beam in focus border and

// border of fields - fixed by making sure we ignore focus messages that

// land in the boder of the field.

bool t_show_ibeam;

if (MCU_point_in_rect(getfrect(), x, y))

t_show_ibeam = true;

else

t_show_ibeam = false;

if (getfocus && t_show_ibeam && !(state & CS_IBEAM) && tool == T_BROWSE)

{

state |= CS_IBEAM;

getstack()->setibeam();

t_cursor_set = true;

}

else if (!getfocus && !t_show_ibeam && state & CS_IBEAM)

{

state &= ~CS_IBEAM;

getstack()->clearibeam();

t_cursor_set = true;

}

if (state & CS_DRAG_TEXT)

dragtext();

else if (getfocus && MCactivefield == this && (focusedparagraph->isselection() || firstparagraph != lastparagraph))

{

computedrag();

t_cursor_set = true;

}

if (!t_cursor_set)

getstack() -> resetcursor(False);

}

else

if (linkstart != NULL)

{

Boolean newstate = MCU_point_in_rect(linkrect, mx, my);

if (newstate != oldstate)

{

MCBlock *bptr = linkstart;

do

{

bptr->sethilite(newstate);

bptr = bptr->next();

}

while (bptr != linkend->next());

// MW-2011-08-18: [[ Layers ]] Invalidate the links part of the field.

layer_redrawrect(linkrect);

}

}

return getfocus;

}

void MCField::munfocus()

{

if (state & CS_IBEAM)

getstack()->clearibeam();

state &= ~(CS_HSCROLL | CS_VSCROLL | CS_SELECTING | CS_IBEAM);

extend = extendwords = False;

linkstart = linkend = NULL;

MCControl::munfocus();

}

void MCField::mdrag(void)

{

// MW-2008-02-27: [[ Bug 5968 ]] dragStart sent if click started in scrollbar

if (getstate(CS_HSCROLL) || getstate(CS_VSCROLL))

return;

// MW-2008-03-31: [[ Bug 6294 ]] dragStart should only be sent to an unlocked

// field if there's a selection already.

bool t_auto_start;

if (getflag(F_LOCK_TEXT) || getstate(CS_SOURCE_TEXT))

t_auto_start = message(MCM_drag_start) != ES_NORMAL;

else

t_auto_start = false;

MCdragtargetptr = this;

if (!t_auto_start)

return;

if (!getstate(CS_SOURCE_TEXT))

return;

MCSharedString *t_data;

t_data = pickleselection();

if (t_data != NULL)

{

MCallowabledragactions = DRAG_ACTION_MOVE | DRAG_ACTION_COPY;

MCdragdata -> Store(TRANSFER_TYPE_STYLED_TEXT, t_data);

t_data -> Release();

}

}

Boolean MCField::mdown(uint2 which)

{

if (state & CS_MFOCUSED)

return False;

if (state & CS_MENU_ATTACHED)

return MCObject::mdown(which);

state |= CS_MFOCUSED;

state &= ~CS_SOURCE_TEXT;

Tool tool = getstack()->gettool(this);

if (tool == T_BROWSE

&& sbdown(which, hscrollbar, vscrollbar))

return True;

switch (which)

{

case Button1:

switch (tool)

{

case T_BROWSE:

{

// MW-2011-02-26: [[ Bug 9417 ]] When clicking on a link in a list we

// still do any autoHilite behavior.

bool t_is_link_in_list;

t_is_link_in_list = false;

MCclickfield = this;

clickx = mx;

clicky = my;

// MW-2011-02-26: [[ Bug 9417 ]] We now get a single char click loc

// which then gets extended to the full link in 'getlinkdata()'.

if ((flags & F_LOCK_TEXT || MCmodifierstate & MS_CONTROL)

&& locmark(False, False, False, True, True, linksi, linkei))

{

getlinkdata(linkrect, linkstart, linkend);

if (linkstart != NULL)

{

MCBlock *bptr = linkstart;

do

{

bptr->sethilite(True);

bptr = bptr->next();

}

while (bptr != linkend->next());

// MW-2011-08-18: [[ Layers ]] Invalidate the links part of the field.

layer_redrawrect(linkrect);

if (!getflag(F_LIST_BEHAVIOR))

{

message_with_args(MCM_mouse_down, "1");

return True;

}

t_is_link_in_list = true;

}

}

if (flags & F_TRAVERSAL_ON ||

(flags & F_LOCK_TEXT || MCmodifierstate & MS_CONTROL) && flags & F_LIST_BEHAVIOR)

{

if (flags & F_TRAVERSAL_ON && !(state & CS_KFOCUSED)

&& !(flags & F_NO_AUTO_HILITE))

{

// MW-2010-10-04: [[ Bug 9027 ]] Keep track of whether the field is still being

// 'mouseDowned'. If there is no longer a mouse down in effect after the openField

// we don't do any of the selection stuff.

state |= CS_MOUSEDOWN;

getstack()->kfocusset(this);

if (!(state & CS_KFOCUSED))

{

state &= ~CS_MFOCUSED;

return False;

}

if (!(state & CS_MOUSEDOWN))

return True;

}

if ((paragraphs != paragraphs->next() || paragraphs->gettextsize())

&& !(flags & F_LIST_BEHAVIOR

&& (my - rect.y > (int4)(textheight + topmargin - texty))))

{

// MW-2012-01-25: [[ FieldMetrics ]] Co-ordinates are now card-based.

startselection(mx, my, False);

if (flags & F_LOCK_TEXT || flags & F_LIST_BEHAVIOR)

message_with_args(MCM_mouse_down, "1");

if (t_is_link_in_list)

endselection();

}

else

if (flags & F_LOCK_TEXT || MCmodifierstate & MS_CONTROL)

message_with_args(MCM_mouse_down, "1");

}

else

message_with_args(MCM_mouse_down, "1");

}

break;

case T_FIELD:

case T_POINTER:

if (MCactivefield == this)

unselect(True, True);

else

if (flags & F_LIST_BEHAVIOR)

sethilitedlines(MCnullmcstring);

start(True);

break;

case T_HELP:

break;

default:

return False;

}

break;

case Button2:

if (flags & F_LOCK_TEXT || getstack()->gettool(this) != T_BROWSE)

{

MCclickfield = this;

clickx = mx;

clicky = my;

message_with_args(MCM_mouse_down, "2");

}

break;

case Button3:

MCclickfield = this;

clickx = mx;

clicky = my;

message_with_args(MCM_mouse_down, "3");

break;

}

return True;

}

Boolean MCField::mup(uint2 which)

{

if (!(state & (CS_MFOCUSED | CS_DRAG_TEXT)))

return False;

if (state & CS_MENU_ATTACHED)

return MCObject::mup(which);

state &= ~(CS_MFOCUSED | CS_MOUSEDOWN);

if (state & CS_GRAB)

{

ungrab(which);

return True;

}

Tool tool = getstack()->gettool(this);

if (tool == T_BROWSE

&& sbup(which, hscrollbar, vscrollbar))

{

if (flags & F_F_AUTO_ARM && flags & F_LOCK_TEXT

&& flags & F_LIST_BEHAVIOR)

{

int4 index = ytooffset(texty);

int4 ei = index;

focusedparagraph = indextoparagraph(paragraphs, index, ei)->next();

focusedy = paragraphtoy(focusedparagraph);

}

return True;

}

switch (which)

{

case Button1:

switch (tool)

{

case T_BROWSE:

if (state & CS_SOURCE_TEXT)

{

state &= ~CS_SOURCE_TEXT;

// MW-2007-11-23: [[ Bug 5546 ]] Make sure we don't reset the activefield when unselecting

// (i.e. pass 'False' as the clear parameter to unselect)

unselect(False, True);

state |= CS_SELECTING;

// MW-2012-01-25: [[ FieldMetrics ]] Co-ordinates are now card-based.

setfocus(clickx, clicky);

}

if (state & CS_SELECTING)

{

endselection();

MCundos->freestate();

signallisteners(P_HILITED_LINES);

message(MCM_selection_changed);

}

if (!(state & CS_DRAG_TEXT))

if ((flags & F_LOCK_TEXT || MCmodifierstate & MS_CONTROL))

if (MCU_point_in_rect(rect, mx, my))

if (flags & F_LIST_BEHAVIOR

&& (my - rect.y > (int4)(textheight + topmargin - texty)

|| paragraphs == paragraphs->next()

&& !paragraphs->gettextsize()))

message_with_args(MCM_mouse_release, "1");

else

{

if (linkstart != NULL)

if (linkstart->gethilite())

{

MCBlock *bptr = linkstart;

do

{

bptr->sethilite(False);

bptr->setvisited();

bptr = bptr->next();

}

while (bptr != linkend->next());