int
set_field_just(FIELD *f, int just)
{
if (just != NO_JUSTIFICATION && just != JUSTIFY_LEFT &&
just != JUSTIFY_CENTER &&just != JUSTIFY_RIGHT)
return (E_BAD_ARGUMENT);
f = Field(f);
if (Just(f) != just) {
Just(f) = just;
return (_sync_attrs(f));
}
return (E_OK);
}
AngelTargetProviderBaseT<ProviderT, ObjectT, TargetT, AntiT>::AngelTargetProviderBaseT(Handler<Heap> const& heap, std::string const& provname, Handler<Heaven> const& heaven)
:AngelTargetProvider(heap, provname, heaven)
{
this->registerReactiveNativeClosure("attatchServant", [this](AngelTargetObject* target, ServantObject* servant) {
AntiT anti;
AngelTargetSideEffect& side = anti;
side.op = AngelTargetSideEffect::DetatchServant;
side.detatchedServant = servant->servant();
target->angelTarget()->attatchServant(servant->servant());
return std::make_tuple(servant, Just(anti));
});
this->registerReactiveNativeClosure("detatchServant", [this](AngelTargetObject* target, ServantObject* servant) {
AntiT anti;
AngelTargetSideEffect& side = anti;
side.op = AngelTargetSideEffect::AttatchServant;
side.attatchedServant = servant->servant();
return std::make_tuple(servant, Just(anti));
});
}
AngelProviderBaseT<ProviderT, ObjectT, AngelT, AntiT>::AngelProviderBaseT(Handler<Heap> const& heap, std::string const& provname, Handler<Heaven> const& heaven)
:AngelProvider(heap, provname, heaven)
{
this->registerPureNativeClosure("newElementTarget", [this](ObjectT* obj, std::string elementId){
return obj->angel()->newElementTarget(elementId)->donutObject(this->heap().lock());
});
this->registerPureNativeClosure("newWidgetTarget", [this](ObjectT* obj, std::string elementId, std::string widgetGuide){
return obj->angel()->newWidgetTarget(elementId, widgetGuide)->donutObject(this->heap().lock());
});
this->registerPureNativeClosure("findElementTarget", [this](ObjectT* obj, std::string elementId){
return obj->angel()->findElementTarget(elementId)->donutObject(this->heap().lock());
});
this->registerPureNativeClosure("findElementById", [this](ObjectT* obj, std::string elementId){
return obj->angel()->findElementById(elementId);
});
this->registerPureNativeClosure("findWidgetTarget", [this](ObjectT* obj, std::string elementId, std::string widgetGuide){
return obj->angel()->findWidgetTarget(elementId, widgetGuide)->donutObject(this->heap().lock());
});
this->registerReactiveNativeClosure("attatchTarget", [this](ObjectT* dangel, AngelTargetObject* dtarget) {
Handler<AngelT> angel(dangel->angel());
Handler<AngelTarget> target(dtarget->angelTarget());
angel->attatchTarget(target);
AntiT side_;
AngelSideEffect& side = side_;
side.op = AngelSideEffect::DetatchTarget;
side.detatchedTarget_ = target;
return std::make_tuple(dtarget, Just(side_));
});
this->registerReactiveNativeClosure("detatchTarget", [this](ObjectT* dangel, AngelTargetObject* dtarget) {
Handler<AngelT> angel(dangel->angel());
Handler<AngelTarget> target(dtarget->angelTarget());
angel->detatchTarget(target);
AntiT side_;
AngelSideEffect& side = side_;
side.op = AngelSideEffect::AttatchTarget;
side.attatchedTarget_ = target;
return std::make_tuple(dtarget, Just(side_));
});
}
/**
* @brief Returns symbolic names for the given parameter from the given map.
*/
Maybe<IntStringMap> getSymbolicNamesForParamFromMap(const std::string &funcName,
unsigned paramPos, const FuncParamsMap &map) {
// Try to find the function.
auto funcIter = map.find(funcName);
if (funcIter == map.end()) {
return Nothing<IntStringMap>();
}
// Try to find the parameter by its position.
auto paramIter = funcIter->second.find(paramPos);
return paramIter != funcIter->second.end() ?
Just(paramIter->second) : Nothing<IntStringMap>();
}
ElementServantProvider::ElementServantProvider(const Handler<Heap>& heap, const Handler<Heaven>& heaven)
:Super(heap, "ElementServant", heaven)
{
this->registerPureNativeClosure("element", [this](ElementServantObject* servant){
return servant->servant()->element()->donutObject();
});
this->registerReactiveNativeClosure("enableAnimation", [this](ElementServantObject* servant_){
auto servant = servant_->servant();
bool enabled = servant->animEnabled();
servant->animEnabled(true);
AntiSideEffect anti;
anti.op = enabled ? AntiSideEffect::None : AntiSideEffect::DisableAnimation;
return std::tuple<bool,Maybe<AntiSideEffect> >(enabled, Just(anti));
});
this->registerReactiveNativeClosure("disableAnimation", [this](ElementServantObject* servant_){
auto servant = servant_->servant();
bool enabled = servant->animEnabled();
servant->animEnabled(false);
AntiSideEffect anti;
anti.op = !enabled ? AntiSideEffect::None : AntiSideEffect::EnableAnimation;
return std::tuple<bool,Maybe<AntiSideEffect> >(enabled, Just(anti));
});
}
inline typename AngelObjectBaseT<ProviderT, ObjectT, AngelT, AntiT>::ResultType AngelObjectBaseT<ProviderT, ObjectT, AngelT, AntiT>::execAntiSideEffect(const Handler<Heap>& heap, const AntiSideEffect& val)
{
AntiT newAnti;
AngelSideEffect& side = newAnti;
AngelSideEffect const& old = val;
switch(old.op){
case AngelSideEffect::AttatchTarget:
this->angel()->attatchTarget(old.attatchedTarget_);
side.op = AngelSideEffect::DetatchTarget;
side.detatchedTarget_ = old.attatchedTarget_;
break;
case AngelSideEffect::DetatchTarget:
this->angel()->detatchTarget(old.detatchedTarget_);
side.op = AngelSideEffect::AttatchTarget;
side.attatchedTarget_ = old.detatchedTarget_;
break;
}
return Just(newAnti);
}
inline typename ServantObjectBaseT<ProviderT, ObjectT, AngelT, AntiT>::ResultType ServantObjectBaseT<ProviderT, ObjectT, AngelT, AntiT>::execAntiSideEffect(const Handler<Heap>& heap, const AntiSideEffect& val)
{
AntiT newAnti;
return Just(newAnti);
}
int
field_just(FIELD *f)
{
return (Just(Field(f)));
}
std::tuple<Handler<ElementObject>, Maybe<WorldSideEffect> > WorldObject::popElement()
{
Handler<World> const world = this->world();
WorldSideEffect anti;
anti.op = AntiSideEffect::PushElement;
anti.elm = world->rootElement();
world->popElement();
return std::tuple<Handler<ElementObject>, Maybe<WorldSideEffect> >(anti.elm->donutObject(), Just(anti));
}
std::tuple<Handler<ElementObject>, Maybe<WorldSideEffect> > WorldObject::pushElement(std::string const& elementId)
{
Handler<World> const world = this->world();
WorldSideEffect anti;
anti.op = AntiSideEffect::PopElement;
world->pushElement(elementId);
return std::tuple<Handler<ElementObject>, Maybe<WorldSideEffect> >(world->rootElement()->donutObject(), Just(anti));
}
