|  | @@ -1,5 +1,5 @@
 | 
	
		
			
				|  |  |  smalltalk.addPackage('Helios-KeyBindings');
 | 
	
		
			
				|  |  | -smalltalk.addClass('HLBinding', smalltalk.Object, ['key', 'label', 'each'], 'Helios-KeyBindings');
 | 
	
		
			
				|  |  | +smalltalk.addClass('HLBinding', smalltalk.Object, ['key', 'label'], 'Helios-KeyBindings');
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  |  "_applyOn_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
	
		
			
				|  | @@ -166,6 +166,21 @@ referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLBinding);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  | +smalltalk.addMethod(
 | 
	
		
			
				|  |  | +"_release",
 | 
	
		
			
				|  |  | +smalltalk.method({
 | 
	
		
			
				|  |  | +selector: "release",
 | 
	
		
			
				|  |  | +category: 'actions',
 | 
	
		
			
				|  |  | +fn: function (){
 | 
	
		
			
				|  |  | +var self=this;
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
return self}, function($ctx1) {$ctx1.fill(self,"release",{},smalltalk.HLBinding)})},
 | 
	
		
			
				|  |  | +args: [],
 | 
	
		
			
				|  |  | +source: "release",
 | 
	
		
			
				|  |  | +messageSends: [],
 | 
	
		
			
				|  |  | +referencedClasses: []
 | 
	
		
			
				|  |  | +}),
 | 
	
		
			
				|  |  | +smalltalk.HLBinding);
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  |  "_renderActionFor_html_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
	
		
			
				|  | @@ -321,19 +336,20 @@ var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
var $2,$3,$4,$5,$1;
 | 
	
		
			
				|  |  |  $2=_st((smalltalk.HLBindingInput || HLBindingInput))._new();
 | 
	
		
			
				|  |  |  _st($2)._label_(_st(_st(self)._command())._inputLabel());
 | 
	
		
			
				|  |  | -_st($2)._callback_((function(val){
 | 
	
		
			
				|  |  | +_st($2)._callback_((function(val,errorBlock){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
$3=_st(self)._command();
 | 
	
		
			
				|  |  |  _st($3)._input_(val);
 | 
	
		
			
				|  |  | +_st($3)._errorBlock_(errorBlock);
 | 
	
		
			
				|  |  |  $4=_st($3)._execute();
 | 
	
		
			
				|  |  |  return $4;
 | 
	
		
			
				|  |  | -}, function($ctx2) {$ctx2.fillBlock({val:val},$ctx1)})}));
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({val:val,errorBlock:errorBlock},$ctx1)})}));
 | 
	
		
			
				|  |  |  $5=_st($2)._yourself();
 | 
	
		
			
				|  |  |  $1=$5;
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  |  }, function($ctx1) {$ctx1.fill(self,"inputBinding",{},smalltalk.HLBindingAction)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  | -source: "inputBinding\x0a\x09^ HLBindingInput new\x0a\x09\x09label: self command inputLabel;\x0a\x09\x09callback: [ :val | \x0a\x09\x09\x09self command \x0a\x09\x09\x09\x09input: val;\x0a\x09\x09\x09\x09execute ];\x0a\x09\x09yourself",
 | 
	
		
			
				|  |  | -messageSends: ["label:", "inputLabel", "command", "new", "callback:", "input:", "execute", "yourself"],
 | 
	
		
			
				|  |  | +source: "inputBinding\x0a\x09^ HLBindingInput new\x0a\x09\x09label: self command inputLabel;\x0a\x09\x09callback: [ :val :errorBlock | \x0a\x09\x09\x09self command \x0a\x09\x09\x09\x09input: val;\x0a\x09\x09\x09\x09errorBlock: errorBlock;\x0a\x09\x09\x09\x09execute ];\x0a\x09\x09yourself",
 | 
	
		
			
				|  |  | +messageSends: ["label:", "inputLabel", "command", "new", "callback:", "input:", "errorBlock:", "execute", "yourself"],
 | 
	
		
			
				|  |  |  referencedClasses: ["HLBindingInput"]
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLBindingAction);
 | 
	
	
		
			
				|  | @@ -581,6 +597,24 @@ referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLBindingGroup);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  | +smalltalk.addMethod(
 | 
	
		
			
				|  |  | +"_release",
 | 
	
		
			
				|  |  | +smalltalk.method({
 | 
	
		
			
				|  |  | +selector: "release",
 | 
	
		
			
				|  |  | +category: 'actions',
 | 
	
		
			
				|  |  | +fn: function (){
 | 
	
		
			
				|  |  | +var self=this;
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
_st(_st(self)._bindings())._do_((function(each){
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx2) {
return _st(each)._release();
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})}));
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"release",{},smalltalk.HLBindingGroup)})},
 | 
	
		
			
				|  |  | +args: [],
 | 
	
		
			
				|  |  | +source: "release\x0a\x09self bindings do: [ :each | each release ]",
 | 
	
		
			
				|  |  | +messageSends: ["do:", "release", "bindings"],
 | 
	
		
			
				|  |  | +referencedClasses: []
 | 
	
		
			
				|  |  | +}),
 | 
	
		
			
				|  |  | +smalltalk.HLBindingGroup);
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  |  "_renderOn_html_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
	
		
			
				|  | @@ -603,7 +637,7 @@ smalltalk.HLBindingGroup);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  | -smalltalk.addClass('HLBindingInput', smalltalk.HLBinding, ['input', 'callback'], 'Helios-KeyBindings');
 | 
	
		
			
				|  |  | +smalltalk.addClass('HLBindingInput', smalltalk.HLBinding, ['input', 'callback', 'status', 'inputText', 'wrapper', 'binder'], 'Helios-KeyBindings');
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  |  "_applyOn_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
	
		
			
				|  | @@ -611,11 +645,19 @@ selector: "applyOn:",
 | 
	
		
			
				|  |  |  category: 'actions',
 | 
	
		
			
				|  |  |  fn: function (aKeyBinder){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
_st(self)._evaluate_(_st(self)._input());
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"applyOn:",{aKeyBinder:aKeyBinder},smalltalk.HLBindingInput)})},
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
var $early={};
 | 
	
		
			
				|  |  | +try {
 | 
	
		
			
				|  |  | +_st(self)._evaluate_onError_(_st(self)._input(),(function(){
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx2) {
_st(self)._errorStatus();
 | 
	
		
			
				|  |  | +_st(self)._refresh();
 | 
	
		
			
				|  |  | +throw $early=[false];
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  | +return self}
 | 
	
		
			
				|  |  | +catch(e) {if(e===$early)return e[0]; throw e}
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"applyOn:",{aKeyBinder:aKeyBinder},smalltalk.HLBindingInput)})},
 | 
	
		
			
				|  |  |  args: ["aKeyBinder"],
 | 
	
		
			
				|  |  | -source: "applyOn: aKeyBinder\x0a\x09self evaluate: self input",
 | 
	
		
			
				|  |  | -messageSends: ["evaluate:", "input"],
 | 
	
		
			
				|  |  | +source: "applyOn: aKeyBinder\x0a\x09self \x0a\x09\x09evaluate: self input \x0a\x09\x09onError: [ \x0a\x09\x09\x09self errorStatus.\x0a\x09\x09\x09self refresh.\x0a\x09\x09\x09^ false ]",
 | 
	
		
			
				|  |  | +messageSends: ["evaluate:onError:", "input", "errorStatus", "refresh"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLBindingInput);
 | 
	
	
		
			
				|  | @@ -662,17 +704,33 @@ referencedClasses: []
 | 
	
		
			
				|  |  |  smalltalk.HLBindingInput);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  | -"_evaluate_",
 | 
	
		
			
				|  |  | +"_errorStatus",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  | -selector: "evaluate:",
 | 
	
		
			
				|  |  | +selector: "errorStatus",
 | 
	
		
			
				|  |  |  category: 'actions',
 | 
	
		
			
				|  |  | -fn: function (aString){
 | 
	
		
			
				|  |  | +fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
_st(_st(self)._callback())._value_(aString);
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"evaluate:",{aString:aString},smalltalk.HLBindingInput)})},
 | 
	
		
			
				|  |  | -args: ["aString"],
 | 
	
		
			
				|  |  | -source: "evaluate: aString\x0a\x09self callback value: aString",
 | 
	
		
			
				|  |  | -messageSends: ["value:", "callback"],
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
_st(self)._status_("error");
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"errorStatus",{},smalltalk.HLBindingInput)})},
 | 
	
		
			
				|  |  | +args: [],
 | 
	
		
			
				|  |  | +source: "errorStatus\x0a\x09self status: 'error'",
 | 
	
		
			
				|  |  | +messageSends: ["status:"],
 | 
	
		
			
				|  |  | +referencedClasses: []
 | 
	
		
			
				|  |  | +}),
 | 
	
		
			
				|  |  | +smalltalk.HLBindingInput);
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +smalltalk.addMethod(
 | 
	
		
			
				|  |  | +"_evaluate_onError_",
 | 
	
		
			
				|  |  | +smalltalk.method({
 | 
	
		
			
				|  |  | +selector: "evaluate:onError:",
 | 
	
		
			
				|  |  | +category: 'actions',
 | 
	
		
			
				|  |  | +fn: function (aString,aBlock){
 | 
	
		
			
				|  |  | +var self=this;
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
_st(_st(self)._callback())._value_value_(aString,aBlock);
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"evaluate:onError:",{aString:aString,aBlock:aBlock},smalltalk.HLBindingInput)})},
 | 
	
		
			
				|  |  | +args: ["aString", "aBlock"],
 | 
	
		
			
				|  |  | +source: "evaluate: aString onError: aBlock\x0a\x09self callback value: aString value: aBlock",
 | 
	
		
			
				|  |  | +messageSends: ["value:value:", "callback"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLBindingInput);
 | 
	
	
		
			
				|  | @@ -685,12 +743,52 @@ category: 'accessing',
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
var $1;
 | 
	
		
			
				|  |  | -$1=_st(_st(self["@input"])._asJQuery())._val();
 | 
	
		
			
				|  |  | +$1=self["@input"];
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  |  }, function($ctx1) {$ctx1.fill(self,"input",{},smalltalk.HLBindingInput)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  | -source: "input\x0a\x09^ input asJQuery val",
 | 
	
		
			
				|  |  | -messageSends: ["val", "asJQuery"],
 | 
	
		
			
				|  |  | +source: "input\x0a\x09^ input",
 | 
	
		
			
				|  |  | +messageSends: [],
 | 
	
		
			
				|  |  | +referencedClasses: []
 | 
	
		
			
				|  |  | +}),
 | 
	
		
			
				|  |  | +smalltalk.HLBindingInput);
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +smalltalk.addMethod(
 | 
	
		
			
				|  |  | +"_inputText",
 | 
	
		
			
				|  |  | +smalltalk.method({
 | 
	
		
			
				|  |  | +selector: "inputText",
 | 
	
		
			
				|  |  | +category: 'accessing',
 | 
	
		
			
				|  |  | +fn: function (){
 | 
	
		
			
				|  |  | +var self=this;
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
var $2,$1;
 | 
	
		
			
				|  |  | +$2=self["@inputText"];
 | 
	
		
			
				|  |  | +if(($receiver = $2) == nil || $receiver == undefined){
 | 
	
		
			
				|  |  | +self["@inputText"]="";
 | 
	
		
			
				|  |  | +$1=self["@inputText"];
 | 
	
		
			
				|  |  | +} else {
 | 
	
		
			
				|  |  | +$1=$2;
 | 
	
		
			
				|  |  | +};
 | 
	
		
			
				|  |  | +return $1;
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"inputText",{},smalltalk.HLBindingInput)})},
 | 
	
		
			
				|  |  | +args: [],
 | 
	
		
			
				|  |  | +source: "inputText\x0a\x09^ inputText ifNil: [ inputText := '' ].",
 | 
	
		
			
				|  |  | +messageSends: ["ifNil:"],
 | 
	
		
			
				|  |  | +referencedClasses: []
 | 
	
		
			
				|  |  | +}),
 | 
	
		
			
				|  |  | +smalltalk.HLBindingInput);
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +smalltalk.addMethod(
 | 
	
		
			
				|  |  | +"_inputText_",
 | 
	
		
			
				|  |  | +smalltalk.method({
 | 
	
		
			
				|  |  | +selector: "inputText:",
 | 
	
		
			
				|  |  | +category: 'accessing',
 | 
	
		
			
				|  |  | +fn: function (aText){
 | 
	
		
			
				|  |  | +var self=this;
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
self["@inputText"]=aText;
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"inputText:",{aText:aText},smalltalk.HLBindingInput)})},
 | 
	
		
			
				|  |  | +args: ["aText"],
 | 
	
		
			
				|  |  | +source: "inputText: aText\x0a\x09inputText := aText",
 | 
	
		
			
				|  |  | +messageSends: [],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLBindingInput);
 | 
	
	
		
			
				|  | @@ -711,34 +809,129 @@ referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLBindingInput);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  | +smalltalk.addMethod(
 | 
	
		
			
				|  |  | +"_refresh",
 | 
	
		
			
				|  |  | +smalltalk.method({
 | 
	
		
			
				|  |  | +selector: "refresh",
 | 
	
		
			
				|  |  | +category: 'rendering',
 | 
	
		
			
				|  |  | +fn: function (){
 | 
	
		
			
				|  |  | +var self=this;
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
var $1,$2;
 | 
	
		
			
				|  |  | +$1=self["@wrapper"];
 | 
	
		
			
				|  |  | +if(($receiver = $1) == nil || $receiver == undefined){
 | 
	
		
			
				|  |  | +$2=self;
 | 
	
		
			
				|  |  | +return $2;
 | 
	
		
			
				|  |  | +} else {
 | 
	
		
			
				|  |  | +$1;
 | 
	
		
			
				|  |  | +};
 | 
	
		
			
				|  |  | +_st(_st(self["@wrapper"])._asJQuery())._empty();
 | 
	
		
			
				|  |  | +_st((function(html){
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx2) {
return _st(self)._renderActionFor_html_(self["@binder"],html);
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({html:html},$ctx1)})}))._appendToJQuery_(_st(self["@wrapper"])._asJQuery());
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"refresh",{},smalltalk.HLBindingInput)})},
 | 
	
		
			
				|  |  | +args: [],
 | 
	
		
			
				|  |  | +source: "refresh\x0a\x09wrapper ifNil: [ ^ self ].\x0a    \x0a\x09wrapper asJQuery empty.\x0a    [ :html | self renderActionFor: binder html: html ] appendToJQuery: wrapper asJQuery",
 | 
	
		
			
				|  |  | +messageSends: ["ifNil:", "empty", "asJQuery", "appendToJQuery:", "renderActionFor:html:"],
 | 
	
		
			
				|  |  | +referencedClasses: []
 | 
	
		
			
				|  |  | +}),
 | 
	
		
			
				|  |  | +smalltalk.HLBindingInput);
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +smalltalk.addMethod(
 | 
	
		
			
				|  |  | +"_release",
 | 
	
		
			
				|  |  | +smalltalk.method({
 | 
	
		
			
				|  |  | +selector: "release",
 | 
	
		
			
				|  |  | +category: 'actions',
 | 
	
		
			
				|  |  | +fn: function (){
 | 
	
		
			
				|  |  | +var self=this;
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
self["@status"]=nil;
 | 
	
		
			
				|  |  | +self["@wrapper"]=nil;
 | 
	
		
			
				|  |  | +self["@binder"]=nil;
 | 
	
		
			
				|  |  | +self["@inputText"]=nil;
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"release",{},smalltalk.HLBindingInput)})},
 | 
	
		
			
				|  |  | +args: [],
 | 
	
		
			
				|  |  | +source: "release\x0a\x09status := nil.\x0a\x09wrapper := nil.\x0a\x09binder := nil.\x0a\x09inputText := nil",
 | 
	
		
			
				|  |  | +messageSends: [],
 | 
	
		
			
				|  |  | +referencedClasses: []
 | 
	
		
			
				|  |  | +}),
 | 
	
		
			
				|  |  | +smalltalk.HLBindingInput);
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  |  "_renderActionFor_html_",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "renderActionFor:html:",
 | 
	
		
			
				|  |  | -category: 'accessing',
 | 
	
		
			
				|  |  | +category: 'rendering',
 | 
	
		
			
				|  |  |  fn: function (aBinder,html){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
var $1,$3,$4,$2,$5;
 | 
	
		
			
				|  |  | -$1=_st(html)._span();
 | 
	
		
			
				|  |  | -_st($1)._class_("command");
 | 
	
		
			
				|  |  | -$2=_st($1)._with_((function(){
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx2) {
$3=_st(html)._input();
 | 
	
		
			
				|  |  | -_st($3)._class_("search-query");
 | 
	
		
			
				|  |  | -$4=_st($3)._placeholder_(_st(self)._displayLabel());
 | 
	
		
			
				|  |  | -self["@input"]=$4;
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
var $1,$2,$4,$5,$3,$6;
 | 
	
		
			
				|  |  | +self["@binder"]=aBinder;
 | 
	
		
			
				|  |  | +$1=self["@wrapper"];
 | 
	
		
			
				|  |  | +if(($receiver = $1) == nil || $receiver == undefined){
 | 
	
		
			
				|  |  | +self["@wrapper"]=_st(html)._span();
 | 
	
		
			
				|  |  | +self["@wrapper"];
 | 
	
		
			
				|  |  | +} else {
 | 
	
		
			
				|  |  | +$1;
 | 
	
		
			
				|  |  | +};
 | 
	
		
			
				|  |  | +$2=self["@wrapper"];
 | 
	
		
			
				|  |  | +_st($2)._class_(_st("control-group ").__comma(_st(self)._status()));
 | 
	
		
			
				|  |  | +$3=_st($2)._with_((function(){
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx2) {
$4=_st(html)._input();
 | 
	
		
			
				|  |  | +_st($4)._class_("input");
 | 
	
		
			
				|  |  | +_st($4)._placeholder_(_st(self)._displayLabel());
 | 
	
		
			
				|  |  | +$5=_st($4)._with_(_st(self)._inputText());
 | 
	
		
			
				|  |  | +self["@input"]=$5;
 | 
	
		
			
				|  |  |  return self["@input"];
 | 
	
		
			
				|  |  |  }, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  |  _st(self["@input"])._onKeyPress_((function(event){
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx2) {
$5=_st(_st(event)._keyCode()).__eq((13));
 | 
	
		
			
				|  |  | -if(smalltalk.assert($5)){
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx2) {
$6=_st(_st(event)._keyCode()).__eq((13));
 | 
	
		
			
				|  |  | +if(smalltalk.assert($6)){
 | 
	
		
			
				|  |  |  return _st(self)._applyOn_(aBinder);
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  }, function($ctx2) {$ctx2.fillBlock({event:event},$ctx1)})}));
 | 
	
		
			
				|  |  |  _st(_st(self["@input"])._asJQuery())._focus();
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"renderActionFor:html:",{aBinder:aBinder,html:html},smalltalk.HLBindingInput)})},
 | 
	
		
			
				|  |  |  args: ["aBinder", "html"],
 | 
	
		
			
				|  |  | -source: "renderActionFor: aBinder html: html\x0a\x09html span \x0a\x09\x09class: 'command'; \x0a\x09\x09with: [\x0a\x09\x09\x09input := html input\x0a\x09\x09\x09\x09class: 'search-query';\x0a\x09\x09\x09\x09placeholder: self displayLabel ].\x0a\x09\x09\x09\x09\x0a\x09input onKeyPress: [:event |\x0a\x09\x09event keyCode = 13 ifTrue: [\x0a\x09\x09\x09self applyOn: aBinder ] ].\x0a\x09\x09\x09\x09\x0a\x09input asJQuery focus",
 | 
	
		
			
				|  |  | -messageSends: ["class:", "span", "with:", "input", "placeholder:", "displayLabel", "onKeyPress:", "ifTrue:", "applyOn:", "=", "keyCode", "focus", "asJQuery"],
 | 
	
		
			
				|  |  | +source: "renderActionFor: aBinder html: html\x0a\x09binder := aBinder.\x0a\x09wrapper ifNil: [ wrapper := html span ].\x0a\x09\x0a\x09wrapper\x0a\x09\x09class: 'control-group ', self status; \x0a\x09\x09with: [\x0a\x09\x09\x09input := html input\x0a\x09\x09\x09\x09class: 'input';\x0a\x09\x09\x09\x09placeholder: self displayLabel;\x0a\x09\x09\x09\x09with: self inputText ].\x0a\x09\x09\x09\x09\x0a\x09input onKeyPress: [ :event |\x0a\x09\x09event keyCode = 13 \x0a\x09\x09\x09ifTrue: [ self applyOn: aBinder ] ].\x0a\x09\x09\x09\x09\x0a\x09input asJQuery focus",
 | 
	
		
			
				|  |  | +messageSends: ["ifNil:", "span", "class:", ",", "status", "with:", "input", "placeholder:", "displayLabel", "inputText", "onKeyPress:", "ifTrue:", "applyOn:", "=", "keyCode", "focus", "asJQuery"],
 | 
	
		
			
				|  |  | +referencedClasses: []
 | 
	
		
			
				|  |  | +}),
 | 
	
		
			
				|  |  | +smalltalk.HLBindingInput);
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +smalltalk.addMethod(
 | 
	
		
			
				|  |  | +"_status",
 | 
	
		
			
				|  |  | +smalltalk.method({
 | 
	
		
			
				|  |  | +selector: "status",
 | 
	
		
			
				|  |  | +category: 'accessing',
 | 
	
		
			
				|  |  | +fn: function (){
 | 
	
		
			
				|  |  | +var self=this;
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
var $2,$1;
 | 
	
		
			
				|  |  | +$2=status;
 | 
	
		
			
				|  |  | +if(($receiver = $2) == nil || $receiver == undefined){
 | 
	
		
			
				|  |  | +status="info";
 | 
	
		
			
				|  |  | +$1=status;
 | 
	
		
			
				|  |  | +} else {
 | 
	
		
			
				|  |  | +$1=$2;
 | 
	
		
			
				|  |  | +};
 | 
	
		
			
				|  |  | +return $1;
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"status",{},smalltalk.HLBindingInput)})},
 | 
	
		
			
				|  |  | +args: [],
 | 
	
		
			
				|  |  | +source: "status\x0a\x09^ status ifNil: [ status := 'info' ]",
 | 
	
		
			
				|  |  | +messageSends: ["ifNil:"],
 | 
	
		
			
				|  |  | +referencedClasses: []
 | 
	
		
			
				|  |  | +}),
 | 
	
		
			
				|  |  | +smalltalk.HLBindingInput);
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  | +smalltalk.addMethod(
 | 
	
		
			
				|  |  | +"_status_",
 | 
	
		
			
				|  |  | +smalltalk.method({
 | 
	
		
			
				|  |  | +selector: "status:",
 | 
	
		
			
				|  |  | +category: 'accessing',
 | 
	
		
			
				|  |  | +fn: function (aStatus){
 | 
	
		
			
				|  |  | +var self=this;
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
self["@status"]=aStatus;
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"status:",{aStatus:aStatus},smalltalk.HLBindingInput)})},
 | 
	
		
			
				|  |  | +args: ["aStatus"],
 | 
	
		
			
				|  |  | +source: "status: aStatus\x0a\x09status := aStatus",
 | 
	
		
			
				|  |  | +messageSends: [],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLBindingInput);
 | 
	
	
		
			
				|  | @@ -852,12 +1045,19 @@ selector: "deactivate",
 | 
	
		
			
				|  |  |  category: 'actions',
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
self["@selectedBinding"]=nil;
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
var $1;
 | 
	
		
			
				|  |  | +$1=self["@selectedBinding"];
 | 
	
		
			
				|  |  | +if(($receiver = $1) == nil || $receiver == undefined){
 | 
	
		
			
				|  |  | +$1;
 | 
	
		
			
				|  |  | +} else {
 | 
	
		
			
				|  |  | +_st(self["@selectedBinding"])._release();
 | 
	
		
			
				|  |  | +};
 | 
	
		
			
				|  |  | +self["@selectedBinding"]=nil;
 | 
	
		
			
				|  |  |  _st(_st(self)._helper())._hide();
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"deactivate",{},smalltalk.HLKeyBinder)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  | -source: "deactivate\x0a    selectedBinding := nil.\x0a\x09self helper hide",
 | 
	
		
			
				|  |  | -messageSends: ["hide", "helper"],
 | 
	
		
			
				|  |  | +source: "deactivate\x0a\x09selectedBinding ifNotNil: [ selectedBinding release ].\x0a    selectedBinding := nil.\x0a\x09self helper hide",
 | 
	
		
			
				|  |  | +messageSends: ["ifNotNil:", "release", "hide", "helper"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLKeyBinder);
 |