void PFOperatorMaterialStaticDADMgr::Drop(ReferenceTarget *dropThis, HWND hwnd, POINT p, SClass_ID type)
{
Mtl *mtl = (Mtl *)dropThis;
if (op() && mtl) {
theHold.Begin();
_op()->SetMaterial(mtl);
theHold.Accept(GetString(IDS_PARAMETERCHANGE));
}
}
double Expression::execute() {
std::function<double(double, double)> _op;
//https://stackoverflow.com/a/10424311
switch (cOperator) {
case '+': _op = std::plus<float>(); break;
case '-': _op = std::minus<float>(); break;
case '*': _op = std::multiplies<float>(); break;
case '/': _op = std::divides<float>(); break;
default:
Output::error("Unsupported operator: %c\n", cOperator);
return 0;
}
return _op(a, b);
}
static cps_api_return_code_t _write_function(void * context, cps_api_transaction_params_t * param,size_t ix) {
cps_api_object_t obj = cps_api_object_list_get(param->change_list,ix);
if (obj==NULL) return cps_api_ret_code_ERR;
cps_api_operation_types_t op = cps_api_object_type_operation(cps_api_object_key(obj));
cps_api_object_t prev = cps_api_object_create();
if (prev==NULL) return cps_api_ret_code_ERR;
if (!cps_api_object_list_append(param->prev,prev)) {
cps_api_object_delete(prev);
return cps_api_ret_code_ERR;
}
cps_api_key_t _local_key;
cps_api_key_init(&_local_key,cps_api_qualifier_TARGET,cps_api_obj_cat_ROUTE,cps_api_route_obj_EVENT,0);
if (cps_api_key_matches(&_local_key,cps_api_object_key(obj),true)) {
os_send_refresh(nas_nl_sock_T_ROUTE);
} else {
return _op(op,context,obj,prev);
}
return cps_api_ret_code_OK;
}
ReferenceTarget *PFOperatorMaterialStaticDADMgr::GetInstance(HWND hwnd, POINT p, SClass_ID type)
{
if (op() == NULL) return NULL;
return _op()->GetMaterial();
}
bool operator()(const std::pair<T, U> &lhs,
const std::pair<T, U> &rhs) const
{ return _op(lhs.first, rhs.first); }
void operator()(const std::pair<T, U> &pr)
{ _mp[pr.first] = _op(pr.second); }
void operator()(const T &lhs, const T &rhs)
{ _container.insert(_op(lhs, rhs)); }
void operator()(const T &object)
{ _container.insert(_op(object)); }
R operator()(const T &lhs, const T &rhs)
{ return _op(lhs, rhs) ? _t : _f; }
R operator()(const T &o) { return _op(o) ? _t : _f; }
template <typename T1> GIL_FORCEINLINE result_type operator()(const T1& t1) { return _op(t1, _t2); }
void Signal(std::size_t n = 1)
{
assert(n < std::size_t(std::numeric_limits<short>::max()));
_op(short(+n));
}
void Wait(std::size_t n = 1)
{
assert(n < std::size_t(std::numeric_limits<short>::max()));
_op(short(-n));
}
