void MCScrollbar::SetEndValue(MCExecContext& ctxt, MCStringRef p_value)
{
// MW-2013-08-27: [[ UnicodifyScrollbar ]] Update to use MCStringRef startstring.
if (MCStringIsEmpty(p_value))
{
reset();
return;
}
if (!MCU_stor8(p_value, endvalue))
{
ctxt . LegacyThrow(EE_OBJECT_NAN);
return;
}
if (startvalue == 0.0 && endvalue == 65535.0)
reset();
else
{
flags |= F_HAS_VALUES;
MCValueAssign(endstring, p_value);
}
update(thumbpos, MCM_scrollbar_drag);
Redraw();
}
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;
}
void MCScrollbar::GetThumbPos(MCExecContext& ctxt, double& r_pos)
{
// AL-2014-07-22: [[ Bug 12843 ]] Round thumbpos according to scrollbar number format
MCAutoStringRef t_formatted_thumbpos;
if (MCU_r8tos(thumbpos, nffw, nftrailing, nfforce, &t_formatted_thumbpos) &&
MCU_stor8(*t_formatted_thumbpos, r_pos))
return;
ctxt . Throw();
}
Exec_stat MCExecPoint::ston()
{
if (svalue.getlength() == 0)
nvalue = 0.0;
else
if (!MCU_stor8(svalue, nvalue, convertoctals))
return ES_ERROR;
format = VF_BOTH;
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);
}
bool MCVariableValue::get_as_real(MCExecPoint& ep, real64_t& r_value)
{
if (is_number())
{
r_value = strnum . nvalue;
return true;
}
if (is_empty())
{
r_value = 0.0;
return true;
}
if (is_string())
return MCU_stor8(MCString(strnum . svalue . string, strnum . svalue . length), r_value, ep . getconvertoctals()) == True;
assert(is_array());
r_value = 0.0;
return true;
}
bool MCVariableValue::coerce_to_real(MCExecPoint& ep)
{
assert(!is_real());
if (is_empty())
{
assign_real(0.0);
return true;
}
if (is_string())
{
if (MCU_stor8(MCString(strnum . svalue . string, strnum . svalue . length), strnum . nvalue, ep . getconvertoctals()) != True)
return false;
set_type(VF_BOTH);
return true;
}
assert(is_array());
assign_real(0.0);
return true;
}
void MCSort::additem(MCExecPoint &ep, MCSortnode *&items, uint4 &nitems, Sort_type form, MCString &s, MCExpression *by)
{
if (by != NULL)
{
MCerrorlock++;
ep.setsvalue(s);
MCeach->store(ep, False);
if (by->eval(ep) == ES_NORMAL)
s = ep.getsvalue();
else
s = MCnullmcstring;
MCerrorlock--;
}
switch (form)
{
case ST_DATETIME:
ep.setsvalue(s);
if (MCD_convert(ep, CF_UNDEFINED, CF_UNDEFINED, CF_SECONDS, CF_UNDEFINED))
{
if (!MCU_stor8(ep.getsvalue(), items[nitems].nvalue))
items[nitems].nvalue = -MAXREAL8;
}
else
items[nitems].nvalue = -MAXREAL8;
break;
case ST_NUMERIC:
{
const char *sptr = s.getstring();
uint4 length = s.getlength();
// MW-2013-03-21: [[ Bug ]] Make sure we skip any whitespace before the
// number starts - making it consistent with string->number conversions
// elsewhere.
MCU_skip_spaces(sptr, length);
// REVIEW - at the moment the numeric prefix of the string is used to
// derive the sort key e.g. 1000abc would get processed as 1000.
while (length && (isdigit((uint1)*sptr) ||
*sptr == '.' || *sptr == '-' || *sptr == '+'))
{
sptr++;
length--;
}
s.setlength(s.getlength() - length);
if (!MCU_stor8(s, items[nitems].nvalue))
items[nitems].nvalue = -MAXREAL8;
}
break;
default:
if (ep.getcasesensitive() && by == NULL)
items[nitems].svalue = (char *)s.getstring();
else
if (ep.getcasesensitive())
items[nitems].svalue = s.clone();
else
{
#if defined(_MAC_DESKTOP) || defined(_IOS_MOBILE)
if (form == ST_INTERNATIONAL)
{
extern char *MCSystemLowercaseInternational(const MCString& s);
items[nitems].svalue = MCSystemLowercaseInternational(s);
}
else
#endif
{
items[nitems].svalue = new char[s.getlength() + 1];
MCU_lower(items[nitems].svalue, s);
items[nitems].svalue[s.getlength()] = '\0';
}
}
break;
}
nitems++;
}
Exec_stat MCEPS::setprop_legacy(uint4 parid, Properties p, MCExecPoint &ep, Boolean effective)
{
Boolean dirty = True;
real8 n;
int2 i;
int2 i1, i2, i3, i4;
MCString data = ep.getsvalue();
switch (p)
{
#ifdef /* MCEPS::setprop */ LEGACY_EXEC
case P_TRAVERSAL_ON:
case P_SHOW_BORDER:
if (MCControl::setprop(parid, p, ep, effective) != ES_NORMAL)
return ES_ERROR;
resetscale();
break;
case P_ANGLE:
if (!MCU_stoi2(data, i))
{
MCeerror->add
(EE_OBJECT_NAN, 0, 0, data);
return ES_ERROR;
}
angle = i;
break;
case P_POSTSCRIPT:
delete postscript;
postscript = data.clone();
size = data.getlength() + 1;
setextents();
resetscale();
break;
case P_PROLOG:
delete prolog;
prolog = data.clone();
break;
case P_RETAIN_IMAGE:
if (!MCU_matchflags(data, flags, F_RETAIN_IMAGE, dirty))
{
MCeerror->add
(EE_OBJECT_NAB, 0, 0, data);
return ES_ERROR;
}
dirty = False;
break;
case P_RETAIN_POSTSCRIPT:
if (!MCU_matchflags(data, flags, F_RETAIN_POSTSCRIPT, dirty))
{
MCeerror->add
(EE_OBJECT_NAB, 0, 0, data);
return ES_ERROR;
}
dirty = False;
break;
case P_SCALE_INDEPENDENTLY:
if (!MCU_matchflags(data, flags, F_SCALE_INDEPENDENTLY, dirty))
{
MCeerror->add
(EE_OBJECT_NAB, 0, 0, data);
return ES_ERROR;
}
if (dirty)
resetscale();
break;
case P_BOUNDING_RECT:
if (!MCU_stoi2x4(data, i1, i2, i3, i4))
{
MCeerror->add
(EE_OBJECT_NAR, 0, 0, data);
return ES_ERROR;
}
if (tx != i1 || ty != i2 || tx + ex != i3 || ty + ey != i4)
{
tx = i1;
ty = i2;
ex = MCU_max(i3 - i1, 1);
ey = MCU_max(i4 - i2, 1);
resetscale();
}
else
dirty = False;
break;
case P_SCALE:
if (!MCU_stor8(data, n))
{
MCeerror->add
(EE_OBJECT_NAN, 0, 0, data);
return ES_ERROR;
}
xscale = yscale = n;
break;
case P_X_SCALE:
if (!MCU_stor8(data, n))
{
MCeerror->add
(EE_OBJECT_NAN, 0, 0, data);
return ES_ERROR;
}
xscale = n;
ex = (uint2)(rect.width * xf / xscale + 0.5);
flags |= F_SCALE_INDEPENDENTLY;
break;
case P_Y_SCALE:
if (!MCU_stor8(data, n))
{
MCeerror->add
(EE_OBJECT_NAN, 0, 0, data);
return ES_ERROR;
}
yscale = n;
ey = (uint2)(rect.height * yf / yscale + 0.5);
flags |= F_SCALE_INDEPENDENTLY;
break;
case P_X_OFFSET:
if (!MCU_stoi2(data, i))
{
MCeerror->add
(EE_OBJECT_NAN, 0, 0, data);
return ES_ERROR;
}
tx = i;
break;
case P_Y_OFFSET:
if (!MCU_stoi2(data, i))
{
MCeerror->add
(EE_OBJECT_NAN, 0, 0, data);
return ES_ERROR;
}
ty = i;
break;
case P_X_EXTENT:
if (!MCU_stoi2(data, i))
{
MCeerror->add
(EE_OBJECT_NAN, 0, 0, data);
return ES_ERROR;
}
ex = i;
resetscale();
break;
case P_Y_EXTENT:
if (!MCU_stoi2(data, i))
{
MCeerror->add
(EE_OBJECT_NAN, 0, 0, data);
return ES_ERROR;
}
ey = i;
resetscale();
break;
case P_CURRENT_PAGE: //set eps current page to display
if (!MCU_stoi2(data, i))
{
MCeerror->add
(EE_OBJECT_NAN, 0, 0, data);
return ES_ERROR;
}
if ((uint2)i > pagecount)
curpage = pagecount;
else
curpage = i;
break;
#endif /* MCEPS::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;
}
Exec_stat MCFunction::evalparams(Functions func, MCParameter *params,
MCExecPoint &ep)
{
uint4 nparams = 0;
real8 n, tn, oldn;
n = oldn = 0.0;
MCSortnode *mditems = NULL;
// JS-2013-06-19: [[ StatsFunctions ]] Support for new stats functions based on arithmeticMean
if (func == F_AVG_DEV || func == F_POP_STD_DEV || func == F_POP_VARIANCE || func == F_SMP_STD_DEV || func == F_SMP_VARIANCE)
{ //use recursion to get average first
if (evalparams(F_ARI_MEAN, params, ep) != ES_NORMAL)
return ES_ERROR;
oldn = ep.getnvalue();
}
// JS-2013-06-19: [[ StatsFunctions ]] Support for geometricMean
if (func == F_GEO_MEAN)
{ //use recursion to count items first
if (evalparams(F_UNDEFINED, params, ep) != ES_NORMAL)
return ES_ERROR;
oldn = ep.getnvalue();
}
if (func == F_MEDIAN)
{ //use recursion to count items first
if (evalparams(F_UNDEFINED, params, ep) != ES_NORMAL)
return ES_ERROR;
mditems = new MCSortnode[(uint4)ep.getnvalue()];
}
if (params != NULL && params->getnext() == NULL)
{
if (params->eval(ep) != ES_NORMAL)
{
MCeerror->add(EE_FUNCTION_BADSOURCE, line, pos);
return ES_ERROR;
}
if (ep.getformat() == VF_ARRAY)
{
if (ep.getarray() -> is_array() && ep.getarray()->get_array()->dofunc(ep, func, nparams, n, oldn, mditems) != ES_NORMAL)
{
MCeerror->add(EE_FUNCTION_BADSOURCE, line, pos);
return ES_ERROR;
}
}
else
{
MCString s(ep.getsvalue());
uint4 length = s.getlength();
const char *sptr = s.getstring();
MCU_skip_spaces(sptr, length);
while (length != 0)
{
s.setstring(sptr);
if (!MCU_strchr(sptr, length, ','))
{
s.setlength(length);
length = 0;
}
else
{
s.setlength(sptr - s.getstring());
MCU_skip_char(sptr, length);
MCU_skip_spaces(sptr, length);
}
if (s.getlength() == 0)
tn = 0.0;
else
if (!MCU_stor8(s, tn))
{
MCeerror->add
(EE_FUNCTION_NAN, 0, 0, s);
return ES_ERROR;
}
MCU_dofunc(func, nparams, n, tn, oldn, mditems);
}
}
}
else
{
MCParameter *tparam = params;
while (tparam != NULL)
{
if (tparam->eval(ep) != ES_NORMAL || ep.ton() != ES_NORMAL)
{
MCeerror->add(EE_FUNCTION_BADSOURCE, line, pos);
return ES_ERROR;
}
MCU_dofunc(func, nparams, n, ep.getnvalue(), oldn, mditems);
tparam = tparam->getnext();
}
}
if (nparams != 0)
switch (func)
{
// JS-2013-06-19: [[ StatsFunctions ]] Support for arithmeticMean (was average)
case F_ARI_MEAN:
n /= nparams;
break;
// JS-2013-06-19: [[ StatsFunctions ]] Support for averageDeviation
case F_AVG_DEV:
n /= nparams;
break;
// JS-2013-06-19: [[ StatsFunctions ]] Support for harmonicMean
case F_HAR_MEAN:
n = nparams/n;
break;
case F_MEDIAN:
{
uint4 toffset;
MCU_sort(mditems, nparams, ST_ASCENDING, ST_NUMERIC);
toffset = (nparams + 1)/2 - 1;
if ((nparams % 2) != 0) //odd
n = mditems[toffset].nvalue;
else //even average 2 closest values
n = (mditems[toffset].nvalue + mditems[toffset+1].nvalue)/2;
break;
}
// JS-2013-06-19: [[ StatsFunctions ]] Support for populationStandardDeviation
case F_POP_STD_DEV:
n = sqrt(n/nparams);
break;
// JS-2013-06-19: [[ StatsFunctions ]] Support for populationVariance
case F_POP_VARIANCE:
n /= nparams;
break;
// JS-2013-06-19: [[ StatsFunctions ]] Support for sampleStandardDeviation (was stdDev)
case F_SMP_STD_DEV:
n = sqrt(n/(nparams - 1));
break;
// JS-2013-06-19: [[ StatsFunctions ]] Support for sampleVariance
case F_SMP_VARIANCE:
n /= nparams - 1;
break;
case F_UNDEFINED:
n = nparams;
break;
default:
break;
}
ep.setnvalue(n);
delete mditems;
return ES_NORMAL;
}
