startup update

src/Startup.hx

@@ -1,3 +1,9 @@
+import util.Observable;
+import lib.ui.reactive.TextElement;
+import lib.ui.reactive.ReactiveUI;
+import kernel.ui.WindowManager;
+import kernel.net.Net;
+import kernel.KernelEvents;
 import kernel.Log;
 import kernel.Init;
 
@@ -6,6 +12,51 @@ using util.Extender.LambdaExtender;
 class Startup {
 	public static function main() {
 		Init.initKernel();
+		uiTest();
+	}
+
+	private static function uiTest() {
+		var context = WindowManager.instance.createNewContext();
+
+		var text1 = new Observable("My text");
+		var text2 = new Observable("Another one");
+
+		var ui = new ReactiveUI(context,[
+			new TextElement(text1,Orange,White,{
+				onClick: (p) ->{
+					text1.set("Click");
+				}
+			}),
+			new TextElement(text2,Black,White,{
+				onClick: (p)->{
+					text2.set("Click");
+				}
+			})
+		]);
+
+		ui.render();
+		WindowManager.instance.focusContextToOutput(context,"main");
+	}
+
+	private static function sendTest() {
+		Net.instance.registerProto("ping",(pack)->{
+			Log.debug("Message: " + pack.data);
+			pack.respond("Hello from: "+Net.instance.networkID);
+		});
+
+		KernelEvents.instance.onChar.handle((char)->{
+			if (char == "s"){
+				Log.debug("Sending to 4");
+				Net.instance.sendAndAwait(4,"ping","Hello world").handle((result)->{
+					switch (result){
+						case Success(pack):
+							Log.debug("Response: "+pack.data);
+						case Failure(err):
+							Log.error(err);
+					}
+				});
+			}
+		});
 	}
 }
 

src/kernel/KernelEvents.hx

@@ -216,7 +216,7 @@ class KernelEvents {
 			case "websocket_success":
 				this.onWebsocketSuccessTrigger.trigger({url: event[2], handle: event[3]});
 			default:
-				Log.error("Unknown cc event: " + eventName);
+				Log.error('Unknown event: $eventName');
 		}
 	}
 

src/kernel/net/Net.hx

@@ -127,7 +127,7 @@ class Net {
 		}
 
 		if (!protoHandlers.exists(proto)) {
-			Log.warn("Trying to route package to proto: \"" + proto + "\" but nothing was register");
+			Log.warn('Trying to route package to proto: $proto but nothing was register');
 			return;
 		}
 

src/kernel/net/Routing.hx

@@ -95,7 +95,7 @@ class Routing {
 				}
 				false;
 			default:
-				Log.error("Expected RouteDiscover or RouteDiscoverResponse type");
+				Log.error("Expected package to be a Route discover package");
 				false;
 		};
 
@@ -153,13 +153,11 @@ class Routing {
 
 		if (this.routingTable.exists(toID)){
 			if (this.routingTable[toID].cost > fullCost){
-				Log.info("Better route: " + toID + " -> " + interf.name() + ":$"+fullCost);
 				this.routingTable[toID] = {interf:interf,cost:cost + interf.getBaseRoutingCost(),rep: rep};
 				this.prepareRouteUpdate();
 			}
 		}else{
 			this.routingTable[toID] = {interf:interf,cost:cost + interf.getBaseRoutingCost(),rep: rep};
-			Log.info("New route: " + toID + " -> " + interf.name() + ":$"+fullCost);
 			this.onNewNeigborTrigger.trigger(toID);
 			this.prepareRouteUpdate();
 		}

src/kernel/ui/WindowContext.hx

@@ -13,42 +13,42 @@ import lib.TermWriteable;
 class WindowContext implements TermWriteable {
 	private final writer:VirtualTermWriter;
 
-	public var clickSignal(default, null):Signal<{button:ButtonType, pos:Vec2<Int>}>;
+	public var onClick(default, null):Signal<{button:ButtonType, pos:Vec2<Int>}>;
-	public var keySignal(default, null):Signal<{keyCode:Int, isHeld:Bool}>;
+	public var onKey(default, null):Signal<{keyCode:Int, isHeld:Bool}>;
-	public var keyUpSignal(default, null):Signal<Int>;
+	public var onKeyUp(default, null):Signal<Int>;
-	public var mouseDragSignal(default, null):Signal<{button:ButtonType, pos:Vec2<Int>}>;
+	public var onMouseDrag(default, null):Signal<{button:ButtonType, pos:Vec2<Int>}>;
-	public var mouseScrollSignal(default, null):Signal<{dir:Int, pos:Vec2<Int>}>;
+	public var onMouseScroll(default, null):Signal<{dir:Int, pos:Vec2<Int>}>;
-	public var mouseUpSignal(default, null):Signal<{button:ButtonType, pos:Vec2<Int>}>;
+	public var onMouseUp(default, null):Signal<{button:ButtonType, pos:Vec2<Int>}>;
-	public var pasteSignal(default, null):Signal<String>;
+	public var onPaste(default, null):Signal<String>;
 
-	@:allow(kernel.ui.WindowManager) private final clickTrigger:SignalTrigger<{button:ButtonType, pos:Vec2<Int>}>;
+	@:allow(kernel.ui.WindowManager) private final onClickTrigger:SignalTrigger<{button:ButtonType, pos:Vec2<Int>}>;
-	@:allow(kernel.ui.WindowManager) private final keyTrigger:SignalTrigger<{keyCode:Int, isHeld:Bool}>;
+	@:allow(kernel.ui.WindowManager) private final onKeyTrigger:SignalTrigger<{keyCode:Int, isHeld:Bool}>;
-	@:allow(kernel.ui.WindowManager) private final keyUpTrigger:SignalTrigger<Int>;
+	@:allow(kernel.ui.WindowManager) private final onKeyUpTrigger:SignalTrigger<Int>;
-	@:allow(kernel.ui.WindowManager) private final mouseDragTrigger:SignalTrigger<{button:ButtonType, pos:Vec2<Int>}>;
+	@:allow(kernel.ui.WindowManager) private final onMouseDragTrigger:SignalTrigger<{button:ButtonType, pos:Vec2<Int>}>;
-	@:allow(kernel.ui.WindowManager) private final mouseScrollTrigger:SignalTrigger<{dir:Int, pos:Vec2<Int>}>;
+	@:allow(kernel.ui.WindowManager) private final onMouseScrollTrigger:SignalTrigger<{dir:Int, pos:Vec2<Int>}>;
-	@:allow(kernel.ui.WindowManager) private final mouseUpTrigger:SignalTrigger<{button:ButtonType, pos:Vec2<Int>}>;
+	@:allow(kernel.ui.WindowManager) private final onMouseUpTrigger:SignalTrigger<{button:ButtonType, pos:Vec2<Int>}>;
-	@:allow(kernel.ui.WindowManager) private final pasteTrigger:SignalTrigger<String>;
+	@:allow(kernel.ui.WindowManager) private final onPasteTrigger:SignalTrigger<String>;
 
 	@:allow(kernel.ui.WindowManager)
 	private function new(writer:VirtualTermWriter) {
 		this.writer = writer;
 		this.onResize = writer.onResize;
 
-		this.clickTrigger = Signal.trigger();
+		this.onClickTrigger = Signal.trigger();
-		this.keyTrigger = Signal.trigger();
+		this.onKeyTrigger = Signal.trigger();
-		this.keyUpTrigger = Signal.trigger();
+		this.onKeyUpTrigger = Signal.trigger();
-		this.mouseDragTrigger = Signal.trigger();
+		this.onMouseDragTrigger = Signal.trigger();
-		this.mouseScrollTrigger = Signal.trigger();
+		this.onMouseScrollTrigger = Signal.trigger();
-		this.mouseUpTrigger = Signal.trigger();
+		this.onMouseUpTrigger = Signal.trigger();
-		this.pasteTrigger = Signal.trigger();
+		this.onPasteTrigger = Signal.trigger();
 
-		this.clickSignal = clickTrigger.asSignal();
+		this.onClick = onClickTrigger.asSignal();
-		this.keySignal = keyTrigger.asSignal();
+		this.onKey = onKeyTrigger.asSignal();
-		this.keyUpSignal = keyUpTrigger.asSignal();
+		this.onKeyUp = onKeyUpTrigger.asSignal();
-		this.mouseDragSignal = mouseDragTrigger.asSignal();
+		this.onMouseDrag = onMouseDragTrigger.asSignal();
-		this.mouseScrollSignal = mouseScrollTrigger.asSignal();
+		this.onMouseScroll = onMouseScrollTrigger.asSignal();
-		this.mouseUpSignal = mouseUpTrigger.asSignal();
+		this.onMouseUp = onMouseUpTrigger.asSignal();
-		this.pasteSignal = pasteTrigger.asSignal();
+		this.onPaste = onPasteTrigger.asSignal();
 	}
 
 	public var onResize(default, null):Signal<Vec2<Int>>;

src/kernel/ui/WindowManager.hx

@@ -8,48 +8,51 @@ class WindowManager {
 		Depends on: KernelEvents, Peripheral
 	**/
 	public static var instance:WindowManager;
+	private var currentMainContext:WindowContext;
+	private final allContexts:Array<WindowContext> = new Array();
+	private final outputMap:Map<String, WindowContext> = new Map();
 
 	@:allow(kernel.Init)
 	private function new() {
 		KernelEvents.instance.onKey.handle(params -> {
 			if (currentMainContext != null) {
-				currentMainContext.keyTrigger.trigger(params);
+				currentMainContext.onKeyTrigger.trigger(params);
 			}
 		});
 
 		KernelEvents.instance.onKeyUp.handle(keyCode -> {
 			if (currentMainContext != null) {
-				currentMainContext.keyUpTrigger.trigger(keyCode);
+				currentMainContext.onKeyUpTrigger.trigger(keyCode);
 			}
 		});
 
 		KernelEvents.instance.onMouseClick.handle(params -> {
 			if (currentMainContext != null) {
-				currentMainContext.clickTrigger.trigger(params);
+				currentMainContext.onClickTrigger.trigger(params);
 			}
 		});
 
 		KernelEvents.instance.onMouseDrag.handle(params -> {
 			if (currentMainContext != null) {
-				currentMainContext.mouseDragTrigger.trigger(params);
+				currentMainContext.onMouseDragTrigger.trigger(params);
 			}
 		});
 
 		KernelEvents.instance.onMouseScroll.handle(params -> {
 			if (currentMainContext != null) {
-				currentMainContext.mouseScrollTrigger.trigger(params);
+				currentMainContext.onMouseScrollTrigger.trigger(params);
 			}
 		});
 
 		KernelEvents.instance.onMouseUp.handle(params -> {
-			if (currentMainContext != null) {
+			// if (currentMainContext != null) {
-				currentMainContext.mouseUpTrigger.trigger(params);
+				currentMainContext.onMouseUpTrigger.trigger(params);
-			}
+			// }
 		});
 
 		KernelEvents.instance.onPaste.handle(text -> {
 			if (currentMainContext != null) {
-				currentMainContext.pasteTrigger.trigger(text);
+				currentMainContext.onPasteTrigger.trigger(text);
 			}
 		});
 
@@ -58,10 +61,6 @@ class WindowManager {
 		});
 	}
 
-	private var currentMainContext:WindowContext;
-	private final allContexts:Array<WindowContext> = new Array();
-	private final outputMap:Map<String, WindowContext> = new Map();
-
 	public function createNewContext():WindowContext {
 		var newContext = new WindowContext(new VirtualTermWriter());
 

src/lib/ui/UIEvents.hx

@@ -0,0 +1,15 @@
+package lib.ui;
+
+import util.Vec.Vec2;
+import kernel.ButtonType;
+using tink.CoreApi;
+
+typedef UIEvents = {
+	public var ?onClick:Callback<{button:ButtonType, pos:Vec2<Int>}>;
+	public var ?onKey:Callback<{keyCode:Int, isHeld:Bool}>;
+	public var ?onKeyUp:Callback<Int>;
+	public var ?onMouseDrag:Callback<{button:ButtonType, pos:Vec2<Int>}>;
+	public var ?onMouseScroll:Callback<{dir:Int, pos:Vec2<Int>}>;
+	public var ?onMouseUp:Callback<{button:ButtonType, pos:Vec2<Int>}>;
+	public var ?onPaste:Callback<String>;
+}

src/lib/ui/reactive/ReactiveUI.hx

@@ -28,13 +28,76 @@ class ReactiveUI {
 	}
 
 	private function setupEvents() {
-		context.clickSignal.handle(params ->{
+		context.onClick.handle(params ->{
-			for (k => v in this.elementMap){
+			for (k => v in elementMap){
 				if (k.isInside(params.pos)){
-					v.handleClickEvent(params.pos,params.button);
+					if (v.eventListner.onClick != null){
+						v.eventListner.onClick.invoke(params);
+					}
 				}
 			}
 		});
+
+		// context.onKey.handle(params ->{
+		// 	for (k => v in elementMap){
+		// 		if (k.isInside(params.pos)){
+		// 			if (v.eventListner.onKey != null){
+		// 				v.eventListner.onKey.invoke(params);
+		// 			}
+		// 		}
+		// 	}
+		// });
+
+		// context.onKeyUp.handle(params ->{
+		// 	for (k => v in elementMap){
+		// 		if (k.isInside(params.pos)){
+		// 			if (v.eventListner.onKeyUp != null){
+		// 				v.eventListner.onKeyUp.invoke(params);
+		// 			}
+		// 		}
+		// 	}
+		// });
+
+		// context.onMouseDrag.handle(params ->{
+		// 	for (k => v in elementMap){
+		// 		if (k.isInside(params.pos)){
+		// 			if (v.eventListner.onMouseDrag != null){
+		// 				v.eventListner.onMouseDrag.invoke(params);
+		// 			}
+		// 		}
+		// 	}
+		// });
+
+		context.onMouseScroll.handle(params ->{
+			for (k => v in elementMap){
+				if (k.isInside(params.pos)){
+					if (v.eventListner.onMouseScroll != null){
+						v.eventListner.onMouseScroll.invoke(params);
+					}
+				}
+			}
+		});
+
+		context.onMouseUp.handle(params ->{
+			for (k => v in elementMap){
+				if (k.isInside(params.pos)){
+					if (v.eventListner.onMouseUp != null){
+						v.eventListner.onMouseUp.invoke(params);
+					}
+				}
+			}
+		});
+
+		// context.onPaste.handle(params ->{
+		// 	for (k => v in elementMap){
+		// 		if (k.isInside(params.pos)){
+		// 			if (v.eventListner.onPaste != null){
+		// 				v.eventListner.onPaste.invoke(params);
+		// 			}
+		// 		}
+		// 	}
+		// });
+
 	}
 
 	public function render() {
@@ -88,7 +151,6 @@ class ReactiveUI {
 		for (child in children) {
 			if (bounds.y - writePoint.y <= 0) {
 				// No more space to render children
-				Log.debug("No more space");
 				break;
 			}
 

src/lib/ui/reactive/TextElement.hx

@@ -14,8 +14,8 @@ class TextElement extends UIElement {
 	private final bg:Color;
 	private final fg:Color;
 
-	public function new(text:Observable<String>, ?background:Color = Black, ?textColor:Color = White) {
+	public function new(text:Observable<String>, ?background:Color = Black, ?textColor:Color = White, events: UIEvents = null) {
-		super();
+		super(events);
 
 		this.text = text;
 		this.bg = background;
@@ -38,8 +38,4 @@ class TextElement extends UIElement {
 
 		return rtn;
 	}
-
-	public override function handleClickEvent(pos: Vec2<Int>,button: ButtonType):Void {
-		Log.debug('Click: ${this.text.get()}');
-	}
 }

src/lib/ui/reactive/UIElement.hx

@@ -1,7 +1,5 @@
 package lib.ui.reactive;
 
-import kernel.Log;
-import kernel.ButtonType;
 import util.Vec.Vec2;
 
 using tink.CoreApi;
@@ -10,11 +8,12 @@ abstract class UIElement {
 	abstract public function render(bounds:Vec2<Int>):Canvas;
 	public var changed(default, null):Signal<Noise>;
 	private final changedTrigger:SignalTrigger<Noise> = Signal.trigger();
+	public final eventListner:UIEvents = {};
 
-	public function new() {
+	public function new(events: UIEvents = null) {
 		changed = changedTrigger.asSignal();
+		if (events != null){
+			this.eventListner = events;
 		}
-
-	public function handleClickEvent(pos: Vec2<Int>,button: ButtonType):Void {
 	}
 }