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

#include "util.h"

#include "font.h"

#include "date.h"

#include "dispatch.h"

#include "stack.h"

#include "card.h"

#include "group.h"

#include "cdata.h"

#include "image.h"

#include "button.h"

#include "field.h"

#include "stacklst.h"

#include "undolst.h"

#include "mcerror.h"

#include "param.h"

#include "globals.h"

#include "mctheme.h"

#include "context.h"

#include "graphics_util.h"

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

void MCButton::draw(MCDC *dc, const MCRectangle& p_dirty, bool p_isolated, bool p_sprite)

{

MCRectangle dirty;

dirty = p_dirty;

if (!p_isolated)

{

// MW-2011-09-06: [[ Redraw ]] If rendering as a sprite, don't change opacity or ink.

if (!p_sprite)

{

dc -> setopacity(blendlevel * 255 / 100);

dc -> setfunction(ink);

}

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

if (m_bitmap_effects == NULL)

dc -> begin(false);

else

{

if (!dc -> begin_with_effects(m_bitmap_effects, MCU_reduce_rect(rect, -gettransient())))

return;

dirty = dc -> getclip();

}

}

MCRectangle shadowrect;

shadowrect = rect;

MCRectangle t_content_rect;

t_content_rect = rect;

uint2 loff = 0;

if (labelwidth != 0)

{

shadowrect.x += labelwidth;

shadowrect.width -= labelwidth;

}

if (flags & F_SHADOW)

{

if ((signed char)shadowoffset < 0)

{

shadowrect.x -= shadowoffset;

shadowrect.y -= shadowoffset;

shadowrect.width += shadowoffset;

shadowrect.height += shadowoffset;

}

else

{

shadowrect.width -= shadowoffset;

shadowrect.height -= shadowoffset;

}

}

Boolean indicator = getstyleint(flags) == F_CHECK

|| getstyleint(flags) == F_RADIO;

if (needfocus())

drawfocus(dc, p_dirty);

Boolean isstdbtn = standardbtn();

uint2 i;

Boolean noback = isstdbtn && !getcindex(DI_BACK, i) && !getpindex(DI_BACK,i);

bool t_isvista = MCmajorosversion >= 0x0600 && MCcurtheme != NULL;

bool t_themed_menu = false;

bool t_use_alpha_layer = false;

if (entry != NULL)

{

drawcombo(dc, shadowrect);

entry->draw(dc, dirty, false, false);

}

else

{

int2 centerx = shadowrect.x + leftmargin

+ ((shadowrect.width - leftmargin - rightmargin) >> 1);

int2 centery = shadowrect.y + topmargin

+ ((shadowrect.height - topmargin - bottommargin) >> 1);

uint2 style = getstyleint(flags);

Boolean macoption = IsMacEmulatedLF() && style == F_MENU

&& (menumode == WM_OPTION || menumode == WM_COMBO);

Boolean white = MClook != LF_MOTIF && !macoption && !(t_isvista && style == F_MENU && menumode == WM_OPTION)

&& ((style == F_MENU && (menumode == WM_OPTION || menumode == WM_COMBO))

|| (flags & F_AUTO_ARM && state & CS_ARMED

&& !(flags & F_SHOW_BORDER)));

if (flags & F_3D && MClook == LF_WIN95

&& state & CS_HILITED && (style == F_STANDARD

|| (indicator && flags & F_SHOW_ICON)))

loff = 1;

if (style == F_MENU && menumode == WM_PULLDOWN && MCcurtheme != NULL &&

getstack() -> hasmenubar() && getparent() -> hasname(getstack() -> getmenubar()) &&

MCcurtheme -> drawmenuheaderbackground(dc, dirty, this))

{

t_themed_menu = true;

//dc -> setforeground(getflag(F_DISABLED) ? dc -> getgray() : dc -> getblack());

setforeground(dc, DI_PSEUDO_BUTTON_TEXT, False);

}

else if (menucontrol != MENUCONTROL_NONE && MCcurtheme != NULL &&

MCcurtheme -> drawmenuitembackground(dc, dirty, this))

{

t_themed_menu = true;

indicator = False;

//dc -> setforeground(getflag(F_DISABLED) ? dc -> getgray() : dc -> getblack());

setforeground(dc, DI_PSEUDO_BUTTON_TEXT, False);

}

else

{

if (flags & F_OPAQUE && (MCcurtheme == NULL || !noback

|| ((style == F_STANDARD && (MCcurtheme != NULL &&

!MCcurtheme->iswidgetsupported(WTHEME_TYPE_PUSHBUTTON))) ||

(style == F_RECTANGLE && (MCcurtheme != NULL &&

!MCcurtheme->iswidgetsupported(WTHEME_TYPE_BEVELBUTTON))))

|| !(flags & F_SHOW_BORDER)

|| flags & F_SHADOW))

{//define when to not draw using themes

MCRectangle trect = shadowrect;

if (style != F_ROUNDRECT)

{

if (flags & F_SHOW_BORDER && !(isstdbtn && noback))

trect = MCU_reduce_rect(trect, borderwidth);

}

else

if (flags & F_SHOW_BORDER)

trect = MCU_reduce_rect(trect, borderwidth >> 1);

setforeground(dc, DI_BACK,

(((state & CS_HILITED && flags & F_HILITE_FILL)

|| (state & CS_ARMED && flags & F_ARM_FILL)

|| (state & CS_ARMED && !(flags & F_SHOW_BORDER)

&& MClook != LF_MOTIF)) && loff == 0

&& (flags & F_SHOW_ICON || !indicator))

|| (white && state & CS_KFOCUSED && !(state & CS_SUBMENU))

|| (macoption && state & CS_SUBMENU),

(white || ((state & CS_ARMED && !(flags & F_SHOW_BORDER))

&& !macoption)));

switch (style)

{

case F_MENU:

case F_CHECK:

case F_RADIO:

case F_RECTANGLE:

case F_STANDARD:

if ((isstdbtn && (state & CS_HILITED))

|| MCcurtheme == NULL

|| !((getstack()->ismetal() && MCcurtheme->drawmetalbackground(dc, dirty, trect, this))

|| (style == F_MENU && menumode == WM_TOP_LEVEL && MCcurtheme->iswidgetsupported(WTHEME_TYPE_TABPANE))))

{

if (isstdbtn && noback)

{

trect = MCU_reduce_rect(trect, 1);

if (state & CS_HILITED)

{

uint2 t_index;

if (getcindex(DI_HILITE, t_index) || getpindex(DI_HILITE, t_index))

setforeground(dc, DI_HILITE, False, False);

else

dc->setforeground(dc->getgray());

}

dc->fillrect(trect);

}

else

{

if (style == F_MENU && menumode == WM_TOP_LEVEL)

{

uint2 theight = MCFontGetAscent(m_font) + 8 - 1;

trect.y += theight;

trect.height -= theight;

}

dc->fillrect(trect);

}

}

break;

case F_ROUNDRECT:

dc->fillroundrect(trect, DEFAULT_RADIUS);

break;

case F_OVAL_BUTTON:

dc->fillarc(trect, 0, 360);

break;

}

}

if (state & CS_SHOW_DEFAULT && !MCcurtheme)

switch (MClook)

{

case LF_MOTIF:

draw3d(dc, MCU_reduce_rect(shadowrect, -MOTIF_DEFAULT_WIDTH), ETCH_SUNKEN, borderwidth >> 1);

drawborder(dc, MCU_reduce_rect(shadowrect, -MOTIF_DEFAULT_WIDTH), borderwidth >> 1);

break;

case LF_MAC:

drawmacdefault(dc, MCU_reduce_rect(shadowrect, -3));

break;

case LF_WIN95:

drawborder(dc, MCU_reduce_rect(shadowrect, -WIN95_DEFAULT_WIDTH), WIN95_DEFAULT_WIDTH);

default:

break;

}

switch (getstyleint(flags))

{

case F_MENU:

switch (menumode)

{

case WM_PULLDOWN:

if ((state & CS_ARMED && !(flags & F_SHOW_BORDER) &&

(MClook == LF_MOTIF || (MCcurtheme && MCcurtheme->getthemeid() == LF_NATIVEGTK)))

|| flags & F_SHOW_BORDER)

drawpulldown(dc, shadowrect);

break;

case WM_OPTION:

drawoption(dc, shadowrect, t_content_rect);

break;

case WM_COMBO:

break;

case WM_TOP_LEVEL:

drawtabs(dc, shadowrect);

break;

}

if (menumode != WM_CASCADE || !(flags & F_AUTO_ARM))

break;

case F_CHECK:

case F_RADIO:

case F_RECTANGLE:

case F_STANDARD:

if (flags & F_SHADOW)

drawshadow(dc, rect, shadowoffset);

if (flags & F_3D)

{

if ((state & CS_HILITED && flags & F_HILITE_BORDER)

|| (flags & F_AUTO_ARM && state & CS_ARMED && flags & F_ARM_BORDER

&& !indicator && MClook == LF_MOTIF))

if (isstdbtn && noback)

drawstandardbutton(dc, shadowrect);

else

if (MClook != LF_MOTIF && state & CS_SHOW_DEFAULT

&& borderwidth == DEFAULT_BORDER)

{

setforeground(dc, DI_BOTTOM, False);

dc->drawrect(shadowrect);

}

else

draw3d(dc, shadowrect, flags & F_SHOW_BORDER ? ETCH_SUNKEN_BUTTON

: ETCH_RAISED, borderwidth);

else

if (flags & F_SHOW_BORDER || (MClook == LF_MOTIF

&& (state & (CS_ARMED | CS_KFOCUSED)) && flags & F_ARM_BORDER))

{

if (isstdbtn && noback)

drawstandardbutton(dc, shadowrect);

else

{

uint2 bwidth = borderwidth;

draw3d(dc, shadowrect, shadowrect.height <= bwidth

|| (state & CS_HILITED && flags & F_HILITE_BORDER)

? ETCH_SUNKEN_BUTTON : ETCH_RAISED, bwidth);

}

}

else if (!(flags & F_SHOW_BORDER) && MCcurtheme && MCcurtheme->getthemeid() == LF_NATIVEGTK

&& (!getcindex(DI_BACK, i) && !getpindex(DI_BACK,i))

&& flags & MENU_ITEM_FLAGS && flags & F_AUTO_ARM)

{

// FG-2014-07-30: [[ Bugfix 9405 ]]

// Clear the previously drawn highlight before drawing GTK highlight

setforeground(dc, DI_BACK, False, False);

dc->fillrect(shadowrect);

if (state & CS_ARMED)

{

MCWidgetInfo winfo;

winfo.type = WTHEME_TYPE_MENUITEMHIGHLIGHT;

getwidgetthemeinfo(winfo);

MCcurtheme->drawwidget(dc, winfo, shadowrect);

}

}

}

else

if ((state & CS_HILITED && flags & F_HILITE_BORDER)

|| flags & F_SHOW_BORDER

|| ((state & (CS_ARMED | CS_KFOCUSED)) && flags & F_ARM_BORDER))

drawborder(dc, shadowrect, borderwidth);

break;

case F_ROUNDRECT:

if (borderwidth != 0)

{

// MM-2014-04-08: [[ Bug 11662/11398 ]] Let the context take care of insetting the rectangle.

// This solves 2 bugs. Round rect buttons are drawn at the wrong size (compared to square buttons) (11662)

// and the corners of round rect buttons are inconsistent (11398).

dc->setlineatts(borderwidth - 1, LineSolid, CapButt, JoinBevel);

setforeground(dc, DI_FORE, False);

dc->drawroundrect(shadowrect, DEFAULT_RADIUS, true);

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

}

break;

case F_OVAL_BUTTON:

if ((state & CS_HILITED && flags & F_HILITE_BORDER)

|| flags & F_SHOW_BORDER

|| ((state & (CS_ARMED | CS_KFOCUSED)) && flags & F_ARM_BORDER))

{

setforeground(dc, DI_FORE, False);

dc->drawarc(shadowrect, 0, 360);

}

break;

}

if (flags & F_DISABLED)

{

if (MClook == LF_MOTIF)

{

setforeground(dc, DI_FORE, False);

dc->setopacity(127);

dc->begin(false);

t_use_alpha_layer = true;

}

else if (IsMacLF())

{

dc->setforeground(dc->getgray());

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

}

else

setforeground(dc, DI_TOP, False);

}

else

{

if ((white && state & CS_KFOCUSED && !(state & CS_SUBMENU)) ||

(isstdbtn && noback && (MCcurtheme == NULL || (MCcurtheme->getthemeid() != LF_NATIVEWIN && MCcurtheme->getthemeid() != LF_NATIVEGTK)) && state & CS_HILITED && !MCaqua) ||

(MClook != LF_MOTIF && style == F_MENU && flags & F_OPAQUE && state & CS_ARMED && !(flags & F_SHOW_BORDER)))

setforeground(dc, DI_PSEUDO_BUTTON_TEXT_SEL, False, True);

else

setforeground(dc, DI_FORE, ((state & CS_HILITED && flags & F_HILITE_FILL)

|| ((state & CS_ARMED && flags & F_ARM_FILL) && flags & F_OPAQUE && ((MClook != LF_WIN95 && !MCaqua)))

|| style != F_STANDARD), False);

}

}

// MW-2009-06-14: We will assume (perhaps unwisely) that is 'opaque' is set

// then the background is now, completely opaque.

bool t_was_opaque = false;

if (getflag(F_OPAQUE))

t_was_opaque = dc -> changeopaque(true);

MCStringRef t_label = getlabeltext();

Boolean icondrawed = False;

// SN-2014-08-12: [[ Bug 13155 ]] Don't try to draw the icons if the button has not got any

// SN-2014-12-17: [[ Bug 14249 ]] Do not try to draw the curicon if there is no current

// icon (as it may after loading a stack).

if (icons != NULL && icons -> curicon && m_icon_gravity != kMCGravityNone)

{

// MW-2014-06-19: [[ IconGravity ]] Use iconGravity to place the icon.

int t_left, t_top, t_right, t_bottom;

t_left = rect . x + leftmargin + borderwidth;

t_top = rect . y + topmargin + borderwidth;

t_right = rect . x + rect . width - rightmargin - borderwidth;

t_bottom = rect . y + rect . height - bottommargin - borderwidth;

MCRectangle t_rect;

if (t_left < t_right)

t_rect . x = t_left, t_rect . width = t_right - t_left;

else

t_rect . x = (t_left + t_right) / 2, t_rect . width = 0;

if (t_top < t_bottom)

t_rect . y = t_top, t_rect . height = t_bottom - t_top;

else

t_rect . y = (t_top + t_bottom) / 2, t_rect . height = 0;

icons -> curicon -> drawwithgravity(dc, t_rect, m_icon_gravity);

icondrawed = True;

}

if (flags & F_SHOW_NAME && !MCStringIsEmpty(t_label) && menucontrol != MENUCONTROL_SEPARATOR)

{

// Split the string on the newlines

MCAutoArrayRef lines;

/* UNCHECKED */ MCStringSplit(t_label, MCSTR("\n"), nil, kMCCompareExact, &lines);

uindex_t nlines = MCArrayGetCount(*lines);

coord_t fascent, fdescent, fleading, fxheight;

fascent = MCFontGetAscent(m_font);

fdescent = MCFontGetDescent(m_font);

fleading = MCFontGetLeading(m_font);

fxheight = MCFontGetXHeight(m_font);

coord_t fheight;

fheight = fascent + fdescent + fleading;

coord_t sx, sy, theight;

if (nlines == 1)

{

// Centre things on the middle of the ascent

sx = shadowrect.x + leftmargin + borderwidth - DEFAULT_BORDER;

sy = roundf(centery + (fascent-fdescent)/2);

theight = fascent;

}

else

{

// Centre things by centring the bounding box of the text

sx = shadowrect.x + leftmargin + borderwidth - DEFAULT_BORDER;

sy = centery - (nlines * fheight / 2) + fleading/2 + fascent;

theight = nlines * fheight;

}

coord_t starty = sy;

uint2 t_line;

coord_t twidth = 0;

dc->save();

dc->cliprect(t_content_rect);

// MW-2014-06-19: [[ IconGravity ]] Use old method of calculating icon location if gravity is none.

if (flags & F_SHOW_ICON && icons != NULL && icons->curicon != NULL && m_icon_gravity == kMCGravityNone)

{

switch (flags & F_ALIGNMENT)

{

case F_ALIGN_LEFT:

case F_ALIGN_JUSTIFY:

centerx = shadowrect.x + shadowrect.width - rightmargin

- (icons->curicon->getrect().width >> 1);

break;

case F_ALIGN_CENTER:

centery -= (theight / 2) + 1;

sy = shadowrect.y + shadowrect.height - bottommargin - theight

+ fascent - fdescent - 1;

break;

case F_ALIGN_RIGHT:

centerx = shadowrect.x + leftmargin

+ (icons->curicon->getrect().width >> 1);

break;

}

}

if (flags & F_SHOW_ICON && icons != NULL && icons->curicon != NULL && m_icon_gravity == kMCGravityNone)

{

icons->curicon->drawcentered(dc, centerx + loff, centery + loff, (state & CS_HILITED) != 0);

icondrawed = True;

}

uindex_t t_totallen = 0;

for (t_line = 0 ; t_line < nlines ; t_line++)

{

// Note: 'lines' is an array of strings

MCValueRef lineval = nil;

/* UNCHECKED */ MCArrayFetchValueAtIndex(*lines, t_line + 1, lineval);

MCStringRef line = (MCStringRef)(lineval);

// MM-2014-04-16: [[ Bug 11964 ]] Pass through the transform of the stack to make sure the measurment is correct for scaled text.

twidth = MCFontMeasureTextFloat(m_font, line, getstack() -> getdevicetransform());

// Mnemonic position calculation

uindex_t t_mnemonic = 0;

uindex_t t_linelen = MCStringGetLength(line);

if (mnemonic > t_totallen && mnemonic <= t_totallen + t_linelen)

t_mnemonic = mnemonic - t_totallen;

switch (flags & F_ALIGNMENT)

{

case F_ALIGN_LEFT:

case F_ALIGN_JUSTIFY:

if (t_line == 0)

{

if (indicator && !(flags & F_SHOW_ICON))

{

sx += GetCheckSize() + leftmargin;

if (MClook == LF_WIN95)

{

sy++;

sx--;

}

}

if (MCaqua && IsMacLFAM()

&& ((style == F_STANDARD && noback)|| (style == F_MENU

&& menumode == WM_OPTION)))

sx += 5;

}

break;

case F_ALIGN_CENTER:

sx = floorf(centerx - (twidth / 2));

if (menumode == WM_OPTION || menumode == WM_COMBO)

sx -= optionrect.width;

// MH-2007-03-16 [[ Bug 3598 ]] Centering of the label did not work correctly on mac os classic and non vista windows option buttons.

if (menumode == WM_OPTION && ((MClook == LF_WIN95 && !t_themed_menu) || MClook == LF_MAC))

sx = t_content_rect . x + (t_content_rect . width - leftmargin) / 2 - twidth / 2;

if (menumode == WM_CASCADE)

sx -= rect.height >> 1;

break;

case F_ALIGN_RIGHT:

sx = shadowrect.x + shadowrect.width - rightmargin - twidth

- (borderwidth - DEFAULT_BORDER);

if (menumode == WM_OPTION)

sx -= optionrect.width << 1;

if (menumode == WM_CASCADE)

sx -= rect.height;

break;

}

uint2 fontstyle;

fontstyle = gettextstyle();

if ((flags & F_DISABLED) != 0 && !t_themed_menu && MClook == LF_WIN95)

{

drawlabel(dc, sx + 1 + loff, sy + 1 + loff, twidth, shadowrect, line, fontstyle, t_mnemonic);

if (getstyleint(flags) == F_MENU && menumode == WM_CASCADE)

{

shadowrect.x++;

shadowrect.y++;

drawcascade(dc, shadowrect); // draw arrow in text color

shadowrect.x--;

shadowrect.y--;

}

setforeground(dc, DI_BOTTOM, False);

}

#ifdef _MACOSX

// FG-2014-10-29: [[ Bugfix 13842 ]] On Yosemite, glowing buttons

// should draw with white text.

if (IsMacLFAM() && MCmajorosversion >= 0x10A0 && MCaqua

&& !(flags & F_DISABLED) && isstdbtn && getstyleint(flags) == F_STANDARD

&& ((state & CS_HILITED) || (state & CS_SHOW_DEFAULT))

&& rect.height <= 24 && MCappisactive)

setforeground(dc, DI_BACK, False, True);

// PM-2014-11-26: [[ Bug 14070 ]] [Removed code] Make sure text color in menuButton inverts when hilited

#endif

drawlabel(dc, sx + loff, sy + loff, twidth, shadowrect, line, fontstyle, t_mnemonic);

if (getstyleint(flags) == F_MENU && menumode == WM_CASCADE && !t_themed_menu)

drawcascade(dc, shadowrect); // draw arrow in text color

if ((flags & F_DISABLED && MClook == LF_WIN95) || t_themed_menu)

setforeground(dc, DI_TOP, False);

sy += fheight;

t_totallen += t_linelen;

}

dc->restore();

if (labelwidth != 0 && !isunnamed())

{

MCStringRef t_name = MCNameGetString(getname());

drawdirectionaltext(dc, rect.x + leftmargin, starty, t_name, m_font);

}

// MW-2012-01-27: [[ Bug 9432 ]] Native GTK handles focus borders itself

// so don't render the win95-style one.

if (MClook == LF_WIN95 && !IsNativeGTK() && state & CS_KFOCUSED && !(flags & F_AUTO_ARM) && !white)

{

MCRectangle trect;

if (indicator && nlines == 1)

MCU_set_rect(trect, sx - 1, starty - fascent, twidth + 2, fascent + fdescent);

else

trect = MCU_reduce_rect(shadowrect, 3);

#if defined(X11) || defined(_WINDOWS)

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

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

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

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

dc->setfunction(GXinvert);

// MM-2013-11-05: [[ Bug 11355 ]] - Handle the insetting of the dashed border manually - was causing drawing artefacts previously.

trect . width -= 1; trect . height -= 1;

dc->drawrect(trect, false);

dc->setfunction(GXcopy);

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

#else

// Windows 95 and Mac don't support user line styles, so kludge away

setforeground(dc, DI_BACK, False);

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

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

MCRectangle xrect = trect;

xrect.height = 1;

dc->fillrect(xrect);

xrect.y = trect.y + trect.height - 1;

dc->fillrect(xrect);

xrect = trect;

xrect.width = 1;

dc->fillrect(xrect);

xrect.x = trect.x + trect.width - 1;

dc->fillrect(xrect);

dc->setbackground(MCzerocolor);

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

#endif

}

}

if (t_use_alpha_layer)

{

dc->end();

}

if (flags & F_DISABLED && MClook == LF_MOTIF)

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

if (indicator && !(flags & F_SHOW_ICON)

&& (state & CS_HILITED || !(flags & F_SHOW_HILITE)))

{

if (getstyleint(flags) == F_CHECK)

drawcheck(dc, shadowrect, white);

if (getstyleint(flags) == F_RADIO)

drawradio(dc, shadowrect, white);

}

if (!icondrawed &&flags & F_SHOW_ICON && icons != NULL && icons->curicon != NULL)

icons->curicon->drawcentered(dc, centerx + loff, centery + loff,

(state & CS_HILITED) != 0);

// MW-2009-06-14: Reset opaqueness

if (getflag(F_OPAQUE))

dc -> changeopaque(t_was_opaque);

}

if (!p_isolated)

{

dc -> end();

}

}

void MCButton::drawlabel(MCDC *dc, int2 sx, int sy, uint2 twidth, const MCRectangle &srect, MCStringRef p_label, uint2 fstyle, uindex_t p_mnemonic)

{

if (getstyleint(flags) == F_MENU && menumode == WM_OPTION

&& MClook != LF_WIN95)

sx += 2;

/*if (MCaqua && IsMacLFAM()

&& (getstyleint(flags) == F_STANDARD || getstyleint(flags) == F_MENU

&& menumode == WM_OPTION))

sy--;*/

drawdirectionaltext(dc, sx, sy, p_label, m_font);

if (!MCStringIsEmpty(acceltext))

{

// MM-2014-04-16: [[ Bug 11964 ]] Pass through the transform of the stack to make sure the measurment is correct for scaled text.

uint2 awidth = MCFontMeasureText(m_font, acceltext, getstack() -> getdevicetransform());

if (rightmargin == defaultmargin || menucontrol == MENUCONTROL_ITEM)

drawdirectionaltext(dc, srect.x + srect.width - rightmargin - awidth, sy, acceltext, m_font);

else

drawdirectionaltext(dc, srect.x + srect.width - rightmargin, sy, acceltext, m_font);

}

if (fstyle & FA_UNDERLINE)

dc->drawline(sx, sy + 1, sx + twidth, sy + 1);

if (fstyle & FA_STRIKEOUT)

{

int32_t fascent;

fascent = MCFontGetAscent(m_font);

dc->drawline(sx, sy - (fascent >> 1), sx + twidth, sy - (fascent >> 1));

}

if (!IsMacLF() && mnemonic

&& (gettheme() == kMCInterfaceThemeLegacy || (MCscreen->querymods() & MS_ALT)))

{

if (p_mnemonic > 0)

{

MCRange t_before = MCRangeMake(0, mnemonic - 1);

MCRange t_letter = MCRangeMake(mnemonic - 1, 1);

// MM-2014-04-16: [[ Bug 11964 ]] Pass through the transform of the stack to make sure the measurment is correct for scaled text.

int32_t mstart = sx + MCFontMeasureTextSubstring(m_font, p_label, t_before, getstack() -> getdevicetransform());

int32_t mwidth = MCFontMeasureTextSubstring(m_font, p_label, t_letter, getstack() -> getdevicetransform());

#ifdef TARGET_PLATFORM_WINDOWS

// No idea why this fudge-factor is required on Windows...

// Without it, the mnemonic underlines are drawn too far

// to the left, mis-aligning them with the mnemonic letter.

mstart -= 1;

#endif

sy += mnemonicoffset;

dc->drawline(mstart, sy, mstart + mwidth - 1, sy);

}

}

}

void MCButton::drawcheck(MCDC *dc, MCRectangle &srect, Boolean white)

{

MCRectangle trect;

trect.x = srect.x + leftmargin - 2;

trect.y = srect.y + ((srect.height - CHECK_SIZE) >> 1) + 1;

trect.width = trect.height = CHECK_SIZE;

uint2 index;

if (!(flags & F_AUTO_ARM) && MCcurtheme &&

MCcurtheme->iswidgetsupported(WTHEME_TYPE_CHECKBOX))

{

if (IsNativeGTK())

{

int32_t t_size, t_spacing;

t_size = MCcurtheme -> getmetric(WTHEME_METRIC_CHECKBUTTON_INDICATORSIZE);

t_spacing = MCcurtheme -> getmetric(WTHEME_METRIC_CHECKBUTTON_INDICATORSPACING);

trect . x = srect . x + leftmargin - t_spacing;

trect . y = srect . y;

trect . width = t_size + 2*t_spacing;

trect . height = srect . height;

}

MCWidgetInfo widgetinfo;

widgetinfo.type = WTHEME_TYPE_CHECKBOX;

getwidgetthemeinfo(widgetinfo);

MCcurtheme->drawwidget(dc, widgetinfo, IsMacLFAM()?rect:trect);

return;

}

switch (MClook)

{

case LF_MAC:

if (!(flags & F_AUTO_ARM))

{

trect.width--;

trect.height--;

trect = MCU_reduce_rect(trect, 1);

if (flags & F_DISABLED)

{

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

dc->setforeground(dc->getgray());

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

dc->drawrect(trect);

break;

}

if (state & CS_MFOCUSED && !(state & CS_SELECTED)

&& MCU_point_in_rect(rect, mx, my))

{

dc->setforeground(maccolors[MAC_SHADOW]);

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

dc->fillrect(trect);

draw3d(dc, trect, ETCH_SUNKEN, 1);

}

else

{

setforeground(dc, DI_BACK, False);

dc->fillrect(trect);

draw3d(dc, trect, ETCH_RAISED, 1);

}

if (state & CS_HILITED)

{

MCPoint p[6];

p[0].x = trect.x + 1;

p[1].x = p[4].x = trect.x + 4;

p[2].x = trect.x + 11;

p[3].x = trect.x + 10;

p[5].x = trect.x + 2;

p[0].y = p[5].y = trect.y + 4;

p[1].y = trect.y + 7;

p[2].y = p[3].y = trect.y;

p[4].y = trect.y + 6;

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

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

dc->drawlines(p, 6);

p[0].x = trect.x + 2;

p[1].x = p[0].x + 2;

p[2].x = p[0].x + 3;

p[3].x = p[0].x + 10;

p[0].y = trect.y + 6;

p[1].y = p[2].y = p[0].y + 2;

p[3].y = trect.y + 1;

setforeground(dc, DI_SHADOW, False);

dc->drawlines(p, 4);

p[0] = p[1];

p[1] = p[3];

p[1].x--;

dc->setforeground(maccolors[MAC_SHADOW]);

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

dc->drawlines(p, 2);

}

trect = MCU_reduce_rect(trect, -1);

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

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

dc->drawrect(trect);

break;

}

// fall through

case LF_WIN95:

if (flags & F_AUTO_ARM)

trect = MCU_reduce_rect(trect, 2);

else

{

draw3d(dc, trect, ETCH_SUNKEN, DEFAULT_BORDER);

trect = MCU_reduce_rect(trect, 2);

if (getcindex(DI_BACK, index) || getpindex(DI_BACK, index))

setforeground(dc, DI_BACK, False);

else

{

if (state & CS_MFOCUSED && !(state & CS_SELECTED)

&& MCU_point_in_rect(rect, mx, my))

dc->setforeground(dc->getgray());

else

dc->setforeground(dc->getwhite());

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

}

if (!(flags & F_DISABLED))

dc->fillrect(trect);

}

if (state & CS_HILITED)

{

// MM-2013-12-16: [[ Bug 11558 ]] Convert checkmark drawing to use polygons rather than lines.

MCPoint p[6];

p[0].x = p[5].x = trect.x + 1;

p[1].x = p[4].x = p[0].x + 2;

p[2].x = p[3].x = p[1].x + 5;

p[0].y = trect.y + 3;

p[1].y = p[0].y + 2;

p[2].y = p[1].y - 5;

p[3].y = p[2].y + 3;

p[4].y = p[1].y + 3;

p[5].y = p[0].y + 3;

if (white && state & CS_ARMED)

dc->setforeground(dc->getwhite());

else

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

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

dc->fillpolygon(p, 6);

}

break;

case LF_MOTIF:

trect.x += 2;

trect.y--;

if (flags & F_3D)

draw3d(dc, trect, state & CS_HILITED ? ETCH_SUNKEN : ETCH_RAISED,

DEFAULT_BORDER);

else

drawborder(dc, trect, DEFAULT_BORDER);

trect = MCU_reduce_rect(trect, 2);

setforeground(dc, DI_BACK, (state & CS_HILITED) != 0);

dc->fillrect(trect);

break;

}

}

void MCButton::drawradio(MCDC *dc, MCRectangle &srect, Boolean white)

{

MCPoint p[12];

MCRectangle trect;

int2 lx = srect.x + leftmargin - 1;

int2 cy = srect.y + (srect.height >> 1);

int2 ty = cy - (CHECK_SIZE >> 1);

uint2 index;

if (!(flags & F_AUTO_ARM) && MCcurtheme &&

MCcurtheme->iswidgetsupported(WTHEME_TYPE_RADIOBUTTON))

{

if (!IsNativeGTK())

{

trect.x = srect.x + leftmargin - 2;

trect.y = srect.y + ((srect.height - CHECK_SIZE) >> 1) + 1;

trect.width = trect.height = CHECK_SIZE;

}

else

{

int32_t t_size, t_spacing;

t_size = MCcurtheme -> getmetric(WTHEME_METRIC_RADIOBUTTON_INDICATORSIZE);

t_spacing = MCcurtheme -> getmetric(WTHEME_METRIC_RADIOBUTTON_INDICATORSPACING);

trect . x = srect . x + leftmargin - t_spacing;

trect . y = srect . y;

trect . width = t_size + 2*t_spacing;

trect . height = srect . height;

}

MCWidgetInfo widgetinfo;

widgetinfo.type = WTHEME_TYPE_RADIOBUTTON;

getwidgetthemeinfo(widgetinfo);

MCcurtheme->drawwidget(dc, widgetinfo, IsMacLFAM()?rect:trect);

return;

}

switch (MClook)

{

case LF_MAC:

if (!(flags & F_AUTO_ARM))

{

if (flags & F_DISABLED)

{

dc->setforeground(dc->getgray());

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

}

else

{

lx += 5;

if (state & CS_MFOCUSED && !(state & CS_SELECTED)

&& MCU_point_in_rect(rect, mx, my))

if (state & CS_HILITED)

macrbhilitetrack->drawcentered(dc, lx, cy, False);

else

macrbtrack->drawcentered(dc, lx, cy, False);

else

if (state & CS_HILITED)

macrbhilite->drawcentered(dc, lx, cy, False);

else

macrb->drawcentered(dc, lx, cy, False);

break;

}

}

// fall through

case LF_WIN95:

if (!(flags & F_AUTO_ARM))

{

p[0].x = p[1].x = p[4].x = p[5].x = lx + 1;

p[2].x = p[3].x = lx;

p[6].x = lx + 2;

p[7].x = lx + 3;

p[8].x = lx + 4;

p[9].x = lx + 7;

p[10].x = lx + 8;

p[11].x = lx + 9;

p[0].y = ty + 9;

p[1].y = ty + 8;

p[2].y = ty + 7;

p[3].y = ty + 4;

p[4].y = ty + 3;

p[5].y = ty + 2;

p[6].y = p[7].y = p[10].y = p[11].y = ty + 1;

p[8].y = p[9].y = ty;

if (!IsMacEmulatedLF() || !(flags & F_DISABLED))

setforeground(dc, DI_BOTTOM, False);

dc->drawlines(p, 12);

p[0].x = lx + 2;

p[1].x = lx + 3;

p[2].x = lx + 4;

p[3].x = lx + 7;

p[4].x = lx + 8;

p[5].x = lx + 9;

p[6].x = p[7].x = p[10].x = p[11].x = lx + 10;

p[8].x = p[9].x = lx + 11;

p[0].y = p[1].y = p[4].y = p[5].y = ty + 10;

p[2].y = p[3].y = ty + 11;

p[6].y = ty + 9;

p[7].y = ty + 8;

p[8].y = ty + 7;

p[9].y = ty + 4;

p[10].y = ty + 3;

p[11].y = ty + 2;

if (!IsMacEmulatedLF() || !(flags & F_DISABLED))

setforeground(dc, DI_TOP, False);

dc->drawlines(p, 12);

if (IsMacEmulatedLF() && flags & F_DISABLED)

break;

p[0].x = p[3].x = p[4].x = lx + 2;

p[1].x = p[2].x = lx + 1;

p[5].x = lx + 3;

p[6].x = lx + 4;

p[7].x = lx + 7;

p[8].x = lx + 8;

p[9].x = lx + 9;

p[0].y = ty + 8;

p[1].y = ty + 7;

p[2].y = ty + 4;

p[3].y = ty + 3;

p[4].y = p[5].y = p[8].y = p[9].y = ty + 2;

p[6].y = p[7].y = ty + 1;

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

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

dc->drawlines(p, 10);

p[0].x = p[1].x = lx + 2;

p[2].x = p[7].x = lx + 4;

p[3].x = p[6].x = lx + 7;

p[4].x = p[5].x = lx + 9;

p[0].y = p[5].y = ty + 7;

p[1].y = p[4].y = ty + 4;

p[2].y = p[3].y = ty + 2;

p[6].y = p[7].y = ty + 9;

p[8] = p[0];