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

#include "objdefs.h"

#include "parsedef.h"

#include "stack.h"

#include "card.h"

#include "cdata.h"

#include "scrolbar.h"

#include "button.h"

#include "field.h"

#include "block.h"

#include "paragraf.h"

#include "sellst.h"

#include "undolst.h"

#include "util.h"

#include "font.h"

#include "execpt.h"

#include "dispatch.h"

#include "mode.h"

#include "globals.h"

#include "mctheme.h"

#include "redraw.h"

#include "context.h"

#ifndef _MACOSX

//normal, control, alt, alt-control

Keytranslations MCField::emacs_keys[] =

{

{XK_Home, {FT_HOME, FT_FOCUSFIRST, FT_HOME, FT_FOCUSFIRST}},

{XK_Left, {FT_LEFTCHAR, FT_LEFTWORD, FT_LEFTCHAR, FT_FOCUSPREV}},

{XK_Up, {FT_UP, FT_FOCUSPREV, FT_UP, FT_FOCUSPREV}},

{XK_Right, {FT_RIGHTCHAR, FT_RIGHTWORD, FT_RIGHTCHAR, FT_FOCUSNEXT}},

{XK_Down, {FT_DOWN, FT_FOCUSNEXT, FT_DOWN, FT_FOCUSNEXT}},

{XK_Prior, {FT_PAGEUP, FT_PAGEUP, FT_PAGEUP, FT_PAGEUP}},

{XK_Next, {FT_PAGEDOWN, FT_PAGEDOWN, FT_PAGEDOWN, FT_PAGEDOWN}},

{XK_Select, {FT_END, FT_FOCUSLAST, FT_END, FT_FOCUSLAST}},

{XK_End, {FT_END, FT_FOCUSLAST, FT_END, FT_FOCUSLAST}},

{XK_BackSpace, {FT_DELBCHAR, FT_DELBWORD, FT_UNDO, FT_UNDEFINED}},

{XK_Delete, {FT_DELBCHAR, FT_DELBWORD, FT_UNDO, FT_UNDEFINED}},

{XK_Insert, {FT_UNDEFINED, FT_COPY, FT_UNDEFINED, FT_UNDEFINED}},

{XK_Tab, {FT_TAB, FT_TAB, FT_TAB, FT_TAB}},

{XK_KP_Tab, {FT_TAB, FT_TAB, FT_TAB, FT_TAB}},

{XK_Return, {FT_PARAGRAPH, FT_FOCUSNEXT, FT_PARAGRAPH, FT_FOCUSNEXT}},

{XK_KP_Enter, {FT_PARAGRAPH, FT_FOCUSNEXT, FT_PARAGRAPH, FT_FOCUSNEXT}},

{XK_A, {FT_UNDEFINED, FT_BOL, FT_BOS, FT_LEFTPARA}},

{XK_a, {FT_UNDEFINED, FT_BOL, FT_BOS, FT_LEFTPARA}},

{XK_B, {FT_UNDEFINED, FT_LEFTCHAR, FT_UNDEFINED, FT_LEFTWORD}},

{XK_b, {FT_UNDEFINED, FT_LEFTCHAR, FT_UNDEFINED, FT_LEFTWORD}},

{XK_D, {FT_UNDEFINED, FT_DELFCHAR, FT_DELFWORD, FT_UNDEFINED}},

{XK_d, {FT_UNDEFINED, FT_DELFCHAR, FT_DELFWORD, FT_UNDEFINED}},

{XK_E, {FT_UNDEFINED, FT_EOL, FT_EOS, FT_RIGHTPARA}},

{XK_e, {FT_UNDEFINED, FT_EOL, FT_EOS, FT_RIGHTPARA}},

{XK_F, {FT_UNDEFINED, FT_RIGHTCHAR, FT_UNDEFINED, FT_RIGHTWORD}},

{XK_f, {FT_UNDEFINED, FT_RIGHTCHAR, FT_UNDEFINED, FT_RIGHTWORD}},

{XK_H, {FT_UNDEFINED, FT_DELBCHAR, FT_UNDEFINED, FT_DELBWORD}},

{XK_h, {FT_UNDEFINED, FT_DELBCHAR, FT_UNDEFINED, FT_DELBWORD}},

{XK_K, {FT_UNDEFINED, FT_CUTLINE, FT_UNDEFINED, FT_UNDEFINED}},

{XK_k, {FT_UNDEFINED, FT_CUTLINE, FT_UNDEFINED, FT_UNDEFINED}},

{XK_L, {FT_UNDEFINED, FT_CENTER, FT_UNDEFINED, FT_UNDEFINED}},

{XK_l, {FT_UNDEFINED, FT_CENTER, FT_UNDEFINED, FT_UNDEFINED}},

{XK_N, {FT_UNDEFINED, FT_DOWN, FT_UNDEFINED, FT_DOWN}},

{XK_n, {FT_UNDEFINED, FT_DOWN, FT_UNDEFINED, FT_DOWN}},

{XK_P, {FT_UNDEFINED, FT_UP, FT_UNDEFINED, FT_UP}},

{XK_p, {FT_UNDEFINED, FT_UP, FT_UNDEFINED, FT_UP}},

{XK_V, {FT_UNDEFINED, FT_PAGEDOWN, FT_PAGEUP, FT_BOF}},

{XK_v, {FT_UNDEFINED, FT_PAGEDOWN, FT_PAGEUP, FT_BOF}},

{XK_Y, {FT_UNDEFINED, FT_PASTE, FT_UNDEFINED, FT_UNDEFINED}},

{XK_y, {FT_UNDEFINED, FT_PASTE, FT_UNDEFINED, FT_UNDEFINED}},

{XK_bracketleft, {FT_UNDEFINED, FT_BOL, FT_LEFTPARA, FT_BOF}},

{XK_bracketright, {FT_UNDEFINED, FT_EOL, FT_RIGHTPARA, FT_EOF}},

{XK_osfHelp, {FT_HELP, FT_HELP, FT_HELP, FT_HELP}},

{XK_osfCut, {FT_CUT, FT_CUT, FT_CUT, FT_CUT}},

{XK_osfCopy, {FT_COPY, FT_COPY, FT_COPY, FT_COPY}},

{XK_osfPaste, {FT_PASTE, FT_PASTE, FT_PASTE, FT_PASTE}},

{XK_osfUndo, {FT_UNDO, FT_UNDO, FT_UNDO, FT_UNDO}},

{XK_WheelDown, {FT_SCROLLDOWN, FT_UNDEFINED, FT_UNDEFINED, FT_UNDEFINED}},

{XK_WheelUp, {FT_SCROLLUP, FT_UNDEFINED, FT_UNDEFINED, FT_UNDEFINED}},

{XK_WheelLeft, {FT_SCROLLLEFT, FT_UNDEFINED, FT_UNDEFINED, FT_UNDEFINED}},

{XK_WheelRight, {FT_SCROLLRIGHT, FT_UNDEFINED, FT_UNDEFINED, FT_UNDEFINED}},

#ifdef _MACOSX

{XK_F1, {FT_UNDO, FT_UNDO, FT_UNDO, FT_UNDO}},

{XK_F2, {FT_CUT, FT_CUT, FT_CUT, FT_CUT}},

{XK_F3, {FT_COPY, FT_COPY, FT_COPY, FT_COPY}},

{XK_F4, {FT_PASTE, FT_PASTE, FT_PASTE, FT_PASTE}},

#endif

{0x0000, {FT_UNDEFINED, FT_UNDEFINED, FT_UNDEFINED, FT_UNDEFINED}},

};

Keytranslations MCField::std_keys[] =

{

{XK_Home, {FT_BOL, FT_BOF, FT_BOF, FT_FOCUSFIRST}},

{XK_Left, {FT_LEFTCHAR, FT_LEFTWORD, FT_LEFTCHAR, FT_FOCUSPREV}},

{XK_Up, {FT_UP, FT_BOF, FT_UP, FT_FOCUSPREV}},

{XK_Right, {FT_RIGHTCHAR, FT_RIGHTWORD, FT_RIGHTCHAR, FT_FOCUSNEXT}},

{XK_Down, {FT_DOWN, FT_EOF, FT_DOWN, FT_FOCUSNEXT}},

{XK_Prior, {FT_PAGEUP, FT_PAGEUP, FT_PAGEUP, FT_PAGEUP}},

{XK_Next, {FT_PAGEDOWN, FT_PAGEDOWN, FT_PAGEDOWN, FT_PAGEDOWN}},

{XK_Select, {FT_END, FT_FOCUSLAST, FT_END, FT_FOCUSLAST}},

{XK_End, {FT_EOL, FT_EOF, FT_EOF, FT_FOCUSLAST}},

{XK_BackSpace, {FT_DELBCHAR, FT_DELBWORD, FT_UNDO, FT_UNDEFINED}},

{XK_Delete, {FT_DELFCHAR, FT_DELFWORD, FT_UNDO, FT_UNDEFINED}},

{XK_Insert, {FT_UNDEFINED, FT_COPY, FT_UNDEFINED, FT_UNDEFINED}},

{XK_Tab, {FT_TAB, FT_TAB, FT_TAB, FT_TAB}},

{XK_Return, {FT_PARAGRAPH, FT_FOCUSNEXT, FT_PARAGRAPH, FT_FOCUSNEXT}},

{XK_KP_Enter, {FT_PARAGRAPH, FT_FOCUSNEXT, FT_PARAGRAPH, FT_FOCUSNEXT}},

{XK_C, {FT_UNDEFINED, FT_COPY, FT_UNDEFINED, FT_UNDEFINED}},

{XK_c, {FT_UNDEFINED, FT_COPY, FT_UNDEFINED, FT_UNDEFINED}},

{XK_V, {FT_UNDEFINED, FT_PASTE, FT_UNDEFINED, FT_UNDEFINED}},

{XK_v, {FT_UNDEFINED, FT_PASTE, FT_UNDEFINED, FT_UNDEFINED}},

{XK_X, {FT_UNDEFINED, FT_CUT, FT_UNDEFINED, FT_UNDEFINED}},

{XK_x, {FT_UNDEFINED, FT_CUT, FT_UNDEFINED, FT_UNDEFINED}},

{XK_Z, {FT_UNDEFINED, FT_UNDO, FT_UNDEFINED, FT_UNDEFINED}},

{XK_z, {FT_UNDEFINED, FT_UNDO, FT_UNDEFINED, FT_UNDEFINED}},

{XK_osfHelp, {FT_HELP, FT_HELP, FT_HELP, FT_HELP}},

{XK_osfCut, {FT_CUT, FT_CUT, FT_CUT, FT_CUT}},

{XK_osfCopy, {FT_COPY, FT_COPY, FT_COPY, FT_COPY}},

{XK_osfPaste, {FT_PASTE, FT_PASTE, FT_PASTE, FT_PASTE}},

{XK_osfUndo, {FT_UNDO, FT_UNDO, FT_UNDO, FT_UNDO}},

{XK_WheelDown, {FT_SCROLLDOWN, FT_UNDEFINED, FT_UNDEFINED, FT_UNDEFINED}},

{XK_WheelUp, {FT_SCROLLUP, FT_UNDEFINED, FT_UNDEFINED, FT_UNDEFINED}},

{XK_WheelLeft, {FT_SCROLLLEFT, FT_UNDEFINED, FT_UNDEFINED, FT_UNDEFINED}},

{XK_WheelRight, {FT_SCROLLRIGHT, FT_UNDEFINED, FT_UNDEFINED, FT_UNDEFINED}},

#ifdef _MACOSX

{XK_F1, {FT_UNDO, FT_UNDO, FT_UNDO, FT_UNDO}},

{XK_F2, {FT_CUT, FT_CUT, FT_CUT, FT_CUT}},

{XK_F3, {FT_COPY, FT_COPY, FT_COPY, FT_COPY}},

{XK_F4, {FT_PASTE, FT_PASTE, FT_PASTE, FT_PASTE}},

#endif

{0x0000, {FT_UNDEFINED, FT_UNDEFINED, FT_UNDEFINED, FT_UNDEFINED}},

};

Field_translations MCField::trans_lookup(Keytranslations table[], KeySym key,

uint2 modifiers)

{

uint2 i = 0;

while (table[i].keysym != 0)

{

if (table[i].keysym == key)

return (Field_translations)table[i].functions[modifiers];

i++;

}

return FT_UNDEFINED;

}

#endif

#ifdef _MACOSX

struct MCKeyBinding

{

unsigned key : 16;

unsigned modifiers : 8;

Field_translations action : 8;

};

#define MK_NONE 0

#define MK_ANY 0xff

#define MK_SHIFT 0x01

#define MK_CMD 0x02

#define MK_CTRL 0x04

#define MK_OPT 0x08

#define MK_IGNORE_SHIFT 0x80

static MCKeyBinding s_mac_keybindings[] =

{

// Insertion

{ XK_Tab, MK_ANY, FT_TAB },

{ XK_Return, MK_ANY, FT_PARAGRAPH },

{ XK_KP_Enter, MK_ANY, FT_PARAGRAPH },

{ XK_O, MK_CTRL, FT_PARAGRAPHAFTER },

// Clipboard

{ XK_C, MK_CMD, FT_COPY },

{ XK_X, MK_CMD, FT_CUT },

{ XK_V, MK_CMD, FT_PASTE },

{ XK_Y, MK_CMD, FT_PASTE },

{ XK_Z, MK_CMD, FT_UNDO },

// Scroll Wheel

{ XK_WheelDown, MK_ANY, FT_SCROLLDOWN },

{ XK_WheelUp, MK_ANY, FT_SCROLLUP },

{ XK_WheelLeft, MK_ANY, FT_SCROLLLEFT },

{ XK_WheelRight, MK_ANY, FT_SCROLLRIGHT },

// Local Navigation

{ XK_P, MK_CTRL | MK_IGNORE_SHIFT, FT_UP },

{ XK_Up, MK_NONE | MK_IGNORE_SHIFT, FT_UP },

{ XK_Up, MK_CMD | MK_IGNORE_SHIFT, FT_BOF },

{ XK_Up, MK_CTRL, FT_SCROLLPAGEUP },

{ XK_Up, MK_OPT | MK_IGNORE_SHIFT, FT_BACKPARA },

{ XK_A, MK_CTRL | MK_IGNORE_SHIFT, FT_BOP },

{ XK_N, MK_CTRL | MK_IGNORE_SHIFT, FT_DOWN },

{ XK_Down, MK_NONE | MK_IGNORE_SHIFT, FT_DOWN },

{ XK_Down, MK_CMD | MK_IGNORE_SHIFT, FT_EOF },

{ XK_Down, MK_CTRL, FT_SCROLLPAGEDOWN },

{ XK_Down, MK_OPT | MK_IGNORE_SHIFT, FT_FORWARDPARA },

{ XK_E, MK_CTRL | MK_IGNORE_SHIFT, FT_EOP },

{ XK_B, MK_CTRL | MK_IGNORE_SHIFT, FT_BACKCHAR },

{ XK_B, MK_CTRL | MK_OPT | MK_IGNORE_SHIFT, FT_BACKWORD },

{ XK_Left, MK_NONE | MK_IGNORE_SHIFT, FT_LEFTCHAR },

{ XK_Left, MK_CMD | MK_IGNORE_SHIFT, FT_BOL },

{ XK_Left, MK_CTRL | MK_IGNORE_SHIFT, FT_BOL },

{ XK_Left, MK_OPT | MK_IGNORE_SHIFT, FT_LEFTWORD },

{ XK_F, MK_CTRL | MK_IGNORE_SHIFT, FT_FORWARDCHAR },

{ XK_F, MK_CTRL | MK_OPT | MK_IGNORE_SHIFT, FT_FORWARDWORD },

{ XK_Right, MK_NONE | MK_IGNORE_SHIFT, FT_RIGHTCHAR },

{ XK_Right, MK_CMD | MK_IGNORE_SHIFT, FT_EOL },

{ XK_Right, MK_CTRL | MK_IGNORE_SHIFT, FT_EOL },

{ XK_Right, MK_OPT | MK_IGNORE_SHIFT, FT_RIGHTWORD },

// Global Navigation

{ XK_Prior, MK_NONE, FT_SCROLLPAGEUP },

{ XK_Prior, MK_SHIFT, FT_PAGEUP },

{ XK_Prior, MK_OPT | MK_IGNORE_SHIFT, FT_PAGEUP },

{ XK_Home, MK_NONE, FT_SCROLLTOP },

{ XK_Home, MK_SHIFT, FT_BOF },

{ XK_Next, MK_NONE, FT_SCROLLPAGEDOWN },

{ XK_Next, MK_SHIFT, FT_PAGEDOWN },

{ XK_Next, MK_OPT | MK_IGNORE_SHIFT, FT_PAGEDOWN },

{ XK_End, MK_NONE, FT_SCROLLBOTTOM },

{ XK_End, MK_SHIFT, FT_EOF },

// Forward Deletion

{ XK_Delete, MK_NONE, FT_DELFCHAR },

{ XK_Delete, MK_OPT, FT_DELFWORD },

{ XK_D, MK_CTRL, FT_DELFCHAR },

{ XK_K, MK_CTRL, FT_DELEOP },

// Backward Deletion

{ XK_BackSpace, MK_NONE, FT_DELBCHAR },

{ XK_BackSpace, MK_CMD, FT_DELBOL },

{ XK_BackSpace, MK_CTRL, FT_DELBSUBCHAR },

{ XK_BackSpace, MK_OPT, FT_DELBWORD },

{ XK_BackSpace, MK_OPT | MK_CTRL, FT_DELBWORD },

// Misc

{ XK_l, MK_CTRL, FT_CENTER },

{ XK_t, MK_CTRL, FT_TRANSPOSE },

// END

{ 0, 0, (Field_translations)0 }

};

Field_translations MCField::lookup_mac_keybinding(KeySym p_key, uint32_t p_modifiers)

{

// Translate old modifiers to Mac-specific ones

uint32_t t_mk_modifiers;

t_mk_modifiers = 0;

if ((p_modifiers & MS_SHIFT) != 0)

t_mk_modifiers |= MK_SHIFT;

if ((p_modifiers & MS_CONTROL) != 0)

t_mk_modifiers |= MK_CMD;

if ((p_modifiers & MS_MAC_CONTROL) != 0)

t_mk_modifiers |= MK_CTRL;

if ((p_modifiers & MS_MOD1) != 0)

t_mk_modifiers |= MK_OPT;

for(uint32_t i = 0; s_mac_keybindings[i] . key != 0; i++)

if (s_mac_keybindings[i] . key == p_key)

{

uint32_t t_key_modifiers;

t_key_modifiers = s_mac_keybindings[i] . modifiers;

if (t_key_modifiers == MK_ANY)

return s_mac_keybindings[i] . action;

if ((t_key_modifiers & MK_IGNORE_SHIFT) == 0)

{

if (t_key_modifiers == t_mk_modifiers)

return s_mac_keybindings[i] . action;

}

else

{

t_key_modifiers &= ~MK_IGNORE_SHIFT;

if (t_key_modifiers == (t_mk_modifiers & ~MK_SHIFT))

return s_mac_keybindings[i] . action;

}

}

return FT_UNDEFINED;

}

#endif

void MCField::resetparagraphs()

{

int4 si = 0;

int4 ei = 0;

MCExecPoint oldhilitedlines;

oldhilitedlines . clear();

// MW-2005-05-13: [[Fix bug 2766]] We always need to retrieve the hilitedLines

// to prevent phantom selections w.r.t. focused paragraph.

if (flags & F_LIST_BEHAVIOR)

hilitedlines(oldhilitedlines);

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

{

// TS-2005-01-06: Fix for bug 2381

// A) get old hilites lines

// B) clear current hilites line, useless now, but may actually do something

// in the future

if (flags & F_LIST_BEHAVIOR)

hilitedlines(oldhilitedlines);

selectedmark(False, si, ei, True, False);

if (flags & F_LIST_BEHAVIOR)

sethilitedlines(MCnullmcstring);

unselect(False, True);

}

curparagraph = focusedparagraph = paragraphs;

firstparagraph = lastparagraph = NULL;

cury = focusedy = topmargin;

textx = texty = 0;

// TS-2005-01-06: Fix for bug 2381

// A) reset focusedparagraph and focusedy and restore oldhilitelines if this

// was the active field with sethilitedlines

// B) pass false for second parameter to sethilitedlines so it doesn't force

// a scroll and cause redraw issues while resizing.

// MW-2005-01-28: Correct small integration error, != instead of ==

if ((flags & F_LIST_BEHAVIOR) != 0)

{

if (oldhilitedlines.getsvalue() != MCnullmcstring)

sethilitedlines(oldhilitedlines.getsvalue(), False);

}

else if (ei != 0)

seltext(si, ei, False);

}

MCCdata *MCField::getcarddata(MCCdata *&list, uint4 parid, Boolean create)

{

if (flags & F_SHARED_TEXT)

parid = 0;

MCCdata *foundptr = NULL;

if (list != NULL)

{

MCCdata *tptr = list;

do

{

if (tptr->getid() == parid)

{

foundptr = tptr;

break;

}

tptr = tptr->next();

}

while (tptr != list);

}

if (foundptr == NULL && create)

{

foundptr = new MCCdata(parid);

foundptr->appendto(list);

}

return foundptr;

}

void MCField::openparagraphs()

{

MCParagraph *pgptr = paragraphs;

uint1 oldopened = opened;

opened = 0; // suppress redraws if open pg causes URL download

do

{

pgptr->setparent(this);

// MW-2012-02-14: [[ FontRefs ]] Pass the field's fontref to open the paragraph.

pgptr->open(m_font);

pgptr = pgptr->next();

}

while (pgptr != paragraphs);

opened = (uint1)oldopened;

focusedparagraph = NULL;

resetparagraphs();

}

void MCField::closeparagraphs(MCParagraph *pgptr)

{

MCParagraph *tpgptr = pgptr;

do

{

tpgptr->close();

tpgptr = tpgptr->next();

}

while (tpgptr != pgptr);

}

void MCField::gettabs(uint2 *&t, uint2 &n, Boolean &fixed)

{

static uint2 ttabs;

if (ntabs == 0)

{

// MW-2012-02-14: [[ FontRefs ]] Compute the width of a space in the field's

// font.

// MW-2012-02-17: If we aren't opened, then just use a default value.

int4 t_space_width;

if (opened)

t_space_width = MCFontMeasureText(m_font, " ", 1, false);

else

t_space_width = 8;

if (t_space_width == 0)

t_space_width = 8;

ttabs = t_space_width * DEFAULT_TAB_SPACING;

t = &ttabs;

n = 1;

}

else

{

t = tabs;

n = ntabs;

}

fixed = (flags & F_VGRID) != 0;

}

void MCField::getlisttabs(int32_t& r_first, int32_t& r_second)

{

uint2 *tabs;

uint2 ntabs;

Boolean fixed;

gettabs(tabs, ntabs, fixed);

int32_t t_first_tab, t_second_tab;

if (ntabs == 1)

{

t_first_tab = tabs[0];

t_second_tab = tabs[0] * 2;

}

else

{

t_first_tab = tabs[0];

t_second_tab = tabs[1];

}

r_first = t_first_tab;

r_second = t_second_tab;

}

// MW-2012-01-25: [[ FieldMetrics ]] Compute the x-offset of the left of the

// field content.

int32_t MCField::getcontentx(void) const

{

return rect . x + borderwidth - DEFAULT_BORDER - textx + leftmargin;

}

// MW-2012-01-25: [[ FieldMetrics ]] Compute the y-offset of the top of the

// field content.

int32_t MCField::getcontenty(void) const

{

return rect . y + borderwidth - TEXT_Y_OFFSET;

}

// MW-2012-01-25: [[ FieldMetrics ]] Compute the optimal layoutwidth for any

// given line.

int32_t MCField::getlayoutwidth(void) const

{

return MCU_max(getfwidth() - (leftmargin + rightmargin), 1);

}

// MW-2012-01-25: [[ ParaStyles ]] Return the indent set at the field level.

int32_t MCField::getfirstindent(void) const

{

return indent;

}

int32_t MCField::gettexty(void) const

{

return texty;

}

// MW-2012-01-25: [[ ParaStyles ]] Returns whether the 'leader' lines should

// be drawn.

bool MCField::getshowlines(void) const

{

return getflag(F_SHOW_LINES) || getstate(CS_SIZE);

}

uint2 MCField::getfwidth() const

{

int4 width = rect.width;

if (borderwidth != 0)

width -= (borderwidth - DEFAULT_BORDER) << 1;

if (flags & F_SHADOW)

width -= shadowoffset;

if (flags & F_VSCROLLBAR)

width -= vscrollbar->getrect().width;

if (width > 0 && width < MAXUINT2)

return (uint2)width;

else

return 0;

}

uint2 MCField::getfheight() const

{

int4 height = rect.height;

if (borderwidth != 0)

height -= borderwidth << 1;

if (flags & F_SHADOW)

height -= shadowoffset;

if (flags & F_HSCROLLBAR)

height -= hscrollbar->getrect().height;

if (height > 0 && height < MAXUINT2)

return (uint2)height;

else

return 0;

}

MCRectangle MCField::getfrect() const

{

MCRectangle trect = rect;

if (borderwidth != 0)

trect = MCU_reduce_rect(trect, borderwidth);

uint2 soffset = shadowoffset;

if (flags & F_SHADOW && trect.width > soffset && trect.height > soffset)

{

trect.width -= soffset;

trect.height -= soffset;

}

if (flags & F_HSCROLLBAR && trect.height > scrollbarwidth)

trect.height -= hscrollbar->getrect().height - 1;

if (flags & F_VSCROLLBAR && trect.width > scrollbarwidth)

trect.width -= vscrollbar->getrect().width - 1;

return trect;

}

void MCField::removecursor()

{

// MW-2006-07-05: [[ Bug 4840 ]] Previous this wouldn't do anything if 'locktext' were true

// this meant that the cursor wouldn't be removed correctly when the property changed.

if (!opened)

return;

if (cursorfield == this && (cursoron || flags & F_LIST_BEHAVIOR))

{

cursoron = False;

cursorfield = NULL;

// MW-2011-08-18: [[ Layers ]] Invalidate the cursor rect.

layer_redrawrect(cursorrect);

}

}

void MCField::drawcursor(MCContext *p_context, const MCRectangle &dirty)

{

setforeground(p_context, DI_FORE, False);

if (flags & F_LIST_BEHAVIOR)

{

// MW-2012-01-27: [[ Bug 9511 ]] Make sure we don't render the win95-esque focus

// border in native GTK mode.

if (focusedparagraph->gettextsize() && !IsMacLF() && !IsNativeGTK() && !getstate(CS_MENUFIELD))

{

if (MClook == LF_WIN95)

{

p_context->setforeground(p_context->getwhite());

p_context->setbackground(p_context->getblack());

p_context->setfillstyle(FillSolid, DNULL, 0, 0);

p_context->setlineatts(0, LineDoubleDash, CapButt, JoinBevel);

p_context->setdashes(0, dotlist, 2);

p_context->setfunction(GXxor);

p_context->drawrect(cursorrect);

p_context->setfunction(GXcopy);

p_context->setlineatts(0, LineSolid, CapButt, JoinBevel);

}

else

p_context->drawrect(cursorrect);

}

}

else

{

// MW-2012-08-06: Use XOR to render the caret so it remains visible regardless

// of background color (apart from 128,128,128!).

p_context->setforeground(p_context->getwhite());

p_context->setfunction(GXxor);

// MW-2012-09-19: [[ Bug 10393 ]] Draw the caret inside a layer to ensure the XOR

// ink works correctly.

p_context->begin(false);

p_context->drawline(cursorrect.x, cursorrect.y, cursorrect.x, cursorrect.y + cursorrect.height - 1);

p_context->end();

p_context->setfunction(GXcopy);

}

}

void MCField::replacecursor(Boolean force, Boolean goal)

{

if (!opened)

return;

MCRectangle drect;

if (composing && composelength)

{

int4 compsi, compei;

compsi = composeoffset + composecursorindex;

compei = composeoffset + composelength;

indextoparagraph(paragraphs,compsi,compei);

// MW-2012-01-25: [[ ParaStyles ]] Request the cursor-rect of the line

// not including any space above/below.

drect = focusedparagraph->getcursorrect(compsi, fixedheight, false);

}

else

{

// MW-2012-01-25: [[ ParaStyles ]] Request the cursor-rect of the line

// not including any space above/below.

drect = focusedparagraph->getcursorrect(-1, fixedheight, false);

}

positioncursor(force, goal, drect, focusedy);

}

void MCField::positioncursor(Boolean force, Boolean goal, MCRectangle &drect, int4 yoffset)

{

if (flags & F_LIST_BEHAVIOR && MClook != LF_WIN95)

{

drect.y -= 2;

drect.height += 4;

}

else

{

drect.y--;

drect.height += 2;

}

// MW-2012-01-25: [[ FieldMetrics ]] The 'goalx' value is in field coords.

// MW-2012-02-02: [[ Bug ]] Make sure we only set goal if it is requested.

if (goal)

goalx = drect . x;

// MW-2012-01-25: [[ FieldMetrics ]] Compute the new position of the cursor

// in card coords.

int32_t newx, newy;

newx = drect . x + getcontentx();

newy = yoffset + drect . y + getcontenty();

MCRectangle mrect = getfrect();

if (force)

{

Boolean reset = False;

// SMR 951 don't scroll if cursor won't fit in field

int4 dy = mrect.y + mrect.height - drect.height - newy;

// MW-2012-02-02: [[ Bug ]] 'newy' now incorporates the rect, so no need

// to adjust for it.

if (newy < mrect.y + 1 && dy > 0)

{

int4 oldy = texty;

vscroll(newy - (mrect.y + 1), True);

newy += oldy - texty;

reset = True;

}

else if (dy < 0)

{

int4 oldy = texty;

vscroll(-dy, True);

newy += oldy - texty;

reset = True;

}

if (!(flags & F_LIST_BEHAVIOR))

{

// MW-2012-02-02: [[ Bug 9681 ]] Incorrect computations for the left

// hand edge of the field mean hscroll doesn't work correctly.

if (newx < mrect.x + leftmargin - DEFAULT_BORDER)

{

hscroll(newx - (mrect.x + leftmargin - DEFAULT_BORDER), True);

newx = mrect.x + leftmargin - DEFAULT_BORDER;

reset = True;

}

else

{

int4 dx = mrect.x + mrect.width - drect.width - newx;

if (dx < 0)

{

hscroll(-dx, True);

newx += dx;

reset = True;

}

else

{

// MW-2012-03-13: [[ Bug ]] Make sure we scroll the field towards

// the left edge if the longest line has got cropped.

dx = (getcontentx() + textwidth + rightmargin - DEFAULT_BORDER) - (mrect . x + mrect . width);

if (dx < 0)

{

dx = MCU_max(-textx, dx);

hscroll(dx, True);

newx -= dx;

reset = True;

}

}

}

}

if (reset)

resetscrollbars(True);

}

// MW-2006-02-26: Even if the screen is locked we still want to set the cursor

// position, otherwise the repositioning gets deferred too much.

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

|| !(flags & F_LIST_BEHAVIOR) && flags & F_LOCK_TEXT)

return;

// OK-2008-07-22 : Crash fix.

if (!(state & CS_DRAG_TEXT) && (focusedparagraph != NULL) && focusedparagraph -> isselection() &&

(IsMacLF() || IsMacLFAM()))

return;

// MW-2012-01-25: [[ FieldMetrics ]] Compute the dirty rect of the cursor.

drect.x = newx;

drect.y = newy;

drect = MCU_intersect_rect(drect, mrect);

if (drect.width && drect.height

&& opened && state & (CS_KFOCUSED | CS_DRAG_TEXT))

{

if (flags & F_LIST_BEHAVIOR)

{

drect.x = mrect.x + 2;

drect.width = mrect.width - 4;

if (MClook != LF_WIN95)

{

drect.x--;

drect.width += 2;

}

}

cursorrect = drect;

cursorfield = this;

cursoron = True;

// MW-2011-08-18: [[ Layers ]] Invalidate the dirty rect.

layer_redrawrect(drect);

}

else

cursoron = False;

}

void MCField::dragtext()

{

removecursor();

// MW-2012-01-25: [[ FieldMetrics ]] Compute the field coords of the mouse

// click.

int32_t cx, cy;

cx = mx - getcontentx();

cy = my - (cury + getcontenty());

MCParagraph *pgptr = curparagraph;

int4 y = 0;

uint2 pgheight = pgptr->getheight(fixedheight);

while (pgptr->next() != paragraphs && y + pgheight <= cy)

{

y += pgheight;

pgptr = pgptr->next();

pgheight = pgptr->getheight(fixedheight);

}

cy -= y;

uint2 ssi, sei;

pgptr->getclickindex(cx, cy, fixedheight, ssi, sei, False, False);

// MW-2012-01-25: [[ ParaStyles ]] Request the cursor rect without spacing.

MCRectangle drect = pgptr->getcursorrect(ssi, fixedheight, false);

positioncursor(True, False, drect, paragraphtoy(pgptr));

// Compute the appropriate drag action depending the state of the keyboard

// MW-2007-12-11: [[ Bug 5542 ]] Wrong keyboard modifier for copying/moving text on OS X

if (MCdispatcher -> isdragsource())

{

#ifdef _MACOSX

if ((MCmodifierstate & MS_MOD1) != 0)

#else

if ((MCmodifierstate & MS_CONTROL) != 0)

#endif

MCdragaction = DRAG_ACTION_COPY;

else

MCdragaction = (MCallowabledragactions & DRAG_ACTION_MOVE) == 0 ? DRAG_ACTION_COPY : DRAG_ACTION_MOVE;

}

else

{

#ifndef _MACOSX

if ((MCmodifierstate & MS_MOD1) != 0)

MCdragaction = (MCallowabledragactions & DRAG_ACTION_MOVE) == 0 ? DRAG_ACTION_COPY : DRAG_ACTION_MOVE;

else

#endif

MCdragaction = DRAG_ACTION_COPY;

}

}

void MCField::computedrag()

{

int4 ti, si, ei;

locmark(False, False, False, False, True, ti, ei);

selectedmark(False, si, ei, False, False);

uint2 c = ti >= si && ti < ei ? PI_ARROW : PI_IBEAM;

getstack()->setcursor(MCcursors[c], False);

//XCURSORS

getstack()->cursoroverride = ( c==PI_ARROW) ;

}

void MCField::adjustpixmapoffset(MCContext *dc, uint2 index, int4 dy)

{

uint2 i;

if (!getpindex(index, i))

return;

uint2 t_current_style;

Pixmap t_current_pixmap;

int2 t_current_x;

int2 t_current_y;

dc -> getfillstyle(t_current_style, t_current_pixmap, t_current_x, t_current_y);

int4 t_offset_x, t_offset_y;

t_offset_x = t_current_x - textx;

t_offset_y = t_current_y - texty + dy;

// MW-2009-01-22: [[ Bug 3869 ]] We need to use the actual width/height of the

// pixmap tile in this case to ensure the offset falls within 32767.

if (MCU_abs(t_offset_y) > 32767 || MCU_abs(t_offset_x) > 32767)

{

uint2 t_width, t_height, t_depth;

MCscreen -> getpixmapgeometry(t_current_pixmap, t_width, t_height, t_depth);

t_offset_x %= t_width;

if (t_offset_x < 0)

t_offset_x += t_width;

t_offset_y %= t_height;

if (t_offset_y < 0)

t_offset_y += t_height;

}

dc -> setfillstyle(t_current_style, t_current_pixmap, t_offset_x, t_offset_y);

}

void MCField::drawrect(MCDC *dc, const MCRectangle &dirty)

{

MCRectangle frect = getfrect();

MCRectangle trect = frect;

MCRectangle grect = frect;

MCRectangle textrect = frect;

if (!(flags & F_SHOW_BORDER))

trect = MCU_reduce_rect(trect, -DEFAULT_BORDER);

trect = MCU_intersect_rect(trect, dirty);

if (trect.width != 0 && trect.height != 0)

{

dc->setclip(trect);

// MW-2008-07-23: [[ Bug ]] Previously the background wouldn't be repainted if

// linkstart != NULL and this was the field containing it. This caused redraw

// oddness on Windows, so have removed the clause.

if (flags & F_OPAQUE)

{

// MW-2010-07-20: Under GTK, field borders are actually 3 pixels, not 2. So

// here we take this into account by only filling from an extra pixel in.

MCRectangle t_fill_rect;

if (getflag(F_SHOW_BORDER) && borderwidth == DEFAULT_BORDER && IsNativeGTK())

t_fill_rect = MCU_intersect_rect(MCU_reduce_rect(frect, 1), dirty);

else

t_fill_rect = trect;

setforeground(dc, DI_BACK, False, flags & F_SHOW_BORDER && (!(flags & F_F_AUTO_ARM) || MClook == LF_WIN95));

// MW-2012-09-04: [[ Bug 9759 ]] Make sure any pattern is offset correctly.

adjustpixmapoffset(dc, DI_BACK);

dc->fillrect(t_fill_rect);

}

// Reduce the textrect by horizontal margins.

textrect.x += leftmargin;

if (textrect.width > leftmargin + rightmargin)

textrect.width -= leftmargin + rightmargin;

else

textrect.width = 0;

// Draw the leader lines (if required).

trect = MCU_intersect_rect(trect, textrect);

if (flags & F_FIXED_HEIGHT && (flags & F_SHOW_LINES || state & CS_SIZE))

{

if (dc -> gettype() == CONTEXT_TYPE_PRINTER)

{

dc->setforeground(dc->getblack());

dc->setlineatts(1, LineOnOffDash, CapButt, JoinBevel);

dc->setdashes(0, dotlist, 2);

int2 x, y;

x = textrect . x - 2 - textx;

y = cury + frect.y + fixeda - TEXT_Y_OFFSET;

while(y <= trect.y + trect.height)

{

if (y >= trect.y)

dc -> drawline(x, y, x + MCU_max(textrect . width + 4, textwidth), y);

y += fixedheight;

}

dc -> setlineatts(0, LineSolid, CapButt, JoinBevel);

}

else

{

setforeground(dc, DI_BACK, False);

dc->setbackground(dc->getblack());

dc->setfillstyle(FillOpaqueStippled, DNULL, 0, 0);

MCRectangle xrect;

xrect.x = textrect.x - 2 - textx;

xrect.y = cury + frect.y + fixeda - TEXT_Y_OFFSET;

xrect.width = MCU_max(textrect.width + 4, textwidth);

xrect.height = 1;

while (xrect.y <= trect.y + trect.height)

{

if (xrect.y >= trect.y)

dc->fillrect(xrect);

xrect.y += fixedheight;

}

dc->setfillstyle(FillSolid, DNULL, 0, 0);

dc->setbackground(MCzerocolor);

}

}

uint2 fontstyle;

fontstyle = gettextstyle();

setforeground(dc, DI_FORE, False);

// Compute the find range.

MCParagraph *foundpgptr = NULL;

int4 fstart = 0;

int4 fend = 0;

if (foundlength != 0)

{

fstart = foundoffset;

fend = foundoffset + foundlength;

foundpgptr = indextoparagraph(paragraphs, fstart, fend);

}

// Compute the composition range.

MCParagraph *comppgptr = NULL;

int4 compstart,compend;

compstart = compend = 0;

if (composelength)

{

compstart = composeoffset;

compend = composeoffset+composelength;

comppgptr = indextoparagraph(paragraphs, compstart, compend);

}

// MW-2012-01-10: [[ Field Metrics ]] Compute the top-left of the current

// paragraph content in card co-ords.

int32_t x, y;

MCParagraph *pgptr;

pgptr = curparagraph;

x = getcontentx();

y = cury + getcontenty();

// MW-2012-01-25: [[ FieldMetrics ]] Compute the layout width.

int32_t t_layout_width;

t_layout_width = getlayoutwidth();

// MW-2012-01-25: [[ FieldMetrics ]] Compute the selection offset / width.

uint2 sx, swidth;

if (getflag(F_LIST_BEHAVIOR))

sx = frect . x, swidth = frect . width;

else

sx = x, swidth = t_layout_width;

uint2 a = 0;

uint2 d = 0;

if (flags & F_FIXED_HEIGHT)

{

a = fixeda;

d = fixedd;

}

int32_t pgheight;

do

{

pgheight = pgptr->getheight(fixedheight);

// MW-2012-03-15: [[ Bug 10069 ]] A paragraph might render a grid line above or below