/* Copyright (C) 2003-2015 LiveCode Ltd.

This file is part of LiveCode.

LiveCode is free software; you can redistribute it and/or modify it under

the terms of the GNU General Public License v3 as published by the Free

Software Foundation.

LiveCode is distributed in the hope that it will be useful, but WITHOUT ANY

WARRANTY; without even the implied warranty of MERCHANTABILITY or

FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License

for more details.

You should have received a copy of the GNU General Public License

along with LiveCode. If not see <http://www.gnu.org/licenses/>. */

#include "prefix.h"

#include "globdefs.h"

#include "filedefs.h"

#include "objdefs.h"

#include "parsedef.h"

#include "util.h"

#include "sellst.h"

#include "stack.h"

#include "tooltip.h"

#include "card.h"

#include "mccontrol.h"

#include "group.h"

#include "field.h"

#include "scrolbar.h"

#include "mcerror.h"

#include "hndlrlst.h"

#include "stacklst.h"

#include "undolst.h"

#include "mctheme.h"

#include "dispatch.h"

#include "parentscript.h"

#include "globals.h"

#include "context.h"

#include "bitmapeffect.h"

#include "graphicscontext.h"

#include "graphics_util.h"

#include "widget.h"

#include "exec.h"

MCControlHandle MCControl::focused;

int2 MCControl::defaultmargin = 4;

int2 MCControl::xoffset;

int2 MCControl::yoffset;

double MCControl::aspect;

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

MCPropertyInfo MCControl::kProperties[] =

{

DEFINE_RW_OBJ_PROPERTY(P_LEFT_MARGIN, Int16, MCControl, LeftMargin)

DEFINE_RW_OBJ_PROPERTY(P_RIGHT_MARGIN, Int16, MCControl, RightMargin)

DEFINE_RW_OBJ_PROPERTY(P_TOP_MARGIN, Int16, MCControl, TopMargin)

DEFINE_RW_OBJ_PROPERTY(P_BOTTOM_MARGIN, Int16, MCControl, BottomMargin)

DEFINE_RW_OBJ_CUSTOM_PROPERTY(P_MARGINS, InterfaceMargins, MCControl, Margins)

DEFINE_RW_OBJ_PROPERTY(P_TOOL_TIP, String, MCControl, ToolTip)

DEFINE_RW_OBJ_PROPERTY(P_UNICODE_TOOL_TIP, BinaryString, MCControl, UnicodeToolTip)

DEFINE_RW_OBJ_PROPERTY(P_LAYER_CLIP_RECT, OptionalRectangle, MCControl, LayerClipRect)

DEFINE_RW_OBJ_NON_EFFECTIVE_ENUM_PROPERTY(P_LAYER_MODE, InterfaceLayerMode, MCControl, LayerMode)

DEFINE_RO_OBJ_EFFECTIVE_ENUM_PROPERTY(P_LAYER_MODE, InterfaceLayerMode, MCControl, LayerMode)

DEFINE_RW_OBJ_RECORD_PROPERTY(P_BITMAP_EFFECT_DROP_SHADOW, MCControl, DropShadow)

DEFINE_RW_OBJ_RECORD_PROPERTY(P_BITMAP_EFFECT_OUTER_GLOW, MCControl, OuterGlow)

DEFINE_RW_OBJ_RECORD_PROPERTY(P_BITMAP_EFFECT_INNER_GLOW, MCControl, InnerGlow)

DEFINE_RW_OBJ_RECORD_PROPERTY(P_BITMAP_EFFECT_COLOR_OVERLAY, MCControl, ColorOverlay)

DEFINE_RW_OBJ_RECORD_PROPERTY(P_BITMAP_EFFECT_INNER_SHADOW, MCControl, InnerShadow)

};

MCObjectPropertyTable MCControl::kPropertyTable =

{

&MCObject::kPropertyTable,

sizeof(kProperties) / sizeof(kProperties[0]),

&kProperties[0],

};

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

MCControl::MCControl()

{

rect.x = rect.y = -1;

rect.width = MCminsize << 4;

rect.height = MCminsize << 2;

leftmargin = rightmargin = topmargin = bottommargin = defaultmargin;

// MW-2004-11-26: Initialise mx and my (VG)

mx = my = 0;

// MW-2009-06-09: [[ Bitmap Effects ]]

MCBitmapEffectsInitialize(m_bitmap_effects);

// MW-2011-09-21: [[ Layers ]] Clear the layer attrs.

layer_resetattrs();

// MW-2011-09-21: [[ Layers ]] The layer starts off as static.

m_layer_mode_hint = kMCLayerModeHintStatic;

m_layer_has_clip_rect = false;

m_layer_clip_rect = kMCEmptyRectangle;

}

MCControl::MCControl(const MCControl &cref) : MCObject(cref)

{

leftmargin = cref.leftmargin;

rightmargin = cref.rightmargin;

topmargin = cref.topmargin;

bottommargin = cref.bottommargin;

state &= ~CS_KFOCUSED;

// MW-2006-04-21: [[ Purify ]] Need to initialise mx and my here too

mx = my = 0;

// MW-2009-06-09: [[ Bitmap Effects ]] Note that this is not currently robust

// as the copy could silently fail.

MCBitmapEffectsInitialize(m_bitmap_effects);

MCBitmapEffectsAssign(m_bitmap_effects, cref . m_bitmap_effects);

// MW-2011-09-21: [[ Layers ]] Clear the layer attrs.

layer_resetattrs();

// MW-2011-09-21: [[ Layers ]] The layer takes its layer hint from the source.

m_layer_mode_hint = cref . m_layer_mode_hint;

m_layer_has_clip_rect = cref.m_layer_has_clip_rect;

m_layer_clip_rect = cref.m_layer_clip_rect;

}

MCControl::~MCControl()

{

if (focused.IsBoundTo(this))

focused = nullptr;

MCscreen->stopmove(this, False);

// MW-2009-06-11: [[ Bitmap Effects ]] Destroy the bitmap effects

MCBitmapEffectsFinalize(m_bitmap_effects);

}

void MCControl::open()

{

if (opened == 0)

{

// MW-2011-10-01: [[ Bug 9777 ]] Special case for when 'open' / 'close' used to

// reinitialize object (i.e. MCImage::reopen) - don't update layer attrs if

// KEEP_LAYER is set.

if (!getstate(CS_KEEP_LAYER))

layer_resetattrs();

// Make sure we keep state which should be preserved across open.

state = (state & (CS_NO_MESSAGES | CS_NO_FILE | CS_SELECTED)) | (state & CS_KEEP_LAYER);

}

MCObject::open();

}

void MCControl::close()

{

// MW-2008-01-09: [[ Bug 5739 ]] Changing group layer cancels mousedown

if (opened == 1 && focused.IsBoundTo(this))

{

focused = nullptr;

}

MCObject::close();

}

void MCControl::kfocus()

{

if (flags & F_TRAVERSAL_ON)

{

uint2 t_old_trans;

t_old_trans = gettransient();

state |= CS_KFOCUSED;

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

// possible change in transient.

layer_transientchangedandredrawall(t_old_trans);;

message(MCM_focus_in);

}

}

void MCControl::kunfocus()

{

if (state & CS_KFOCUSED)

{

uint2 t_old_trans;

t_old_trans = gettransient();

state &= ~CS_KFOCUSED;

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

// possible change in transient.

layer_transientchangedandredrawall(t_old_trans);

message(MCM_focus_out);

}

}

Boolean MCControl::kdown(MCStringRef p_string, KeySym key)

{

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

return True;

switch (key)

{

case XK_space:

case XK_Return:

case XK_KP_Enter:

message_with_valueref_args(MCM_mouse_up, MCSTR("1"));

return True;

default:

break;

}

return False;

}

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

{

// SMR 594 do menu stuff before visibility check

if (state & CS_MENU_ATTACHED)

return MCObject::mfocus(x, y);

if (!(flags & F_VISIBLE || showinvisible())

|| (flags & F_DISABLED && getstack()->gettool(this) == T_BROWSE))

return False;

if (state & CS_GRAB)

{

MCRectangle newrect = rect;

newrect.x = x - xoffset;

newrect.y = y - yoffset;

mx = x;

my = y;

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

if (newrect.x != rect.x || newrect.y != rect.y)

layer_setrect(newrect, false);

message_with_args(MCM_mouse_move, x, y);

return True;

}

if (state & CS_MOVE)

{

mx = x;

my = y;

MCselected->continuemove(x, y);

// MM-2012-09-05: [[ Property Listener ]] Moving object using IDE. Make sure location property is flagged as changed.

signallisteners(P_LOCATION);

message_with_args(MCM_mouse_move, x, y);

return True;

}

if (state & CS_SIZE)

{

continuesize(x, y);

// MM-2012-09-05: [[ Property Listener ]] Resizing object using IDE. Make sure rect property is flagged as changed.

signallisteners(P_RECTANGLE);

message_with_args(MCM_mouse_move, x, y);

return True;

}

MCRectangle srect;

MCU_set_rect(srect, x, y, 1, 1);

mx = x;

my = y;

Boolean is = maskrect(srect) || (state & CS_SELECTED

&& MCU_point_in_rect(geteffectiverect(), x, y)

&& sizehandles(x, y) != 0);

if (is || state & CS_MFOCUSED)

{

if (focused.IsBoundTo(this) || getstack() -> gettool(this) == T_POINTER)

{

if (MCdispatcher -> isdragtarget())

message_with_args(MCM_drag_move, x, y);

else

message_with_args(MCM_mouse_move, x, y);

}

}

switch (getstack()->gettool(this))

{

case T_BROWSE:

case T_HELP:

case T_POINTER:

if (state & CS_MFOCUSED)

return True;

break;

case T_BUTTON:

case T_SCROLLBAR:

case T_PLAYER:

case T_FIELD:

case T_IMAGE:

case T_GRAPHIC:

if ((is && state & CS_SELECTED) || state & CS_MFOCUSED)

return True;

else

return False;

break;

default:

is = False;

break;

}

return is;

}

void MCControl::munfocus()

{

if (focused.IsBoundTo(this))

{

if (state & CS_MFOCUSED)

{

mfocus(mx, my);

// IM-2013-08-07: [[ Bug 10671 ]] Release grabbed controls when removing focus

state &= ~(CS_MFOCUSED | CS_GRAB);

message(MCM_mouse_release);

}

else

leave();

}

mx = rect.x - 1;

my = rect.y - 1;

}

Boolean MCControl::doubledown(uint2 which)

{

switch (which)

{

case Button1:

switch (getstack()->gettool(this))

{

case T_BROWSE:

case T_BUTTON:

case T_FIELD:

case T_SCROLLBAR:

case T_PLAYER:

case T_IMAGE:

case T_GRAPHIC:

case T_POINTER:

message_with_valueref_args(MCM_mouse_double_down, MCSTR("1"));

break;

default:

return False;

}

break;

case Button2:

case Button3:

message_with_args(MCM_mouse_double_down, which);

break;

}

return True;

}

Boolean MCControl::doubleup(uint2 which)

{

switch (which)

{

case Button1:

switch (getstack()->gettool(this))

{

case T_BUTTON:

case T_FIELD:

case T_SCROLLBAR:

case T_PLAYER:

case T_IMAGE:

case T_GRAPHIC:

case T_POINTER:

// MW-2010-10-15: [[ Bug 9055 ]] Pass false here to prevent 'mouseUp' being sent.

end(false, false);

case T_BROWSE:

message_with_valueref_args(MCM_mouse_double_up, MCSTR("1"));

break;

default:

return False;

}

break;

case Button2:

case Button3:

message_with_args(MCM_mouse_double_up, which);

break;

}

return True;

}

void MCControl::timer(MCNameRef mptr, MCParameter *params)

{

if (MCNameIsEqualToCaseless(mptr, MCM_idle))

{

if (opened && getstack()->gettool(this) == T_BROWSE)

{

Boolean again = False;

MCRectangle srect;

MCU_set_rect(srect, mx, my, 1, 1);

if (maskrect(srect))

{

if (conditionalmessage(HH_MOUSE_WITHIN, MCM_mouse_within) == ES_ERROR)

senderror();

else

again = True;

}

if (state & CS_MFOCUSED)

{

if (conditionalmessage(HH_MOUSE_STILL_DOWN, MCM_mouse_still_down) == ES_ERROR)

senderror();

else

again = True;

}

if (hashandlers & HH_IDLE)

{

if (message(MCM_idle) == ES_ERROR)

senderror();

else

again = True;

}

if (again)

MCscreen->addtimer(this, MCM_idle, MCidleRate);

}

}

else

MCObject::timer(mptr, params);

}

uint2 MCControl::gettransient() const

{

if (state & CS_KFOCUSED && MClook == LF_MOTIF

&& !(extraflags & EF_NO_FOCUS_BORDER))

return MCfocuswidth;

return 0;

}

void MCControl::select()

{

state |= CS_SELECTED;

kunfocus();

getcard()->dirtyselection(rect);

}

void MCControl::deselect()

{

if (state & CS_SELECTED)

{

getcard()->dirtyselection(rect);

state &= ~(CS_SELECTED | CS_MOVE | CS_SIZE | CS_CREATE);

}

}

Boolean MCControl::del(bool p_check_flag)

{

if (!isdeletable(p_check_flag))

return False;

switch (gettype())

{

case CT_BUTTON:

message(MCM_delete_button);

break;

case CT_EPS:

message(MCM_delete_eps);

break;

case CT_FIELD:

message(MCM_delete_field);

break;

case CT_IMAGE:

message(MCM_delete_image);

break;

case CT_SCROLLBAR:

message(MCM_delete_scrollbar);

break;

case CT_PLAYER:

message(MCM_delete_player);

break;

case CT_GRAPHIC:

message(MCM_delete_graphic);

break;

case CT_GROUP:

message(MCM_delete_group);

message(MCM_delete_background);

break;

case CT_WIDGET:

message(MCM_delete_widget);

break;

default:

break;

}

// IM-2016-10-05: [[ Bug 17008 ]] Dirty selection handles when object deleted

if (getselected())

getcard()->dirtyselection(rect);

// IM-2012-05-16 [[ BZ 10212 ]] deleting the dragtarget control in response

// to a 'dragdrop' message would leave these globals pointing to the deleted

// object, leading to an infinite loop if the target was a field

if (MCdragdest == this)

{

MCdragdest = nil;

MCdropfield = nil;

}

if (MCdragsource == this)

MCdragsource = nil;

switch (parent->gettype())

{

case CT_STACK:

removereferences();

parent.GetAs<MCStack>()->removecontrol(this);

break;

case CT_CARD:

if (!parent.GetAs<MCCard>()->removecontrol(this, False, True))

return False;

removereferences();

getstack()->removecontrol(this);

break;

case CT_GROUP:

parent.GetAs<MCGroup>()->removecontrol(this, True);

removereferences();

break;

default:

MCUnreachable();

}

// MCObject now does things on del(), so we must make sure we finish by

// calling its implementation.

return MCObject::del(p_check_flag);

}

void MCControl::paste(void)

{

if (MCdefaultstackptr->getmode() != WM_TOP_LEVEL)

return;

parent = MCdefaultstackptr->getchild(CT_THIS, kMCEmptyString, CT_CARD);

MCCard *cptr = parent.GetAs<MCCard>();

obj_id = 0;

//newcontrol->resetfontindex(oldstack);

if (!MCU_point_in_rect(cptr->getrect(), rect.x + (rect.width >> 1),

rect.y + (rect.height >> 1)))

setrect(MCU_center_rect(cptr->getrect(), rect));

attach(OP_NONE, false);

if (getstack()->gettool(this) == T_POINTER && opened)

{

state |= CS_SELECTED;

MCselected->clear(False);

MCselected->add(this);

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

layer_redrawall();

}

}

/* The MCRereferenceChildrenVisitor visits each of a control's descendents

* recursively and makes sure they have a weak-proxy and that the parent is

* updated. */

class MCRereferenceChildrenVisitor: public MCObjectVisitor

{

public:

static void Visit(MCControl *p_control)

{

MCRereferenceChildrenVisitor t_visitor(p_control);

/* Make sure the control has a weak proxy (needed to set the parent of

* its children!). */

p_control->ensure_weak_proxy();

/* Now visit the controls children. */

p_control->visit_children(0, 0, &t_visitor);

}

private:

MCRereferenceChildrenVisitor(MCObject *p_new_parent)

: m_new_parent(p_new_parent)

{

}

bool OnControl(MCControl* p_control)

{

/* Update the control's parent */

p_control->setparent(m_new_parent);

/* Update its children */

MCRereferenceChildrenVisitor::Visit(p_control);

return true;

}

MCObject *m_new_parent;

};

void MCControl::undo(Ustruct *us)

{

MCRectangle newrect = rect;

switch (us->type)

{

case UT_MOVE:

if (!(flags & F_LOCK_LOCATION))

{

newrect.x -= us->ud.deltas.x;

newrect.y -= us->ud.deltas.y;

us->ud.deltas.x = -us->ud.deltas.x;

us->ud.deltas.y = -us->ud.deltas.y;

}

break;

case UT_SIZE:

newrect = us->ud.rect;

us->ud.rect = rect;

break;

case UT_DELETE:

{

MCCard *card = (MCCard *)parent->getcard();

getstack()->appendcontrol(this);

/* Visit the control and its children, creating weak_proxys and

* reparenting as we go. */

MCRereferenceChildrenVisitor::Visit(this);

card->newcontrol(this, False);

Boolean oldrlg = MCrelayergrouped;

MCrelayergrouped = True;

card->relayer(this, us->ud.layer);

MCrelayergrouped = oldrlg;

Boolean oldlock = MClockmessages;

MClockmessages = True;

MCselected->add(this);

MClockmessages = oldlock;

MCscreen->delaymessage(this, MCM_selected_object_changed);

us->type = UT_REPLACE;

}

return;

case UT_REPLACE:

if (gettype() == CT_WIDGET)

{

static_cast<MCWidget*>(this)->delforundo(true);

}

else

{

del(true);

}

us->type = UT_DELETE;

return;

default:

break;

}

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

layer_setrect(newrect, false);

// MW-2011-10-03: [[ Scrolling ]] Make sure the parent is notified.

resizeparent();

}

// MW-2011-09-06: [[ Redraw ]] Added 'sprite' option - if true, ink and opacity are not set.

void MCControl::draw(MCDC *dc, const MCRectangle &dirty, bool p_isolated, bool p_sprite)

{

fprintf(stderr, "Control: ERROR tried to draw control id %d\n", obj_id);

}

IO_stat MCControl::save(IO_handle stream, uint4 p_part, bool p_force_ext, uint32_t p_version)

{

return MCObject::save(stream, p_part, p_force_ext, p_version);

}

Boolean MCControl::kfocusset(MCControl *target)

{

if (target == this)

return True;

return False;

}

MCControl *MCControl::clone(Boolean attach, Object_pos p, bool invisible)

{

fprintf(stderr, "Control: ERROR tried to clone control id %d\n", obj_id);

return NULL;

}

MCControl *MCControl::findnum(Chunk_term type, uint2 &num)

{

if ((type == gettype() || type == CT_LAYER) && num-- == 0)

return this;

else

return NULL;

}

MCControl *MCControl::findname(Chunk_term type, MCNameRef p_name)

{

if ((type == gettype() || type == CT_LAYER)

&& MCU_matchname(p_name, gettype(), getname()))

return this;

else

return NULL;

}

MCControl *MCControl::findid(Chunk_term type, uint4 inid, Boolean alt)

{

if ((type == gettype() || type == CT_LAYER)

&& (inid == obj_id || (alt && inid == altid)))

return this;

else

return NULL;

}

Boolean MCControl::count(Chunk_term type, MCObject *stop, uint2 &num)

{

if (type == gettype() || type == CT_LAYER)

num++;

if (stop == this)

return True;

return False;

}

Boolean MCControl::maskrect(const MCRectangle &srect)

{

if (!(flags & F_VISIBLE || showinvisible()))

return False;

MCRectangle drect = MCU_intersect_rect(srect, rect);

return drect.width != 0 && drect.height != 0;

}

void MCControl::installaccels(MCStack *stack)

{ }

void MCControl::removeaccels(MCStack *stack)

{ }

MCCdata *MCControl::getdata(uint4 cardid, Boolean clone)

{

return NULL;

}

void MCControl::replacedata(MCCdata *&data, uint4 newid)

{ }

void MCControl::compactdata()

{ }

void MCControl::resetfontindex(MCStack *oldstack)

{

}

Exec_stat MCControl::hscroll(int4 offset, Boolean doredraw)

{

return ES_NORMAL;

}

Exec_stat MCControl::vscroll(int4 offset, Boolean doredraw)

{

return ES_NORMAL;

}

void MCControl::readscrollbars()

{ }

void MCControl::setsbrects()

{ }

void MCControl::resetscrollbars(Boolean move)

{ }

void MCControl::fliph()

{ }

void MCControl::flipv()

{ }

void MCControl::attach(Object_pos p, bool invisible)

{

int2 v1 = rect.x;

int2 v2 = rect.y;

if (p == OP_CENTER && v1 == -1 && v2 == -1)

positionrel(getcard()->getrect(), OP_CENTER, OP_MIDDLE);

else

if (p == OP_OFFSET)

{

MCRectangle newrect = rect;

newrect.x += MCcloneoffset;

newrect.y += MCcloneoffset;

setrect(newrect);

}

uint4 cid = parent->gettype() == CT_CARD ? parent->getid() : 0;

if (obj_id == 0)

{

obj_id = getstack()->newid();

// MW-2011-08-09: If we are attaching a group, make sure the object

// id's are non-zero.

if (gettype() == CT_GROUP)

static_cast<MCGroup *>(this) -> ensureids();

}

if (invisible)

setflag(False, F_VISIBLE);

if (!parent || parent->gettype() == CT_CARD

|| parent->gettype() == CT_STACK)

{

MCCard *card = getcard(cid);

getstack()->appendcontrol(this);

card->newcontrol(this, True);

}

else

{

MCGroup *gptr = parent.GetAs<MCGroup>();

gptr->appendcontrol(this);

}

newmessage();

}

inline MCRectangle MCGRectangleGetPixelRect(const MCGRectangle &p_rect)

{

int32_t t_left, t_right, t_top, t_bottom;

t_left = floorf(p_rect.origin.x);

t_top = floorf(p_rect.origin.y);

t_right = floorf(p_rect.origin.x + p_rect.size.width);

t_bottom = floorf(p_rect.origin.y + p_rect.size.height);

return MCRectangleMake(t_left, t_top, t_right - t_left, t_bottom - t_top);

}

void MCControl::redraw(MCDC *dc, const MCRectangle &dirty)

{

// SN-2014-11-14: [[ Bug 14028 ]] Use the current control visibility state

if (!opened || !(getflag(F_VISIBLE) || showinvisible()))

return;

// MW-2009-06-11: [[ Bitmap Effects ]] A control needs to be (partially)

// redrawn if the dirty region touches it or one of its effects.

MCRectangle trect = MCU_intersect_rect(dirty, geteffectiverect());

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

{

dc->save();

dc -> setopacity(255);

dc -> setfunction(GXcopy);

/* Apply the layerClipRect property, if set. */

if (m_layer_has_clip_rect)

{

trect = MCU_intersect_rect(trect, m_layer_clip_rect);

}

dc->cliprect(trect);

// MW-2011-09-06: [[ Redraw ] Make sure we draw the control normally (not

// as a sprite).

draw(dc, trect, false, false);

dc->restore();

}

}

void MCControl::sizerects(const MCRectangle &p_object_rect, MCRectangle r_rects[8])

{

int2 x[3];

int2 y[3];

uint2 handlesize = MCsizewidth;

x[0] = p_object_rect.x - (handlesize >> 1);

x[1] = p_object_rect.x + ((p_object_rect.width - handlesize) >> 1);

x[2] = p_object_rect.x + p_object_rect.width - (handlesize >> 1);

y[0] = p_object_rect.y - (handlesize >> 1);

y[1] = p_object_rect.y + ((p_object_rect.height - handlesize) >> 1);

y[2] = p_object_rect.y + p_object_rect.height - (handlesize >> 1);

uint2 i;

uint2 j;

uint2 k = 0;

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

for (j = 0 ; j < 3 ; j++)

if (i != 1 || j != 1)

{

r_rects[k].width = r_rects[k].height = handlesize;

r_rects[k].x = x[j];

r_rects[k].y = y[i];

k++;

}

}

void MCControl::drawselection(MCDC *dc, const MCRectangle& p_dirty)

{

MCAssert(getopened() != 0 && (getflag(F_VISIBLE) || showinvisible()));

if (!getselected())

{

return;

}

if (MCdragging)

return;

dc -> setopacity(255);

dc -> setquality(QUALITY_SMOOTH);

dc -> setfunction(GXcopy);

drawmarquee(dc, rect);

MCRectangle rects[8];

sizerects(rect, rects);

if (flags & F_LOCK_LOCATION)

dc->setfillstyle(FillStippled, nil, 0, 0);

else

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

dc->setforeground(MCselectioncolor);

for (uint2 i = 0; i < 8; i++)

dc->fillarc(rects[i], 0, 360, false);

if (flags & F_LOCK_LOCATION)

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

dc->setquality(QUALITY_DEFAULT);

}

void MCControl::drawarrow(MCDC *dc, int2 x, int2 y, uint2 size,

Arrow_direction dir, Boolean border, Boolean hilite)

{

MCRectangle trect;

MCU_set_rect(trect, x, y, size, size);

MCPoint ap[5];

int2 ho = hilite && MClook == LF_WIN95 ? 0 : -1;

if (MCcurtheme && MCcurtheme->iswidgetsupported(WTHEME_TYPE_ARROW))

{

//fill winfo structure for arrow

return;//exit

}

switch (MClook)

{

case LF_MOTIF:

if (dir == AD_UP || dir == AD_DOWN)

{

ap[0].x = x + (size >> 1);

if (dir == AD_UP)

{

ap[1].x = x + size - 1;

ap[2].x = x + 1;

ap[0].y = y + 1;

ap[1].y = ap[2].y = y + size - 2;

}

else

{

ap[1].x = x + 1;

ap[2].x = x + size - 1;

ap[0].y = y + size - 1;

ap[1].y = ap[2].y = y + 1;

}

}

else

{

ap[0].y = y + (size >> 1);

if (dir == AD_LEFT)

{

ap[0].x = x;

ap[1].x = ap[2].x = x + size - 2;

ap[1].y = y + size - 1;

ap[2].y = y + 1;

}

else

{

ap[0].x = x + size - 1;

ap[1].x = ap[2].x = x + 1;

ap[1].y = y + 1;

ap[2].y = y + size - 1;

}

}

setforeground(dc, DI_BACK, False);

dc->fillpolygon(ap, 3);

uint1 i;

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

{

setforeground(dc, flags & F_3D ? DI_BOTTOM : DI_BORDER, hilite);

if (dir == AD_UP || dir == AD_LEFT)

dc->drawlines(ap, 3);

else

dc->drawline(ap[0].x, ap[0].y, ap[2].x, ap[2].y);

setforeground(dc, flags & F_3D ? DI_TOP : DI_BORDER, hilite);

if (dir == AD_UP || dir == AD_LEFT)

dc->drawline(ap[0].x, ap[0].y, ap[2].x, ap[2].y);

else

dc->drawlines(ap, 3);

switch (dir)

{

case AD_UP:

ap[0].y++;

ap[1].x--;

ap[1].y--;

ap[2].x++;

ap[2].y--;

break;

case AD_DOWN:

ap[0].y--;

ap[1].x++;

ap[1].y++;

ap[2].x--;

ap[2].y++;

break;

case AD_LEFT:

ap[0].x++;

ap[1].y--;

ap[1].x--;

ap[2].y++;

ap[2].x--;

break;