bool MCNativeControl::ParseColor(MCExecPoint &ep, uint16_t &r_red, uint16_t &r_green, uint16_t &r_blue, uint16_t &r_alpha)
{
uint8_t t_r8, t_g8, t_b8, t_a8;
MCColor t_color;
char *t_name = nil;
if (MCParseRGBA(ep.getsvalue(), false, t_r8, t_g8, t_b8, t_a8))
{
r_red = (t_r8 << 8) | t_r8;
r_green = (t_g8 << 8) | t_g8;
r_blue = (t_b8 << 8) | t_b8;
r_alpha = (t_a8 << 8) | t_a8;
return true;
}
else if (MCscreen->parsecolor(ep.getsvalue(), &t_color, &t_name))
{
delete t_name;
r_red = t_color.red;
r_green = t_color.green;
r_blue = t_color.blue;
r_alpha = 0xFFFF;
return true;
}
else
return false;
}
void MCSystemListFontsForFamily(MCExecPoint& ep, const char *p_family)
{
uint32_t t_styles;
t_styles = 0;
for (uint32_t i = 0; s_droid_fonts[i].name != nil; i++)
{
if (MCCStringEqualCaseless(s_droid_fonts[i].name, p_family))
{
t_styles = s_droid_fonts[i].styles;
break;
}
}
if (t_styles == 0)
t_styles = MCAndroidCustomFontsGetStyle(p_family);
ep . clear();
if (t_styles & kMCAndroidFontStyleRegular)
ep.concatcstring("plain", EC_RETURN, ep.getsvalue().getlength() == 0);
if (t_styles & kMCAndroidFontStyleBold)
ep.concatcstring("bold", EC_RETURN, ep.getsvalue().getlength() == 0);
if (t_styles & kMCAndroidFontStyleItalic)
ep.concatcstring("italic", EC_RETURN, ep.getsvalue().getlength() == 0);
if (t_styles & kMCAndroidFontStyleBoldItalic)
ep.concatcstring("bold-italic", EC_RETURN, ep.getsvalue().getlength() == 0);
}
bool MCParseMenuString(MCString &r_string, IParseMenuCallback *p_callback, bool p_is_unicode, uint1 p_menumode)
{
MCString *t_lines = NULL;
uint2 t_nlines = 0;
MCMenuItem t_menuitem;
MCU_break_string(r_string, t_lines, t_nlines, p_is_unicode);
MCExecPoint ep;
bool t_hastags = false;
p_callback->Start();
for (int i=0; i<t_nlines; i++)
{
memset(&t_menuitem, 0, sizeof(MCMenuItem));
t_menuitem.is_unicode = p_is_unicode;
t_menuitem.menumode = p_menumode;
char *t_string;
uint4 t_strlen;
if (p_is_unicode)
{
ep.setsvalue(t_lines[i]);
ep.utf16toutf8();
t_string = ep.getsvalue().clone();
t_strlen = ep.getsvalue().getlength();
}
else
{
t_string = t_lines[i].clone();
t_strlen = t_lines[i].getlength();
}
ParseMenuItemString(t_string, t_strlen, &t_menuitem);
if (p_is_unicode)
{
ep.setsvalue(t_menuitem.label);
ep.utf8toutf16();
t_menuitem.label.set(ep.getsvalue().clone(), ep.getsvalue().getlength());
}
p_callback->ProcessItem(&t_menuitem);
delete t_string;
if (t_menuitem.tag != NULL)
{
delete t_menuitem.tag.getstring();
t_hastags = true;
}
if (p_is_unicode)
delete t_menuitem.label.getstring();
}
p_callback->End(t_hastags);
delete t_lines;
return false;
}
bool MCNativeControl::ParseBoolean(MCExecPoint& ep, bool& r_value)
{
Boolean t_bool;
if (!MCU_stob(ep.getsvalue(), t_bool))
{
MCeerror->add(EE_OBJECT_NAB, 0, 0, ep.getsvalue());
return false;
}
r_value = t_bool == True;
return true;
}
void MCSystemListFontFamilies(MCExecPoint& ep)
{
ep . clear();
for (uint32_t i = 0; s_droid_fonts[i].name != nil; i++)
ep.concatcstring(s_droid_fonts[i].name, EC_RETURN, ep.getsvalue().getlength() == 0);
char *t_custom_font_names;
t_custom_font_names = nil;
MCAndroidCustomFontsList(t_custom_font_names);
if (t_custom_font_names != nil)
ep.concatcstring(t_custom_font_names, EC_RETURN, ep.getsvalue().getlength() == 0);
/*UNCHECKED */ MCCStringFree(t_custom_font_names);
}
Exec_stat MCSHA1Digest::eval(MCExecPoint &ep)
{
if (source->eval(ep) != ES_NORMAL)
{
MCeerror->add(EE_SHA1DIGEST_BADSOURCE, line, pos);
return ES_ERROR;
}
sha1_state_t state;
uint8_t digest[20];
sha1_init(&state);
sha1_append(&state, ep.getsvalue().getstring(), ep.getsvalue().getlength());
sha1_finish(&state, digest);
ep.copysvalue((char *)digest, 20);
return ES_NORMAL;
}
Exec_stat MCMD5Digest::eval(MCExecPoint &ep)
{
if (source->eval(ep) != ES_NORMAL)
{
MCeerror->add(EE_MD5DIGEST_BADSOURCE, line, pos);
return ES_ERROR;
}
md5_state_t state;
md5_byte_t digest[16];
md5_init(&state);
md5_append(&state, (const md5_byte_t *)ep.getsvalue().getstring(), ep.getsvalue().getlength());
md5_finish(&state, digest);
ep.copysvalue((char *)digest, 16);
return ES_NORMAL;
}
float android_font_measure_text(void *p_font, const char *p_text, uint32_t p_text_length, bool p_is_unicode)
{
MCAndroidFont *t_font = (MCAndroidFont*)p_font;
SkPaint t_paint;
t_paint.setTypeface(t_font->sk_typeface);
t_paint.setTextSize(t_font->size);
if (p_is_unicode)
{
t_paint.setTextEncoding(SkPaint::kUTF16_TextEncoding);
return t_paint.measureText(p_text, p_text_length);
}
else
{
MCExecPoint ep;
ep.setsvalue(MCString(p_text, p_text_length));
ep.nativetoutf8();
const MCString &t_utf_string = ep.getsvalue();
t_paint.setTextEncoding(SkPaint::kUTF8_TextEncoding);
return t_paint.measureText(t_utf_string.getstring(), t_utf_string.getlength());
}
}
Exec_stat MCColors::setprop_legacy(uint4 parid, Properties p, MCExecPoint &ep, Boolean effective)
{
Boolean dirty = True;
MCString data = ep.getsvalue();
switch (p)
{
#ifdef /* MCColors::setprop */ LEGACY_EXEC
case P_SELECTED_COLOR:
{
MCColor color;
char *colorname = NULL;
if (!MCscreen->parsecolor(data, &color, &colorname))
{
MCeerror->add
(EE_COLOR_BADSELECTEDCOLOR, 0, 0, data);
return ES_ERROR;
}
if (colorname != NULL)
delete colorname;
MCscreen->alloccolor(color);
selectedcolor = color.pixel;
}
break;
#endif /* MCColors::setprop */
default:
return MCControl::setprop_legacy(parid, p, ep, effective);
}
if (dirty && opened)
{
// MW-2011-08-18: [[ Layers ]] Invalidate the whole object.
layer_redrawall();
}
return ES_NORMAL;
}
bool MCServerGetSessionIdFromCookie(char *&r_id)
{
MCVariable *t_cookie_array;
t_cookie_array = MCVariable::lookupglobal_cstring("$_COOKIE");
if (t_cookie_array == NULL)
{
r_id = NULL;
return true;
}
// ensure cookie array is evaluated
if (t_cookie_array->isdeferred() && ES_NORMAL != ((MCDeferredVariable*)t_cookie_array)->compute())
return false;
MCExecPoint ep;
if (ES_NORMAL != t_cookie_array->fetch_element(ep, MCS_get_session_name()))
return false;
// retrieve ID from cookie value
if (ep.isempty())
r_id = NULL;
else
r_id = ep.getsvalue().clone();
return true;
}
Exec_stat MCMarking::exec(MCExecPoint &ep)
{
if (card != NULL)
{
MCObject *optr;
uint4 parid;
if (card->getobj(ep, optr, parid, True) != ES_NORMAL
|| optr->gettype() != CT_CARD)
{
MCeerror->add
(EE_MARK_BADCARD, line, pos);
return ES_ERROR;
}
ep.setboolean(mark);
return optr->setprop(0, P_MARKED, ep, False);
}
if (tofind == NULL)
MCdefaultstackptr->mark(ep, where, mark);
else
{
if (tofind->eval(ep) != ES_NORMAL)
{
MCeerror->add
(EE_MARK_BADSTRING, line, pos);
return ES_ERROR;
}
MCdefaultstackptr->markfind(ep, mode, ep.getsvalue(), field, mark);
}
return ES_NORMAL;
}
Exec_stat MCFind::exec(MCExecPoint &ep)
{
if (tofind->eval(ep) != ES_NORMAL)
{
MCeerror->add
(EE_FIND_BADSTRING, line, pos);
return ES_ERROR;
}
if (ep.getsvalue().getlength() == 0)
{
if (MCfoundfield != NULL)
MCfoundfield->clearfound();
MCresult->sets(MCnotfoundstring);
return ES_NORMAL;
}
MCdefaultstackptr->find(ep, mode, ep.getsvalue(), field);
return ES_NORMAL;
}
bool MCNativeControl::ParseRange(MCExecPoint &ep, uint32_t &r_start, uint32_t &r_length)
{
const char *sptr = ep.getsvalue().getstring();
uint4 l = ep.getsvalue().getlength();
uint32_t d1, d2;
Boolean done;
d1 = MCU_strtol(sptr, l, ',', done, True, False);
if (!done || l == 0)
return false;
d2 = MCU_strtol(sptr, l, '\0', done, True, False);
if (!done || l != 0)
return false;
r_start = d1;
r_length = d2;
return true;
}
bool MCNativeControl::ParseReal(MCExecPoint& ep, double& r_value)
{
if (!MCU_stor8(ep . getsvalue(), r_value))
{
MCeerror->add(EE_OBJECT_NAN, 0, 0, ep.getsvalue());
return false;
}
return true;
}
Exec_stat MCThrowKeyword::exec(MCExecPoint &ep)
{
if (error->eval(ep) != ES_NORMAL)
MCeerror->add
(EE_THROW_BADERROR, line, pos);
else
MCeerror->copysvalue(ep.getsvalue(), True);
return ES_ERROR;
}
bool MCNativeControl::ParseUnsignedInteger(MCExecPoint& ep, uint32_t& r_value)
{
if (!MCU_stoui4(ep . getsvalue(), r_value))
{
MCeerror->add(EE_OBJECT_NAN, 0, 0, ep.getsvalue());
return false;
}
return true;
}
bool MCNativeControl::ParseEnum(MCExecPoint& ep, MCNativeControlEnumEntry *p_entries, int32_t& r_value)
{
for(uint32_t i = 0; p_entries[i] . key != nil; i++)
if (MCCStringEqualCaseless(p_entries[i] . key, ep . getcstring()))
{
r_value = p_entries[i] . value;
return true;
}
MCeerror->add(EE_OBJECT_BADSTYLE, 0, 0, ep.getsvalue());
return false;
}
bool MCNativeControl::ParseRectangle32(MCExecPoint& ep, MCRectangle32& r_rect)
{
int32_t t_left, t_top, t_right, t_bottom;
if (!MCU_stoi4x4(ep . getsvalue(), t_left, t_top, t_right, t_bottom))
{
MCeerror->add(EE_OBJECT_NAR, 0, 0, ep.getsvalue());
return false;
}
MCU_set_rect(r_rect, t_left, t_top, t_right - t_left, t_bottom - t_top);
return true;
}
static char *getfield(MCField *fptr, int *retval)
{
if (fptr == NULL)
{
*retval = xresFail;
return NULL;
}
*retval = xresSucc;
// MW-2012-02-21: [[ FieldExport ]] Use the new text export method.
MCExecPoint ep;
fptr->exportastext(0, ep, 0, INT32_MAX, false);
return ep.getsvalue().clone();
}
// MW-2005-05-15: Updated for new answer command restructuring
int MCA_color(MCExecPoint &ep, const char *p_title, const char *p_initial, Boolean sheet)
{
ep . setsvalue(p_initial);
MCColor oldcolor;
if (ep.getsvalue().getlength() == 0)
{
oldcolor.red = MCpencolor.red;
oldcolor.green = MCpencolor.green;
oldcolor.blue = MCpencolor.blue;
}
else
{
char *cname = NULL;
MCscreen->parsecolor(ep.getsvalue(), &oldcolor, &cname);
delete cname;
}
if (!MCModeMakeLocalWindows())
{
MCRemoteColorDialog(ep, p_title, oldcolor.red >> 8, oldcolor.green >> 8, oldcolor.blue >> 8);
return 0;
}
Exec_stat MCDoMenu::exec(MCExecPoint &ep)
{
if (source->eval(ep) != ES_NORMAL)
{
MCeerror->add
(EE_DOMENU_BADEXP, line, pos);
return ES_ERROR;
}
const char *dstring = lookup(ep.getsvalue());
if (dstring == NULL)
{
char *tptr = ep.getsvalue().clone();
ep.setstringf("doMenu \"%s\" not implemented", tptr);
delete tptr;
MCresult->sets(ep.getsvalue());
}
else
{
ep.getobj()->domess(dstring);
}
return ES_NORMAL;
}
Exec_stat MCVideoClip::setprop(uint4 parid, Properties p, MCExecPoint &ep, Boolean effective)
{
MCString data = ep.getsvalue();
Boolean dirty = False;
switch (p)
{
case P_DONT_REFRESH:
if (!MCU_matchflags(data, flags, F_DONT_REFRESH, dirty))
{
MCeerror->add
(EE_OBJECT_NAB, 0, 0, data);
return ES_ERROR;
}
return ES_NORMAL;
case P_FRAME_RATE:
if (data.getlength() == 0)
flags &= ~F_FRAME_RATE;
else
{
if (!MCU_stoui2(data, framerate))
{
MCeerror->add
(EE_OBJECT_NAN, 0, 0, data);
return ES_ERROR;
}
flags |= F_FRAME_RATE;
}
return ES_NORMAL;
case P_SCALE:
if (!MCU_stor8(data, scale))
{
MCeerror->add
(EE_OBJECT_NAN, 0, 0, data);
return ES_ERROR;
}
flags |= F_SCALE_FACTOR;
return ES_NORMAL;
case P_TEXT:
delete frames;
size = data.getlength();
frames = new uint1[size];
memcpy(frames, data.getstring(), size);
return ES_NORMAL;
default:
break;
}
return MCObject::setprop(parid, p, ep, effective);
}
static char *get_global(const char *arg1, const char *arg2,
const char *arg3, int *retval)
{
MCVariable *tmp;
tmp = MCVariable::lookupglobal_cstring(arg1);
if (tmp != nil)
{
*retval = xresSucc;
MCExecPoint ep;
tmp->fetch(ep);
return ep.getsvalue().clone();
}
*retval = xresFail;
return NULL;
}
Exec_stat MCGet::exec(MCExecPoint &ep)
{
if (value->eval(ep) != ES_NORMAL)
{
MCeerror->add
(EE_GET_BADEXP, line, pos);
return ES_ERROR;
}
if (it->set
(ep) != ES_NORMAL)
{
MCeerror->add
(EE_GET_CANTSET, line, pos, ep.getsvalue());
return ES_ERROR;
}
return ES_NORMAL;
}
static bool cgi_send_cookies(void)
{
bool t_success = true;
char *t_cookie_header = NULL;
MCExecPoint ep;
for (uint32_t i = 0; t_success && i < MCservercgicookiecount; i++)
{
t_success = MCCStringFormat(t_cookie_header, "Set-Cookie: %s=%s", MCservercgicookies[i].name, MCservercgicookies[i].value);
if (t_success && MCservercgicookies[i].expires != 0)
{
ep.setuint(MCservercgicookies[i].expires);
t_success = MCD_convert(ep, CF_SECONDS, CF_UNDEFINED, CF_INTERNET_DATE, CF_UNDEFINED);
if (t_success)
{
MCString t_date;
t_date = ep.getsvalue();
t_success = MCCStringAppendFormat(t_cookie_header, "; Expires=%.*s", t_date.getlength(), t_date.getstring());
}
}
if (t_success && MCservercgicookies[i].path != NULL)
t_success = MCCStringAppendFormat(t_cookie_header, "; Path=%s", MCservercgicookies[i].path);
if (t_success && MCservercgicookies[i].domain != NULL)
t_success = MCCStringAppendFormat(t_cookie_header, "; Domain=%s", MCservercgicookies[i].domain);
if (t_success && MCservercgicookies[i].secure)
t_success = MCCStringAppend(t_cookie_header, "; Secure");
if (t_success && MCservercgicookies[i].http_only)
t_success = MCCStringAppend(t_cookie_header, "; HttpOnly");
if (t_success)
t_success = MCCStringAppend(t_cookie_header, "\n");
if (t_success)
t_success = IO_NORMAL == MCS_write(t_cookie_header, 1, MCCStringLength(t_cookie_header), IO_stdout);
MCCStringFree(t_cookie_header);
t_cookie_header = NULL;
}
return t_success;
}
Exec_stat MCSet::exec(MCExecPoint &ep)
{
if (value->eval(ep) != ES_NORMAL)
{
MCeerror->add
(EE_SET_BADEXP, line, pos);
return ES_ERROR;
}
ep.grabsvalue();
MCresult->clear(False);
if (target->set
(ep) != ES_NORMAL)
{
MCeerror->add
(EE_SET_BADSET, line, pos, ep.getsvalue());
return ES_ERROR;
}
return ES_NORMAL;
}
static void MCFontDrawTextCallback(MCFontRef p_font, const char *p_text, uint32_t p_length, bool p_is_unicode, font_draw_text_context *ctxt)
{
MCGFont t_font;
t_font = MCFontStructToMCGFont(p_font->fontstruct);
// MW-2013-12-04: [[ Bug 11535 ]] Pass through the fixed advance.
t_font . fixed_advance = p_font -> fixed_advance;
// MW-2013-12-04: [[ Bug 11549 ]] Make sure unicode text is short-aligned.
MCExecPoint ep;
ep . setsvalue(MCString(p_text, p_length));
if (!p_is_unicode)
ep . nativetoutf16();
else if ((((uintptr_t)ep . getsvalue() . getstring()) & 1) != 0)
ep . grabsvalue();
MCGContextDrawPlatformText(ctxt->m_gcontext, (unichar_t *) ep . getsvalue() . getstring(), ep . getsvalue() . getlength(), MCGPointMake(ctxt->x, ctxt->y), t_font);
// The draw position needs to be advanced. Can this be done more efficiently?
ctxt -> x += MCGContextMeasurePlatformText(NULL, (unichar_t*)ep.getsvalue().getstring(), ep.getsvalue().getlength(), t_font);
}
IO_stat MCS_runcmd(MCExecPoint& ep)
{
void *t_data;
uint32_t t_data_length;
int t_return_code;
if (!MCsystem -> Shell(ep . getsvalue() . getstring(), ep . getsvalue() . getlength(), t_data, t_data_length, t_return_code))
{
MCresult -> clear(False);
MCeerror -> add(EE_SHELL_BADCOMMAND, 0, 0, ep.getsvalue());
return IO_ERROR;
}
ep . grabbuffer((char *)t_data, t_data_length);
// MW-2013-08-07: [[ Bug 11089 ]] The MCSystem::Shell() call returns binary data,
// so since uses of MCS_runcmd() expect text, we need to do EOL conversion.
ep . texttobinary();
MCresult -> setnvalue(t_return_code);
return IO_NORMAL;
}
Exec_stat MCConvert::exec(MCExecPoint &ep)
{
MCresult->clear(False);
if (container != NULL)
{
if (container->eval(ep) != ES_NORMAL)
{
MCeerror->add
(EE_CONVERT_CANTGET, line, pos);
return ES_ERROR;
}
}
else
if (source->eval(ep) != ES_NORMAL)
{
MCeerror->add
(EE_CONVERT_CANTGET, line, pos);
return ES_ERROR;
}
if (!MCD_convert(ep, fform, fsform, pform, sform))
{
MCresult->sets("invalid date");
return ES_NORMAL;
}
Exec_stat stat;
if (it != NULL)
stat = it->set
(ep);
else
stat = container->set
(ep, PT_INTO);
if (stat != ES_NORMAL)
{
MCeerror->add
(EE_CONVERT_CANTSET, line, pos, ep.getsvalue());
return ES_ERROR;
}
return ES_NORMAL;
}
// MW-2005-05-15: Updated for new answer command restructuring
int MCA_folder(MCExecPoint &ep, const char *p_title, const char *p_prompt, const char *p_initial, unsigned int p_options)
{
if (MCmajorosversion >= 0x0600 && MCModeMakeLocalWindows())
return MCA_file(ep, p_title, p_prompt, nil, p_initial, p_options | MCA_OPTION_FOLDER_DIALOG);
// MW-2005-05-27: We'll use a static (I know bad me) to store the version
// of the shell dll.
static int s_shell_version = -1;
static char *s_last_folder = NULL;
char *t_native_filename;
unsigned int t_native_filename_length;
if (p_initial != NULL)
{
t_native_filename_length = strlen(p_initial);
t_native_filename = (char *)_alloca(t_native_filename_length + 2);
strcpy(t_native_filename, p_initial);
MCU_path2native(t_native_filename);
}
else
{
t_native_filename = s_last_folder;
t_native_filename_length = 0;
}
if (!MCModeMakeLocalWindows())
{
MCRemoteFolderDialog(ep, p_title, p_prompt, t_native_filename);
if (!ep.isempty())
{
if (s_last_folder != NULL)
delete s_last_folder;
s_last_folder = ep.getsvalue().clone();
MCU_path2native(s_last_folder);
}
return 0;
}
if (s_shell_version == -1)
s_shell_version = get_dll_version("shell32.dll");
bool sheet = (p_options & MCA_OPTION_SHEET) != 0;
char *prompt = (char *)p_prompt;
ep . clear();
BROWSEINFOA bi;
memset(&bi, 0, sizeof(BROWSEINFO));
Window pw;
pw = MCModeGetParentWindow();
if (pw != DNULL)
bi.hwndOwner = (HWND)pw->handle.window;
bi.pidlRoot = NULL;
bi.lpszTitle = prompt;
bi.ulFlags = BIF_RETURNONLYFSDIRS;
if (s_shell_version >= 500)
bi.ulFlags |= BIF_NEWDIALOGSTYLE;
if (t_native_filename != NULL)
{
bi . lpfn = BrowseCallbackProc;
bi . lParam = (LPARAM)t_native_filename;
}
else
{
bi.lpfn = NULL;
bi.lParam = NULL;
}
LPITEMIDLIST lpiil;
LPMALLOC lpm;
char *tdir = NULL;
SHGetMalloc(&lpm);
DWORD t_error;
lpiil = SHBrowseForFolderA(&bi);
if (lpiil == NULL)
{
t_error = GetLastError();
}
if (lpiil != NULL && SHGetPathFromIDListA(lpiil, ep.getbuffer(PATH_MAX)))
{
if (s_last_folder != NULL)
delete s_last_folder;
s_last_folder = strclone(ep . getbuffer(0));
MCU_path2std(ep.getbuffer(0));
ep.setstrlen();
}
else
{
ep.clear();
MCresult->sets(MCcancelstring);
}
// SMR 1880 clear shift and button state
waitonbutton();
lpm->Free(lpiil);
lpm->Release();
return 0;
}
