bool Editor::handleEditingKeyboardEvent(KeyboardEvent* evt)
{
const PlatformKeyboardEvent* keyEvent = evt->keyEvent();
// do not treat this as text input if it's a system key event
if (!keyEvent || keyEvent->isSystemKey())
return false;
String commandName = behavior().interpretKeyEvent(*evt);
Command command = this->createCommand(commandName);
if (keyEvent->type() == PlatformEvent::RawKeyDown) {
// WebKit doesn't have enough information about mode to decide how
// commands that just insert text if executed via Editor should be treated,
// so we leave it upon WebCore to either handle them immediately
// (e.g. Tab that changes focus) or let a keypress event be generated
// (e.g. Tab that inserts a Tab character, or Enter).
if (command.isTextInsertion() || commandName.isEmpty())
return false;
return command.execute(evt);
}
if (command.execute(evt))
return true;
if (!behavior().shouldInsertCharacter(*evt) || !canEdit())
return false;
// Return true to prevent default action. e.g. Space key scroll.
if (dispatchBeforeInputInsertText(evt->target(), evt->keyEvent()->text()) != DispatchEventResult::NotCanceled)
return true;
return insertText(evt->keyEvent()->text(), evt);
}
void UmlOpaqueAction::write(FileOut & out) {
write_begin(out, "OpaqueAction");
write_end(out, TRUE);
Q3CString body;
switch(_lang) {
case Uml:
body = behavior();
break;
case Cpp:
body = cppBehavior();
break;
default:
// Java
body = javaBehavior();
}
if (!body.isEmpty()) {
out.indent();
out << "<body>";
out.quote(body);
out << "</body>\n";
}
write_close(out);
}
// -----------------------------------------------------------------------------
// CTFAStifTestCaseAdapter::RunTestL
// -----------------------------------------------------------------------------
void CTFAStifTestCaseAdapter::RunTestL( TTestResult& aResult )
{
COMPONENT_TRACE( ( _L( " DSYTESTTOOL - CTFAStifTestCaseAdapter::RunTestL(0x%x)" ), &aResult ) );
// Test module behavior is set according to flags of current test case.
TUint32 behavior( 0 );
if ( iTestCase.Flags() & ETFMayLeakMemory )
{
behavior |= CTestModuleIf::ETestLeaksMem;
}
if ( iTestCase.Flags() & ETFMayLeakRequests )
{
behavior |= CTestModuleIf::ETestLeaksRequests;
}
if ( iTestCase.Flags() & ETFMayLeakHandles )
{
behavior |= CTestModuleIf::ETestLeaksHandles;
}
iTestModule->TestModuleIf().SetBehavior( ( CTestModuleIf::TTestBehavior )behavior );
iTestCase.SetupL();
TRAPD( err, iTestCase.RunTestL() );
COMPONENT_TRACE( ( _L( " DSYTESTTOOL - CTFAStifTestCaseAdapter::RunTestL - Result: %d" ), err ) );
aResult.iResult = err;
iTestCase.Teardown();
COMPONENT_TRACE( ( _L( " DSYTESTTOOL - CTFAStifTestCaseAdapter::RunTestL - return void" ) ) );
}
void AssFlyObj::act (dd dt)
{
if (!watcher) throw AssException("zero watcher", 3);
watcher->update (dt);
behavior(dt);
pos += vel * dt;
}
void AssBehaviorObj::act (dd dt)
{
if (!watcher) throw AssException("no watcher", 4);
watcher->update (dt);
if (cmunit) cmunit->update (dt);
behavior (dt);
}
bool core::run(int cycle_count) {
#ifdef _NO_SYSTEMC_
if (cycle_count == -1) {
while (1) {
try {
_clock->tick();
_pll_clock->tick();
if (_clock->get_tick()) {
behavior();
}
if (_pll_clock->get_tick()) {
_thread_controller->pll_behavior();
}
} catch (int n) {
return false;
}
}
}
for (int i = 0; i < cycle_count; i++) {
try {
_clock->tick();
_pll_clock->tick();
if (_clock->get_tick()) {
behavior();
}
if (_pll_clock->get_tick()) {
_thread_controller->pll_behavior();
}
} catch (int n) {
return false;
}
}
#else
try {
sc_start(cycle_count);
} catch (int n) {
return false;
}
#endif /* _NO_SYSTEMC_ */
return true;
}
// Pass a WebKeyboardEvent into the EditorClient and get back the string
// name of which editing event that key causes.
// E.g., sending in the enter key gives back "InsertNewline".
const char* interpretKeyEvent(
const WebKeyboardEvent& webKeyboardEvent,
PlatformEvent::Type keyType)
{
PlatformKeyboardEventBuilder evt(webKeyboardEvent);
evt.setKeyType(keyType);
RefPtrWillBeRawPtr<KeyboardEvent> keyboardEvent = KeyboardEvent::create(evt, 0);
OwnPtr<Settings> settings = Settings::create();
EditingBehavior behavior(settings->editingBehaviorType());
return behavior.interpretKeyEvent(*keyboardEvent);
}
void cpp_gradient_descent_learning::update_weights_offline(cpp_device_array* deltas, cpp_device_array* weights, cpp_device_array* gradientSums, float itCount)
{
assert(weights);
assert(gradientSums);
idx_t size = weights->size();
assert(gradientSums->size() == size);
assert(deltas->size() == size);
float* weightsPtr = weights->ptr();
float* gradientSumsPtr = gradientSums->ptr();
float* deltasPtr = deltas->ptr();
float rate = behavior()->learning_rate();
float momentum = behavior()->momentum();
if (behavior()->smoothing())
{
float smoothV = 1.0f - momentum;
for (idx_t idx = 0; idx < size; idx++)
{
float update = (gradientSumsPtr[idx] * rate) / itCount;
float lastUpdate = deltasPtr[idx];
update = (lastUpdate * momentum) + (update * smoothV);
weightsPtr[idx] += update;
deltasPtr[idx] = update;
}
}
else
{
for (idx_t idx = 0; idx < size; idx++)
{
float update = (gradientSumsPtr[idx] * rate) / itCount;
float lastUpdate = deltasPtr[idx];
update = (lastUpdate * momentum) + update;
weightsPtr[idx] += update;
deltasPtr[idx] = update;
}
}
}
void UmlCallBehaviorAction::write(FileOut & out) {
write_begin(out, "CallBehaviorAction");
write_end(out, TRUE);
UmlItem * b = behavior();
if (b != 0) {
out.indent();
out << "<behavior";
out.idref(b);
out << "/>\n";
}
write_close(out);
}
void cpp_gradient_descent_learning::run(idx_t iterationCount, const device_array_ptr& error)
{
if (behavior()->weight_update_mode() == weight_update_mode::online)
{
idx_t idx = 0;
for (auto& node : *nodes())
{
update_weights_online(_deltas[idx++].get(), _fast_cast_alt<cpp_device_array>(node.weights().get()), _fast_cast_alt<cpp_device_array>(node.gradients().get()));
}
}
else
{
idx_t idx = 0;
float itCount = iterationCount;
for (auto& node : *nodes())
{
update_weights_offline(_deltas[idx++].get(), _fast_cast_alt<cpp_device_array>(node.weights().get()), _fast_cast_alt<cpp_device_array>(node.gradient_sums().get()), itCount);
}
}
}
SCM SCM_invoke(SCM function, unsigned long number, ...) {
if ( SCM_FixnumP(function) ) {
return SCM_error(SCM_ERR_CANNOT_APPLY); /* Cannot apply a number! */
} else {
switch SCM_2tag(function) {
case SCM_SUBR_TAG: {
SCM (*behavior)(void) = (SCM_Unwrap(function)->subr).behavior;
long arity = (SCM_Unwrap(function)->subr).arity;
SCM result;
if ( arity >= 0 ) { /* Fixed arity subr */
if ( arity != number ) {
return SCM_error(SCM_ERR_WRONG_ARITY); /* Wrong arity! */
} else {
if ( arity == 0) {
result = behavior();
} else {
va_list args;
va_start(args,number);
{ SCM a0 ;
a0 = va_arg(args,SCM);
if ( arity == 1 ) {
result = ((SCM (*)(SCM)) *behavior)(a0);
} else {
SCM a1 ;
a1 = va_arg(args,SCM);
if ( arity == 2 ) {
result = ((SCM (*)(SCM,SCM)) *behavior)(a0,a1);
} else {
SCM a2 ;
a2 = va_arg(args,SCM);
if ( arity == 3 ) {
result = ((SCM (*)(SCM,SCM,SCM)) *behavior)(a0,a1,a2);
} else {
/* No fixed arity subr with more than 3 variables */
return SCM_error(SCM_ERR_INTERNAL);
}
}
}
}
va_end(args);
}
return result;
}
} else { /* Nary subr */
long min_arity = SCM_MinimalArity(arity) ;
if ( number < min_arity ) {
return SCM_error(SCM_ERR_MISSING_ARGS); /* Too less arguments! */
} else {
va_list args;
SCM result;
va_start(args,number);
result = ((SCM (*)(unsigned long,va_list)) *behavior)(number,args);
va_end(args);
return result;
}
}
}
case SCM_CLOSURE_TAG: {
SCM (*behavior)(void) = (SCM_Unwrap(function)->closure).behavior ;
long arity = (SCM_Unwrap(function)->closure).arity ;
SCM result;
va_list args;
va_start(args,number);
if ( arity >= 0 ) {
if ( arity != number ) { /* Wrong arity! */
return SCM_error(SCM_ERR_WRONG_ARITY);
} else {
result = ((SCM (*)(SCM,unsigned long,va_list)) *behavior)(function,number,args);
}
} else {
long min_arity = SCM_MinimalArity(arity) ;
if ( number < min_arity ) {
return SCM_error(SCM_ERR_MISSING_ARGS); /* Too less arguments! */
} else {
result = ((SCM (*)(SCM,unsigned long,va_list)) *behavior)(function,number,args);
}
}
va_end(args);
return result;
}
case SCM_ESCAPE_TAG: {
if ( number == 1) {
va_list args;
va_start(args,number);
jumpvalue = va_arg(args,SCM);
va_end(args);
{ struct SCM_jmp_buf *address =
SCM_Unwrap(function)->escape.stack_address;
if ( SCM_EqP(address->back_pointer,function)
&& ( (void *) &address SCM_STACK_HIGHER (void *) address ) ) {
longjmp(address->jb,1);
} else { /* surely out of dynamic extent! */
return SCM_error(SCM_ERR_OUT_OF_EXTENT);
}
}
} else {
return SCM_error(SCM_ERR_MISSING_ARGS); /* Too less arguments! */
}
}
default: {
return SCM_error(SCM_ERR_CANNOT_APPLY); /* Cannot apply! */
}
}
}
}
int main(int argc, char* argv[])
{
bool norelease = false;
if (YARPParseParameters::parse(argc, argv, "-norelease"))
norelease = true;
YARPString cfgFile;
if (!YARPParseParameters::parse(argc, argv, "-cfg", cfgFile))
cfgFile = __defaultCfgFile;
ReflexShared shared;
GRBehavior behavior(&shared);
GRBLoopTouch loopTouch;
GRBWaitIdle waitClose1;
GRBWaitIdle waitOpen1;
GRBWaitIdle waitOpen2;
GRBPickRndAction pickRnd;
GRBWaitDeltaT waitT[] = {0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2,
0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2 };
GRBGrasp grasp;
GRBCloseOutputCommand closeCmd;
GRBOpenOutputCommand openCmd;
GRBInhibitCommand inhibitOutput;
GRBReleaseCommand enableOutput;
GRBOutputSignal sendClutching(YBVGraspRflxClutch);
GRBOutputSignal inhibitReaching(YBVReachingInhibit);
GRBOutputSignal enableReaching(YBVReachingEnable);
GRBInit init;
GRBSimpleInput motionDone(YBVHandDone);
GRBSimpleInput inhibit(YBVGraspRflxInhibit);
GRBSimpleInput release(YBVGraspRflxRelease);
GRBSimpleInput forceOpen(YBVGraspRflxForceOpen);
readConfigFile(cfgFile, shared);
behavior.setInitialState(&loopTouch);
behavior.add(&inhibit, &inhibitOutput);
behavior.add(&release, &enableOutput);
behavior.add(&init, &loopTouch, &pickRnd, &inhibitReaching);
behavior.add(NULL, &loopTouch, &loopTouch); // loopTouch is a blocking state
behavior.add(NULL, &pickRnd, &waitOpen1, &openCmd);
behavior.add(&motionDone, &waitOpen1, &grasp, &closeCmd);
behavior.add(NULL, &grasp, &waitClose1);
behavior.add(&motionDone, &waitClose1, &waitT[0], &sendClutching);
for(int i = 0; i<(N-1); i++)
behavior.add(NULL, &waitT[i], &waitT[i+1]);
// check no automatic release
if (norelease)
behavior.add(&forceOpen, &waitT[N-1], &waitOpen2, &openCmd);
else
behavior.add(NULL, &waitT[N-1], &waitOpen2, &openCmd);
behavior.add(&motionDone, &waitOpen2, &loopTouch, &enableReaching);
behavior.Begin();
behavior.loop();
return 0;
}
shared_ptr<BehaviorExecution> SignalWidgetAction::createBehaviorExecution(shared_ptr<InstanceSpecification> host, const Parameters& p, bool sync)
{
shared_ptr<SignalWidgetBehaviorExecution> behavior(new SignalWidgetBehaviorExecution(shared_dynamic_cast<SignalWidgetAction>(shared_from_this()),host,p));
return behavior;
}
void AssUnitWatch::update (dd dt)
{
visible.clear ();
world->getVisible(this);
behavior (dt);
}
int main(int argc, char* argv[])
{
ExplorationShared shared;
EBehavior behavior(&shared);
EBWaitIdle waitStart("Start");
EBWaitIdle waitMotion1("ArmPositioning");
EBWaitIdle waitMotion2("Turn1");
EBWaitIdle waitMotion3("Turn2");
EBWaitIdle waitMotion4("Turn3");
EBWaitIdle waitMotion5("Turn4");
EBWaitIdle waitMotion6("Turn5");
EBWaitIdle waitMotion7("Final pos");
EBWaitIdle waitMotion8("Going back to rest");
EBWaitIdle endState1("end1");
EBWaitIdle endState2("end2");
EBWaitIdle stateInhibitHandTracking("Inhibit hand tracking");
EBWaitIdle stateEnableHandTracking("Enable hand tracking");
EBWaitIdle position1Wait("Position1 done");
EBWaitIdle position2Wait("Position2 done");
EBWaitIdle position3Wait("Position3 done");
EBWaitDeltaT position2Train(6);
EBWaitDeltaT position3Train(6);
EBWaitDeltaT position4Train(6);
EBWaitIdle position2("Waiting arm done");
EBWaitIdle position3("Waiting arm done");
EBWaitIdle position4("Waiting arm done");
EBWaitIdle waitArmAck("Wait armAck");
EBWaitDeltaT dT1(6);
EBWaitDeltaT dT2(0.2);
EBWaitDeltaT dT3OneSecond(3);
EBWaitDeltaT dTHandClosing(0.1);
EBWaitDeltaT waitArmSeemsToRest(5);
EBBehaviorOutput startTrain(YBVKFTrainStart);
EBBehaviorOutput startSequence(YBVKFStart);
EBBehaviorOutput stopTrain(YBVKFTrainStop);
EBBehaviorOutput stop(YBVKFStop);
EBSimpleOutput forceOpen(YBVGraspRflxForceOpen);
EBSimpleOutput parkArm(YBVArmForceRestingTrue);
// output: enable and disable hand tracking system
EBEnableTracker enableHandTracking;
EBInhibitTracker inhibitHandTracking;
EBOutputCommand cmd1(YBVArmForceNewCmd, YVector(_nJoints, pos1));
EBOutputCommand cmd2(YBVArmForceNewCmd, YVector(_nJoints, pos2));
EBOutputCommand cmd3(YBVArmForceNewCmd, YVector(_nJoints, pos3));
// EBOutputCommand cmd4(YBVArmForceNewCmd, YVector(_nJoints, pos4));
// EBOutputCommand cmd5(YBVArmForceNewCmd, YVector(_nJoints, pos5));
// EBOutputCommand cmd6(YBVArmForceNewCmd, YVector(_nJoints, pos6));
EBOutputCommand cmd7(YBVArmForceNewCmd, YVector(_nJoints, pos7));
EBOutputCommand cmd8(YBVArmForceNewCmd, YVector(_nJoints, pos8));
EBOutputCommand cmd9(YBVArmForceNewCmd, YVector(_nJoints, pos9));
EBOutputCommand cmd10(YBVArmForceNewCmd, YVector(_nJoints, pos10));
EBSimpleInput armDone(YBVArmDone);
EBSimpleInput handDone(YBVHandDone);
EBSimpleInput start(YBVKFExplorationStart);
EBSimpleInput start2(YBVGraspRflxClutch);
EBSimpleInput armAck(YBVArmIssuedCmd);
EBSimpleInput armNAck(YBVArmIsBusy);
behavior.setInitialState(&waitStart);
behavior.add(&start, &waitStart, &waitMotion1, &cmd1);
behavior.add(&start2, &waitStart, &dTHandClosing, &enableHandTracking);
behavior.add(NULL, &dTHandClosing, &waitArmAck, &cmd1);
behavior.add(&armAck, &waitArmAck, &stateEnableHandTracking, &startSequence);
behavior.add(&armNAck, &waitArmAck, &waitArmSeemsToRest, &inhibitHandTracking);
behavior.add(NULL, &waitArmSeemsToRest, &waitStart, &forceOpen);
behavior.add(NULL, &stateEnableHandTracking, &waitMotion1, &enableHandTracking);
behavior.add(&armDone, &waitMotion1, &dT3OneSecond);
// wait some extra time before issueing the startKF signal
behavior.add(NULL, &dT3OneSecond, &dT1, &startTrain);
// july 21/04
behavior.add(NULL, &dT1, &waitMotion6);
behavior.add(NULL, &waitMotion6, &position1Wait, &stopTrain);
// position2
behavior.add(NULL, &position1Wait, &position2, &cmd7);
behavior.add(&armDone, &position2, &position2Train, &startTrain);
behavior.add(NULL, &position2Train, &position2Wait, &stopTrain);
//position3
behavior.add(NULL, &position2Wait, &position3, &cmd8);
behavior.add(&armDone, &position3, &position3Train, &startTrain);
behavior.add(NULL, &position3Train, &position3Wait, &stopTrain);
//position 4
behavior.add(NULL, &position3Wait, &position4, &cmd9);
behavior.add(&armDone, &position4, &position4Train, &startTrain);
behavior.add(NULL, &position4Train, &stateInhibitHandTracking, &stopTrain);
behavior.add(NULL, &stateInhibitHandTracking, &dT2);
/*
behavior.add(NULL, &dT1, &waitMotion2, &cmd2);
// behavior.add(&armDone, &waitMotion1, &waitMotion2, &cmd2);
behavior.add(&armDone, &waitMotion2, &waitMotion3, &cmd3);
behavior.add(&armDone, &waitMotion3, &waitMotion4, &cmd4);
behavior.add(&armDone, &waitMotion4, &waitMotion5, &cmd5);
behavior.add(&armDone, &waitMotion5, &waitMotion6, &cmd6);
behavior.add(&armDone, &waitMotion6, &dT2, &stopKF);
*/
behavior.add(NULL, &dT2, &waitMotion7, &cmd10);
behavior.add(&armDone, &waitMotion7, &waitMotion8, &forceOpen);
behavior.add(&handDone, &waitMotion8, &endState1, &parkArm);
behavior.add(NULL, &endState1, &endState2, &inhibitHandTracking);
behavior.add(NULL, &endState2, &waitStart, &stop);
behavior.Begin();
behavior.loop();
return 0;
}
shared_ptr<BehaviorExecution> CallOperationAction::createBehaviorExecution(shared_ptr<InstanceSpecification> host, const Parameters& p, bool sync)
{
shared_ptr<CallOperationBehaviorExecution> behavior(new CallOperationBehaviorExecution(shared_dynamic_cast<CallOperationAction>(shared_from_this()),host,p));
return behavior;
}
Particle::Particle(char *l)
{
parser(l);
behavior();
inits();
}
Thunder::Thunder(char *l)
{
parser(l);
behavior();
inits();
}
// Pass a WebKeyboardEvent into the EditorClient and get back the string
// name of which editing event that key causes.
// E.g., sending in the enter key gives back "InsertNewline".
const char* interpretKeyEvent(const WebKeyboardEvent& webKeyboardEvent) {
KeyboardEvent* keyboardEvent = KeyboardEvent::create(webKeyboardEvent, 0);
std::unique_ptr<Settings> settings = Settings::create();
EditingBehavior behavior(settings->editingBehaviorType());
return behavior.interpretKeyEvent(*keyboardEvent);
}
supervised_learning_iteration_type cpp_gradient_descent_learning::iteration_type() const
{
return behavior()->weight_update_mode() == weight_update_mode::online ? supervised_learning_iteration_type::online : supervised_learning_iteration_type::offline;
}
