Serialization of handles working!

Makefile

@@ -1,14 +1,14 @@
 CXX = g++
-CXXFLAGS = -std=c++23 -Wall -g -fno-omit-frame-pointer -gdwarf-4 -Og -Wnarrowing -DLIBREMIDI_ALSA=1
-CXXINC = -Iinclude
+CXXFLAGS = -std=c++23 -Wall -g -fno-omit-frame-pointer -gdwarf-4 -Og -Wnarrowing -DLIBREMIDI_ALSA=1 -DLIBREMIDI_HEADER_ONLY=1
+CXXINC = -isysteminclude
 
-LDLIBS = -lraylib -lasound -pthread 
+LDLIBS = -lraylib -lasound -llibremidi -pthread 
 LDFLAGS = -Llib -L/usr/lib -L/usr/local/lib
 
 hdr_files = ${wildcard src/*.h}
 
 src_files = ${wildcard src/*.cpp}
-src_files += ${wildcard include/libremidi/*.cpp}
+#src_files += ${wildcard include/libremidi/*.cpp}
 
 all: viseq
 	
@@ -20,13 +20,13 @@ $(src_files): %.cpp : %_src
 	$(CXX) -c $@ -o build/$(*F).o $(CXXFLAGS) $(CXXINC)
 
 $(hdr_files): %.h : %_hdr
-	@echo "G++  >---------- $(*F).h -----------<"
+	$(NOECHO) $(NOOP)
 
 %_src:
-	@echo "G++  >---------- $(*F).cpp -----------<"
+	$(NOECHO) $(NOOP)
 
 %_hdr:
-	@echo "G++  >---------- $(*F).h -----------<"
+	$(NOECHO) $(NOOP)
 
 clean:
 	rm -f build/*

src/app-manager.h

@@ -0,0 +1,187 @@
+#pragma once
+
+#include <filesystem>
+#include <fstream>
+#include "interaction-manager.h"
+#include "nlohmann/json.hpp"
+#include "datatypes.h"
+#include "canvas.h"
+#include "graph-manager.h"
+#include "midi-node.h"
+#include "node.h"
+#include "raylib.h"
+#include "signal-manager.h"
+#include "state.h"
+#include "ui.h"
+
+#include <memory>
+
+using json = nlohmann::json;
+
+namespace VISEQ::APP {
+	class AppManager{
+		public:
+			AppManager() : im(gm->getPtr(), sm->getPtr(), canvas), ui(sm->getPtr(), gm->getPtr()) {}
+
+
+			std::mutex mutex;
+
+			std::shared_ptr<APP::State> state = APP::State::get();
+
+			std::shared_ptr<CANVAS::Canvas> canvas = std::make_shared<CANVAS::Canvas>();
+			std::shared_ptr<GraphManager> gm = std::make_shared<GraphManager>();
+			std::shared_ptr<SIGNAL::SignalManager> sm = std::make_shared<SIGNAL::SignalManager>(gm->getPtr(), &mutex);
+			VISEQ::INTERACTION::InteractionManager im;
+
+			UI::AppUI ui;
+
+	        NLOHMANN_DEFINE_TYPE_INTRUSIVE(AppManager, gm, sm);
+
+			void init(){
+				canvas->camera.target = (Vector2){ state->settings.width/2.0f, state->settings.height/2.0f };
+				canvas->camera.offset = (Vector2){ state->settings.width/2.0f, state->settings.height/2.0f };
+				canvas->camera.rotation = 0.0f;
+				canvas->camera.zoom = 1.0f;	
+			}
+			
+			void close(){
+				std::ofstream file("state.json");
+				file << json(*this);
+ 				std::cout << std::setw(4) << json(*this) << std::endl;
+			}
+
+			void startSignals(){
+				sm->startSignalThread();
+			}
+			
+			void loadState(){
+				if(std::filesystem::exists("state.json")){
+					std::ifstream f("state.json");
+					json graph = json::parse(f);
+
+					for(auto n : graph.at("gm").at("nodes")){
+						std::cout << "object? " << n << std::endl;
+						if(n.is_object()){
+							std::cout << "nodeType = " << n.at("nodeType").get<int>() << std::endl;
+
+							if(n.at("nodeType").get<int>() == NodeType::MIDINODE) gm->addNode(n.template get<std::shared_ptr<MidiNode>>());
+							if(n.at("nodeType").get<int>() == NodeType::CONFIGNODE) gm->addNode(n.template get<std::shared_ptr<ConfigNode>>());
+						}
+					}
+
+					int highest_id = 0;
+					for(auto n : graph.at("gm").at("nodes")){
+						std::cout << n << std::endl;
+						if(n.is_object()){
+							if(n.at("id").get<int>() > highest_id) {
+								highest_id = n.at("id").get<int>();
+							}
+						}
+					}
+
+					for(auto e : graph.at("gm").at("edges")){
+						if(e.at("id") > highest_id){
+							highest_id = e.at("id");
+						}
+					}
+
+					for(auto e : graph.at("gm").at("edges")){
+						int start_id = e.at("start").get<int>();
+						int end_id = e.at("end").get<int>();
+
+						VEC_WPTR_Node start = gm->getNodesByID(start_id);
+						VEC_WPTR_Node end = gm->getNodesByID(end_id);
+
+						if(!start.empty() && !end.empty()) {
+							std::cout << std::format("connection {} to {}", start_id, end_id) << std::endl;
+							gm->addConnection(start.front(), end.front());
+						}
+					}
+					gm->lastEdge().lock()->newId(highest_id);
+
+					for(auto s : graph.at("sm").at("signals")){
+						int start_id = s.at("start").get<int>();
+						int next_id = s.at("next").get<int>();
+						int last_id = s.at("last").get<int>();
+						std::shared_ptr<VISEQ::SIGNAL::Signal> ms = s;
+						VEC_WPTR_Node start = gm->getNodesByID(start_id);
+						VEC_WPTR_Node last = gm->getNodesByID(last_id);
+						VEC_WPTR_Node next = gm->getNodesByID(next_id);
+						
+						ms->start = start.front();
+						ms->next = next.front();
+						ms->last = last.front();
+						sm->signals.push_back(ms);
+
+						std::cout << std::format("adding signal with start node {}", start_id) << std::endl;
+					}
+					
+				} else {
+					for(int i = 0; i < 4; ++i){
+						gm->createMidiNode(Vec2Df{(float)i * state->settings.grid*4 + 7 * state->settings.grid, 2 * state->settings.grid*4});
+					}
+					for(int i = 3; i >= 0; --i){
+						gm->createMidiNode(Vec2Df{(float)i * state->settings.grid*4 + 7 * state->settings.grid, 3 * state->settings.grid*4});
+					}
+
+					for(int i = 0; i < 8; ++i){
+						gm->addConnection(gm->getNode(i), gm->getNode((i+1) % 8));
+					}
+					sm->addSignalAtNode(gm->getFirstNode());
+				}
+
+			}
+
+			void updateMidiPorts(){
+				for(auto& n : gm->getMidiNodes()){
+					auto nc = std::dynamic_pointer_cast<MidiNode>(n.lock());
+					for(auto& mo : sm->midi.midi_out_ports){
+						if(!nc->midi_outs.contains(mo.number) && mo.enabled){
+							nc->midi_outs[mo.number] = {mo.number, mo.port.port_name, false};	
+						}
+						if(nc->midi_outs.contains(mo.number) && !mo.enabled){
+							nc->midi_outs.erase(mo.number);
+						}
+					}
+				}
+			}
+
+			void update(){
+				state->update(canvas->camera);
+				canvas->update();
+				gm->update();
+
+				mutex.lock();
+				updateMidiPorts();
+				mutex.unlock();
+				
+				im.update();
+
+			}
+
+			void draw(){
+			BeginDrawing();
+				ClearBackground((Color){46,46,46});
+				canvas->drawStart();
+				canvas->draw();
+
+				gm->drawNodes(SCREEN_MOUSE, canvas->camera);
+				gm->drawEdges(SCREEN_MOUSE, canvas->camera);
+				sm->drawSignals(SCREEN_MOUSE, canvas->camera);
+
+				im.draw();
+
+				canvas->drawEnd();
+				drawUI();
+				EndDrawing();
+			}
+
+			void drawUI(){
+				mutex.lock();
+				ui.draw(SCREEN_MOUSE, canvas->camera);
+				mutex.unlock();
+			}
+	
+	};
+
+}

src/button.h

@@ -1,15 +1,76 @@
 #pragma once
 
 #include "datatypes.h"
+#include "interactable.h"
+#include "vmath.h"
 #include "raylib.h"
 #include "raymath.h"
+#include "state.h"
 
 inline bool ViButton(Vec2Df mp, float x, float y, float radius, Color color){
 	DrawCircle(x,y,radius, color);
 	return (Vector2Distance(mp, (Vector2){x,y}) < radius && IsMouseButtonPressed(MOUSE_BUTTON_LEFT));
 }
 
+inline bool ViButton(Vec2Df mp, Vec2Df position, float radius, Color color){
+	return ViButton(mp, position.x, position.y, radius, color);
+}
+
+inline bool ViButtonText(Vec2Df mp, Vec2Df position, float radius, Color color, std::string text, float text_size, Color text_color){
+	float offset = MeasureText(text.c_str(), text_size);
+	DrawCircle(position.x, position.y, radius, color);
+	DrawText(text.c_str(), position.x-offset/2.0f, position.y - text_size/2, text_size, text_color);
+	return (Vector2Distance(mp, position) < radius && IsMouseButtonPressed(MOUSE_BUTTON_LEFT));
+}
+
 inline bool ViSegButton(Vec2Df mp, float x, float y, float start_angle, float end_angle, float radius, Color color){
 	DrawCircleSector((Vector2){x,y},radius, start_angle, end_angle, 5, color);
 	return (Vector2Distance(mp, (Vector2){x,y}) < radius && IsMouseButtonPressed(MOUSE_BUTTON_LEFT));
 }
+
+inline void DrawCenteredText(std::string text, Vec2Df position, float text_size, Color color){
+	float offset = MeasureText(text.c_str(), text_size);
+	DrawText(text.c_str(), position.x-offset/2.0f, position.y-text_size/2.0f, text_size, color);
+}
+
+namespace VISEQ::APP::UI{
+
+	class Button : public BASE::Interactable{
+		public:
+			Button() {}
+			Button(Vec2Df position, Color color) : color(color), position(position) {}
+			Color color = VS_COLOR_YELLOW;
+			Color hover_color = VS_COLOR_SUN;
+			Vec2Df position = {0,0};
+			std::string text = "";
+			Color text_color = VS_COLOR_BROWN;
+			float text_size = 10;
+			virtual void draw() = 0;
+			virtual GRAPH::GraphItemType getType() override {return GRAPH::GraphItemType::VS_BUTTON;}
+	};
+
+	class ButtonRound : public Button{
+		public:
+			ButtonRound() {}
+			ButtonRound(Vec2Df position, float radius, Color color) : Button(position, color), radius(radius){}
+
+			std::shared_ptr<APP::State> state = APP::State::get();
+
+			float radius = 0.0f;
+			virtual bool hovering() override {	
+				return CheckCollisionPointCircle(SCREEN_MOUSE, position, radius);
+			}
+
+			virtual void pickUp() override {}
+			virtual void pickUp(Vec2Df position) override {}
+			virtual void drag(Vec2Df position) override {}
+			virtual void putDown() override {}
+
+			virtual void draw() override {
+				float offset = MeasureText(text.c_str(), text_size);
+				if(!hovering()) DrawCircle(position.x, position.y, radius, color);
+				else DrawCircle(position.x, position.y, radius, hover_color);
+				if(text != "") DrawText(text.c_str(), position.x-offset/2.0f, position.y - text_size/2, text_size, text_color);
+			}
+	};
+}

src/canvas.h

@@ -0,0 +1,100 @@
+#pragma once
+
+
+#include "datatypes.h"
+#include "interaction-event.h"
+#include "state.h"
+#include "draggable.h"
+#include "raylib.h"
+#include "raymath.h"
+#include "vmath.h"
+#include <memory>
+
+namespace VISEQ::APP::CANVAS {
+	class Canvas : public BASE::Draggable, public std::enable_shared_from_this<Canvas> {
+		public:
+			Canvas() {}
+
+			Camera2D camera;
+			Vec2Df camera_delta;
+			Vec2Df select_start;
+
+			virtual bool hovering() override {	
+				return state->mouse_z == z_index;
+			}
+
+			virtual void drag(Vec2Df position) override {
+				Vec2Df select1 = {SCREEN_MOUSE.x > select_start.x ? select_start.x : SCREEN_MOUSE.x, SCREEN_MOUSE.y > select_start.y ? select_start.y : SCREEN_MOUSE.y};
+				Vec2Df select2 = {SCREEN_MOUSE.x > select_start.x ? SCREEN_MOUSE.x - select_start.x : select_start.x - SCREEN_MOUSE.x, SCREEN_MOUSE.y > select_start.y ? SCREEN_MOUSE.y - select_start.y : select_start.y - SCREEN_MOUSE.y};
+				state->selection = (Rectangle){select1.x, select1.y, select2.x, select2.y};
+			}
+
+			virtual void pickUp() override {
+				std::cout << "canvas pickUp" << std::endl;
+				BASE::Draggable::pickUp();
+				select_start = SCREEN_MOUSE;
+				state->pushEvent({getPtr(), Interaction::DESELECT});
+			}
+
+			virtual void putDown() override {
+				std::cout << "canvas putDown" << std::endl;
+				BASE::Draggable::putDown();
+				state->pushEvent({getPtr(), Interaction::SELECT});
+			}
+			
+			void clearSelectionRect(){
+				state->selection = (Rectangle){0,0,0,0};
+			}
+
+			virtual void drawStart(){
+				BeginMode2D(camera);
+			}
+
+			virtual void drawEnd(){
+				EndMode2D();
+			}
+
+			GRAPH::GraphItemType getType() override {
+				return GRAPH::GraphItemType::CANVAS;
+			}
+		
+			std::shared_ptr<Canvas> getPtr(){
+				return shared_from_this();
+			}
+			
+			virtual void update() override {
+				camera_delta = state->mouse_delta * (-1.0f/camera.zoom);
+				
+				if(state->mouse_right.down) {
+					camera.target = Vector2Add(camera.target, camera_delta);
+				}
+
+				if(hovering() && clicked()) state->pushEvent({getPtr(), APP::Interaction::PICKUP});
+				if(pickedUp()) state->pushEvent({getPtr(), APP::Interaction::DRAG});
+				if(picked_up && released()) state->pushEvent({getPtr(), APP::Interaction::PUTDOWN});
+
+				float wheel = GetMouseWheelMove();
+				if(wheel != 0){
+					if(!KEYS_DOWN.shift && !KEYS_DOWN.ctrl && !KEYS_DOWN.alt){
+						camera.offset = state->raw_mouse;
+						camera.target = SCREEN_MOUSE;
+						float scaleFactor = 1.0f + (0.25f*fabsf(wheel));
+						if (wheel < 0) scaleFactor = 1.0f/scaleFactor;
+						camera.zoom = Clamp(camera.zoom*scaleFactor, 0.125f, 64.0f);
+					}
+				}
+			}
+
+			virtual void draw() {
+				for(int x = -SETTINGS.grid*100; x < SETTINGS.grid*100; x+=SETTINGS.grid){
+					for(int y = -SETTINGS.grid*100; y < SETTINGS.grid*100; y+=SETTINGS.grid){
+						DrawPixel(x, y, (Color){130,130,130,200});
+					}
+				}
+				if(state->selection.width > 0 || state->selection.height > 0) DrawRectangleLines(state->selection.x, state->selection.y, state->selection.width, state->selection.height, (Color){150,150,150,150});
+
+			}
+	};
+}
+
+

src/clipboard.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "node.h"
+
+namespace VISEQ::APP {
+	class Clipboard {
+		public:
+			Clipboard() {}
+
+			std::vector<GRAPH::NODES::VEC_SPTR_Node> clipboard;
+
+			GRAPH::NODES::VEC_SPTR_Node pasteNodes(){
+				return clipboard.back();
+			}
+
+			void copyNodes(GRAPH::NODES::VEC_SPTR_Node selected_nodes){
+				if(clipboard.size() == 20) clipboard.pop_back();
+				clipboard.emplace(clipboard.begin());
+				for(auto n : selected_nodes){
+					clipboard.front().push_back(n);
+				}
+			}
+
+	};
+}

src/config-node.h

@@ -0,0 +1,304 @@
+#pragma once
+
+#include "datatypes.h"
+#include "edge.h"
+#include "node.h"
+#include "raymath.h"
+#include "state.h"
+#include <memory>
+
+namespace VISEQ::GRAPH::NODES {
+
+	class ConfigNode : public Node{
+
+		public:
+			ConfigNode() {std::cout << "ConfigNode Constructor std" << std::endl;}
+			ConfigNode(Vec2Df position) : Node(position) {}
+
+			std::shared_ptr<ConfigNode> getPtr() {
+				return std::static_pointer_cast<ConfigNode>(shared_from_this());
+			}
+
+			NodeType nodeType = NodeType::CONFIGNODE;
+
+			MIDI::MidiNote midiNote;
+			MIDI::MidiCC midiCC;
+			MIDI::MidiPitchBend midiPitchBend;
+			MIDI::MidiPolyPressure midiPolyPressure;
+			MIDI::MidiPC midiPC;
+			MIDI::MidiAftertouch midiAftertouch;
+
+			int mode = 0;
+			float radius = 20.0f;
+
+			virtual NodeType getNodeType() const override {return nodeType;}
+	
+			virtual void trigger() override {}
+
+			virtual void setMode(int _mode) override {
+				mode = _mode;
+			}
+
+			MIDI::MidiNote getNotes() const {
+				MIDI::MidiNote cNote;
+				for(auto cn : getConnectedConfigNodes()){
+					cNote += cn.lock()->getNotes();
+				}
+				return midiNote + cNote;
+			}
+
+			MIDI::MidiCC getCC() const {
+				MIDI::MidiCC cCC;
+				for(auto cn : getConnectedConfigNodes()){
+					cCC += cn.lock()->getCC();
+				}
+				return midiCC + cCC;
+			}
+
+			MIDI::MidiPC getPC() const {
+				MIDI::MidiPC cPC;
+				for(auto cn : getConnectedConfigNodes()){
+					cPC += cn.lock()->getPC();
+				}
+				return midiPC + cPC;
+			}
+
+			MIDI::MidiPitchBend getPitchBend() const {
+				MIDI::MidiPitchBend cPitchBend;
+				for(auto cn : getConnectedConfigNodes()){
+					cPitchBend += cn.lock()->getPitchBend();
+				}
+				return midiPitchBend + cPitchBend;
+			}
+
+			MIDI::MidiAftertouch getAftertouch() const {
+				MIDI::MidiAftertouch cAftertouch;
+				for(auto cn : getConnectedConfigNodes()){
+					cAftertouch += cn.lock()->getAftertouch();
+				}
+				return midiAftertouch + cAftertouch;
+			}
+
+			MIDI::MidiPolyPressure getPolyPressure() const {
+				MIDI::MidiPolyPressure cPolyPressure;
+				for(auto cn : getConnectedConfigNodes()){
+					cPolyPressure += cn.lock()->getPolyPressure();
+				}
+				return midiPolyPressure + cPolyPressure;
+			}
+
+			std::vector<std::weak_ptr<ConfigNode>> getConnectedConfigNodes() const { // TODO: check for cyclic connections of config nodes (crashes)
+				auto config_conns = connections | RANGE_FILTER([](EDGES::SPTR_Edge c){ return c->start.lock()->getNodeType() == NodeType::CONFIGNODE || c->end.lock()->getNodeType() == NodeType::CONFIGNODE;}) | std::ranges::to<std::vector<std::shared_ptr<EDGES::Edge>>>();
+				std::vector<std::weak_ptr<ConfigNode>> config_nodes;
+				for(auto e : config_conns){
+					if(e->start.lock().get() != this && e->start.lock()->getNodeType() == NodeType::CONFIGNODE) config_nodes.push_back(std::dynamic_pointer_cast<ConfigNode>(e->start.lock()));
+					//if(e->end.lock().get() != this && e->end.lock()->getNodeType() == NodeType::CONFIGNODE) config_nodes.push_back(std::dynamic_pointer_cast<ConfigNode>(e->end.lock()));
+				}
+				/*std::cout << "id: " << id << " n cn: " << config_nodes.size() << std::endl;*/
+				return config_nodes;
+			}
+
+			void update() override {
+				Node::update();
+				mode = state->node_mode;
+			}
+
+			void interact(){
+				float wheel = GetMouseWheelMove();
+
+				if(KEYS_DOWN.ctrl && !KEYS_DOWN.alt){
+					switch(state->node_mode){
+						case 0:{
+								   midiNote.note += KEYS_DOWN.shift ? ((wheel > 0) - (wheel < 0)) * 12 : wheel;
+								   break;}
+						case 1:{
+								   midiCC.value += KEYS_DOWN.shift ? ((wheel > 0) - (wheel < 0)) * 12 : wheel;
+								   break;}
+						case 2:{
+								   midiPitchBend.value += KEYS_DOWN.shift ? ((wheel > 0) - (wheel < 0)) * 12 : wheel;
+								   break;}
+					};
+
+					if(midiNote.note < -127 ) midiNote.note = -127;
+					if(midiNote.note > 127 ) midiNote.note = 127;
+
+					if(midiCC.value < -127 ) midiCC.value = -127;
+					if(midiCC.value > 127 ) midiCC.value = 127;
+
+					if(midiPitchBend.value < -16383 ) midiPitchBend.value = -16383;
+					if(midiPitchBend.value > 16383 ) midiPitchBend.value = 16383;
+
+				} else if(KEYS_DOWN.alt) {
+					switch(state->node_mode){
+						case 0:{
+								   midiNote.channel += wheel;
+								   if(midiNote.channel < 0 ) midiNote.channel = 0;
+								   if(midiNote.channel > 15) midiNote.channel = 15;
+								   break;}
+						case 1:{
+								   midiCC.channel += wheel;
+								   if(midiCC.channel < 0 ) midiCC.channel = 0;
+								   if(midiCC.channel > 15 ) midiCC.channel = 15;
+								   break;}
+						case 2:{
+								   midiPitchBend.channel += KEYS_DOWN.shift ? ((wheel > 0) - (wheel < 0)) * 100 : wheel;
+								   if(midiPitchBend.channel < 0 ) midiPitchBend.channel = 0;
+								   if(midiPitchBend.channel > 15 ) midiPitchBend.channel = 15;
+								   break;}
+					};
+				}
+			}
+			
+			void draw(Vec2Df mouse, Camera2D cam) override {
+				Node::draw();
+				if(hovering() || selected) interact();
+
+				DrawRing(position, radius, radius+4, 0, 360, 24, (Color){60, 60, 60, 255});
+				DrawCircleLinesV(position, radius + 4, (Color){100, 100, 100, 255});
+
+				Color gate_color = VS_COLOR_GREEN;
+
+				switch(mode){
+					case 0:{
+							   gate_color = ColorAlphaBlend(VS_COLOR_RED, (Color){180, 210, 115 + 70, (unsigned char)Clamp(255, 0, 255)}, WHITE);
+							   break;}
+					case 1:{
+							   gate_color = ColorAlphaBlend(VS_COLOR_RED, (Color){229, 181, 103 + 70, (unsigned char)Clamp(255, 0, 255)}, WHITE);
+							   break;}
+					case 2:{
+							   gate_color = ColorAlphaBlend(VS_COLOR_RED, (Color){232, 125, 62 + 70, (unsigned char)Clamp(255, 0, 255)}, WHITE);
+							   break;}
+				}
+				if(!picked_up && !selected && !in_selection_rect && !hovering()) DrawCircle(position.x, position.y, radius, gate_color);
+				if(picked_up || in_selection_rect || hovering()) DrawCircle(position.x, position.y, radius, (Color){108, 153, 187, 255});
+				if(selected) DrawCircle(position.x, position.y, radius, (Color){255, 153, 187, 255});
+
+				if(distributionMode == Distribution::RANDOM) DrawCircle(position.x, position.y, radius/2.0f, VS_COLOR_PINK);
+				if(distributionMode == Distribution::ROUNDROBIN) DrawCircle(position.x, position.y, radius/2.0f, VS_COLOR_YELLOW);
+
+				if(selected) DrawCircleLinesV(position, radius+8, (Color){158, 255, 210, 255});
+
+				if(KEYS_DOWN.alt){
+					float value = 0;
+					int offset_gate = 0;
+					switch(mode){
+						case 0:
+							value = (float)getNotes().channel;
+							offset_gate = MeasureText(std::format("{}", value).c_str(), 12);
+							DrawText(std::format("{}",value).c_str(), position.x-offset_gate/2.0f, position.y-5, 12, VS_COLOR_BLACK );
+							break;
+						case 1:
+							value = (float)getCC().channel;
+							offset_gate = MeasureText(std::format("{}", value).c_str(), 12);
+							DrawText(std::format("{}",value).c_str(), position.x-offset_gate/2.0f, position.y-5, 12, VS_COLOR_BLACK );
+							break;
+						case 2:
+							value = (float)getPC().channel;
+							offset_gate = MeasureText(std::format("{}", value).c_str(), 12);
+							DrawText(std::format("{}",value).c_str(), position.x-offset_gate/2.0f, position.y-5, 12, VS_COLOR_BLACK );
+							break;
+						case 3:
+							value = (float)getPitchBend().channel;
+							offset_gate = MeasureText(std::format("{}", value).c_str(), 12);
+							DrawText(std::format("{}",value).c_str(), position.x-offset_gate/2.0f, position.y-5, 12, VS_COLOR_BLACK );
+							break;
+						case 4:
+							value = (float)getAftertouch().channel;
+							offset_gate = MeasureText(std::format("{}", value).c_str(), 12);
+							DrawText(std::format("{}",value).c_str(), position.x-offset_gate/2.0f, position.y-5, 12, VS_COLOR_BLACK );
+							break;
+						case 5:
+							value = (float)getPolyPressure().channel;
+							offset_gate = MeasureText(std::format("{}", value).c_str(), 12);
+							DrawText(std::format("{}",value).c_str(), position.x-offset_gate/2.0f, position.y-5, 12, VS_COLOR_BLACK );
+							break;
+					}
+				} else {
+					switch(mode){
+						case 0:{
+								   int offset = MeasureText(std::format("{:+}", getNotes().note).c_str(), 12);
+								   DrawText(std::format("{:+}", getNotes().note).c_str(), position.x-offset/2.0f, position.y-5, 12, VS_COLOR_BLACK );
+								   break;}
+						case 1:{
+								   int offset = MeasureText(std::format("{:+}", getCC().value).c_str(), 12);
+								   DrawText(std::format("{:+}", getCC().value).c_str(), position.x-offset/2.0f, position.y-5, 12, VS_COLOR_BLACK );
+								   break;}
+						case 2:{
+								   int offset = MeasureText(std::format("{:+}", getPC().value).c_str(), 12);
+								   DrawText(std::format("{:+}", getPC().value).c_str(), position.x-offset/2.0f, position.y-5, 12, VS_COLOR_BLACK );
+								   break;}
+						case 3:{
+								   int offset = MeasureText(std::format("{:+}", getPitchBend().value).c_str(), 12);
+								   DrawText(std::format("{:+}", getPitchBend().value).c_str(), position.x-offset/2.0f, position.y-5, 12, VS_COLOR_BLACK );
+								   break;}
+						case 4:{
+								   int offset = MeasureText(std::format("{:+}", getAftertouch().value).c_str(), 12);
+								   DrawText(std::format("{:+}", getAftertouch().value).c_str(), position.x-offset/2.0f, position.y-5, 12, VS_COLOR_BLACK );
+								   break;}
+						case 5:{
+								   int offset = MeasureText(std::format("{:+}", getPolyPressure().value).c_str(), 12);
+								   DrawText(std::format("{:+}", getPolyPressure().value).c_str(), position.x-offset/2.0f, position.y-5, 12, VS_COLOR_BLACK );
+								   break;}
+					}
+				}
+
+				if(highlighted) DrawCircleLinesV(position, radius+2, (Color){255, 0, 0, 200});
+				//DrawText(std::format("{}", id).c_str(), position.x + 20.0f, position.y + 20.0f, 10, WHITE);
+			}
+	
+			friend void to_json(json& j, const ConfigNode& N){
+				std::vector<int> conns;		
+				std::ranges::transform(N.connections.begin(), N.connections.end(), std::back_inserter(conns), [](VISEQ::GRAPH::EDGES::SPTR_Edge e){ return e->id;});
+
+				j = json{
+					{"id", N.id},
+					{"position", N.position},
+					{"distributionMode", N.distributionMode},
+					{"nodeType", N.nodeType},
+					{"midi_note_channel",N.midiNote.channel},
+					{"midi_note_note",N.midiNote.note},
+					{"midi_note_velocity",N.midiNote.velocity},
+					{"midi_note_gate",N.midiNote.gate},
+					{"midi_cc_channel",N.midiCC.channel},
+					{"midi_cc_control",N.midiCC.control},
+					{"midi_cc_value",N.midiCC.value},
+					{"midi_pc_channel",N.midiPC.channel},
+					{"midi_pc_program",N.midiPC.program},
+					{"midi_pc_value",N.midiPC.value},
+					{"midi_pitch_bend_channel",N.midiPitchBend.channel},
+					{"midi_pitch_bend_value",N.midiPitchBend.value},
+					{"midi_aftertouch_channel",N.midiAftertouch.channel},
+					{"midi_aftertouch_value",N.midiAftertouch.value},
+					{"midi_polypressure_channel",N.midiPolyPressure.channel},
+					{"midi_polypressure_value",N.midiPolyPressure.value},
+					{"connections",conns}};
+			}
+
+			friend void from_json(const json& j, ConfigNode& N){
+				std::cout << "configNode from_json" << std::endl;
+
+				j.at("id").get_to(N.id);
+				j.at("position").get_to<Vec2Df>(N.position);
+				j.at("distributionMode").get_to(N.distributionMode);
+				j.at("nodeType").get_to(N.nodeType);
+				j.at("midi_note_channel").get_to(N.midiNote.channel);
+				j.at("midi_note_note").get_to(N.midiNote.note);
+				j.at("midi_note_velocity").get_to(N.midiNote.velocity);
+				j.at("midi_note_gate").get_to(N.midiNote.gate);
+				j.at("midi_cc_channel").get_to(N.midiCC.channel);
+				j.at("midi_cc_control").get_to(N.midiCC.control);
+				j.at("midi_cc_value").get_to(N.midiCC.value);
+				j.at("midi_pc_channel").get_to(N.midiPC.channel);
+				j.at("midi_pc_program").get_to(N.midiPC.program);
+				j.at("midi_pc_value").get_to(N.midiPC.value);
+				j.at("midi_pitch_bend_channel").get_to(N.midiPitchBend.channel);
+				j.at("midi_pitch_bend_value").get_to(N.midiPitchBend.value);
+				j.at("midi_aftertouch_channel").get_to(N.midiAftertouch.channel);
+				j.at("midi_aftertouch_value").get_to(N.midiAftertouch.value);
+				j.at("midi_polypressure_channel").get_to(N.midiPolyPressure.channel);
+				j.at("midi_polypressure_value").get_to(N.midiPolyPressure.value);
+
+				//j.at("connections").get_to(N.connections);
+			}
+	};
+}

src/connectable.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include "draggable.h"
+#include "vmath.h"
+#include <memory>
+
+namespace VISEQ::BASE {
+	class Connectable : public Draggable {
+		public:
+			Connectable() {}
+			Connectable(Vec2Df position) : Draggable(position) {}
+				
+			std::weak_ptr<Connectable> partner;
+	
+			bool new_partner = false;
+			bool connecting = false;
+			bool connected = false;
+
+			Vec2Df connecting_position;
+	
+			virtual void drag(Vec2Df new_position) override {
+				connecting = true;
+				connecting_position = new_position;
+			}
+			
+			void putDown() override {
+				connect();
+				Draggable::putDown();
+			}
+
+			virtual void connect() {
+				if(picked_up){
+					connecting = false;
+					connected = true;
+				}
+			}
+
+			virtual void draw(){
+				if(connecting) DrawLineV(position, connecting_position, (Color){229, 181, 103, 255});
+			}
+	};
+}

src/connector.h

@@ -0,0 +1,84 @@
+#pragma once
+
+#include "connectable.h"
+#include "datatypes.h"
+#include "graph-item.h"
+#include "interaction-event.h"
+#include "raymath.h"
+#include "state.h"
+#include "vmath.h"
+#include <fcntl.h>
+#include <memory>
+
+namespace VISEQ::GRAPH {
+	class Connector : public BASE::Connectable, public GraphItem, public std::enable_shared_from_this<Connector> {
+		public:
+			Connector() {}
+
+			Connector(std::shared_ptr<GraphItem> parent, Vec2Df center_position, float orbit) : orbit(orbit) {
+				setPosition(center_position);
+				setParent(parent);
+			}
+			
+			std::weak_ptr<GraphItem> parent;
+		
+			bool passable = false;
+
+			float radius = 8.0f;
+			float orbit = 20.0f;
+			Vec2Df center_position;
+			
+			GraphItemType getType() override{
+				return GraphItemType::CONNECTOR;
+			}
+			
+			std::shared_ptr<Connector> getPtr(){
+				return shared_from_this();
+			}
+
+			virtual bool hovering() override {
+				return partner.expired() && CheckCollisionPointCircle(SCREEN_MOUSE, position, radius);
+			}
+
+			void setParent(std::shared_ptr<GraphItem> _parent){
+				parent = _parent;
+			}
+
+			void setPosition(Vec2Df pos) override {
+				center_position = pos;
+			}
+			void setOrbit(float r) {
+				orbit = r;
+			}
+
+			void update() override {
+				if(hovering()) state->pushEvent({getPtr(), APP::Interaction::HOVER});
+				if(hovering() && clicked()) state->pushEvent({getPtr(), APP::Interaction::PICKUP});
+				if(pickedUp()) state->pushEvent({getPtr(), APP::Interaction::DRAG});
+				if(picked_up && released()) state->pushEvent({getPtr(), APP::Interaction::PUTDOWN});
+				if(connected) {
+					state->pushEvent({getPtr(), APP::Interaction::CONNECT});
+					connected = false;
+				}
+
+				if(partner.expired()) position = center_position.orbitAlongVector(SCREEN_MOUSE, orbit);
+				if(!partner.expired()) position = center_position .orbitAlongVector(partner.lock()->position, orbit);
+				if(new_partner) {
+					new_partner = false;
+					state->pushEvent({getPtr(), APP::Interaction::CONNECT});
+				}
+			}
+
+			void draw() override {
+				BASE::Connectable::draw();
+				float opacity = 150.0f - Clamp(position.dist(SCREEN_MOUSE), 0.0f, 150.0f);
+								
+				if(hovering()){
+					DrawCircle(position.x, position.y, 8.0f, (Color){108, 203, 237, 255});
+				} else {
+					DrawCircle(position.x, position.y, 8.0f, (Color){108, 153, 187, (unsigned char)opacity});
+				}
+
+			}
+	};
+}

src/control-node.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include "node.h"
+
+namespace VISEQ::GRAPH::NODES{
+
+	class ControlNode: public Node{
+		public:
+			ControlNode(){}
+			
+			float radius = 6;
+		
+			NodeType nodeType = NodeType::CONTROLNODE;
+
+			Vec2Df center;
+		
+			std::shared_ptr<ControlNode> getPtr(){
+				return std::static_pointer_cast<ControlNode>(shared_from_this());
+			}
+			
+			virtual GRAPH::GraphItemType getType() override {
+				return GraphItemType::NODE;
+			}
+		
+			virtual NodeType getNodeType() const override {return nodeType;}
+
+			virtual bool hovering() override {
+				return CheckCollisionPointCircle(SCREEN_MOUSE, position, radius);
+			}
+
+			virtual void update() override {
+				Node::update();
+			}
+
+			virtual void draw() override {
+				DrawCircleV(position, radius, VS_COLOR_SUN);
+			}
+
+			virtual bool select() override {
+				return false;
+			}
+	};
+}

src/datatypes.h

@@ -4,6 +4,7 @@
 #define _USE_MATH_DEFINES
 #endif
 
+#define VS_COLOR_BLACK (Color){20, 20, 20, 255}
 #define VS_COLOR_DARKGREY (Color){46, 46, 46, 255}
 #define VS_COLOR_LIGHTGREY (Color){100, 100, 100, 255}
 #define VS_COLOR_WHITE (Color){214, 214, 214, 255}
@@ -18,8 +19,6 @@
 #define VS_COLOR_BROWN (Color){84, 75, 61, 255}
 #define VS_COLOR_SUN (Color){214, 170, 21, 255}
 
-#include "vmath.h"
-
 #include "nlohmann/json.hpp"
 using json = nlohmann::json;
 
@@ -33,27 +32,56 @@ namespace VISEQ::GRAPH::NODES {
 	enum Distribution {GEOMETRIC, ROUNDROBIN, RANDOM};
 }
 
-namespace VISEQ::APP{
-	struct AppSettings{
-		int mode = 0;
-		int width;
-		int height;
-		float grid;
-		float bpm;
-		float fps;
-		float speed = 16.0f;
-		int gui_selected_midi_out;
-	};
-	NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(AppSettings, mode, width, height, grid, bpm, fps, speed, gui_selected_midi_out)
-}
 
 namespace VISEQ::GRAPH{
-	enum GraphItemType {NODE, EDGE};
-	enum NodeType {OSCNODE, MIDINODE};
+	enum GraphItemType {NODE, EDGE, CONNECTOR, CANVAS, HANDLE, VS_BUTTON};
+	enum NodeType {OSCNODE, MIDINODE, CONFIGNODE, CONTROLNODE};
+	enum EdgeType {MIDIEDGE, CONFIGEDGE};
 }
 
 
 namespace VISEQ::MIDI{
+	struct MidiNote{
+		int channel = 0;
+		int note = 0;
+		int velocity = 0;
+		int gate = 0; // gate time in milliseconds
+		NLOHMANN_DEFINE_TYPE_INTRUSIVE(MidiNote, channel, note, velocity, gate);
+	};
+
+	struct MidiCC{
+		int channel = 0;
+		int control = 0;
+		int value = 0;
+		NLOHMANN_DEFINE_TYPE_INTRUSIVE(MidiCC, channel, control, value);
+	};
+
+	struct MidiPC{
+		int channel = 0;
+		int program = 0;
+		int value = 0;
+		NLOHMANN_DEFINE_TYPE_INTRUSIVE(MidiPC, channel, program, value);
+	};
+
+	struct MidiPitchBend{
+		int channel = 0;
+		int value = 0;
+		NLOHMANN_DEFINE_TYPE_INTRUSIVE(MidiPitchBend, channel, value);
+	};
+	
+	struct MidiAftertouch{
+		int channel = 0;
+		int value = 0;
+		NLOHMANN_DEFINE_TYPE_INTRUSIVE(MidiAftertouch, channel, value);
+	};
+	
+	struct MidiPolyPressure{
+		int channel = 0;
+		int note = 0;
+		int value = 0;
+		NLOHMANN_DEFINE_TYPE_INTRUSIVE(MidiPolyPressure, channel, note, value);
+	};
+
 	struct MidiOutPort{
 		libremidi::output_port port;
 		int number;
@@ -65,6 +93,193 @@ namespace VISEQ::MIDI{
 		int number;	
 	};
 
+	inline std::ostream& operator<<(std::ostream& os, const MidiNote note){
+		os << "note: " << note.note << " channel: " << note.channel << " velocity: " << note.velocity << " gate: " << note.gate;
+		return os;
+	}
+
+	inline MidiNote operator+(const MidiNote left, const MidiNote right){
+		MidiNote added;
+		added.note = std::clamp(left.note + right.note, 0, 127);
+		added.channel = std::clamp(left.channel + right.channel, 0, 15);
+		added.gate = std::max(left.gate + right.gate, 0);
+		added.velocity = std::clamp(left.velocity + right.velocity, 0, 127);
+		return added;
+	}
+	
+	inline MidiCC operator+(const MidiCC left, const MidiCC right){
+		MidiCC added;
+		added.channel = left.channel + right.channel;
+		added.control = left.control + right.control;
+		added.value = left.value+ right.value;
+		return added;
+	}
+	
+	inline MidiPC operator+(const MidiPC left, const MidiPC right){
+		MidiPC added;
+		added.channel = left.channel + right.channel;
+		added.program = left.program + right.program;
+		added.value = left.value+ right.value;
+		return added;
+	}
+	
+	inline MidiPitchBend operator+(const MidiPitchBend left, const MidiPitchBend right){
+		MidiPitchBend added;
+		added.channel = left.channel + right.channel;
+		added.value = left.value+ right.value;
+		return added;
+	}
+	
+	inline MidiAftertouch operator+(const MidiAftertouch left, const MidiAftertouch right){
+		MidiAftertouch added;
+		added.channel = left.channel + right.channel;
+		added.value = left.value+ right.value;
+		return added;
+	}
+	
+	inline MidiPolyPressure operator+(const MidiPolyPressure left, const MidiPolyPressure right){
+		MidiPolyPressure added;
+		added.channel = left.channel + right.channel;
+		added.note = left.note + right.note;
+		added.value = left.value+ right.value;
+		return added;
+	}
+	
+	inline MidiNote operator-(const MidiNote left, const MidiNote right){
+		MidiNote added;
+		added.note = left.note - right.note;
+		added.channel = left.channel - right.channel;
+		added.gate = left.gate - right.gate;
+		added.velocity = left.velocity - right.velocity;
+		return added;
+	}
+	
+	inline MidiCC operator-(const MidiCC left, const MidiCC right){
+		MidiCC added;
+		added.channel = left.channel - right.channel;
+		added.control = left.control - right.control;
+		added.value = left.value- right.value;
+		return added;
+	}
+	
+	inline MidiPC operator-(const MidiPC left, const MidiPC right){
+		MidiPC added;
+		added.channel = left.channel - right.channel;
+		added.program = left.program - right.program;
+		added.value = left.value- right.value;
+		return added;
+	}
+	
+	inline MidiPitchBend operator-(const MidiPitchBend left, const MidiPitchBend right){
+		MidiPitchBend added;
+		added.channel = left.channel - right.channel;
+		added.value = left.value- right.value;
+		return added;
+	}
+	
+	inline MidiAftertouch operator-(const MidiAftertouch left, const MidiAftertouch right){
+		MidiAftertouch added;
+		added.channel = left.channel - right.channel;
+		added.value = left.value- right.value;
+		return added;
+	}
+	
+	inline MidiPolyPressure operator-(const MidiPolyPressure left, const MidiPolyPressure right){
+		MidiPolyPressure added;
+		added.channel = left.channel - right.channel;
+		added.note = left.note - right.note;
+		added.value = left.value- right.value;
+		return added;
+	}
+
+	// COMPOUND
+	
+	inline MidiNote& operator+=(MidiNote& left, const MidiNote& right){
+		left.note += right.note;
+		left.channel += right.channel;
+		left.gate += right.gate;
+		left.velocity += right.velocity;
+		return left;
+	}
+	
+	inline MidiCC& operator+=(MidiCC& left, const MidiCC right){
+		left.channel += right.channel;
+		left.control += right.control;
+		left.value += right.value;
+		return left;
+	}
+	
+	inline MidiPC& operator+=(MidiPC& left, const MidiPC right){
+		left.channel += right.channel;
+		left.program += right.program;
+		left.value += right.value;
+		return left;
+	}
+	
+	inline MidiPitchBend& operator+=(MidiPitchBend& left, const MidiPitchBend right){
+		left.channel += right.channel;
+		left.value += right.value;
+		return left;
+	}
+	
+	inline MidiAftertouch& operator+=(MidiAftertouch& left, const MidiAftertouch right){
+		left.channel += right.channel;
+		left.value += right.value;
+		return left;
+	}
+	
+	inline MidiPolyPressure& operator+=(MidiPolyPressure& left, const MidiPolyPressure right){
+		left.channel += right.channel;
+		left.note += right.note;
+		left.value += right.value;
+		return left;
+	}
+	
+	
+	inline MidiNote& operator-=(MidiNote& left, const MidiNote& right){
+		left.note -= right.note;
+		left.channel -= right.channel;
+		left.gate -= right.gate;
+		left.velocity -= right.velocity;
+		return left;
+	}
+	
+	inline MidiCC& operator-=(MidiCC& left, const MidiCC right){
+		left.channel -= right.channel;
+		left.control -= right.control;
+		left.value -= right.value;
+		return left;
+	}
+	
+	inline MidiPC& operator-=(MidiPC& left, const MidiPC right){
+		left.channel -= right.channel;
+		left.program -= right.program;
+		left.value -= right.value;
+		return left;
+	}
+	
+	inline MidiPitchBend& operator-=(MidiPitchBend& left, const MidiPitchBend right){
+		left.channel -= right.channel;
+		left.value -= right.value;
+		return left;
+	}
+	
+	inline MidiAftertouch& operator-=(MidiAftertouch& left, const MidiAftertouch right){
+		left.channel -= right.channel;
+		left.value -= right.value;
+		return left;
+	}
+	
+	inline MidiPolyPressure& operator-=(MidiPolyPressure& left, const MidiPolyPressure right){
+		left.channel -= right.channel;
+		left.note -= right.note;
+		left.value -= right.value;
+		return left;
+	}
+	/*Vec2D<T> operator*(const Vec2D<T> left, T scalar){*/
+	/*	return Vec2D<T>(left.x * scalar, left.y * scalar);*/
+	/*};*/
+
 	NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(MidiOut, number)
 	NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(MidiOutPort, number, enabled)
 

src/draggable.h

@@ -0,0 +1,62 @@
+#pragma once
+
+#include "moveable.h"
+#include "raylib.h"
+#include "selectable.h"
+#include "state.h"
+#include "vmath.h"
+
+namespace VISEQ::BASE {
+	class Draggable : public Movable, public Selectable{
+		public:
+			Draggable() {}
+			Draggable(float x, float y) : Movable(Vec2Df(x, y), 960.0f) {}
+			Draggable(Vec2Df p) : Movable(p, 960.0f) {}
+			virtual ~Draggable() {}
+
+			std::shared_ptr<APP::State> state = APP::State::get();
+
+			Vec2Df drag_offset;
+
+			bool picked_up = false;
+
+			virtual bool entered() override {
+				return !is_hovering && hovering();
+			}
+
+			virtual bool exited() override {
+				return is_hovering && !hovering();
+			}
+
+			virtual bool pickedUp() {
+				return held() && picked_up;
+			}
+			
+			virtual void pickUp() override {
+				picked_up = true;
+				drag_offset = position - SCREEN_MOUSE; 
+			}
+
+			virtual void pickUp(Vec2Df selection_origin) override {
+				picked_up = true;
+				drag_offset = position - selection_origin; 
+			}
+
+			virtual void drag(Vec2Df new_position) override {
+				position = new_position;
+			}
+
+			virtual void putDown() override {
+				picked_up = false;
+			}
+
+			virtual bool select() override {
+				return CheckCollisionPointRec(position, state->selection);
+			}
+
+			virtual void deselect() override {
+				selected = false;
+			}
+
+	};
+}

src/edge.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "connector.h"
 #include "graph-item.h"
 #include <memory>
 #include "node.h"
@@ -11,10 +12,15 @@ namespace VISEQ::GRAPH::EDGES {
 
 		public:
 			Edge() {}
-			Edge(std::shared_ptr<NODES::Node> start, std::shared_ptr<NODES::Node> end) : start(start), end(end) {}
+			Edge(std::weak_ptr<NODES::Node> start, std::weak_ptr<NODES::Node> end) : start(start), end(end) {}
 
-			std::shared_ptr<NODES::Node> start;
-			std::shared_ptr<NODES::Node> end;
+			std::weak_ptr<NODES::Node> start;
+			std::weak_ptr<NODES::Node> end;
+
+			std::weak_ptr<Connector> start_conn;
+			std::weak_ptr<Connector> end_conn;
+
+			EdgeType edgeType;
 
 			bool pass_forward = true;
 			bool pass_backward = true;
@@ -22,19 +28,26 @@ namespace VISEQ::GRAPH::EDGES {
 			bool active = false;
 			bool config = false;
 			bool split = false;
+			
+			float speed = 0;
+			float bpm = 120.0f;
 
 			float connector_offset = 8.0f;
 			float switches_offset = 25.0f;
 
 			virtual bool GActive() {return active;}
+			
+			virtual EdgeType getEdgeType() const {return edgeType;}
 
-			std::shared_ptr<NODES::Node> getNextNode(std::shared_ptr<NODES::Node> origin){
-				return start == origin ? end : start;
+			std::weak_ptr<NODES::Node> getNextNode(std::weak_ptr<NODES::Node> origin){
+				return start.lock() == origin.lock() ? end : start;
 			}
 
 			void draw(Vec2Df mouse_pos, Camera2D cam) {}
 	};
 	
 	typedef std::shared_ptr<Edge> SPTR_Edge;
+	typedef std::weak_ptr<Edge> WPTR_Edge;
 	typedef std::vector<SPTR_Edge> VEC_SPTR_Edge;
+	typedef std::vector<WPTR_Edge> VEC_WPTR_Edge;
 }

src/graph-item.h

@@ -2,20 +2,20 @@
 
 #include "raylib.h"
 #include "datatypes.h"
-#include <memory>
-#include <vector>
+#include "vmath.h"
 
 namespace VISEQ::GRAPH {
-	class GraphItem{
+	class GraphItem {
 
 		public:
 			GraphItem() {newId(-1);}
 			GraphItem(const GraphItem& G) {
 				newId(-1);
-				graphItemType = G.graphItemType;
+				gItemType = G.gItemType;
 			}
-			GraphItemType graphItemType;
-			
+
+			GraphItemType gItemType;
+
 			int id = 0;
 
 			void newId(int start){
@@ -25,8 +25,9 @@ namespace VISEQ::GRAPH {
 				_id++;
 			}
 			
+			virtual void draw() {};
 			virtual void draw(Vec2Df mouse, Camera2D cam) {};
-			virtual GraphItemType getType() {return graphItemType;}
+			virtual GraphItemType getType() {return gItemType;}
 			virtual ~GraphItem() = default;
 
 	};

src/graph-manager.h

@@ -1,7 +1,10 @@
 #pragma once
 
 
+#include "config-node.h"
 #include "datatypes.h"
+#include "state.h"
+#include "vmath.h"
 #include "raylib.h"
 #include "raymath.h"
 
@@ -18,6 +21,7 @@
 #include <iterator>
 #include <map>
 #include <memory>
+#include <ostream>
 #include <random>
 #include <ranges>
 #include <vector>
@@ -31,35 +35,98 @@ using namespace VISEQ::GRAPH::EDGES;
 
 namespace VISEQ::GRAPH {
 
-	class GraphManager{
+	class GraphManager : public std::enable_shared_from_this<GraphManager>{
+		private:
+			NODES::VEC_SPTR_Node nodes;
+			EDGES::VEC_SPTR_Edge edges;
+			
+			EDGES::VEC_WPTR_Edge remove_edges;
+			EDGES::VEC_WPTR_Edge split_edges;
+
+			VEC_SPTR_Node selected_nodes;
+
+			std::map<NODES::SPTR_Node, int> counter;
+
+			std::shared_ptr<APP::State> state = APP::State::get();
 
 		public:
 
 			GraphManager() {}
 
-			NODES::VEC_SPTR_Node nodes;
-			EDGES::VEC_SPTR_Edge edges;
+			std::shared_ptr<GraphManager> getPtr(){
+				return shared_from_this();
+			}
 
-			EDGES::VEC_SPTR_Edge remove_edges;
-			EDGES::VEC_SPTR_Edge split_edges;
+			int getNodesSize(){
+				return nodes.size();
+			}
 
-			std::map<NODES::SPTR_Node, int> counter;
-
-			NODES::SPTR_Node getRandomNode(){
-				VEC_SPTR_GraphItem o; 
-				std::ranges::sample(nodes, std::back_inserter(o), 1, std::mt19937{std::random_device{}()});
-				return std::dynamic_pointer_cast<VISEQ::GRAPH::NODES::Node>(o.front());
+			void createMidiNode(Vec2Df position){
+				nodes.emplace_back(std::make_shared<MidiNode>(position));
+				nodes.back()->update();
 			}
 			
-			EDGES::SPTR_Edge getRandomEdge(){
-				VEC_SPTR_GraphItem o; 
-				std::ranges::sample(edges, std::back_inserter(o), 1, std::mt19937{std::random_device{}()});
-				return std::dynamic_pointer_cast<VISEQ::GRAPH::EDGES::Edge>(o.front());
+			void createConfigNode(Vec2Df position){
+				nodes.emplace_back(std::make_shared<ConfigNode>(position));
+				nodes.back()->update();
+			}
+			
+			void setMidiPortForAll(int number, bool _state){
+				for(auto n : nodes){
+					if(n->getNodeType() == NodeType::MIDINODE) std::dynamic_pointer_cast<MidiNode>(n)->setMidiPort(number, _state);
+				}
 			}
 
+			void addNode(SPTR_Node node){
+				std::cout << "added node " << node->id << std::endl;
+				nodes.insert(nodes.end(), node);
+				node->update();
+			}
+			
+			void addConnection(WPTR_Node from, WPTR_Node to){
+				EdgeType et = EdgeType::MIDIEDGE;
+				if(from.lock()->getNodeType() == NodeType::CONFIGNODE || to.lock()->getNodeType() == NodeType::CONFIGNODE) et = EdgeType::CONFIGEDGE;
+				if(from.lock() != to.lock()) {
+					edges.emplace_back(std::make_shared<Edge>());
+					edges.back()->edgeType = et;
+					edges.back()->start = from;
+					edges.back()->end = to;
+					edges.back()->start_conn = from.lock()->connectors.back();
+					edges.back()->end_conn = to.lock()->connectors.back();
+					from.lock()->connections.push_back(edges.back());
+					to.lock()->connections.push_back(edges.back());
+				}
+			}
+			
+			void addToSelection(){
+				auto temp_nodes = nodes | RANGE_FILTER([](SPTR_Node n){return n->selected;}) | std::ranges::to<VEC_SPTR_Node>();
+				selected_nodes.insert(selected_nodes.end(), temp_nodes.begin(), temp_nodes.end());
+			}
+
+			void select(){
+				auto temp_nodes = nodes | RANGE_FILTER([](SPTR_Node n){return n->select();}) | std::ranges::to<VEC_SPTR_Node>();
+				if(!KEYS_DOWN.shift) selected_nodes.clear();
+				selected_nodes.insert(selected_nodes.end(), temp_nodes.begin(), temp_nodes.end());
+				std::for_each(selected_nodes.begin(), selected_nodes.end(), [](WPTR_Node n){n.lock()->selected = true;});
+			}
+			
+			void deselect(){
+				std::cout << "deselect" << std::endl;
+				for(auto s : selected_nodes){
+					s->selected = false;
+				}
+				selected_nodes.clear();
+			}
+
+			VEC_SPTR_Node getSelection(){
+				return selected_nodes;
+			}
+	
 			void copyNodes(VEC_SPTR_Node _nodes, Vec2Df position){
 				for(auto n: _nodes){
 					nodes.insert(nodes.end(), std::make_shared<Node>(*n));
+					/*if(n->getNodeType() == NodeType::MIDINODE) nodes.insert(nodes.end(), std::make_shared<MidiNode>(*n));*/
+					/*if(n->getNodeType() == NodeType::CONFIGNODE) nodes.insert(nodes.end(), std::make_shared<ConfigNode>(*n));*/
 					nodes.back()->setPosition(position + nodes.back()->drag_offset);
 					nodes.back()->selected = false;
 				}
@@ -72,10 +139,23 @@ namespace VISEQ::GRAPH {
 					nodes.back()->selected = false;
 				}
 			}
-			
+		
+			VEC_SPTR_Node getCopiesOfSelectedNodes(){
+				VEC_SPTR_Node copied_nodes;
+				for(auto n : selected_nodes){
+					copied_nodes.insert(copied_nodes.end(), std::make_shared<Node>(*n));
+					/*if(n->getNodeType() == NodeType::MIDINODE) copied_nodes.insert(copied_nodes.end(), std::make_shared<MidiNode>(*n));*/
+					/*if(n->getNodeType() == NodeType::CONFIGNODE) copied_nodes.insert(copied_nodes.end(), std::make_shared<ConfigNode>(*n));*/
+					copied_nodes.back()->deselect();
+				}
+				return copied_nodes;				
+			}
+
 			SPTR_Node copyNode(SPTR_Node n, Vec2Df position){
 				std::cout << "copy basenode" << std::endl;
 				nodes.insert(nodes.end(), std::make_shared<Node>(*n));
+				/*if(n->getNodeType() == NodeType::MIDINODE) nodes.insert(nodes.end(), std::make_shared<MidiNode>(*n));*/
+				/*if(n->getNodeType() == NodeType::CONFIGNODE) nodes.insert(nodes.end(), std::make_shared<ConfigNode>(*n));*/
 				nodes.back()->setPosition(position);
 				return nodes.back();
 			}
@@ -83,40 +163,76 @@ namespace VISEQ::GRAPH {
 			SPTR_Node copyNode(std::shared_ptr<MidiNode> n, Vec2Df position){
 				std::cout << "copy midinode" << std::endl;
 				nodes.insert(nodes.end(), std::make_shared<MidiNode>(*n));
+				nodes.back()->clearConnectors();
 				nodes.back()->setPosition(position);
 				return nodes.back();
 			}
-				
-			SPTR_Node addMidiNode(Vec2Df position){
-				nodes.emplace_back(std::make_shared<MidiNode>(position));
-				return nodes.back();
-			}
-
+					
 			void setNodeMode(int mode){
 				for(auto n: nodes){
-					n->SMode(mode);
+					n->setMode(mode);
 				}
 			}
 
 			void reset(){
 				counter.clear();
 			}
+			WPTR_Node getNode(int i){
+				return nodes.at(i);
+			}
+			
+			WPTR_Node getFirstNode(){
+				return nodes.front();
+			}
+			
+			WPTR_Node getLastNode(){
+				return nodes.back();
+			}
+			
+			VEC_WPTR_Node getMidiNodes(){
+				return nodes | RANGE_FILTER([](VISEQ::GRAPH::NODES::SPTR_Node n){return n->getNodeType() == NodeType::MIDINODE;}) | std::ranges::to<VEC_WPTR_Node>();
+			}
 
-			SPTR_Node next(SPTR_Node current, SPTR_Node last){
-				VEC_SPTR_Edge possible_connections = current->connections | RANGE_FILTER([current](SPTR_Edge c){
-						return (c->start == current && c->pass_forward) || (c->end == current && c->pass_backward);
-						}) | std::ranges::to<VEC_SPTR_Edge>();
+			NODES::SPTR_Node getRandomNode(){
+				VEC_SPTR_GraphItem o; 
+				std::ranges::sample(nodes, std::back_inserter(o), 1, std::mt19937{std::random_device{}()});
+				return std::dynamic_pointer_cast<VISEQ::GRAPH::NODES::Node>(o.front());
+			}
+			
+			EDGES::SPTR_Edge getRandomEdge(){
+				VEC_SPTR_GraphItem o; 
+				std::ranges::sample(edges, std::back_inserter(o), 1, std::mt19937{std::random_device{}()});
+				return std::dynamic_pointer_cast<VISEQ::GRAPH::EDGES::Edge>(o.front());
+			}
+			
+			SPTR_Node getClosestNode(Vec2Df position){
+				auto neighbors = nodes | RANGE_FILTER([](SPTR_Node n){ return !n->picked_up;}) | std::ranges::to<VEC_SPTR_Node>();
+				std::sort(neighbors.begin(), neighbors.end(), [position](SPTR_Node na, SPTR_Node nb){ return na->position.dist(position) < nb->position.dist(position);});
+				return neighbors.front();
+			}
+			VEC_WPTR_Node getNodesByID(int _id){
+				return nodes | RANGE_FILTER([_id](SPTR_Node n){return n->id == _id;}) | std::ranges::to<VEC_WPTR_Node>(); // TODO: Multiple nodes with the same ID? Why not return only one node?
+			}
+			
+			WPTR_Edge lastEdge(){
+				return edges.back();
+			}
+
+			WPTR_Node next(WPTR_Node current, WPTR_Node last){
+				VEC_WPTR_Edge possible_connections = current.lock()->connections | RANGE_FILTER([current](WPTR_Edge c){
+						return (c.lock()->getEdgeType() == EdgeType::MIDIEDGE) && ((c.lock()->start.lock() == current.lock() && c.lock()->pass_forward) || (c.lock()->end.lock() == current.lock() && c.lock()->pass_backward));
+						}) | std::ranges::to<VEC_WPTR_Edge>();
 
 				if(possible_connections.empty()) return SPTR_Node(nullptr);
 				
 				int return_path = 0;
 				float angle = -1;
-				if(current->distributionMode == Distribution::GEOMETRIC){
-					Vec2Df coming_from = (current->position - last->position).norm();
+				if(current.lock()->distributionMode == Distribution::GEOMETRIC){
+					Vec2Df coming_from = (current.lock()->position - last.lock()->position).norm();
 					int i = 0;
 					for(auto n : possible_connections){
-						SPTR_Node next_node = n->getNextNode(current);
-						float angle_v1_v2 = coming_from.norm().dot((next_node->position - current->position).norm());
+						WPTR_Node next_node = n.lock()->getNextNode(current);
+						float angle_v1_v2 = coming_from.norm().dot((next_node.lock()->position - current.lock()->position).norm());
 						if(angle_v1_v2 > angle) {
 							return_path = i;
 							angle = angle_v1_v2;
@@ -125,37 +241,20 @@ namespace VISEQ::GRAPH {
 					}
 				}
 
-				if(current->distributionMode == Distribution::ROUNDROBIN){
-					if(counter.find(current) == counter.end()) {
-						counter[current] = 0;
+				if(current.lock()->distributionMode == Distribution::ROUNDROBIN){
+					if(counter.find(current.lock()) == counter.end()) {
+						counter[current.lock()] = 0;
 					} else {
-						counter[current] = (counter[current] + 1) % possible_connections.size();
-						return_path = counter[current];
+						counter[current.lock()] = (counter[current.lock()] + 1) % possible_connections.size();
+						return_path = counter[current.lock()];
 					}
 				}
 				
-				if(current->distributionMode == Distribution::RANDOM){
+				if(current.lock()->distributionMode == Distribution::RANDOM){
 					return_path = rand() % possible_connections.size();
 				}
 				
-				//possible_connections.at(return_path)->active = true;
-				return possible_connections.at(return_path)->getNextNode(current);
-			}
-
-			SPTR_Node getClosestNode(Vec2Df position){
-				auto neighbors = nodes | RANGE_FILTER([](SPTR_Node n){ return !n->dragging;}) | std::ranges::to<VEC_SPTR_Node>();
-				std::sort(neighbors.begin(), neighbors.end(), [position](SPTR_Node na, SPTR_Node nb){ return na->position.dist(position) < nb->position.dist(position);});
-				return neighbors.front();
-			}
-
-			void addConnection(SPTR_Node from, SPTR_Node to){
-				if(from != to) {
-					edges.emplace_back(std::make_shared<Edge>());
-					edges.back()->start = from;
-					edges.back()->end = to;
-					from->connections.push_back(edges.back());
-					to->connections.push_back(edges.back());
-				}
+				return possible_connections.at(return_path).lock()->getNextNode(current);
 			}
 
 			void splitEdge(SPTR_Edge edge){
@@ -164,10 +263,10 @@ namespace VISEQ::GRAPH {
 			
 			void splitEdges(){
 				for(auto s : split_edges){
-					Vec2Df center = s->end->position.center(s->start->position);
-					SPTR_Node cn = copyNode(std::dynamic_pointer_cast<MidiNode>(s->start), center);
-					addConnection(s->start, cn);
-					addConnection(cn, s->end);
+					Vec2Df center = s.lock()->end.lock()->position.center(s.lock()->start.lock()->position);
+					SPTR_Node cn = copyNode(std::dynamic_pointer_cast<MidiNode>(s.lock()->start.lock()), center); // TODO: copy connectors
+					addConnection(s.lock()->start.lock(), cn);
+					addConnection(cn, s.lock()->end.lock());
 					remove_edges.push_back(s);
 				}
 				split_edges.clear();
@@ -179,132 +278,218 @@ namespace VISEQ::GRAPH {
 
 			void removeEdges(){
 				for(auto edge : remove_edges){
-					std::erase(edge->start->connections, edge);
-					std::erase(edge->end->connections, edge);
-					std::erase(edges, edge);	
+					edge.lock()->start.lock()->removeConnector(edge.lock()->start_conn);
+					edge.lock()->end.lock()->removeConnector(edge.lock()->end_conn);
+					std::erase(edge.lock()->start.lock()->connections, edge.lock());
+					std::erase(edge.lock()->end.lock()->connections, edge.lock());
+					std::erase(edges, edge.lock());	
 				}
 				remove_edges.clear();
 			}
 
-			void drawEdges(Vec2Df mouse_pos, Camera2D cam){
+			VEC_WPTR_Node getAdjacentNodes(VEC_SPTR_Node selected_nodes){
+				for(auto n : nodes){
+					n->highlighted = false;
+				}
+
+				auto erase_connections = edges | RANGE_FILTER([selected_nodes](SPTR_Edge c){ return std::ranges::contains(selected_nodes, c->start.lock()) || std::ranges::contains(selected_nodes, c->end.lock());});
+				
+				VEC_WPTR_Node adjacent_nodes;
+				for(auto c : erase_connections){
+					if(!c->start.lock()->selected) adjacent_nodes.push_back(c->start);
+					if(!c->end.lock()->selected) adjacent_nodes.push_back(c->end);
+				}
+
+				return adjacent_nodes;
+			}
+
+			void removeNodesAndEdges(VEC_SPTR_Node selected_nodes){
+				VEC_WPTR_Node adjacent_nodes = getAdjacentNodes(selected_nodes);
+
+				for(auto n : adjacent_nodes){
+					std::erase_if(n.lock()->connections, [n, selected_nodes](VISEQ::GRAPH::EDGES::WPTR_Edge c){ return std::ranges::contains(selected_nodes, c.lock()->start.lock()) || std::ranges::contains(selected_nodes, c.lock()->end.lock());});
+				}
+				
+				for(auto n : selected_nodes){
+					std::erase_if(this->edges, [n](WPTR_Edge c){ return c.lock()->start.lock() == n || c.lock()->end.lock() == n;});
+				}
+
+				std::erase_if(this->nodes, [selected_nodes](SPTR_Node n){ return std::ranges::contains(selected_nodes, n);});
+			}
+
+			void pasteNodesAndEdges(VEC_SPTR_Node nodes, Vec2Df position){
+
+				VEC_SPTR_Edge copy_connections;
+				for(auto c : edges){
+					if(std::ranges::contains(nodes, c->start.lock()) && std::ranges::contains(nodes, c->end.lock())) {
+						copy_connections.push_back(std::make_shared<Edge>(*c));
+					}
+				}
+				std::cout << copy_connections.size() << std::endl;
+
+				for(auto old_node : nodes){
+					SPTR_Node new_node;
+
+					if(old_node->getNodeType() == NodeType::MIDINODE) {
+						new_node = copyNode(std::dynamic_pointer_cast<MidiNode>(old_node), position + old_node->drag_offset);
+					} else {
+						new_node = copyNode(old_node, position + old_node->drag_offset);
+					}
+
+					new_node->copied = false;
+					new_node->selected = true;
+					
+					//TODO copy connectors 
+
+					for(auto c : copy_connections){
+						if(c->start.lock() == old_node) {
+							c->start = new_node;
+							c->start.lock()->connections.push_back(c);
+						}
+						if(c->end.lock() == old_node) {
+							c->end = new_node;
+							c->end.lock()->connections.push_back(c);
+						}
+					}
+				}
+				std::ranges::copy(copy_connections.begin(), copy_connections.end(), std::back_inserter(edges));
+			}
+			
+			void update(){
 				if(!remove_edges.empty()) removeEdges();
 				if(!split_edges.empty()) splitEdges();
+			}
+
+			void drawEdges(Vec2Df mouse_pos, Camera2D cam){
 				for(auto c : edges){
-					Vec2Df v1_position = c->start->position - ((c->start->position - c->end->position)).norm() * (c->start->radius + c->connector_offset);
-					Vec2Df v2_position = c->end->position - ((c->end->position - c->start->position)).norm() * (c->end->radius + c->connector_offset);
+					Vec2Df v1_position = c->start.lock()->position - ((c->start.lock()->position - c->end.lock()->position)).norm() * (c->start.lock()->radius + c->connector_offset);
+					Vec2Df v2_position = c->end.lock()->position - ((c->end.lock()->position - c->start.lock()->position)).norm() * (c->end.lock()->radius + c->connector_offset);
 					float v1_v2_distance = v1_position.dist(&v2_position);
-
-					float midi_gate_v1 = Clamp((4.f / 1000.f) * c->start->GGate(), 1.f, 4.f);
-					float midi_gate_v2 = Clamp((4.f / 1000.f) * c->end->GGate(), 1.f, 4.f);
-					// Line with small connector circles
-					
-					Color col = {229, 181, 103, 255};
-					if(c->GActive()) col = {108, 153, 187, 255};
-					DrawLine(v1_position.x, v1_position.y, v2_position.x, v2_position.y, col);
-					{
-						float d = c->start->position.dist(c->end->position);
-						std::string frac = MIDI::Fractions.at(std::clamp<int>(round(d/60) - 1, 0, 31));
-						Vector2 text_length = MeasureTextEx(GetFontDefault(), std::format("{:.1f}",d).c_str(), 10.0f, 2.0f); 
-						Vector2 text_length_frac = MeasureTextEx(GetFontDefault(), frac.c_str(), 10.0f, 2.0f); 
-						
-						Vec2Df middle_handle = c->start->position + (c->end->position - c->start->position) * ((d - text_length.x)*0.5f)/d;
-						Vec2Df middle_handle_frac = c->start->position + (c->end->position - c->start->position) * ((d - text_length_frac.x)*0.5f)/d;
-						Vec2Df text_position = middle_handle + (c->start->position - c->end->position).norm().orth() * 12.0f;
-						Vec2Df text_position_frac = middle_handle_frac - (c->start->position - c->end->position).norm().orth() * 4.0f;
-
-						float rotation = Vector2Angle((Vector2){1,0}, (c->end->position - c->start->position)) * RAD2DEG;
-						DrawTextPro(GetFontDefault(), std::format("{:.1f}",d).c_str(), text_position, (Vector2){0,0}, rotation, 10.0f, 2.0f, VS_COLOR_PINK);
-						if( (int)d % 60 == 0) DrawTextPro(GetFontDefault(), frac.c_str(), text_position_frac, (Vector2){0,0}, rotation, 10.0f, 2.0f, VS_COLOR_PINK);
-					}
-					if(midi_gate_v1 == 4.0f) col = VS_COLOR_RED;
-					DrawCircle(v1_position.x, v1_position.y, midi_gate_v1, col);
-					
-					col = {229, 181, 103, 255};
-					if(midi_gate_v2 == 4.0f) col = VS_COLOR_RED;
-					DrawCircle(v2_position.x, v2_position.y, midi_gate_v2, col);
 					
 					if(v1_v2_distance < 100) c->switches_offset = v1_v2_distance/2.3f;
-					Vec2Df from_to_handle = c->start->position - ((c->start->position - c->end->position)).norm() * (c->start->radius + c->switches_offset);
-					Vec2Df to_from_handle = c->end->position - ((c->end->position - c->start->position)).norm() * (c->end->radius + c->switches_offset);
-					Vec2Df middle_handle = c->end->position - ((c->end->position - c->start->position))*0.4f;
-					Vec2Df middle_handle_2 = c->end->position - ((c->end->position - c->start->position))*0.6f;
+					Vec2Df from_to_handle = c->start.lock()->position - ((c->start.lock()->position - c->end.lock()->position)).norm() * (c->start.lock()->radius + c->switches_offset);
+					Vec2Df to_from_handle = c->end.lock()->position - ((c->end.lock()->position - c->start.lock()->position)).norm() * (c->end.lock()->radius + c->switches_offset);
+					Vec2Df middle_handle = c->end.lock()->position - ((c->end.lock()->position - c->start.lock()->position))*0.4f;
+					Vec2Df middle_handle_2 = c->end.lock()->position - ((c->end.lock()->position - c->start.lock()->position))*0.6f;
 					Vec2Df flip_handle = middle_handle + (v1_position - v2_position).norm().orth() * (v1_v2_distance < 120.0f ? Clamp((120.0f - v1_v2_distance)*0.2, 0.f, 20.f) : 1.0f);
 					Vec2Df flip_handle_2 = middle_handle_2 + (v1_position - v2_position).norm().orth() * (v1_v2_distance < 120.0f ? Clamp((120.0f - v1_v2_distance)*-0.2, -20.f, 0.f) : 1.0f);
-				
+						
 					// Dynamic opacity by distance to mouse
 					unsigned char opacity = 150.0f - Clamp(middle_handle.dist(mouse_pos), 0.0f, 150.0f);
 					unsigned char opacity_from = 250.0f - Clamp(from_to_handle.dist(mouse_pos), 0.0f, 220.0f);
 					unsigned char opacity_to = 250.0f - Clamp(to_from_handle.dist(mouse_pos), 0.0f, 220.0f);
-				
-					if(!c->start->dragging && !c->end->dragging){
-						// On/Off switches on both sides
-						if(ViButton(mouse_pos, from_to_handle.x, from_to_handle.y, 8.0f, c->pass_forward ? (Color){120, 210, 115, opacity_from} : (Color){232, 50, 32, opacity_from} )) c->pass_forward = !c->pass_forward;
-						if(ViButton(mouse_pos, to_from_handle.x, to_from_handle.y, 8.0f, c->pass_backward ? (Color){120, 210, 115, opacity_to} : (Color){232, 50, 32, opacity_to} )) c->pass_backward = !c->pass_backward;
 
-						if(!c->pass_forward){
-							Vec2Df block_point1 = (v1_position - v2_position).norm().orth()*4.0f + from_to_handle;
-							Vec2Df block_point2 = (v1_position - v2_position).norm().orth()*-4.0f + from_to_handle;
-							DrawLineEx(block_point1, block_point2, 2.0f, (Color){232,232,232,opacity_from});
+					float midi_gate_v1 = 0.0f;
+					float midi_gate_v2 = 0.0f; 
+
+					if(c->start.lock()->getNodeType() == NodeType::MIDINODE){
+						midi_gate_v1 = Clamp((4.f / 1000.f) * std::dynamic_pointer_cast<MidiNode>(c->start.lock())->getNotes().gate, 1.f, 4.f);
+					}
+					if(c->end.lock()->getNodeType() == NodeType::MIDINODE){
+						midi_gate_v2 = Clamp((4.f / 1000.f) * std::dynamic_pointer_cast<MidiNode>(c->end.lock())->getNotes().gate, 1.f, 4.f);
+					}
+					// Line with small connector circles
+					if(c->end.lock()->getNodeType() == NodeType::MIDINODE && c->start.lock()->getNodeType() == NodeType::MIDINODE){
+
+						Color col = {229, 181, 103, 255};
+						if(c->GActive()) col = {108, 153, 187, 255};
+						DrawLine(v1_position.x, v1_position.y, v2_position.x, v2_position.y, col);
+						{
+							float d = c->start.lock()->position.dist(c->end.lock()->position);
+							std::string frac = MIDI::Fractions.at(std::clamp<int>(round(d/60) - 1, 0, 31));
+							Vector2 text_length = MeasureTextEx(GetFontDefault(), std::format("{:.1f}",d).c_str(), 10.0f, 2.0f); 
+							Vector2 text_length_frac = MeasureTextEx(GetFontDefault(), frac.c_str(), 10.0f, 2.0f); 
+							
+							Vec2Df middle_handle = c->start.lock()->position + (c->end.lock()->position - c->start.lock()->position) * ((d - text_length.x)*0.5f)/d;
+							Vec2Df middle_handle_frac = c->start.lock()->position + (c->end.lock()->position - c->start.lock()->position) * ((d - text_length_frac.x)*0.5f)/d;
+							Vec2Df text_position = middle_handle + (c->start.lock()->position - c->end.lock()->position).norm().orth() * 12.0f;
+							Vec2Df text_position_frac = middle_handle_frac - (c->start.lock()->position - c->end.lock()->position).norm().orth() * 4.0f;
+
+							float rotation = Vector2Angle((Vector2){1,0}, (c->end.lock()->position - c->start.lock()->position)) * RAD2DEG;
+							DrawTextPro(GetFontDefault(), std::format("{:.1f}",d).c_str(), text_position, (Vector2){0,0}, rotation, 10.0f, 2.0f, VS_COLOR_PINK);
+							if( (int)d % 60 == 0) DrawTextPro(GetFontDefault(), frac.c_str(), text_position_frac, (Vector2){0,0}, rotation, 10.0f, 2.0f, VS_COLOR_PINK);
 						}
+						if(midi_gate_v1 == 4.0f) col = VS_COLOR_RED;
+						DrawCircle(v1_position.x, v1_position.y, midi_gate_v1, col);
 						
-						if(!c->pass_backward){
-							Vec2Df block_point1 = (v1_position - v2_position).norm().orth()*4.0f + to_from_handle;
-							Vec2Df block_point2 = (v1_position - v2_position).norm().orth()*-4.0f + to_from_handle;
-							DrawLineEx(block_point1, block_point2, 2.0f, (Color){232,232,232,opacity_to});
+						col = {229, 181, 103, 255};
+						if(midi_gate_v2 == 4.0f) col = VS_COLOR_RED;
+						DrawCircle(v2_position.x, v2_position.y, midi_gate_v2, col);
+					
+						if(!c->start.lock()->picked_up && !c->end.lock()->picked_up){
+							// On/Off switches on both sides
+							if(ViButton(mouse_pos, from_to_handle.x, from_to_handle.y, 8.0f, c->pass_forward ? (Color){120, 210, 115, opacity_from} : (Color){232, 50, 32, opacity_from} )) c->pass_forward = !c->pass_forward;
+							if(ViButton(mouse_pos, to_from_handle.x, to_from_handle.y, 8.0f, c->pass_backward ? (Color){120, 210, 115, opacity_to} : (Color){232, 50, 32, opacity_to} )) c->pass_backward = !c->pass_backward;
+
+							if(!c->pass_forward){
+								Vec2Df block_point1 = (v1_position - v2_position).norm().orth()*4.0f + from_to_handle;
+								Vec2Df block_point2 = (v1_position - v2_position).norm().orth()*-4.0f + from_to_handle;
+								DrawLineEx(block_point1, block_point2, 2.0f, (Color){232,232,232,opacity_from});
+							}
+							
+							if(!c->pass_backward){
+								Vec2Df block_point1 = (v1_position - v2_position).norm().orth()*4.0f + to_from_handle;
+								Vec2Df block_point2 = (v1_position - v2_position).norm().orth()*-4.0f + to_from_handle;
+								DrawLineEx(block_point1, block_point2, 2.0f, (Color){232,232,232,opacity_to});
+							}
+							
+							if(ViButton(mouse_pos, flip_handle_2.x, flip_handle_2.y, 8.0f, (Color){232, 125, 62, opacity} )) splitEdge(c);
+						}
+					}
+					if(c->start.lock()->getNodeType() == NodeType::CONFIGNODE || c->end.lock()->getNodeType() == NodeType::CONFIGNODE){
+						DrawLine(v1_position.x, v1_position.y, v2_position.x, v2_position.y, VS_COLOR_BLUE);
+					}
+
+					if(ViButton(mouse_pos, flip_handle.x, flip_handle.y, 8.0f, (Color){232, 50, 32, opacity} )) removeEdge(c);
+				}
+			}
+
+			void drawNeighborLines(SPTR_Node node, Vec2Df mouse_pos, Camera2D camera){
+				float min_d = 480;
+				auto neighbors_local = nodes | RANGE_FILTER([mouse_pos](SPTR_Node n){ return !n->picked_up && !n->selected && n->position.dist(mouse_pos) < 960;}) | std::ranges::to<VEC_SPTR_Node>();
+				std::sort(neighbors_local.begin(), neighbors_local.end(), [node, mouse_pos](SPTR_Node na, SPTR_Node nb){ return na->position.dist(mouse_pos) < nb->position.dist(mouse_pos);});
+				if(!neighbors_local.empty()){
+					min_d = neighbors_local.front()->position.dist(mouse_pos);
+					DrawCircleLinesV(neighbors_local.front()->position, 22.0f, VS_COLOR_PINK);
+					node->neighbors = neighbors_local | std::ranges::views::filter([mouse_pos, min_d](SPTR_Node n){return abs(n->position.dist(mouse_pos) - min_d) < 5;}) | std::ranges::to<VEC_SPTR_Node>();
+					for(auto nb : node->neighbors){
+						DrawCircleLinesV(nb->position, 20.0f, VS_COLOR_RED);
+						float d = nb->position.dist(mouse_pos);
+						float dn = nb->position.dist(node->position);
+						if(d > 0 && d < min_d*1.5 && d < 960) {
+							std::string frac = MIDI::Fractions.at(std::clamp<int>(round(dn/60) - 1, 0, 31));
+							Vector2 text_length = MeasureTextEx(GetFontDefault(), std::format("{:.1f}",dn).c_str(), 10.0f, 2.0f); 
+							Vector2 text_length_frac = MeasureTextEx(GetFontDefault(), frac.c_str(), 10.0f, 2.0f); 
+							
+							Vec2Df middle_handle = nb->position + (node->position - nb->position) * ((dn - text_length.x)*0.5f)/dn;
+							Vec2Df middle_handle_frac = nb->position + (node->position - nb->position) * ((dn - text_length_frac.x)*0.5f)/dn;
+							Vec2Df text_position = middle_handle + (nb->position - node->position).norm().orth() * 12.0f;
+							Vec2Df text_position_frac = middle_handle_frac - (nb->position - node->position).norm().orth() * 4.0f;
+
+							float rotation = Vector2Angle((Vector2){1,0}, (node->position - nb->position)) * RAD2DEG;
+							DrawTextPro(GetFontDefault(), std::format("{:.1f}",dn).c_str(), text_position, (Vector2){0,0}, rotation, 10.0f, 2.0f, VS_COLOR_PINK);
+							if(IsKeyDown(KEY_LEFT_SHIFT)) DrawTextPro(GetFontDefault(), frac.c_str(), text_position_frac, (Vector2){0,0}, rotation, 10.0f, 2.0f, VS_COLOR_PINK);
+							Vec2Df n_position = node->position - ((node->position - nb->position)).norm() * 20.0f;
+							Vec2Df nb_position = nb->position - ((nb->position - node->position)).norm() * 20.0f;
+							DrawLineV(n_position, nb_position, VS_COLOR_PINK);
 						}
-						
-						if(ViButton(mouse_pos, flip_handle.x, flip_handle.y, 8.0f, (Color){232, 50, 32, opacity} )) removeEdge(c);
-						if(ViButton(mouse_pos, flip_handle_2.x, flip_handle_2.y, 8.0f, (Color){232, 125, 62, opacity} )) splitEdge(c);
 					}
 				}
 			}
 
 			void drawNodes(Vec2Df mouse_pos, Camera2D camera){
-				float min_d = 480;
 				for(auto n : nodes){
-					if(n->dragging){
-						auto neighbors_local = nodes | RANGE_FILTER([mouse_pos](SPTR_Node n){ return !n->dragging && !n->selected && n->position.dist(mouse_pos) < 960;}) | std::ranges::to<VEC_SPTR_Node>();
-						std::sort(neighbors_local.begin(), neighbors_local.end(), [n, mouse_pos](SPTR_Node na, SPTR_Node nb){ return na->position.dist(mouse_pos) < nb->position.dist(mouse_pos);});
-						if(!neighbors_local.empty()){
-							min_d = neighbors_local.front()->position.dist(mouse_pos);
-							DrawCircleLinesV(neighbors_local.front()->position, 22.0f, VS_COLOR_PINK);
-							n->neighbors = neighbors_local | std::ranges::views::filter([mouse_pos, min_d](SPTR_Node n){return abs(n->position.dist(mouse_pos) - min_d) < 5;}) | std::ranges::to<VEC_SPTR_Node>();
-							for(auto nb : n->neighbors){
-								DrawCircleLinesV(nb->position, 20.0f, VS_COLOR_RED);
-								float d = nb->position.dist(mouse_pos);
-								float dn = nb->position.dist(n->position);
-								if(d > 0 && d < min_d*1.5 && d < 960) {
-									std::string frac = MIDI::Fractions.at(std::clamp<int>(round(dn/60) - 1, 0, 31));
-									Vector2 text_length = MeasureTextEx(GetFontDefault(), std::format("{:.1f}",dn).c_str(), 10.0f, 2.0f); 
-									Vector2 text_length_frac = MeasureTextEx(GetFontDefault(), frac.c_str(), 10.0f, 2.0f); 
-									
-									Vec2Df middle_handle = nb->position + (n->position - nb->position) * ((dn - text_length.x)*0.5f)/dn;
-									Vec2Df middle_handle_frac = nb->position + (n->position - nb->position) * ((dn - text_length_frac.x)*0.5f)/dn;
-									Vec2Df text_position = middle_handle + (nb->position - n->position).norm().orth() * 12.0f;
-									Vec2Df text_position_frac = middle_handle_frac - (nb->position - n->position).norm().orth() * 4.0f;
-
-									float rotation = Vector2Angle((Vector2){1,0}, (n->position - nb->position)) * RAD2DEG;
-									DrawTextPro(GetFontDefault(), std::format("{:.1f}",dn).c_str(), text_position, (Vector2){0,0}, rotation, 10.0f, 2.0f, VS_COLOR_PINK);
-									if(IsKeyDown(KEY_LEFT_SHIFT)) DrawTextPro(GetFontDefault(), frac.c_str(), text_position_frac, (Vector2){0,0}, rotation, 10.0f, 2.0f, VS_COLOR_PINK);
-									Vec2Df n_position = n->position - ((n->position - nb->position)).norm() * 20.0f;
-									Vec2Df nb_position = nb->position - ((nb->position - n->position)).norm() * 20.0f;
-									DrawLineV(n_position, nb_position, VS_COLOR_PINK);
-								}
-								
-							}
-						}
-					}
+					if(KEYS_PRESSED.ctrl && n->hovering()) state->selection_origin = n->position;
+				}
+				BASE::Interactable::z_hovering = -1;
+				for(auto n : nodes){
+					n->update();
+					if(n->picked_up) drawNeighborLines(n, mouse_pos, camera);
 					n->draw(mouse_pos, camera);
 				}
 			}
 
+			NLOHMANN_DEFINE_TYPE_INTRUSIVE(GraphManager, nodes, edges, selected_nodes)
 	};
 
-	inline void to_json(json& j, const GraphManager& G){
-		j = json{{"nodes", G.nodes}, {"edges", G.edges}};
-	}
-	
-	inline void from_json(const json& j, GraphManager& G){
-		j.at("nodes").template get_to<VEC_SPTR_Node>(G.nodes); // = json{{"nodes", G.nodes}, {"edges", G.edges}};
-	}
 }

src/helper.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "vmath.h"
+#include <raymath.h>
+#include <string>
+
+namespace VISEQ::HELPER{
+		inline void DrawSuperText(std::string text, Vec2Df start, Vec2Df end, float pos, float dist, float size, Color col){
+			float d = start.dist(end);
+			Vector2 text_length = MeasureTextEx(GetFontDefault(), text.c_str(), size, 2.0f); 
+
+			Vec2Df middle_handle = start + (end - start) * ((d - text_length.x)*pos)/d;
+			Vec2Df text_position = middle_handle + (start - end).norm().orth() * dist;
+
+			float rotation = Vector2Angle((Vector2){1,0}, (end - start)) * RAD2DEG;
+			DrawTextPro(GetFontDefault(), text.c_str(), text_position, (Vector2){0,0}, rotation, size, 2.0f, col);
+		}
+}

src/interactable.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include "datatypes.h"
+#include "raylib.h"
+#include "vmath.h"
+namespace VISEQ::BASE {
+
+	class Interactable{
+		public:
+			Interactable() {
+				static int _z_index = 0;
+				z_index = _z_index;
+				_z_index++;
+			}
+
+			virtual ~Interactable() {}
+		
+			bool is_hovering = false;
+			
+			int z_index = 0;
+			inline static int z_hovering = 0;
+
+			virtual bool hovering() = 0;
+			virtual bool entered() {return false;};
+			virtual bool exited() {return false;};
+
+			virtual bool clicked() {
+				return hovering() && IsMouseButtonPressed(MOUSE_BUTTON_LEFT);
+			}
+			
+			virtual bool held() {
+				return IsMouseButtonDown(MOUSE_BUTTON_LEFT);
+			}
+			
+			virtual bool released() {
+				return IsMouseButtonReleased(MOUSE_BUTTON_LEFT);
+			}
+
+			virtual GRAPH::GraphItemType getType() = 0;
+			virtual void pickUp() = 0;
+			virtual void pickUp(Vec2Df position) = 0;
+			virtual void drag(Vec2Df position) = 0;
+			virtual void putDown() = 0;
+	};
+
+}

src/interaction-event.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "interactable.h"
+#include <deque>
+#include <memory>
+
+namespace VISEQ::APP{
+
+	enum Interaction {NONE, HOVER, CLICK, RIGHTCLICK, HOLD, RELEASE, PICKUP, DRAG, PUTDOWN, SELECT, DESELECT, CONNECT};
+	
+	struct InteractionEvent{
+		std::shared_ptr<BASE::Interactable> item;
+		Interaction action;
+	};
+	
+	inline bool operator==(const InteractionEvent& lhs, const InteractionEvent& rhs){
+		return lhs.item == rhs.item;
+	}
+
+	inline static std::deque<APP::InteractionEvent> event_queue;
+}

src/interaction-manager.h

@@ -0,0 +1,311 @@
+#pragma once
+
+#include "clipboard.h"
+#include "connector.h"
+#include "datatypes.h"
+#include "draggable.h"
+#include "graph-item.h"
+#include "graph-manager.h"
+#include "interaction-event.h"
+#include "node.h"
+#include "raylib.h"
+#include "signal-manager.h"
+#include "state.h"
+#include "canvas.h"
+#include <algorithm>
+#include <memory>
+
+namespace VISEQ::INTERACTION{
+	class ScaleHandle : public BASE::Draggable, public GraphItem, public std::enable_shared_from_this<ScaleHandle>{
+		public:
+			ScaleHandle(){}
+			
+			float radius = 6;
+		
+			std::shared_ptr<ScaleHandle> getPtr(){
+				return shared_from_this();
+			}
+			
+			virtual GRAPH::GraphItemType getType() override {
+				return GraphItemType::HANDLE;
+			}
+
+			virtual bool hovering() override {
+				return CheckCollisionPointCircle(SCREEN_MOUSE, position, radius);
+			}
+
+			virtual void update() override {
+				if(hovering()) state->pushEvent({getPtr(), APP::Interaction::HOVER});
+				if(hovering() && clicked()) state->pushEvent({getPtr(), APP::Interaction::PICKUP});
+				if(pickedUp()) state->pushEvent({getPtr(), APP::Interaction::DRAG});
+				if(picked_up && released()) state->pushEvent({getPtr(), APP::Interaction::PUTDOWN});
+			}
+
+			virtual void draw() override {
+				DrawCircleV(position, radius, VS_COLOR_SUN);
+			}
+
+			virtual bool select() override {
+				return false;
+			}
+	};
+
+	class InteractionManager{
+		public:
+			InteractionManager() {}
+			InteractionManager(std::shared_ptr<GRAPH::GraphManager> gm, std::shared_ptr<SIGNAL::SignalManager> sm, std::shared_ptr<APP::CANVAS::Canvas> canvas) : canvas(canvas), gm(gm), sm(sm) {}
+
+			std::shared_ptr<APP::CANVAS::Canvas> canvas;
+			std::shared_ptr<GraphManager> gm;
+			std::shared_ptr<SIGNAL::SignalManager> sm;
+			VISEQ::APP::Clipboard cb;
+
+			std::shared_ptr<APP::State> state = APP::State::get();
+			
+			Vec2Df scale_start;
+			std::shared_ptr<ScaleHandle> scale_handle = std::make_shared<ScaleHandle>();
+
+			void update(){
+				if(KEYS_DOWN.ctrl && IsKeyPressed(KEY_C)){
+					VEC_SPTR_Node selected_nodes = gm->getCopiesOfSelectedNodes();
+					if(!selected_nodes.empty()) cb.copyNodes(selected_nodes);
+				}
+
+				if(KEYS_DOWN.ctrl && IsKeyPressed(KEY_V)){
+					VEC_SPTR_Node paste_nodes = cb.pasteNodes();
+					if(!paste_nodes.empty()) gm->pasteNodesAndEdges(paste_nodes, MOD_MOUSE);
+				}
+
+				if(IsKeyPressed(KEY_DELETE)){
+					removeNodes(gm->getSelection());
+				}
+
+				if(!KEYS_DOWN.shift && IsKeyPressed(KEY_TAB)) {
+					state->node_mode = (state->node_mode + 1) % 7;
+				}
+				
+				if(KEYS_DOWN.shift && IsKeyPressed(KEY_TAB)) {
+					state->node_mode -= state->node_mode > 0 ? 1 : -6;
+				}
+				
+			}
+			
+			void draw(){
+				doInteraction();
+				scaleSelection();
+				if(!gm->getSelection().empty()){
+					DrawRectangleRoundedLines(state->bounding_box, 0.1f, 3, VS_COLOR_LIGHTGREY);
+					scale_handle->draw();
+				}
+			}
+			
+			void removeNodes(VEC_SPTR_Node nodes){
+
+				VEC_WPTR_Node adjacent_nodes = gm->getAdjacentNodes(nodes);
+
+				sm->rerouteSignal(nodes, adjacent_nodes);
+				sm->rebaseSignal(nodes);
+
+				gm->removeNodesAndEdges(nodes);
+			}
+			
+			void scaleSelection(){
+				if(!gm->getSelection().empty()){
+					float offset = 30;
+					Vec2Df corner_tl = {50000, 50000};
+					Vec2Df corner_br = {-50000, -50000};
+					std::shared_ptr<Node> node_tl;
+					std::shared_ptr<Node> node_br;
+
+					for(auto n : gm->getSelection()){
+						float x = n->position.x;
+						float y = n->position.y;
+
+						if(x < corner_tl.x && y < corner_tl.y) node_tl = n;
+						if(x > corner_br.x && y > corner_br.y) node_br = n;
+
+						if(x <= corner_tl.x) corner_tl.x = x;
+						if(x >= corner_br.x) corner_br.x = x;
+						if(y <= corner_tl.y) corner_tl.y = y;
+						if(y >= corner_br.y) corner_br.y = y;
+					}
+					corner_tl -= Vec2Df(offset, offset);
+					corner_br += Vec2Df(offset, offset);
+					state->bounding_box = (Rectangle){corner_tl.x, corner_tl.y, corner_br.x - corner_tl.x, corner_br.y - corner_tl.y};
+
+					scale_handle->update();
+
+					if(scale_handle->clicked()){
+						scale_start = (corner_br - corner_tl);
+						for(auto n : gm->getSelection()){
+							n->drag_offset = n->position - node_tl->position;
+						}
+					}
+					if(scale_handle->picked_up){
+						Vec2Df scale = (scale_handle->position - corner_tl) / scale_start;
+						if(IsKeyDown(KEY_LEFT_SHIFT)) scale.y = scale.x;
+						DrawText(std::format("{:.2f} {:.2f}", scale.x, scale.y).c_str(), corner_br.x+5, corner_br.y+5, 10, RED);
+						for(auto n : gm->getSelection()){
+							n->position = node_tl->position + (n->drag_offset * scale);
+						}
+					} else {
+						scale_handle->position = corner_br;
+					}
+				}
+			}
+			
+			void snapPolar(std::shared_ptr<Node> dragNode){
+				float steps = round((dragNode->neighbors.front()->position.dist(SCREEN_MOUSE)) / state->settings.grid) * state->settings.grid;
+				if(dragNode->neighbors.size() > 1){
+					Vec2Df dn1 = dragNode->neighbors[0]->position;
+					Vec2Df dn2 = dragNode->neighbors[1]->position;
+					Vec2Df v1_orth = dn1.center(dn2);
+
+					if(dn1.x < dn2.x) std::swap(dn1,dn2);
+
+					float dist = dn1.dist(dn2);
+					float dist_orth = std::sqrt(std::pow(steps,2) - std::pow(dist/2,2));
+
+					if(SCREEN_MOUSE.y < v1_orth.y) dist_orth *= -1;
+
+					Vec2Df v1_orth_t = v1_orth + (dn1-dn2).norm().orth() * dist_orth;
+					DrawLineV(dn1, dn2, VS_COLOR_RED);
+					DrawLineV(v1_orth, v1_orth_t, VS_COLOR_RED);
+					DrawCircleV(v1_orth, 3.0f, VS_COLOR_RED);
+					dragNode->position = v1_orth_t;
+				} else if(!dragNode->neighbors.empty()){
+					float pol_r = steps;
+					float pol_theta = Vector2Angle(Vec2Df{1,0},(SCREEN_MOUSE - dragNode->neighbors.front()->position));
+					Vec2Df polar = VISEQ::VMATH::polarToCartesian(pol_r, pol_theta); 
+					dragNode->position = dragNode->neighbors.front()->position + polar;
+				}
+			}
+
+			void doInteraction(){
+				bool exit = false;
+				bool once = false;
+				bool connect_once = false;
+
+				state->mouse_z = canvas->z_index;
+
+				for(auto e : APP::event_queue){
+					if(!connect_once && e.action == APP::Interaction::CONNECT){
+						APP::InteractionEvent partner;
+						bool found = false;
+						for(auto ei : APP::event_queue){
+							if(ei.action == APP::Interaction::HOVER && ei.item->getType() == GraphItemType::CONNECTOR) {
+								std::cout << "YEAH" << std::endl;
+								partner = ei;
+								found = true;
+								break;
+							}
+						}
+
+						auto connector = std::dynamic_pointer_cast<Connector>(e.item);
+						if(found && partner != e){
+							auto connector_to = std::dynamic_pointer_cast<Connector>(partner.item);
+							connector->partner = connector_to;
+							connector_to->partner = connector;
+							gm->addConnection(std::dynamic_pointer_cast<Node>(connector->parent.lock()), std::dynamic_pointer_cast<Node>(connector_to->parent.lock()));
+						} else if (partner != e){
+							if(KEYS_DOWN.alt){
+								gm->createConfigNode(SCREEN_MOUSE);
+							} else {	
+								gm->createMidiNode(SCREEN_MOUSE);
+							}
+							gm->addConnection(std::dynamic_pointer_cast<Node>(connector->parent.lock()), gm->getLastNode());
+						}
+						connect_once = true;
+						break;
+					}
+				}
+
+				while(APP::event_queue.size() > 0 && !exit){
+					auto e = APP::event_queue.front();
+					if(e.action == APP::Interaction::RIGHTCLICK){
+						gm->addToSelection();
+						state->context_menu = !state->context_menu;
+					}
+					if(state->context_menu) break;
+
+					if(e.action == APP::Interaction::HOVER){
+						state->mouse_z = e.item->z_index;
+					}
+
+					if(e.item->getType() == GraphItemType::CANVAS) {
+						if(e.action == APP::Interaction::SELECT) {
+							gm->select();
+							canvas->clearSelectionRect();
+						}
+						if(e.action == APP::Interaction::DESELECT) {
+							gm->deselect();
+						}
+					}
+
+					if(!once && e.item->getType() == GraphItemType::NODE){
+						auto node = std::dynamic_pointer_cast<Node>(e.item);
+						if(e.action == APP::Interaction::PICKUP) {
+							node->pickUp();
+							if(node->selected){
+								for(auto s : gm->getSelection()){
+									s->pickUp(node->position);
+								}
+							}
+							once = true;
+						}
+						if(e.action == APP::Interaction::DRAG) {
+							if(KEYS_DOWN.ctrl) node->drag(MOD_MOUSE);
+							else if(KEYS_DOWN.shift) {
+								snapPolar(node);
+							}
+							else node->drag(MOD_MOUSE + node->drag_offset);
+
+							if(node->selected){
+								for(auto s : gm->getSelection()){
+									s->drag(MOD_MOUSE + s->drag_offset);
+								}
+							}
+							once = true;
+						}
+						if(e.action == APP::Interaction::PUTDOWN) {
+							node->putDown();
+							if(node->selected){
+								for(auto s : gm->getSelection()){
+									s->putDown();
+								}
+							}
+						}
+					}
+					if(exit) break;
+
+					if(!once && (e.item->getType() == GraphItemType::CONNECTOR || e.item->getType() == GraphItemType::CANVAS || e.item->getType() == GraphItemType::HANDLE)) {
+						switch(e.action){
+							case VISEQ::APP::Interaction::PICKUP:
+							{
+								e.item->pickUp();
+								once = true;
+								break;
+							}
+							case VISEQ::APP::Interaction::DRAG:
+							{
+								e.item->drag(MOD_MOUSE);
+								once = true;
+								break;
+							}
+							case VISEQ::APP::Interaction::PUTDOWN:
+							{
+								e.item->putDown();
+								break;
+							}
+							default:
+							{}
+						}	
+					}
+
+					APP::event_queue.pop_front();
+				}
+				APP::event_queue.clear();
+			}
+			
+	};
+}

src/main.cpp

@@ -1,4 +1,3 @@
-
 /*
  *
  * VISEQ - The Visual Sequencer
@@ -6,41 +5,22 @@
  *
 */
 
-#include "graph-manager.h"
-#include "node.h"
-#include "vmath.h"
-#include <filesystem>
-#include <fstream>
 #define RAYGUI_IMPLEMENTATION
 #include <raylib.h>
 #include <raymath.h>
 
-#include "state-manager.h"
-#include "datatypes.h"
-#include "midi-node.h"
-
-#include "nlohmann/json.hpp"
+#include "state.h"
+#include "app-manager.h"
 
 #include <cstdlib>
 #include <stdio.h>
 #include <cmath>
-#include <ranges>
-#include <algorithm>
-#include <iterator>
 #include <memory>
 
-using json = nlohmann::json;
 
-VISEQ::APP::AppState app;
+VISEQ::APP::AppManager app;
 
-Vec2Df mouse_pos;
-Vec2Df drag_start;
-
-Camera2D camera = { {0} };
-
-bool mouse_clicked = false;
-bool mouse_touched = false;
-bool mouse_dragging = false;
+std::shared_ptr<VISEQ::APP::State> state = VISEQ::APP::State::get();
 
 int main(){
 
@@ -58,497 +38,31 @@ int main(){
 	SetWindowSize(monitor_width - 300, monitor_height - 300);
 
 	//ToggleFullscreen();
+	
+	state->settings.fps = 60.0f;
+	state->settings.bpm = 120.0f;
+	state->settings.grid = 60.0f; // 120px for a 16th note
 
+	state->settings.speed = (state->settings.grid * 16.0f) * (state->settings.bpm / 120.f);
+
+	state->settings.width = monitor_width - 300;
+	state->settings.height = monitor_height - 300;
+	
+	SetTargetFPS(state->settings.fps);
+
+	app.init();
 	app.ui.init();
 
-	app.settings.fps = 60.0f;
-	app.settings.bpm = 120.0f;
-	app.settings.grid = 60.0f; // 120px for a 16th note
+	app.loadState();
 
-	app.settings.speed = (app.settings.grid * 16.0f) * (app.settings.bpm / 120.f);
+	app.startSignals();
 
-	app.settings.width = monitor_width - 300;
-	app.settings.height = monitor_height - 300;
-	
-	SetTargetFPS(app.settings.fps);
-
-    camera.target = (Vector2){ app.settings.width/2.0f, app.settings.height/2.0f };
-    camera.offset = (Vector2){ app.settings.width/2.0f, app.settings.height/2.0f };
-    camera.rotation = 0.0f;
-    camera.zoom = 1.0f;	
-
-	if(std::filesystem::exists("state.json")){
-		std::ifstream f("state.json");
-		json graph = json::parse(f);
-
-		app.settings = graph.at("settings");
-
-		int highest_id = 0;
-		std::shared_ptr<Node> hid;
-		for(auto n : graph.at("graphmanager").at("nodes")){
-			std::shared_ptr<MidiNode> mn = n;
-			if(mn->id > highest_id) {
-				highest_id = mn->id;
-				hid = mn;
-			}
-		}
-
-		for(auto e : graph.at("graphmanager").at("edges")){
-			if(e.at("id") > highest_id){
-				highest_id = e.at("id");
-			}
-		}
-		
-		for(auto n : graph.at("graphmanager").at("nodes")){
-			std::shared_ptr<MidiNode> mn = n;
-			app.gm.nodes.push_back(mn);
-			std::cout << std::format("adding node {}", mn->id) << std::endl;
-		}
-
-		for(auto e : graph.at("graphmanager").at("edges")){
-			int start_id = e.at("start").get<int>();
-			int end_id = e.at("end").get<int>();
-
-			VEC_SPTR_Node start = app.gm.nodes | RANGE_FILTER([start_id](SPTR_Node n){return n->id == start_id;}) | std::ranges::to<VEC_SPTR_Node>();			
-			VEC_SPTR_Node end = app.gm.nodes | RANGE_FILTER([end_id](SPTR_Node n){return n->id == end_id;}) | std::ranges::to<VEC_SPTR_Node>();
-
-			if(!start.empty() && !end.empty()) {
-				std::cout << std::format("connection {} to {}", start_id, end_id) << std::endl;
-				app.gm.addConnection(start.front(), end.front());
-			}
-
-		}
-
-		app.gm.edges.back()->newId(highest_id); // set static id counter in base class to highest value from json file
-
-		for(auto s : graph.at("signalmanager").at("signals")){
-			int start_id = s.at("start").get<int>();
-			int next_id = s.at("next").get<int>();
-			int last_id = s.at("last").get<int>();
-			std::shared_ptr<VISEQ::SIGNAL::Signal> ms = s;
-			
-			VEC_SPTR_Node start = app.gm.nodes | RANGE_FILTER([start_id](SPTR_Node n){return n->id == start_id;}) | std::ranges::to<VEC_SPTR_Node>();
-			VEC_SPTR_Node last = app.gm.nodes | RANGE_FILTER([last_id](SPTR_Node n){return n->id == last_id;}) | std::ranges::to<VEC_SPTR_Node>();
-			VEC_SPTR_Node next = app.gm.nodes | RANGE_FILTER([next_id](SPTR_Node n){return n->id == next_id;}) | std::ranges::to<VEC_SPTR_Node>();
-			ms->start = start.front();
-			ms->next = next.front();
-			ms->last = last.front();
-			app.sm.signals.push_back(ms);
-
-			std::cout << std::format("adding signal with start node {}", start_id) << std::endl;
-		}
-		
-	} else {
-		for(int i = 0; i < 4; ++i){
-			app.gm.addMidiNode(Vec2Df{(float)i * app.settings.grid*4 + 7 * app.settings.grid, 2 * app.settings.grid*4});
-		}
-		for(int i = 3; i >= 0; --i){
-			app.gm.addMidiNode(Vec2Df{(float)i * app.settings.grid*4 + 7 * app.settings.grid, 3 * app.settings.grid*4});
-		}
-
-		for(int i = 0; i < 8; ++i){
-			app.gm.addConnection(app.gm.nodes[i], app.gm.nodes[(i+1) % 8]);
-		}
-		app.sm.addSignalAtNode(app.gm.nodes.front());
-	}
-
-	app.sm.startSignalThread();
-
-	enum InteractionState {HOVER_CANVAS, HOVER_NODE, HOVER_CONNECTOR, DRAG_NODE, CONNECT_NODE, DRAW_SELECTION, SCALE_SELECTION, DELETE_SELECTED_NODES, COPY_SELECTED_NODES, PASTE_SELECTED_NODES};
-	InteractionState istate = HOVER_CANVAS;
-
-	Vec2Df select_start;
-	Rectangle selection;
-
-	Vec2Df scale_start;
-	Vec2Df scale_rectangle;
-
-	VEC_SPTR_Node copied_nodes;
-	
-	
 	while(!WindowShouldClose()){
-
-        BeginDrawing();
-        ClearBackground((Color){46,46,46});
-        BeginMode2D(camera);
-
-		app.settings.speed = (app.settings.grid * 16.0f) * (app.settings.bpm / 120.f);
-				
-		Vector2 mp = GetScreenToWorld2D(GetMousePosition(), camera);
-		Vec2Df mouse_pos = {(float)mp.x, (float)mp.y};
-		Vec2Df cam_pos = {camera.offset.x, camera.offset.y};
-
-		bool mouse_down = IsMouseButtonDown(MOUSE_BUTTON_LEFT);
-		bool mouse_clicked = IsMouseButtonPressed(MOUSE_BUTTON_LEFT);
-		bool mouse_released = IsMouseButtonReleased(MOUSE_BUTTON_LEFT);
-		
-		bool mouse_right_down = IsMouseButtonDown(MOUSE_BUTTON_RIGHT);
-		bool mouse_right_clicked = IsMouseButtonPressed(MOUSE_BUTTON_RIGHT);
-		bool mouse_right_released = IsMouseButtonReleased(MOUSE_BUTTON_RIGHT);
-
-		Vec2Df mouse_delta = {GetMouseDelta().x, GetMouseDelta().y};
-        Vec2Df delta = mouse_delta * (-1.0f/camera.zoom);
-		
-		auto dragging_nodes = app.gm.nodes | RANGE_FILTER([](SPTR_Node n) { return n->dragging;});
-		auto connecting_nodes = app.gm.nodes | RANGE_FILTER([](SPTR_Node n) { return n->connecting;});
-		auto selected_nodes = app.gm.nodes | RANGE_FILTER([](SPTR_Node n) { return n->selected && !n->dragging;}) | std::ranges::to<VEC_SPTR_Node>();
-		auto hovering_nodes = app.gm.nodes | RANGE_FILTER([&mouse_pos](SPTR_Node n) { return CheckCollisionPointCircle(mouse_pos, n->position, n->radius);});
-		auto hovering_connectors = app.gm.nodes | RANGE_FILTER([&mouse_pos](SPTR_Node n) { return CheckCollisionPointCircle(mouse_pos, (n->position - ((n->position - mouse_pos)).norm() * (n->radius + 14.0f)), 8.0f);});
-
-		for(auto &n : app.gm.nodes ){
-			if(hovering_nodes.empty()) n->hovering = false;
-			if(hovering_connectors.empty()) n->hover_connect = false;
-		}
-
-		if(!mouse_down && !mouse_right_down && dragging_nodes.empty() && connecting_nodes.empty() && hovering_nodes.empty() && hovering_connectors.empty()) istate = InteractionState::HOVER_CANVAS;
-		if((mouse_clicked || mouse_down || mouse_released) && !mouse_right_down && dragging_nodes.empty() && connecting_nodes.empty() && hovering_nodes.empty() && hovering_connectors.empty() && istate != InteractionState::SCALE_SELECTION) istate = InteractionState::DRAW_SELECTION;
-
-		if(!hovering_nodes.empty() && !mouse_down && !mouse_right_down) istate = InteractionState::HOVER_NODE;
-		if(!dragging_nodes.empty()) istate = InteractionState::DRAG_NODE; 
-		if(!hovering_connectors.empty() && !mouse_right_down && istate == InteractionState::HOVER_CANVAS) istate = InteractionState::HOVER_CONNECTOR;
-		if(!connecting_nodes.empty()) istate = InteractionState::CONNECT_NODE;
-
-		if(!selected_nodes.empty() && IsKeyPressed(KEY_DELETE)) istate = InteractionState::DELETE_SELECTED_NODES;
-		if(!selected_nodes.empty() && IsKeyDown(KEY_LEFT_CONTROL) && IsKeyPressed(KEY_C)) istate = InteractionState::COPY_SELECTED_NODES;
-		
-		if(!copied_nodes.empty() && IsKeyDown(KEY_LEFT_CONTROL) && IsKeyPressed(KEY_V)) istate = InteractionState::PASTE_SELECTED_NODES;
-
-		if(IsKeyPressed(KEY_TAB)) {
-			app.settings.mode = (app.settings.mode + 1) % 3;
-			app.gm.setNodeMode(app.settings.mode);
-		}
-
-		if(!selected_nodes.empty()){
-			float offset = 30;
-			Vec2Df corner_tl = {50000, 50000};
-			Vec2Df corner_br = {-50000, -50000};
-			std::shared_ptr<Node> node_tl;
-			std::shared_ptr<Node> node_br;
-
-			for(auto n : selected_nodes){
-				float x = n->position.x;
-				float y = n->position.y;
-
-				if(x < corner_tl.x && y < corner_tl.y) node_tl = n;
-				if(x > corner_br.x && y > corner_br.y) node_br = n;
-				
-				if(x <= corner_tl.x) corner_tl.x = x;
-				if(x >= corner_br.x) corner_br.x = x;
-				if(y <= corner_tl.y) corner_tl.y = y;
-				if(y >= corner_br.y) corner_br.y = y;
-			}
-			corner_tl -= Vec2Df(offset, offset);
-			corner_br += Vec2Df(offset, offset);
-
-			DrawRectangleLines(corner_tl.x, corner_tl.y, (corner_br.x - corner_tl.x), (corner_br.y - corner_tl.y), VS_COLOR_LIGHTGREY);
-			DrawCircleV(corner_br, 5, YELLOW);
-
-			if(istate == InteractionState::SCALE_SELECTION && mouse_released){
-				istate = InteractionState::HOVER_CANVAS;
-			}
-			if(mouse_clicked && corner_br.dist(mouse_pos) < 10){
-				scale_start = (corner_br - corner_tl);
-				for(auto n : selected_nodes){
-					n->drag_offset = n->position - node_tl->position;
-				}
-				istate = InteractionState::SCALE_SELECTION;
-			}
-			if(istate == InteractionState::SCALE_SELECTION && mouse_down){
-				Vec2Df scale = (mouse_pos - corner_tl) / scale_start;
-				if(IsKeyDown(KEY_LEFT_SHIFT)) scale.y = scale.x;
-				DrawText(std::format("{:.2f} {:.2f}", scale.x, scale.y).c_str(), corner_br.x+5, corner_br.y+5, 10, RED);
-				for(auto n : selected_nodes){
-					n->position = node_tl->position + (n->drag_offset * scale);
-				}
-				istate = InteractionState::SCALE_SELECTION;
-			}
-		}
-
-		switch(istate){
-			case InteractionState::SCALE_SELECTION:
-			case InteractionState::HOVER_CANVAS:
-			{
-				for(auto &n : app.gm.nodes){	
-					n->hover_connect = false;
-				}
-				if(mouse_right_down) {
-		            camera.target = Vector2Add(camera.target, delta);
-				}
-				break;
-			}
-			case InteractionState::DRAW_SELECTION:
-			{
-				if(mouse_clicked){
-					select_start = mouse_pos;
-				}
-				if(mouse_down){
-					Vec2Df select1 = {mouse_pos.x > select_start.x ? select_start.x : mouse_pos.x, mouse_pos.y > select_start.y ? select_start.y : mouse_pos.y};
-					Vec2Df select2 = {mouse_pos.x > select_start.x ? mouse_pos.x - select_start.x : select_start.x - mouse_pos.x, mouse_pos.y > select_start.y ? mouse_pos.y - select_start.y : select_start.y - mouse_pos.y};
-					DrawRectangleLines(select1.x, select1.y, select2.x, select2.y, (Color){150,150,150,150});
-					selection = (Rectangle){select1.x, select1.y, select2.x, select2.y};
-
-					for(auto& n : app.gm.nodes){
-						if(CheckCollisionPointRec(n->position, selection)) {
-							n->in_rect = true;
-						} else {
-							n->in_rect = false;
-						}
-					}
-				}
-
-				if(mouse_released){	
-					int n_selected = 0;
-					for(auto& n : app.gm.nodes){
-						if(CheckCollisionPointRec(n->position, selection)) {
-							n->selected = true;
-							n->in_rect = false;
-							n_selected++;
-						} else {
-							if(!IsKeyDown(KEY_LEFT_SHIFT)) n->selected = false;
-						}
-					}
-					if(n_selected > 0) copied_nodes.clear();
-					selection = (Rectangle){0,0,0,0};
-				}
-				break;
-			}
-			case InteractionState::HOVER_NODE:
-			{
-				if(mouse_clicked) {
-					if(IsKeyDown(KEY_LEFT_SHIFT)) {
-						hovering_nodes.front()->selected = true;
-					} else {
-						hovering_nodes.front()->dragging = true;
-						hovering_nodes.front()->drag_offset = hovering_nodes.front()->position - mouse_pos;
-					}
-				}
-				if(mouse_right_clicked) hovering_nodes.front()->config = true;
-				break;
-			}
-			case InteractionState::DRAG_NODE:
-			{
-				if(!dragging_nodes.empty()){
-					SPTR_Node dragNode = dragging_nodes.front();
-					
-					for(auto &n : selected_nodes){
-						if(!n->picked_up) n->drag_offset = n->position - dragNode->position;
-						n->picked_up = true;
-					}
-					
-					if(IsKeyDown(KEY_LEFT_CONTROL)) {
-						dragNode->position.x = round((mouse_pos.x + dragNode->drag_offset.x) / app.settings.grid) * app.settings.grid;
-						dragNode->position.y = round((mouse_pos.y + dragNode->drag_offset.y) / app.settings.grid) * app.settings.grid;
-					} else if(IsKeyDown(KEY_LEFT_SHIFT)){
-						float steps = round((dragNode->neighbors.front()->position.dist(mouse_pos)) / app.settings.grid) * app.settings.grid;
-						if(dragNode->neighbors.size() > 1){
-							Vec2Df dn1 = dragNode->neighbors[0]->position;
-							Vec2Df dn2 = dragNode->neighbors[1]->position;
-							Vec2Df v1_orth = dn1.center(dn2);
-							
-							if(dn1.x < dn2.x) std::swap(dn1,dn2);
-
-							float dist = dn1.dist(dn2);
-							float dist_orth = std::sqrt(std::pow(steps,2) - std::pow(dist/2,2));
-							
-							if(mouse_pos.y < v1_orth.y) dist_orth *= -1;
-							
-							Vec2Df v1_orth_t = v1_orth + (dn1-dn2).norm().orth() * dist_orth;
-							DrawLineV(dn1, dn2, VS_COLOR_RED);
-							DrawLineV(v1_orth, v1_orth_t, VS_COLOR_RED);
-							DrawCircleV(v1_orth, 3.0f, VS_COLOR_RED);
-							dragNode->position = v1_orth_t;
-						} else if(!dragNode->neighbors.empty()){
-							float pol_r = steps;
-							float pol_theta = Vector2Angle(Vec2Df{1,0},(mouse_pos - dragNode->neighbors.front()->position));
-							Vec2Df polar = VISEQ::VMATH::polarToCartesian(pol_r, pol_theta); 
-							dragNode->position = dragNode->neighbors.front()->position + polar;
-						}
-					} else {
-						dragNode->position = mouse_pos + dragNode->drag_offset;
-					}
-					
-					for(auto &n : selected_nodes){
-						n->position = dragNode->position + n->drag_offset;
-					}
-				
-					if(mouse_released) {
-						for(auto &n : dragging_nodes){
-							n->dragging = false;
-							n->picked_up = false;
-						}
-						for(auto &n : selected_nodes){
-							n->picked_up = false;
-							n->dragging = false;
-						}
-					}
-				}
-				break;
-			}
-			case InteractionState::HOVER_CONNECTOR:
-			{
-				if(!hovering_connectors.empty()){
-					hovering_connectors.front()->hover_connect = true;
-					if(mouse_clicked) hovering_connectors.front()->connecting = true;
-				}
-				break;
-			}
-			case InteractionState::CONNECT_NODE:
-			{
-				Vec2Df connector_position = connecting_nodes.front()->position - ((connecting_nodes.front()->position - mouse_pos)).norm() * (connecting_nodes.front()->radius + 14.0f);
-				Vec2Df target_position = mouse_pos;
-
-				if(IsKeyDown(KEY_LEFT_CONTROL)) {
-					target_position.x = round((mouse_pos.x) / app.settings.grid) * app.settings.grid;
-					target_position.y = round((mouse_pos.y) / app.settings.grid) * app.settings.grid;
-				} else if(IsKeyDown(KEY_LEFT_SHIFT)){
-					std::shared_ptr<Node> closest = app.gm.getClosestNode(mouse_pos);
-					float steps = round((closest->position.dist(mouse_pos)) / app.settings.grid) * app.settings.grid;
-					float pol_r = steps;
-					float pol_theta = Vector2Angle(Vec2Df{1,0},(mouse_pos - closest->position));
-
-					Vec2Df polar = VISEQ::VMATH::polarToCartesian(pol_r, pol_theta); 
-					target_position = closest->position + polar;
-				} else {
-					target_position = mouse_pos;
-				}
-			
-				if(connecting_nodes.front()->connecting && mouse_down){
-					DrawLine(connector_position.x, connector_position.y, target_position.x, target_position.y, (Color){229, 181, 103, 255});
-					connecting_nodes.front()->hovering = true;
-					connecting_nodes.front()->hover_connect = true;
-				}
-
-				if(!hovering_connectors.empty()) {
-					hovering_connectors.front()->hovering = true;
-					hovering_connectors.front()->hover_connect = true;
-				}
-				if(!hovering_nodes.empty()) hovering_nodes.front()->hovering = true;
-
-				if(mouse_released) {
-					if(&hovering_nodes.front() != &connecting_nodes.front() && &connecting_nodes.front() != &hovering_connectors.front()){
-						if(!hovering_nodes.empty()){
-							app.gm.addConnection(connecting_nodes.front(), hovering_nodes.front());
-						} else if(!hovering_connectors.empty()){
-							app.gm.addConnection(connecting_nodes.front(), hovering_connectors.front());
-						} else {
-							SPTR_Node new_node = app.gm.copyNode(std::dynamic_pointer_cast<MidiNode>(connecting_nodes.front()), target_position);
-							new_node->connecting = false;
-							app.gm.addConnection(connecting_nodes.front(), new_node);
-						}
-					}
-					connecting_nodes.front()->connecting = false;
-					istate = InteractionState::HOVER_CANVAS;
-				}
-				break;
-			}
-			case InteractionState::DELETE_SELECTED_NODES:
-			{
-				app.removeNodes(selected_nodes | std::ranges::to<VEC_SPTR_Node>());
-				break;
-			}
-			case InteractionState::COPY_SELECTED_NODES:
-			{
-				std::ranges::copy(selected_nodes.begin(), selected_nodes.end(), std::back_inserter(copied_nodes));
-				std::ranges::for_each(selected_nodes.begin(), selected_nodes.end(), [](SPTR_Node n){n->selected = false;});
-				selected_nodes.clear();
-				break;
-			}
-			case InteractionState::PASTE_SELECTED_NODES:
-			{
-				for(auto n: copied_nodes){
-					n->drag_offset = (n->position - copied_nodes.front()->position);
-				}
-				app.copyNodesAndConnections(copied_nodes, mouse_pos);
-				//copied_nodes.clear();
-				break;
-			}
-		};
-
-		float wheel = GetMouseWheelMove();
-		if(wheel != 0){
-			if(!hovering_nodes.empty() && hovering_nodes.front()->getNodeType() == NodeType::MIDINODE) {
-				VEC_SPTR_Node modify_nodes;
-				std::copy_if(selected_nodes.begin(), selected_nodes.end(), std::back_inserter(modify_nodes), [](SPTR_Node n){ return n->getNodeType() == NodeType::MIDINODE;});
-				if(selected_nodes.empty()) std::copy_if(hovering_nodes.begin(), hovering_nodes.end(), std::back_inserter(modify_nodes), [modify_nodes](SPTR_Node n){ return n->getNodeType() == NodeType::MIDINODE && !std::ranges::contains(modify_nodes, n);});
-
-				for(auto n : modify_nodes){
-					std::shared_ptr<MidiNode> midiNode = std::dynamic_pointer_cast<MidiNode>(n);
-					if(IsKeyDown(KEY_LEFT_CONTROL) && !IsKeyDown(KEY_LEFT_ALT)){
-						switch(app.settings.mode){
-							case 0:{
-								midiNode->midi_note += wheel;
-							break;}
-							case 1:{
-								midiNode->midi_cc += wheel;
-							break;}
-							case 2:{
-								midiNode->midi_pitch_bend += wheel;
-							break;}
-						};
-						if(midiNode->midi_note < 0 ) midiNode->midi_note = VISEQ::MIDI::Notes.size()-1;
-						if(midiNode->midi_note >= VISEQ::MIDI::Notes.size() ) midiNode->midi_note = 0;
-						
-						if(midiNode->midi_cc < 0 ) midiNode->midi_cc = 127;
-						if(midiNode->midi_cc > 127 ) midiNode->midi_cc = 0;
-					
-						if(midiNode->midi_pitch_bend < 0 ) midiNode->midi_pitch_bend = 0;
-						if(midiNode->midi_pitch_bend > 16383 ) midiNode->midi_pitch_bend = 16383;
-
-					} else if(IsKeyDown(KEY_LEFT_SHIFT) && !IsKeyDown(KEY_LEFT_ALT)) {
-						midiNode->midi_velocity += wheel;
-						if(midiNode->midi_velocity < 0 ) midiNode->midi_velocity = 127;
-						if(midiNode->midi_velocity > 127 ) midiNode->midi_velocity = 0; 
-					} else if(IsKeyDown(KEY_LEFT_ALT)) {
-						switch(app.settings.mode){
-							case 0:{
-								float incr = (float)wheel * (IsKeyDown(KEY_LEFT_SHIFT) ? 100.0f : IsKeyDown(KEY_LEFT_CONTROL) ? 1000.0f : 10.0f);
-								midiNode->midi_gate += incr;
-								if(midiNode->midi_gate < 0 ) midiNode->midi_gate = 0;
-							break;}
-							case 1:{
-								midiNode->midi_cc_value += wheel;
-								if(midiNode->midi_cc_value < 0 ) midiNode->midi_cc_value = 0;
-								if(midiNode->midi_cc_value > 127 ) midiNode->midi_cc_value = 127;
-							break;}
-							case 2:{
-								float incr = (float)wheel * (IsKeyDown(KEY_LEFT_SHIFT) ? 100.0f : IsKeyDown(KEY_LEFT_CONTROL) ? 1000.0f : 10.0f);
-								midiNode->midi_pitch_bend += incr;
-								if(midiNode->midi_pitch_bend < 0 ) midiNode->midi_pitch_bend = 0;
-								if(midiNode->midi_pitch_bend > 16383 ) midiNode->midi_pitch_bend = 16383;
-							break;}
-						};
-					}
-				}
-			}
-			if(!IsKeyDown(KEY_LEFT_SHIFT) && !IsKeyDown(KEY_LEFT_CONTROL) && !IsKeyDown(KEY_LEFT_ALT)){
-				Vector2 mouseWorldPos = GetScreenToWorld2D(GetMousePosition(), camera);
-				camera.offset = GetMousePosition();
-				camera.target = mouseWorldPos;
-				float scaleFactor = 1.0f + (0.25f*fabsf(wheel));
-				if (wheel < 0) scaleFactor = 1.0f/scaleFactor;
-				camera.zoom = Clamp(camera.zoom*scaleFactor, 0.125f, 64.0f);
-			}
-		}
-
-		for(int x = -app.settings.grid*100; x < app.settings.grid*100; x+=app.settings.grid){
-			for(int y = -app.settings.grid*100; y < app.settings.grid*100; y+=app.settings.grid){
-				DrawPixel(x, y, (Color){130,130,130,200});
-			}
-		}
-	
-		app.draw(mouse_pos, camera);
-
-		EndMode2D();
-
-		app.drawUI(&mouse_pos, &camera);
-
-		EndDrawing();
+		app.update();
+		app.draw();
 	}
 
-	std::ofstream file("state.json");
-	file << json(app);
-
- 	std::cout << std::setw(4) << json(app) << std::endl;
+	app.close();
 	
 	CloseWindow();
 

src/midi-node.h

@@ -1,28 +1,53 @@
 #pragma once
 
+#include "config-node.h"
 #include "datatypes.h"
+#include "edge.h"
+#include "node-handle.h"
 #include "node.h"
-#include "raymath.h"
+#include "raylib.h"
+#include "state.h"
 #include <map>
+#include <memory>
 
-#define RADIUS 14.0f
+namespace VISEQ::APP::UI{
+	class AppUI;
+}
 
 namespace VISEQ::GRAPH::NODES {
 
 	class MidiNode : public Node{
-	
+		friend class APP::UI::AppUI;
+
+		private:
+		MIDI::MidiNote midiNote;
+		MIDI::MidiCC midiCC;
+		MIDI::MidiPC midiPC;
+		MIDI::MidiPitchBend midiPitchBend;
+		MIDI::MidiAftertouch midiAftertouch;
+		MIDI::MidiPolyPressure midiPolyPressure;
+
+		std::vector<std::shared_ptr<NodeHandle<int>>> midiNoteHandles;
+		std::vector<std::shared_ptr<NodeHandle<int>>> midiCCHandles;
+		std::vector<std::shared_ptr<NodeHandle<int>>> midiPCHandles;
+		std::vector<std::shared_ptr<NodeHandle<int>>> midiPitchBendHandles;
+		std::vector<std::shared_ptr<NodeHandle<int>>> midiAftertouchHandles;
+		std::vector<std::shared_ptr<NodeHandle<int>>> midiPolyPressureHandles;
+
 		public:
-		
+
 		struct NodeMidiOut{
 			int i;
 			std::string name;
 			bool enabled;
 		};
 
-		MidiNode() {}
-		MidiNode(Vec2Df position) : Node(position) {}
+		MidiNode() {init();}
+		MidiNode(Vec2Df position) : Node(position) {init();}
 
 		NodeType nodeType = NodeType::MIDINODE;
+		
+		//std::vector<std::shared_ptr<ControlNode>> controlNodes;
 
 		bool send_note = true;
 		bool send_cc = false;
@@ -38,104 +63,318 @@ namespace VISEQ::GRAPH::NODES {
 		bool gui_midi_velocity_edit = false;
 		bool gui_midi_gate_edit = false;
 		
-		bool triggered = false;
-
-		int mode = 0;
-
-		int midi_note_channel = 1;
-		int midi_note = 48;
-		int midi_velocity = 60;
-		int midi_gate = 10; // gate time in milliseconds
-
-		int midi_cc_channel = 0;
-		int midi_cc = 0;
-		int midi_cc_value = 0;
-
-		int midi_pc_channel = 0;
-		int midi_pc = 0;
-		int midi_pc_value = 0;
-		
-		int midi_pitch_bend_channel = 0;
-		int midi_pitch_bend = 8192;
-
 		float start = 0;
 		float fade = 0;
 		float time = 0;
 		float last = 0;
+		
+		void init(){
+			midiNoteHandles.emplace_back(std::make_shared<NodeHandle<int>>(midiNote.note, position, VS_COLOR_GREEN, "NOTE"));
+			midiNoteHandles.emplace_back(std::make_shared<NodeHandle<int>>(midiNote.channel, position, VS_COLOR_PINK, "CHANNEL", 1, 16, 40, 150));
+			midiNoteHandles.emplace_back(std::make_shared<NodeHandle<int>>(midiNote.gate, position, VS_COLOR_RED, "GATE", 10, 30000, 40, 300));
+			midiNoteHandles.emplace_back(std::make_shared<NodeHandle<int>>(midiNote.velocity, position, VS_COLOR_PURPLE, "VELOCITY"));
+			
+			midiCCHandles.emplace_back(std::make_shared<NodeHandle<int>>(midiCC.control, position, VS_COLOR_SUN, "CONTROL"));
+			midiCCHandles.emplace_back(std::make_shared<NodeHandle<int>>(midiCC.channel, position, VS_COLOR_PINK, "CHANNEL", 1, 16, 40, 150));
+			midiCCHandles.emplace_back(std::make_shared<NodeHandle<int>>(midiCC.value, position, VS_COLOR_GREEN, "VALUE"));
+			
+			midiPCHandles.emplace_back(std::make_shared<NodeHandle<int>>(midiPC.program, position, VS_COLOR_SUN, "PROGRAM"));
+			midiPCHandles.emplace_back(std::make_shared<NodeHandle<int>>(midiPC.channel, position, VS_COLOR_PINK, "CHANNEL", 1, 16, 40, 150));
+			midiPCHandles.emplace_back(std::make_shared<NodeHandle<int>>(midiPC.value, position, VS_COLOR_GREEN, "VALUE"));
+
+			midiPitchBendHandles.emplace_back(std::make_shared<NodeHandle<int>>(midiPitchBend.channel, position, VS_COLOR_PINK, "CHANNEL", 1, 16, 40, 150));
+			midiPitchBendHandles.emplace_back(std::make_shared<NodeHandle<int>>(midiPitchBend.value, position, VS_COLOR_GREEN, "VALUE", -8192, 8192, 40, 300));
+			
+			midiAftertouchHandles.emplace_back(std::make_shared<NodeHandle<int>>(midiAftertouch.channel, position, VS_COLOR_PINK, "CHANNEL", 1, 16, 40, 150));
+			midiAftertouchHandles.emplace_back(std::make_shared<NodeHandle<int>>(midiAftertouch.value, position, VS_COLOR_GREEN, "VALUE"));
+			
+			midiPolyPressureHandles.emplace_back(std::make_shared<NodeHandle<int>>(midiPolyPressure.channel, position, VS_COLOR_PINK, "CHANNEL", 1, 16, 40, 150));
+			midiPolyPressureHandles.emplace_back(std::make_shared<NodeHandle<int>>(midiPolyPressure.value, position, VS_COLOR_GREEN, "VALUE"));
+			midiPolyPressureHandles.emplace_back(std::make_shared<NodeHandle<int>>(midiPolyPressure.note, position, VS_COLOR_SUN, "NOTE"));
+		}
+
+		std::shared_ptr<MidiNode> getPtr(){
+			return std::static_pointer_cast<MidiNode>(shared_from_this());
+		}
 
 		virtual NodeType getNodeType() const override {return nodeType;}
 
-		void setMidiPort(int midi_port, bool state){
-			midi_outs[midi_port].enabled = state;
+		void setMidiPort(int midi_port, bool _state){
+			midi_outs[midi_port].enabled = _state;
 		}
 
 		void trigger() override {
 			triggered = true;
 			start = GetTime();
-			fade = midi_gate;
+			fade = getNotes().gate;
 		}
 
-		void SMode(int _mode) override{
+		void setMode(int _mode) override {
 			mode = _mode;
 		}
 
-		int Ggate(){
-			return midi_gate;
+		MIDI::MidiNote getNotes() const {
+			MIDI::MidiNote cNote;
+			for(auto cn : getConnectedConfigNodes()){
+				cNote += cn.lock()->getNotes();
+			}
+			return midiNote + cNote;
+		}
+		
+		MIDI::MidiCC getCC() const {
+			MIDI::MidiCC cCC;
+			for(auto cn : getConnectedConfigNodes()){
+				cCC += cn.lock()->getCC();
+			}
+			return midiCC + cCC;
+		}
+		
+		MIDI::MidiPC getPC() const {
+			MIDI::MidiPC cPC;
+			for(auto cn : getConnectedConfigNodes()){
+				cPC += cn.lock()->getPC();
+			}
+			return midiPC + cPC;
+		}
+		
+		MIDI::MidiPitchBend getPitchBend() const {
+			MIDI::MidiPitchBend cPitchBend;
+			for(auto cn : getConnectedConfigNodes()){
+				cPitchBend += cn.lock()->getPitchBend();
+			}
+			return midiPitchBend + cPitchBend;
+		}
+		
+		MIDI::MidiAftertouch getAftertouch() const {
+			MIDI::MidiAftertouch cAftertouch;
+			for(auto cn : getConnectedConfigNodes()){
+				cAftertouch += cn.lock()->getAftertouch();
+			}
+			return midiAftertouch + cAftertouch;
+		}
+		
+		MIDI::MidiPolyPressure getPolyPressure() const {
+			MIDI::MidiPolyPressure cPolyPressure;
+			for(auto cn : getConnectedConfigNodes()){
+				cPolyPressure += cn.lock()->getPolyPressure();
+			}
+			return midiPolyPressure + cPolyPressure;
+		}
+		
+		std::vector<std::weak_ptr<ConfigNode>> getConnectedConfigNodes() const {
+			auto config_conns = connections | RANGE_FILTER([](EDGES::SPTR_Edge c){ return c->start.lock()->getNodeType() == NodeType::CONFIGNODE || c->end.lock()->getNodeType() == NodeType::CONFIGNODE;}) | std::ranges::to<std::vector<std::shared_ptr<EDGES::Edge>>>();
+			std::vector<std::weak_ptr<ConfigNode>> config_nodes;
+			for(auto e : config_conns){
+				if(e->start.lock()->getNodeType() == NodeType::CONFIGNODE) config_nodes.push_back(std::dynamic_pointer_cast<ConfigNode>(e->start.lock()));
+				if(e->end.lock()->getNodeType() == NodeType::CONFIGNODE) config_nodes.push_back(std::dynamic_pointer_cast<ConfigNode>(e->end.lock()));
+			}
+			/*std::cout << "id: " << id << " n cn: " << config_nodes.size() << std::endl;*/
+			return config_nodes;
+		}
+
+		void update() override {
+			Node::update();
+			mode = state->node_mode;	
+			for(auto mh : midiNoteHandles){
+				mh->update(position);
+			}
+			for(auto mh : midiCCHandles){
+				mh->update(position);
+			}
+			for(auto mh : midiPCHandles){
+				mh->update(position);
+			}
+			for(auto mh : midiPitchBendHandles){
+				mh->update(position);
+			}
+			for(auto mh : midiAftertouchHandles){
+				mh->update(position);
+			}
+			for(auto mh : midiPolyPressureHandles){
+				mh->update(position);
+			}
+		}
+		
+		void modMidiNote(int incr){
+			midiNote.note += incr;
+			if(midiNote.note < 0 ) midiNote.note = VISEQ::MIDI::Notes.size()-1;
+			if(midiNote.note >= (int)VISEQ::MIDI::Notes.size()) midiNote.note = 0;	
+		}
+
+		void modMidiCC(int incr){
+			midiCC.control += incr;
+			if(midiCC.control < 0 ) midiCC.control = 127;
+			if(midiCC.control > 127 ) midiCC.control = 0;
+		}
+		
+		void modMidiPC(int incr){
+			midiPC.program += incr;
+			if(midiPC.program < 0 ) midiPC.program = 127;
+			if(midiPC.program > 127 ) midiPC.program = 0;
+		}
+		
+		void modMidiPitchBend(int incr){
+			midiPitchBend.value += incr;
+			if(midiPitchBend.value < 0 ) midiPitchBend.value = 0;
+			if(midiPitchBend.value > 16383 ) midiPitchBend.value = 16383;
+		}
+		
+		void modMidiAftertouch(int incr){
+			midiAftertouch.value += incr;
+			if(midiAftertouch.value < 0 ) midiAftertouch.value = 0;
+			if(midiAftertouch.value > 127 ) midiAftertouch.value = 127;
+		}
+		
+		void modMidiPolyPressure(int incr){
+			midiPolyPressure.value += incr;
+			if(midiPolyPressure.value < 0 ) midiPolyPressure.value = 0;
+			if(midiPolyPressure.value > 127 ) midiPolyPressure.value = 127;
+		}
+
+		void interact(){
+			float wheel = GetMouseWheelMove();
+
+			if(KEYS_DOWN.ctrl && !KEYS_DOWN.alt){
+				switch(state->node_mode){
+					case 0:{
+						modMidiNote(wheel);
+					break;}
+					case 1:{
+						modMidiCC(wheel);
+					break;}
+					case 2:{
+						modMidiPC(wheel);
+					break;}
+					case 3:{
+						modMidiPitchBend(wheel);
+					break;}
+					case 4:{
+						modMidiAftertouch(wheel);
+					break;}
+					case 5:{
+						modMidiPolyPressure(wheel);
+					break;}
+				};
+			} else if(KEYS_DOWN.shift && !KEYS_DOWN.alt) {
+				midiNote.velocity += wheel;
+				if(midiNote.velocity < 0 ) midiNote.velocity = 127;
+				if(midiNote.velocity > 127 ) midiNote.velocity = 0; 
+			} else if(KEYS_DOWN.alt) {
+				switch(state->node_mode){
+					case 0:{
+						float incr = (float)wheel * (KEYS_DOWN.shift ? 100.0f : KEYS_DOWN.ctrl ? 1000.0f : 10.0f);
+						midiNote.gate += incr;
+						if(midiNote.gate < 0 ) midiNote.gate = 0;
+					break;}
+					case 1:{
+						midiCC.value += wheel;
+						if(midiCC.value < 0 ) midiCC.value = 0;
+						if(midiCC.value > 127 ) midiCC.value = 127;
+					break;}
+					case 2:{
+						midiPC.value += wheel;
+						if(midiPC.value < 0 ) midiPC.value = 0;
+						if(midiPC.value > 127 ) midiPC.value = 127;
+					break;}
+					case 3:{
+						float incr = (float)wheel * (KEYS_DOWN.shift ? 100.0f : KEYS_DOWN.ctrl ? 1000.0f : 10.0f);
+						midiPitchBend.value += incr;
+						if(midiPitchBend.value < 0 ) midiPitchBend.value = 0;
+						if(midiPitchBend.value > 16383 ) midiPitchBend.value = 16383;
+					break;}
+					case 4:{
+						float incr = (float)wheel * (KEYS_DOWN.shift ? 100.0f : KEYS_DOWN.ctrl ? 1000.0f : 10.0f);
+						midiAftertouch.value += incr;
+						if(midiAftertouch.value < 0 ) midiAftertouch.value = 0;
+						if(midiAftertouch.value > 127 ) midiAftertouch.value = 127;
+					break;}
+					case 5:{
+						float incr = (float)wheel * (KEYS_DOWN.shift ? 100.0f : KEYS_DOWN.ctrl ? 1000.0f : 10.0f);
+						midiPolyPressure.value += incr;
+						if(midiPolyPressure.value < 0 ) midiPolyPressure.value = 0;
+						if(midiPolyPressure.value > 127 ) midiPolyPressure.value = 127;
+					break;}
+				};
+			}
 		}
 
 		void draw(Vec2Df mouse, Camera2D cam) override {
+			Node::draw();
+			for(auto mh : midiNoteHandles){
+				if(mode == 0) mh->unlock();
+				else mh->lock();
+				mh->draw();
+			}
+			for(auto mh : midiCCHandles){
+				if(mode == 1) mh->unlock();
+				else mh->lock();
+				mh->draw();
+			}
+			for(auto mh : midiPCHandles){
+				if(mode == 2) mh->unlock();
+				else mh->lock();
+				mh->draw();
+			}
+			for(auto mh : midiPitchBendHandles){
+				if(mode == 3) mh->unlock();
+				else mh->lock();
+				mh->draw();
+			}
+			for(auto mh : midiAftertouchHandles){
+				if(mode == 4) mh->unlock();
+				else mh->lock();
+				mh->draw();
+			}
+			for(auto mh : midiPolyPressureHandles){
+				if(mode == 5) mh->unlock();
+				else mh->lock();
+				mh->draw();
+			}
+			
+			if(hovering() || selected) interact();
+
 			last = time;
 			time = GetTime();
-			if(time - start >= (float)midi_gate / 1000.0f){
+			if(time - start >= (float)getNotes().gate / 1000.0f){
 				triggered = false;
 				fade = 0;
 			} else {
 				fade -= (time - last)*1000.0f;
 			}
 
-			DrawRing(position, radius, radius+4, 0, 360, 24, (Color){60, 60, 60, 255});
-			DrawRing(position, radius, radius+4, 0.0f - 90.0f, (360.0f/127.0f) * midi_velocity - 90.0f, 24, (Color){158, 134, 200, 255});
+			DrawRing(position, radius, radius + 4, 0, 360, 24, (Color){60, 60, 60, 255});
+			DrawRing(position, radius, radius + 4, 0.0f - 90.0f, (360.0f/127.0f) * getNotes().velocity - 90.0f, 24, (Color){158, 134, 200, 255});
 			DrawCircleLinesV(position, radius + 4, (Color){100, 100, 100, 255});
 
-			float midi_gate_map = round((255.f / midi_gate) * fade);
-
-			Color gate_color = VS_COLOR_GREEN;
-
-			switch(mode){
-				case 0:{
-					gate_color = ColorAlphaBlend(VS_COLOR_RED, (Color){180, 210, 115, (unsigned char)Clamp(255 - midi_gate_map, 0, 255)}, WHITE);
-					break;}
-				case 1:{
-					gate_color = ColorAlphaBlend(VS_COLOR_RED, (Color){229, 181, 103, (unsigned char)Clamp(255 - midi_gate_map, 0, 255)}, WHITE);
-					break;}
-				case 2:{
-					gate_color = ColorAlphaBlend(VS_COLOR_RED, (Color){232, 125, 62, (unsigned char)Clamp(255 - midi_gate_map, 0, 255)}, WHITE);
-					break;}
-			}
-			if(!dragging && !selected && !in_rect && !hovering) DrawCircle(position.x, position.y, radius, gate_color);
-			if(selected || dragging || in_rect || hovering) DrawCircle(position.x, position.y, radius, (Color){108, 153, 187, 255});
+			float trigger_alpha = (1.f / getNotes().gate) * fade;
+			
+			if(!picked_up && !selected && !in_selection_rect && !hovering()) DrawCircle(position.x, position.y, radius, ColorLerp(state->mode_color, VS_COLOR_RED, trigger_alpha));
+			if(picked_up || in_selection_rect || hovering()) DrawCircle(position.x, position.y, radius, (Color){108, 153, 187, 255});
+			if(selected) DrawCircle(position.x, position.y, radius, (Color){255, 153, 187, 255});
 
 			if(distributionMode == Distribution::RANDOM) DrawCircle(position.x, position.y, radius/2.0f, VS_COLOR_PINK);
 			if(distributionMode == Distribution::ROUNDROBIN) DrawCircle(position.x, position.y, radius/2.0f, VS_COLOR_YELLOW);
 			
 			if(selected) DrawCircleLinesV(position, radius+8, (Color){158, 255, 210, 255});
-				
-			if(IsKeyDown(KEY_LEFT_ALT)){
+			
+			/*if(fade > 0) DrawCircle(position.x, position.y, radius, ColorAlpha(VS_COLOR_RED, trigger_alpha));*/
+
+			if(KEYS_DOWN.alt){
 				float value = 0;
 				int offset_gate = 0;
 				switch(mode){
 					case 0:
-						value = (float)midi_gate/1000.0f;
+						value = (float)getNotes().gate/1000.0f;
 						offset_gate = MeasureText(std::format("{:.2f}", value).c_str(), 12);
 						DrawText(std::format("{:.2f}",value).c_str(), position.x-offset_gate/2.0f, position.y-5, 12, WHITE );
 						break;
 					case 1:
-						value = (float)midi_cc_value;
+						value = (float)getCC().value;
 						offset_gate = MeasureText(std::format("{}", value).c_str(), 12);
 						DrawText(std::format("{}",value).c_str(), position.x-offset_gate/2.0f, position.y-5, 12, WHITE );
 						break;
 					case 2:
-						value = (float)midi_pitch_bend;
+						value = (float)getPitchBend().value;
 						offset_gate = MeasureText(std::format("{}", value).c_str(), 12);
 						DrawText(std::format("{}",value).c_str(), position.x-offset_gate/2.0f, position.y-5, 12, WHITE );
 						break;
@@ -143,30 +382,125 @@ namespace VISEQ::GRAPH::NODES {
 			} else {
 				switch(mode){
 					case 0:{
-						int offset = MeasureText(MIDI::Notes[(int)midi_note].c_str(), 12);
-						DrawText(MIDI::Notes[midi_note].c_str(), position.x-offset/2.0f, position.y-5, 12, WHITE );
+						int offset = MeasureText(MIDI::Notes[(int)getNotes().note].c_str(), 12);
+						DrawText(MIDI::Notes[getNotes().note].c_str(), position.x-offset/2.0f, position.y-5, 12, WHITE );
 						break;}
 					case 1:{
-						int offset = MeasureText(std::format("{}", midi_cc).c_str(), 12);
-						DrawText(std::format("{}", midi_cc).c_str(), position.x-offset/2.0f, position.y-5, 12, WHITE );
+						int offset = MeasureText(std::format("{}", getCC().control).c_str(), 12);
+						DrawText(std::format("{}", getCC().control).c_str(), position.x-offset/2.0f, position.y-5, 12, WHITE );
 						break;}
 					case 2:{
-						int offset = MeasureText(std::format("{}", midi_pitch_bend).c_str(), 12);
-						DrawText(std::format("{}", midi_pitch_bend).c_str(), position.x-offset/2.0f, position.y-5, 12, WHITE );
+						int offset = MeasureText(std::format("{}", getPitchBend().value).c_str(), 12);
+						DrawText(std::format("{}", getPitchBend().value).c_str(), position.x-offset/2.0f, position.y-5, 12, WHITE );
 						break;}
 				}
 			}
 
-			Vec2Df connector = position - ((position - mouse)).norm() * (radius + RADIUS);
-			float opacity = 150.0f - Clamp(position.dist(mouse), 0.0f, 150.0f);
-			
-			if(hover_connect){
-				DrawCircle(connector.x, connector.y, 8.0f, (Color){108, 153, 187, 255});
-			} else {
-				DrawCircle(connector.x, connector.y, 8.0f, (Color){108, 153, 187, (unsigned char)opacity});
-			}
 			if(highlighted) DrawCircleLinesV(position, radius+2, (Color){255, 0, 0, 200});
-			DrawText(std::format("{}", id).c_str(), position.x + 20.0f, position.y + 20.0f, 10, WHITE);
+			//DrawText(std::format("{}", id).c_str(), position.x + 20.0f, position.y + 20.0f, 10, WHITE);
+		}
+	
+		friend void to_json(json& j, const MidiNode& N){
+			std::vector<int> conns;		
+			std::ranges::transform(N.connections.begin(), N.connections.end(), std::back_inserter(conns), [](VISEQ::GRAPH::EDGES::SPTR_Edge e){ return e->id;});
+			std::map<std::string, Vec2Df> noteHandles;
+			std::map<std::string, Vec2Df> CCHandles;
+			std::map<std::string, Vec2Df> PCHandles;
+			std::map<std::string, Vec2Df> pitchBendHandles;
+			std::map<std::string, Vec2Df> aftertouchHandles;
+			std::map<std::string, Vec2Df> polyPressureHandles;
+
+			for(auto i : N.midiNoteHandles){
+				noteHandles.insert(std::make_pair(i->name, i->position));
+			}
+			for(auto i : N.midiCCHandles){
+				CCHandles.insert(std::make_pair(i->name, i->position));
+			}
+			for(auto i : N.midiPCHandles){
+				PCHandles.insert(std::make_pair(i->name, i->position));
+			}
+			for(auto i : N.midiPitchBendHandles){
+				pitchBendHandles.insert(std::make_pair(i->name, i->position));
+			}
+			for(auto i : N.midiAftertouchHandles){
+				pitchBendHandles.insert(std::make_pair(i->name, i->position));
+			}
+			for(auto i : N.midiPolyPressureHandles){
+				polyPressureHandles.insert(std::make_pair(i->name, i->position));
+			}
+
+			j = json{
+				{"id", N.id},
+				{"position", N.position},
+				{"distributionMode", N.distributionMode},
+				{"nodeType", N.nodeType},
+				{"midiNote", N.midiNote},
+				{"midiCC", N.midiCC},
+				{"midiPC", N.midiPC},
+				{"midiPitchBend", N.midiPitchBend},
+				{"midiAftertouch", N.midiAftertouch},
+				{"midiPolyPressure", N.midiPolyPressure},
+				{"midiNoteHandle", noteHandles},
+				{"midiCCHandle", CCHandles},
+				{"midiPCHandle", PCHandles},
+				{"midiPitchBendHandle", pitchBendHandles},
+				{"midiAftertouchHandle", aftertouchHandles},
+				{"midiPolyPressureHandle", polyPressureHandles},
+				{"connections",conns}};
+
+		}
+
+		friend void from_json(const json& j, MidiNode& N){
+			std::cout << "MidiNode" << std::endl;
+
+			j.at("id").get_to(N.id);
+			j.at("position").get_to<Vec2Df>(N.position);
+			j.at("distributionMode").get_to(N.distributionMode);
+			j.at("nodeType").get_to(N.nodeType);
+			j.at("midiNote").get_to(N.midiNote);
+			j.at("midiCC").get_to(N.midiCC);
+			j.at("midiPC").get_to(N.midiPC);
+			j.at("midiPitchBend").get_to(N.midiPitchBend);
+			j.at("midiAftertouch").get_to(N.midiAftertouch);
+			j.at("midiPolyPressure").get_to(N.midiPolyPressure);
+
+			std::map<std::string, Vec2Df> noteHandles;
+			std::map<std::string, Vec2Df> CCHandles;
+			std::map<std::string, Vec2Df> PCHandles;
+			std::map<std::string, Vec2Df> pitchBendHandles;
+			std::map<std::string, Vec2Df> aftertouchHandles;
+			std::map<std::string, Vec2Df> polyPressureHandles;
+
+			j.at("midiNoteHandle").get_to(noteHandles);
+			j.at("midiCCHandle").get_to(CCHandles);
+			j.at("midiPCHandle").get_to(PCHandles);
+			j.at("midiPitchBendHandle").get_to(pitchBendHandles);
+			j.at("midiAftertouchHandle").get_to(aftertouchHandles);
+			j.at("midiPolyPressureHandle").get_to(polyPressureHandles);
+
+			N.midiNoteHandles[0]->position = noteHandles["NOTE"];
+			N.midiNoteHandles[1]->position = noteHandles["CHANNEL"];
+			N.midiNoteHandles[2]->position = noteHandles["GATE"];
+			N.midiNoteHandles[3]->position = noteHandles["VELOCITY"];
+
+			N.midiCCHandles[0]->position = CCHandles["CONTROL"];
+			N.midiCCHandles[1]->position = CCHandles["CHANNEL"];
+			N.midiCCHandles[2]->position = CCHandles["VALUE"];
+			
+			N.midiPCHandles[0]->position = PCHandles["PROGRAM"];
+			N.midiPCHandles[1]->position = PCHandles["CHANNEL"];
+			N.midiPCHandles[2]->position = PCHandles["VALUE"];
+
+			N.midiPitchBendHandles[0]->position = pitchBendHandles["CHANNEL"];
+			N.midiPitchBendHandles[1]->position = pitchBendHandles["VALUE"];
+			
+			N.midiAftertouchHandles[0]->position = aftertouchHandles["CHANNEL"];
+			N.midiAftertouchHandles[1]->position = aftertouchHandles["VALUE"];
+
+			N.midiPolyPressureHandles[0]->position = polyPressureHandles["CHANNEL"];
+			N.midiPolyPressureHandles[1]->position = polyPressureHandles["VALUE"];
+			N.midiPolyPressureHandles[2]->position = polyPressureHandles["NOTE"];
+			//j.at("connections").get_to(N.connections);
 		}
 	};
 }

src/modifier-node.h

@@ -0,0 +1,315 @@
+#pragma once
+
+#include "datatypes.h"
+#include "edge.h"
+#include "node.h"
+#include "raymath.h"
+#include "state.h"
+#include <memory>
+
+namespace VISEQ::GRAPH::NODES {
+
+	class ModNode : public Node{
+
+		public:
+			ModNode() {std::cout << "ModNode Constructor std" << std::endl;}
+			ModNode(Vec2Df position) : Node(position) {}
+
+			std::shared_ptr<ModNode> getPtr() {
+				return std::static_pointer_cast<ModNode>(shared_from_this());
+			}
+
+			NodeType nodeType = NodeType::CONFIGNODE;
+
+			MIDI::MidiNote midiNote;
+			MIDI::MidiCC midiCC;
+			MIDI::MidiPitchBend midiPitchBend;
+			MIDI::MidiPolyPressure midiPolyPressure;
+			MIDI::MidiPC midiPC;
+			MIDI::MidiAftertouch midiAftertouch;
+
+			int mode = 0;
+			float radius = 20.0f;
+
+			virtual NodeType getNodeType() const override {return nodeType;}
+	
+			virtual void trigger() override {}
+
+			virtual void setMode(int _mode) override {
+				mode = _mode;
+			}
+
+			MIDI::MidiNote getNotes() const {
+				MIDI::MidiNote cNote;
+				for(auto cn : getConnectedModNodes()){
+					cNote += cn.lock()->getNotes();
+				}
+				return midiNote + cNote;
+			}
+
+			MIDI::MidiCC getCC() const {
+				MIDI::MidiCC cCC;
+				for(auto cn : getConnectedModNodes()){
+					cCC += cn.lock()->getCC();
+				}
+				return midiCC + cCC;
+			}
+
+			MIDI::MidiPC getPC() const {
+				MIDI::MidiPC cPC;
+				for(auto cn : getConnectedModNodes()){
+					cPC += cn.lock()->getPC();
+				}
+				return midiPC + cPC;
+			}
+
+			MIDI::MidiPitchBend getPitchBend() const {
+				MIDI::MidiPitchBend cPitchBend;
+				for(auto cn : getConnectedModNodes()){
+					cPitchBend += cn.lock()->getPitchBend();
+				}
+				return midiPitchBend + cPitchBend;
+			}
+
+			MIDI::MidiAftertouch getAftertouch() const {
+				MIDI::MidiAftertouch cAftertouch;
+				for(auto cn : getConnectedModNodes()){
+					cAftertouch += cn.lock()->getAftertouch();
+				}
+				return midiAftertouch + cAftertouch;
+			}
+
+			MIDI::MidiPolyPressure getPolyPressure() const {
+				MIDI::MidiPolyPressure cPolyPressure;
+				for(auto cn : getConnectedModNodes()){
+					cPolyPressure += cn.lock()->getPolyPressure();
+				}
+				return midiPolyPressure + cPolyPressure;
+			}
+
+			std::vector<std::weak_ptr<ModNode>> getConnectedModNodes() const { // TODO: check for cyclic connections of config nodes (crashes)
+				auto config_conns = connections | RANGE_FILTER([](EDGES::SPTR_Edge c){ return c->start.lock()->getNodeType() == NodeType::CONFIGNODE || c->end.lock()->getNodeType() == NodeType::CONFIGNODE;}) | std::ranges::to<std::vector<std::shared_ptr<EDGES::Edge>>>();
+				std::vector<std::weak_ptr<ModNode>> config_nodes;
+				for(auto e : config_conns){
+					if(e->start.lock().get() != this && e->start.lock()->getNodeType() == NodeType::CONFIGNODE) config_nodes.push_back(std::dynamic_pointer_cast<ModNode>(e->start.lock()));
+					//if(e->end.lock().get() != this && e->end.lock()->getNodeType() == NodeType::CONFIGNODE) config_nodes.push_back(std::dynamic_pointer_cast<ModNode>(e->end.lock()));
+				}
+				/*std::cout << "id: " << id << " n cn: " << config_nodes.size() << std::endl;*/
+				return config_nodes;
+			}
+			
+			std::vector<std::weak_ptr<ModNode>> getConnectedMidiNodes() const {
+				auto config_conns = connections | RANGE_FILTER([](EDGES::SPTR_Edge c){ return c->start.lock()->getNodeType() == NodeType::MIDINODE || c->end.lock()->getNodeType() == NodeType::MIDINODE;}) | std::ranges::to<std::vector<std::shared_ptr<EDGES::Edge>>>();
+				std::vector<std::weak_ptr<ModNode>> config_nodes;
+				for(auto e : config_conns){
+					if(e->start.lock().get() != this && e->start.lock()->getNodeType() == NodeType::MIDINODE) config_nodes.push_back(std::dynamic_pointer_cast<ModNode>(e->start.lock()));
+					if(e->end.lock().get() != this && e->end.lock()->getNodeType() == NodeType::MIDINODE) config_nodes.push_back(std::dynamic_pointer_cast<ModNode>(e->end.lock()));
+				}
+				/*std::cout << "id: " << id << " n cn: " << config_nodes.size() << std::endl;*/
+				return config_nodes;
+			}
+
+			void update() override {
+				Node::update();
+				mode = state->node_mode;
+			}
+
+			void interact(){
+				float wheel = GetMouseWheelMove();
+
+				if(KEYS_DOWN.ctrl && !KEYS_DOWN.alt){
+					switch(state->node_mode){
+						case 0:{
+								   midiNote.note += KEYS_DOWN.shift ? ((wheel > 0) - (wheel < 0)) * 12 : wheel;
+								   break;}
+						case 1:{
+								   midiCC.value += KEYS_DOWN.shift ? ((wheel > 0) - (wheel < 0)) * 12 : wheel;
+								   break;}
+						case 2:{
+								   midiPitchBend.value += KEYS_DOWN.shift ? ((wheel > 0) - (wheel < 0)) * 12 : wheel;
+								   break;}
+					};
+
+					if(midiNote.note < -127 ) midiNote.note = -127;
+					if(midiNote.note > 127 ) midiNote.note = 127;
+
+					if(midiCC.value < -127 ) midiCC.value = -127;
+					if(midiCC.value > 127 ) midiCC.value = 127;
+
+					if(midiPitchBend.value < -16383 ) midiPitchBend.value = -16383;
+					if(midiPitchBend.value > 16383 ) midiPitchBend.value = 16383;
+
+				} else if(KEYS_DOWN.alt) {
+					switch(state->node_mode){
+						case 0:{
+								   midiNote.channel += wheel;
+								   if(midiNote.channel < 0 ) midiNote.channel = 0;
+								   if(midiNote.channel > 15) midiNote.channel = 15;
+								   break;}
+						case 1:{
+								   midiCC.channel += wheel;
+								   if(midiCC.channel < 0 ) midiCC.channel = 0;
+								   if(midiCC.channel > 15 ) midiCC.channel = 15;
+								   break;}
+						case 2:{
+								   midiPitchBend.channel += KEYS_DOWN.shift ? ((wheel > 0) - (wheel < 0)) * 100 : wheel;
+								   if(midiPitchBend.channel < 0 ) midiPitchBend.channel = 0;
+								   if(midiPitchBend.channel > 15 ) midiPitchBend.channel = 15;
+								   break;}
+					};
+				}
+			}
+			
+			void draw(Vec2Df mouse, Camera2D cam) override {
+				Node::draw();
+				if(hovering() || selected) interact();
+
+				DrawRing(position, radius, radius+4, 0, 360, 24, (Color){60, 60, 60, 255});
+				DrawCircleLinesV(position, radius + 4, (Color){100, 100, 100, 255});
+
+				Color gate_color = VS_COLOR_GREEN;
+
+				switch(mode){
+					case 0:{
+							   gate_color = ColorAlphaBlend(VS_COLOR_RED, (Color){180, 210, 115 + 70, (unsigned char)Clamp(255, 0, 255)}, WHITE);
+							   break;}
+					case 1:{
+							   gate_color = ColorAlphaBlend(VS_COLOR_RED, (Color){229, 181, 103 + 70, (unsigned char)Clamp(255, 0, 255)}, WHITE);
+							   break;}
+					case 2:{
+							   gate_color = ColorAlphaBlend(VS_COLOR_RED, (Color){232, 125, 62 + 70, (unsigned char)Clamp(255, 0, 255)}, WHITE);
+							   break;}
+				}
+				if(!picked_up && !selected && !in_selection_rect && !hovering()) DrawCircle(position.x, position.y, radius, gate_color);
+				if(picked_up || in_selection_rect || hovering()) DrawCircle(position.x, position.y, radius, (Color){108, 153, 187, 255});
+				if(selected) DrawCircle(position.x, position.y, radius, (Color){255, 153, 187, 255});
+
+				if(distributionMode == Distribution::RANDOM) DrawCircle(position.x, position.y, radius/2.0f, VS_COLOR_PINK);
+				if(distributionMode == Distribution::ROUNDROBIN) DrawCircle(position.x, position.y, radius/2.0f, VS_COLOR_YELLOW);
+
+				if(selected) DrawCircleLinesV(position, radius+8, (Color){158, 255, 210, 255});
+
+				if(KEYS_DOWN.alt){
+					float value = 0;
+					int offset_gate = 0;
+					switch(mode){
+						case 0:
+							value = (float)getNotes().channel;
+							offset_gate = MeasureText(std::format("{}", value).c_str(), 12);
+							DrawText(std::format("{}",value).c_str(), position.x-offset_gate/2.0f, position.y-5, 12, VS_COLOR_BLACK );
+							break;
+						case 1:
+							value = (float)getCC().channel;
+							offset_gate = MeasureText(std::format("{}", value).c_str(), 12);
+							DrawText(std::format("{}",value).c_str(), position.x-offset_gate/2.0f, position.y-5, 12, VS_COLOR_BLACK );
+							break;
+						case 2:
+							value = (float)getPC().channel;
+							offset_gate = MeasureText(std::format("{}", value).c_str(), 12);
+							DrawText(std::format("{}",value).c_str(), position.x-offset_gate/2.0f, position.y-5, 12, VS_COLOR_BLACK );
+							break;
+						case 3:
+							value = (float)getPitchBend().channel;
+							offset_gate = MeasureText(std::format("{}", value).c_str(), 12);
+							DrawText(std::format("{}",value).c_str(), position.x-offset_gate/2.0f, position.y-5, 12, VS_COLOR_BLACK );
+							break;
+						case 4:
+							value = (float)getAftertouch().channel;
+							offset_gate = MeasureText(std::format("{}", value).c_str(), 12);
+							DrawText(std::format("{}",value).c_str(), position.x-offset_gate/2.0f, position.y-5, 12, VS_COLOR_BLACK );
+							break;
+						case 5:
+							value = (float)getPolyPressure().channel;
+							offset_gate = MeasureText(std::format("{}", value).c_str(), 12);
+							DrawText(std::format("{}",value).c_str(), position.x-offset_gate/2.0f, position.y-5, 12, VS_COLOR_BLACK );
+							break;
+					}
+				} else {
+					switch(mode){
+						case 0:{
+								   int offset = MeasureText(std::format("{:+}", getNotes().note).c_str(), 12);
+								   DrawText(std::format("{:+}", getNotes().note).c_str(), position.x-offset/2.0f, position.y-5, 12, VS_COLOR_BLACK );
+								   break;}
+						case 1:{
+								   int offset = MeasureText(std::format("{:+}", getCC().value).c_str(), 12);
+								   DrawText(std::format("{:+}", getCC().value).c_str(), position.x-offset/2.0f, position.y-5, 12, VS_COLOR_BLACK );
+								   break;}
+						case 2:{
+								   int offset = MeasureText(std::format("{:+}", getPC().value).c_str(), 12);
+								   DrawText(std::format("{:+}", getPC().value).c_str(), position.x-offset/2.0f, position.y-5, 12, VS_COLOR_BLACK );
+								   break;}
+						case 3:{
+								   int offset = MeasureText(std::format("{:+}", getPitchBend().value).c_str(), 12);
+								   DrawText(std::format("{:+}", getPitchBend().value).c_str(), position.x-offset/2.0f, position.y-5, 12, VS_COLOR_BLACK );
+								   break;}
+						case 4:{
+								   int offset = MeasureText(std::format("{:+}", getAftertouch().value).c_str(), 12);
+								   DrawText(std::format("{:+}", getAftertouch().value).c_str(), position.x-offset/2.0f, position.y-5, 12, VS_COLOR_BLACK );
+								   break;}
+						case 5:{
+								   int offset = MeasureText(std::format("{:+}", getPolyPressure().value).c_str(), 12);
+								   DrawText(std::format("{:+}", getPolyPressure().value).c_str(), position.x-offset/2.0f, position.y-5, 12, VS_COLOR_BLACK );
+								   break;}
+					}
+				}
+
+				if(highlighted) DrawCircleLinesV(position, radius+2, (Color){255, 0, 0, 200});
+				//DrawText(std::format("{}", id).c_str(), position.x + 20.0f, position.y + 20.0f, 10, WHITE);
+			}
+	
+			friend void to_json(json& j, const ModNode& N){
+				std::vector<int> conns;		
+				std::ranges::transform(N.connections.begin(), N.connections.end(), std::back_inserter(conns), [](VISEQ::GRAPH::EDGES::SPTR_Edge e){ return e->id;});
+
+				j = json{
+					{"id", N.id},
+					{"position", N.position},
+					{"distributionMode", N.distributionMode},
+					{"nodeType", N.nodeType},
+					{"midi_note_channel",N.midiNote.channel},
+					{"midi_note_note",N.midiNote.note},
+					{"midi_note_velocity",N.midiNote.velocity},
+					{"midi_note_gate",N.midiNote.gate},
+					{"midi_cc_channel",N.midiCC.channel},
+					{"midi_cc_control",N.midiCC.control},
+					{"midi_cc_value",N.midiCC.value},
+					{"midi_pc_channel",N.midiPC.channel},
+					{"midi_pc_program",N.midiPC.program},
+					{"midi_pc_value",N.midiPC.value},
+					{"midi_pitch_bend_channel",N.midiPitchBend.channel},
+					{"midi_pitch_bend_value",N.midiPitchBend.value},
+					{"midi_aftertouch_channel",N.midiAftertouch.channel},
+					{"midi_aftertouch_value",N.midiAftertouch.value},
+					{"midi_polypressure_channel",N.midiPolyPressure.channel},
+					{"midi_polypressure_value",N.midiPolyPressure.value},
+					{"connections",conns}};
+			}
+
+			friend void from_json(const json& j, ModNode& N){
+				std::cout << "configNode from_json" << std::endl;
+
+				j.at("id").get_to(N.id);
+				j.at("position").get_to<Vec2Df>(N.position);
+				j.at("distributionMode").get_to(N.distributionMode);
+				j.at("nodeType").get_to(N.nodeType);
+				j.at("midi_note_channel").get_to(N.midiNote.channel);
+				j.at("midi_note_note").get_to(N.midiNote.note);
+				j.at("midi_note_velocity").get_to(N.midiNote.velocity);
+				j.at("midi_note_gate").get_to(N.midiNote.gate);
+				j.at("midi_cc_channel").get_to(N.midiCC.channel);
+				j.at("midi_cc_control").get_to(N.midiCC.control);
+				j.at("midi_cc_value").get_to(N.midiCC.value);
+				j.at("midi_pc_channel").get_to(N.midiPC.channel);
+				j.at("midi_pc_program").get_to(N.midiPC.program);
+				j.at("midi_pc_value").get_to(N.midiPC.value);
+				j.at("midi_pitch_bend_channel").get_to(N.midiPitchBend.channel);
+				j.at("midi_pitch_bend_value").get_to(N.midiPitchBend.value);
+				j.at("midi_aftertouch_channel").get_to(N.midiAftertouch.channel);
+				j.at("midi_aftertouch_value").get_to(N.midiAftertouch.value);
+				j.at("midi_polypressure_channel").get_to(N.midiPolyPressure.channel);
+				j.at("midi_polypressure_value").get_to(N.midiPolyPressure.value);
+
+				//j.at("connections").get_to(N.connections);
+			}
+	};
+}

src/mouse.h

@@ -0,0 +1,65 @@
+#pragma once
+
+#include "draggable.h"
+#include "graph-manager.h"
+#include "interaction-event.h"
+#include <memory>
+namespace VISEQ::APP {
+	class Mouse {
+		public:
+			Mouse() {}
+			Mouse(GraphManager *gm) : gm(gm) {}
+
+			GraphManager *gm;
+
+			void update(){
+				/*auto hovering_nodes = gm->nodes | RANGE_FILTER([](SPTR_Node n) { return n->hovering() || n->picked_up;}) | std::ranges::to<std::vector<std::shared_ptr<BASE::Draggable>>>();*/
+				/**/
+				/*if(!hovering_nodes.empty()){*/
+				/*	hovering_nodes.front()->is_hovering = true;*/
+				/**/
+				/*	if(hovering_nodes.front()->pickedUp()) hovering_nodes.front()->drag();*/
+				/*	if(hovering_nodes.front()->released()) hovering_nodes.front()->putDown();*/
+				/**/
+				/*}*/
+
+			}
+		
+			void interact(InteractionEvent e){
+
+			}
+
+			/*virtual void select() override {*/
+			/*	if(STATE == IState::DRAW_SELECTION) in_selection_rect = CheckCollisionPointRec(position, state->selection);*/
+			/*	if(MOUSE_LEFT.released) selected = (KEYS_DOWN.shift && selected) || in_selection_rect;*/
+			/*}*/
+			/**/
+			/*virtual void update() override {*/
+			/*	if(STATE != IState::HOVER_NODE) select();*/
+			/*	if((pickedUp() || hovering()) && z_hovering == -1) z_hovering = z_index;*/
+			/**/
+			/*	if(z_index == z_hovering || selected){*/
+			/*		if(pickedUp()){*/
+			/*			drag();*/
+			/*			STATE = IState::DRAG_NODE;*/
+			/*		}*/
+			/*	}*/
+			/*	if(STATE != IState::DRAG_NODE){*/
+			/*		if(entered()){*/
+			/*			STATE = IState::HOVER_NODE;*/
+			/*			std::cout << "z_index=" << z_index << " z_hovering=" << z_hovering << std::endl;*/
+			/*			is_hovering = true;*/
+			/*		}*/
+			/*		if(exited()){*/
+			/*			STATE = IState::HOVER_CANVAS;*/
+			/*			is_hovering = false;*/
+			/*		}*/
+			/*	}*/
+			/*	if(released() && picked_up){*/
+			/*		putDown();*/
+			/*		STATE = IState::HOVER_CANVAS;*/
+			/*		if(hovering()) STATE = IState::HOVER_NODE;*/
+			/*	}*/
+			/*}*/
+	};
+}

src/moveable.h

@@ -1,6 +1,8 @@
 #pragma once
 
-#include "datatypes.h"
+#include "state.h"
+#include "vmath.h"
+#include <memory>
 
 namespace VISEQ::BASE {
 	class Movable{
@@ -12,31 +14,18 @@ namespace VISEQ::BASE {
 		Movable(Vec2Df p, Vec2Df d, float s) : speed(s), position(p), direction(d) {}
 		Movable(Vec2Df p, float s) : speed(s), position(p) {}
 
+		std::shared_ptr<APP::State> state = APP::State::get();
+
 		float speed = 960.0f;
 		
 		Vec2Df position;
 		Vec2Df direction;
-
-		Vec2Df drag_offset;
 		
-		bool in_rect = false;
-		
-		bool picked_up = false;
-		bool dragging = false;
-		bool hover_connect = false;
-		bool hovering = false;
-		bool connecting = false;
-		bool selected = false;
-		bool highlighted = false;
-		bool copied = false;
-		
-		bool erase = false;
-
 		virtual void setPosition(Vec2Df _position) {position = _position;}
 		virtual Vec2Df getPosition() {return position;};
 		virtual void update(double frametime) {};
 		virtual void update() {};
-
+		virtual void update(Vec2Df pos) {};
 	};
 
 }

src/node-handle.h

@@ -0,0 +1,136 @@
+#pragma once
+
+#include "datatypes.h"
+#include "draggable.h"
+#include "graph-item.h"
+#include "helper.h"
+#include "raylib.h"
+#include "raymath.h"
+#include "state.h"
+#include <memory>
+#include <nlohmann/json.hpp>
+
+namespace VISEQ::GRAPH::NODES{
+	
+	template<typename T>
+	class NodeHandle : public BASE::Draggable, public GraphItem, public std::enable_shared_from_this<NodeHandle<T>>{
+		public:
+			NodeHandle() {}
+			NodeHandle(T &_assignedValue, Vec2Df parentPos, Color _col, std::string name) : assignedValueRef(_assignedValue), parentPosition(parentPos), col(_col), name(name) {init();}
+			NodeHandle(T &_assignedValue, Vec2Df parentPos, Color _col, std::string name, float min, float max, float minDist, float maxDist) : assignedValueRef(_assignedValue), parentPosition(parentPos), col(_col), name(name), minValue(min), maxValue(max), minDistance(minDist), maxDistance(maxDist) {init();}
+
+			virtual GRAPH::GraphItemType getType() override {
+				return GraphItemType::HANDLE;
+			}
+			
+			std::shared_ptr<NodeHandle<T>> getPtr(){
+				return this->shared_from_this();
+			}
+			
+			T &assignedValueRef;
+			Vec2Df parentPosition = {0,0};
+			Color col;
+			std::string name = "";
+
+			float minValue = 0;
+			float maxValue = 127;
+			float minDistance = 40;
+			float maxDistance = 40 + 2*127;
+			bool stopAtMax = true;
+
+			float radius = 10.0f;
+			float orbit = 0.0f;
+
+			Vec2Df minP;
+			Vec2Df maxP;
+
+			bool locked = true;
+			bool visible = false;
+
+			void init(){
+				position = parentPosition.orbitAtAngle(minDistance, DEG2RAD * GetRandomValue(0, 360)) - parentPosition;
+			}
+
+			void assignValue(T &value){
+				assignedValueRef = value;
+			}
+		
+			float distance(){
+				return (parentPosition + position).dist(parentPosition);
+			}
+
+			virtual void drag(Vec2Df mouse_pos) override {
+				if(KEYS_DOWN.shift)	{
+					orbit = (parentPosition + position).dist(parentPosition);
+					position = parentPosition.orbitAlongVector(SCREEN_MOUSE, orbit) - parentPosition;
+				} else {
+					float step = (maxDistance - minDistance) / (maxValue - minValue);
+					orbit =  round(parentPosition.dist(SCREEN_MOUSE) / step) * step;
+					position = parentPosition.orbitAlongVector(maxP, orbit) - parentPosition;
+				}
+				if(distance() >= maxDistance) position = parentPosition.orbitAlongVector(maxP, maxDistance) - parentPosition;
+				if(distance() <= minDistance) position = parentPosition.orbitAlongVector(maxP, minDistance) - parentPosition;
+			}
+			
+			void lock(){
+				visible = false;
+				locked = true;
+			}
+
+			void unlock(){
+				visible = true;
+				locked = false;
+			}
+
+			void assignValue(T &value, float min, float max, float minDistance, float maxDistance){
+				assignedValueRef = value;
+			}
+
+			void updateAssignedValue(){
+				assignedValueRef = (T)Remap((float)(parentPosition + position).dist(parentPosition), minDistance, maxDistance, minValue, maxValue);
+			}
+
+			virtual bool hovering() override {
+				return CheckCollisionPointCircle(SCREEN_MOUSE, position + parentPosition, radius);
+			}
+
+			virtual void update(Vec2Df pos) override {
+				if(!locked && visible){
+					if(hovering()) state->pushEvent({getPtr(), APP::Interaction::HOVER});
+					if(hovering() && clicked()) state->pushEvent({getPtr(), APP::Interaction::PICKUP});
+					if(pickedUp()) state->pushEvent({getPtr(), APP::Interaction::DRAG});
+				}
+				if(picked_up && released()) state->pushEvent({getPtr(), APP::Interaction::PUTDOWN});
+				
+				parentPosition = pos;
+				if(!locked && visible) updateAssignedValue();
+				
+				minP = parentPosition.orbitAlongVector((parentPosition + position), minDistance);
+				maxP = parentPosition.orbitAlongVector((parentPosition + position), maxDistance);
+			}
+
+			virtual void draw() override {
+				if(!locked && visible){
+					bool show = hovering() || picked_up;
+					Color dcol = ColorBrightness(col, -0.5f);
+					Color dyncol = show ? col : dcol;
+
+					DrawLineV(minP, maxP, dcol);
+					//DrawLineV(parentPosition, minP, VS_COLOR_LIGHTGREY);
+					DrawCircleV(minP, 3.0f, dyncol);
+					DrawCircleV(maxP, 3.0f, dyncol);
+					DrawCircleV(position + parentPosition, radius, dyncol);
+					if(show) VISEQ::HELPER::DrawSuperText(name, minP, maxP, 0.5f, 8.0f, 10.0f, dyncol);
+				}
+			}
+			
+			virtual bool select() override {
+				return false;
+			}
+			
+			/*friend void to_json(json& j, const NodeHandle<T>& N){*/
+			/*	j = json{{"position",N.position}};*/
+			/*}*/
+			NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(NodeHandle, position, name);
+	};
+}

src/node.h

@@ -3,9 +3,13 @@
 #include <memory>
 #include <raylib.h>
 
+#include "connector.h"
 #include "datatypes.h"
+#include "draggable.h"
 #include "graph-item.h"
-#include "moveable.h"
+#include "interaction-event.h"
+#include "state.h"
+#include "vmath.h"
 
 namespace VISEQ::GRAPH::EDGES{
 	class Edge;
@@ -13,33 +17,97 @@ namespace VISEQ::GRAPH::EDGES{
 
 namespace VISEQ::GRAPH::NODES {
 
-	class Node : public BASE::Movable, public GraphItem{
+	class Node : public BASE::Draggable, public GraphItem, public std::enable_shared_from_this<Node> {
 
 		public:
-		Node() {}
-		Node(float x, float y) : Movable(Vec2Df(x, y), 960.0f) {}
-		Node(Vec2Df p) : Movable(p, 960.0f) {}
 
+		Node() {std::cout << "Node constructor" << std::endl;}
+		Node(float x, float y) : Draggable(Vec2Df(x, y)) {}
+		Node(Vec2Df p) : Draggable(p) {}
+		
 		NodeType nodeType;
 	
 		std::vector<std::shared_ptr<Node>> neighbors;
 		std::vector<std::shared_ptr<VISEQ::GRAPH::EDGES::Edge>> connections;
 
+		std::vector<std::shared_ptr<Connector>> connectors;
+
 		Distribution distributionMode = Distribution::GEOMETRIC;
 
 		float radius = 15.0f;
+		float node_radius = 15.0f;
+		float hover_radius = 32.0f;
 		bool config = false;
+		
+		bool triggered = false;
+		int mode = 0;
+	
+		virtual void trigger() {}
+		virtual void setMode(int _mode) {mode = _mode;}
+
+		std::shared_ptr<Node> getPtr(){
+			return shared_from_this();
+		}
+
+		virtual bool hovering() override {
+			return CheckCollisionPointCircle(SCREEN_MOUSE, position, radius);
+		}
+
+		void addConnector() {
+			connectors.emplace_back(std::make_shared<Connector>(getPtr(), position, radius + 5.0f));
+		}
+
+		void removeConnector(std::weak_ptr<Connector> connector){
+			std::erase(connectors, connector.lock());
+		}
 
 		virtual NodeType getNodeType() const {return nodeType;}
+	
+		void deselect() override {
+			selected = false;
+		}
+
+		GraphItemType getType() override{
+			return GraphItemType::NODE;
+		}
+
+		void clearConnectors(){
+			connectors.clear();
+			update();
+		}
+
+		void update() override{
+			if(hovering()) state->pushEvent({getPtr(), APP::Interaction::HOVER});
+			if(hovering() && clicked()) state->pushEvent({getPtr(), APP::Interaction::PICKUP});
+			if(pickedUp()) state->pushEvent({getPtr(), APP::Interaction::DRAG});
+			if(picked_up && released()) state->pushEvent({getPtr(), APP::Interaction::PUTDOWN});
+			if(hovering() && MOUSE_RIGHT.clicked) {
+				selected = true;
+				config = true;
+				state->pushEvent({getPtr(), APP::Interaction::RIGHTCLICK});
+			}
+			int free_connectors = 0;
+			for(auto c : connectors){
+				if(c->partner.expired()) free_connectors++;
+				c->setPosition(position);
+				c->setOrbit(radius + 8.0f);
+				c->update();
+			}
+			if(free_connectors == 0) addConnector();
+		}
+	
+		void draw(Vec2Df mp, Camera2D cam) override {}
+
+		void draw() override{
+			for(auto c : connectors){
+				c->draw();
+			}
+		}
 
-		virtual void SMode(int mode) {};
-		virtual int GGate() {return 0;};
-		virtual int GActive() {return 0;};
-		virtual void trigger() {};
-		void draw(Vec2Df mouse_pos, Camera2D cam) override {}
 	};
 
 	typedef std::shared_ptr<VISEQ::GRAPH::NODES::Node> SPTR_Node;
+	typedef std::weak_ptr<VISEQ::GRAPH::NODES::Node> WPTR_Node;
 	typedef std::vector<SPTR_Node> VEC_SPTR_Node;
-
+	typedef std::vector<WPTR_Node> VEC_WPTR_Node;
 }

src/selectable.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "interactable.h"
+#include "vmath.h"
+
+namespace VISEQ::BASE {
+	class Selectable : public Interactable{
+		public:
+			Selectable() {}
+			
+			bool in_selection_rect = false;
+			bool selected = false;
+
+			bool copied = false;
+			bool highlighted = false;
+			bool erase = false;
+			Vec2Df selection_offset;
+
+			virtual bool clicked() override {
+				return (selected || hovering()) && IsMouseButtonPressed(MOUSE_BUTTON_LEFT);
+			}
+
+			virtual bool select() = 0;
+			virtual void deselect() = 0;
+	};
+}

src/signal-manager.h

@@ -3,11 +3,11 @@
 #include "datatypes.h"
 #include "graph-manager.h"
 #include "midi-node.h"
+#include "node.h"
 #include "signal.h"
 #include "midi.h"
 
 #include <chrono>
-#include <locale>
 #include <memory>
 #include <thread>
 
@@ -18,16 +18,20 @@ namespace VISEQ::SIGNAL {
 	typedef std::shared_ptr<Signal> SPTR_Signal;
 	typedef std::vector<SPTR_Signal> VEC_SPTR_Signal;
 
-	class SignalManager{
+	class SignalManager : public std::enable_shared_from_this<SignalManager>{
 
 		public:
 			SignalManager() {}
-			SignalManager(GraphManager *gm, std::mutex *mutex) : mutex(mutex), gm(gm) {}
+			SignalManager(std::shared_ptr<GraphManager> gm, std::mutex *mutex) : mutex(mutex), gm(gm) {}
 			
+			std::shared_ptr<SignalManager> getPtr(){
+				return shared_from_this();
+			}
+
 			VISEQ::MIDI::Midi midi;
 			
 			std::mutex *mutex;
-			GraphManager *gm;
+			std::shared_ptr<GraphManager> gm;
 
 			VEC_SPTR_Signal signals;
 
@@ -51,7 +55,7 @@ namespace VISEQ::SIGNAL {
 			
 			void reset(){
 				for(auto &s : signals){
-					s->position = s->start->position + Vec2Df{0.1, 0.1};
+					s->position = s->start.lock()->position + Vec2Df{0.1, 0.1};
 					s->next = s->start;
 					s->last = s->start;
 				}
@@ -67,14 +71,40 @@ namespace VISEQ::SIGNAL {
 				loop = false;
 			}
 		
-			void addSignalAtNode(SPTR_Node node){
+			void addSignalAtNode(WPTR_Node node){
 				Color c = {(unsigned char)(20 + (rand() % 200)), 100, (unsigned char)(20 + (int)(rand() % 200)), 200};
-				signals.emplace_back(std::make_shared<Signal>(node->position + Vec2Df{0.5f, 0.5f}, 8.0f, 0, c)); // position + 1 or else it does not render. why? no idea!
+				signals.emplace_back(std::make_shared<Signal>(node.lock()->position + Vec2Df{0.5f, 0.5f}, 8.0f, 480, c)); // position + 1 or else it does not render. why? no idea!
 				signals.back()->next = node;
 				signals.back()->last = node;
 				signals.back()->start = node;
 			}
 
+			void rerouteSignal(VEC_SPTR_Node nodes, VEC_WPTR_Node adjacent_nodes){
+				auto reroute_signals = signals | RANGE_FILTER([nodes](SIGNAL::SPTR_Signal s){return std::ranges::contains(nodes, s->next.lock());});
+
+				for(auto s : reroute_signals){
+					float dist = 10000000;
+					SPTR_Node next_node;
+					for(auto n : adjacent_nodes){
+						if(n.lock()->position.dist(s->position) < dist) {
+							dist = n.lock()->position.dist(s->position);
+							next_node = n.lock();
+						}
+					}
+					s->next = next_node;
+					s->last = next_node;
+				}
+
+			}
+
+			void rebaseSignal(VEC_SPTR_Node nodes){
+				auto rebase_signals = signals | RANGE_FILTER([nodes](SIGNAL::SPTR_Signal s){return std::ranges::contains(nodes, s->start.lock());});
+				
+				for(auto s : rebase_signals){
+					s->start = s->next;
+				}
+			}
+
 			void removeSignal(std::shared_ptr<Signal> s){
 				erase_signals.push_back(s);
 			}
@@ -87,19 +117,19 @@ namespace VISEQ::SIGNAL {
 						mutex->lock();
 						if(play){
 							for(auto& s : signals){
-								s->direction = (s->next->position - s->position).norm();
+								s->direction = (s->next.lock()->position - s->position).norm();
 								s->update(diff.count());
-								if(s->position.dist(s->next->position) < 0.6f) {
-									SPTR_Node next_node = gm->next(s->next, s->last);
-									s->next->trigger();
+								if(s->position.dist(s->next.lock()->position) < 0.6f) {
+									WPTR_Node next_node = gm->next(s->next, s->last);
+									s->next.lock()->trigger();
 
-									if(next_node != s->next && next_node != SPTR_Node(nullptr) && s->next->getNodeType() == NodeType::MIDINODE) {
-										auto midinode = std::dynamic_pointer_cast<MidiNode>(s->next);
+									if(next_node.lock() != s->next.lock() && !next_node.expired() && s->next.lock()->getNodeType() == NodeType::MIDINODE) {
+										auto midinode = std::dynamic_pointer_cast<MidiNode>(s->next.lock());
 										for(auto &m : midinode->midi_outs){
 											if(m.second.enabled) {
-												if(midinode->send_note) midi.note(m.second.i, midinode->midi_note_channel, (int)Clamp(midinode->midi_note + s->midi_note_offset, 0, 127), midinode->midi_velocity, midinode->midi_gate);	
-												if(midinode->send_cc) midi.cc(m.second.i, midinode->midi_cc_channel, midinode->midi_cc, (int)Clamp(midinode->midi_cc_value + s->midi_cc_offset, 0, 127));	
-												if(midinode->send_pitch_bend) midi.pitch_bend(m.second.i, midinode->midi_pitch_bend_channel, midinode->midi_pitch_bend);	
+												if(midinode->send_note) midi.note(m.second.i, midinode->getNotes().channel, (int)Clamp(midinode->getNotes().note + s->midi_note_offset, 0, 127), midinode->getNotes().velocity, midinode->getNotes().gate);	
+												if(midinode->send_cc) midi.cc(m.second.i, midinode->getCC().channel, midinode->getCC().control, (int)Clamp(midinode->getCC().value + s->midi_cc_offset, 0, 127));	
+												if(midinode->send_pitch_bend) midi.pitch_bend(m.second.i, midinode->getPitchBend().channel, midinode->getPitchBend().value);	
 											}
 										}
 										s->last = s->next;
@@ -129,9 +159,7 @@ namespace VISEQ::SIGNAL {
 				mutex->unlock();
 			}
 
+	        NLOHMANN_DEFINE_TYPE_INTRUSIVE(SignalManager, signals)
+		
 	};
-
-	inline void to_json(json& j, const SignalManager& G){
-		j = json{{"signals", G.signals}};
-	}
 }

src/signal.h

@@ -15,11 +15,11 @@ namespace VISEQ::SIGNAL {
 		Signal() {}
 		Signal(Vec2Df position, float r, float _speed, Color color) : Movable(position, Vec2Df(0,0), _speed), radius(r), color(color) {}
 		
-		NODES::SPTR_Node next;
-		NODES::SPTR_Node last;
-		EDGES::SPTR_Edge edge;
+		NODES::WPTR_Node next;
+		NODES::WPTR_Node last;
+		EDGES::WPTR_Edge edge;
 
-		NODES::SPTR_Node start;
+		NODES::WPTR_Node start;
 
 		bool at_target = false;
 		bool run = true;
@@ -34,6 +34,14 @@ namespace VISEQ::SIGNAL {
 
 		int midi_note_offset = 0;
 		int midi_cc_offset = 0;
+	
+		void reset(){
+			toStart();
+		}
+
+		void toStart(){
+			position = start.lock()->position;
+		}
 
 		void update(double t_delta){
 			// 120px / 16th = 1920px / whole note

src/state-io.h

@@ -1,10 +1,11 @@
 #pragma once
 
+#include "config-node.h"
 #include "midi-node.h"
 #include "graph-item.h"
+#include "node-handle.h"
 #include "node.h"
 #include "edge.h"
-//#include "graph-manager.h"
 
 #include "datatypes.h"
 #include "signal.h"
@@ -12,19 +13,56 @@
 #include <iostream>
 #include <memory>
 
-/*using namespace VISEQ::BASE;*/
-/*using namespace VISEQ::SIGNAL;*/
-/*using namespace VISEQ::GRAPH::NODES;*/
-/*using namespace VISEQ::GRAPH::EDGES;*/
-
 typedef std::shared_ptr<VISEQ::GRAPH::GraphItem> SPTR_GraphItem;
 typedef std::vector<SPTR_GraphItem> VEC_SPTR_GraphItem;
 
+namespace nlohmann {
+	template <typename T>
+	struct adl_serializer<std::shared_ptr<T>> {
+		static void to_json(json& j, const std::shared_ptr<T>& opt) {
+			if (opt) {
+				j = *opt;
+			} else {
+				j = nullptr;
+			}
+		}
+
+		static void from_json(const json& j, std::shared_ptr<T>& opt) {
+			if (j.is_null()) {
+				opt = nullptr;
+			} else {
+				opt.reset(new T(j.get<T>()));
+			}
+		}
+	};
+	
+	/*template <typename T>*/
+	/*struct adl_serializer<std::shared_ptr<T>> {*/
+	/*	template <typename J>*/
+	/*	static void to_json(J& j, const std::shared_ptr<T>& opt) {*/
+	/*		if (opt) {*/
+	/*			j = *opt;*/
+	/*		} else {*/
+	/*			j = nullptr;*/
+	/*		}*/
+	/*	}*/
+	/**/
+	/*	template <typename J>*/
+	/*	static void from_json(const J& j, std::shared_ptr<T>& opt) {*/
+	/*		if (j.is_null()) {*/
+	/*			opt = nullptr;*/
+	/*		} else {*/
+	/*			opt.reset(new T(j.template get<T>()));*/
+	/*		}*/
+	/*	}*/
+	/*};*/
+}
+
 namespace VISEQ::GRAPH::EDGES {
 	using namespace VISEQ::GRAPH::NODES;
 
 	inline void to_json(json& j, const VISEQ::GRAPH::EDGES::Edge& E){
-		j = json{{"id",E.id}, {"start", E.start->id}, {"end",E.end->id}, {"pass_forward",E.pass_forward}, {"pass_backward", E.pass_backward}}; 
+		j = json{{"id",E.id}, {"start", E.start.lock()->id}, {"end",E.end.lock()->id}, {"pass_forward",E.pass_forward}, {"pass_backward", E.pass_backward}}; 
 	}
 	
 	inline void from_json(const json& j, Edge& E){
@@ -36,7 +74,7 @@ namespace VISEQ::GRAPH::EDGES {
 	inline void to_json(json& j, const VISEQ::GRAPH::EDGES::SPTR_Edge& E){
 		j = *E; 
 	}
-	
+
 	inline void from_json(const json& j, VISEQ::GRAPH::EDGES::SPTR_Edge& E){
 		E.reset(new Edge(j.get<Edge>()));
 	}
@@ -46,64 +84,33 @@ namespace VISEQ::GRAPH::NODES {
 	
 	/* ------------------- MIDINODE ---------------------- */
 	
-	inline void to_json(json& j, const MidiNode& N){
-		std::vector<int> conns;		
-		std::ranges::transform(N.connections.begin(), N.connections.end(), std::back_inserter(conns), [](VISEQ::GRAPH::EDGES::SPTR_Edge e){ return e->id;});
-
-		j = json{
-			{"id", N.id},
-			{"position", N.position},
-			{"distributionMode", N.distributionMode},
-			{"nodeType", N.nodeType},
-			{"midi_note_channel",N.midi_note_channel},
-			{"midi_note",N.midi_note},
-			{"midi_velocity",N.midi_velocity},
-			{"midi_gate",N.midi_gate},
-			{"midi_cc_channel",N.midi_cc_channel},
-			{"midi_cc",N.midi_cc},
-			{"midi_cc_value",N.midi_cc_value},
-			{"midi_pc_channel",N.midi_pc_channel},
-			{"midi_pc_value",N.midi_pc_value},
-			{"midi_pitch_bend_channel",N.midi_pitch_bend_channel},
-			{"midi_pitch_bend",N.midi_pitch_bend},
-			{"connections",conns}};
-	}
-
-	inline void from_json(const json& j, MidiNode& N){
-		std::cout << "MidiNode" << std::endl;
-
-		j.at("id").get_to(N.id);
-		j.at("position").get_to<Vec2Df>(N.position);
-		j.at("distributionMode").get_to(N.distributionMode);
-		j.at("nodeType").get_to(N.nodeType);
-		j.at("midi_note_channel").get_to(N.midi_note_channel);
-		j.at("midi_note").get_to(N.midi_note);
-		j.at("midi_velocity").get_to(N.midi_velocity);
-		j.at("midi_gate").get_to(N.midi_gate);
-		j.at("midi_cc_channel").get_to(N.midi_cc_channel);
-		j.at("midi_cc").get_to(N.midi_cc);
-		j.at("midi_cc_value").get_to(N.midi_cc_value);
-		j.at("midi_pc_channel").get_to(N.midi_pc_channel);
-		j.at("midi_pc_value").get_to(N.midi_pc_value);
-		j.at("midi_pitch_bend_channel").get_to(N.midi_pitch_bend_channel);
-		j.at("midi_pitch_bend").get_to(N.midi_pitch_bend);
-
-		//j.at("connections").get_to(N.connections);
-	}
-
-	inline void to_json(json& j, const std::shared_ptr<MidiNode>& N){
-		j = *N;
-	}
-	
-	inline void from_json(const json& j, std::shared_ptr<MidiNode>& N){
-		N.reset(new MidiNode(j.get<MidiNode>()));
-	}
+	/*inline void to_json(json& j, const std::shared_ptr<MidiNode>& N){*/
+	/*	j = *N;*/
+	/*}*/
+	/**/
+	/*inline void from_json(const json& j, std::shared_ptr<MidiNode>& N){*/
+	/*	N.reset(new MidiNode(j.get<MidiNode>()));*/
+	/*}*/
 	
 	inline void to_json(json& j, const MidiNode::NodeMidiOut& MO){
 		j = json{{"port_id", MO.i}, {"enabled", MO.enabled}, {"name", MO.name}};
 	}
 
+	/*template< typename T>*/
+	/*inline void to_json(json& j, const std::shared_ptr<NodeHandle<T>>& NH){*/
+	/*	j = json{{"position", NH->position}};*/
+	/*}*/
+	/* ----------------- CONFIG NODE -----------------*/
 
+
+	/*inline void to_json(json& j, const std::shared_ptr<ConfigNode>& N){*/
+	/*	j = *N;*/
+	/*}*/
+	/**/
+	/*inline void from_json(const json& j, std::shared_ptr<ConfigNode>& N){*/
+	/*	N.reset(new ConfigNode(j.get<ConfigNode>()));*/
+	/*}*/
+	
 	/* ------------------- NODE ---------------------- */
 
 
@@ -111,23 +118,33 @@ namespace VISEQ::GRAPH::NODES {
 		if(N.getNodeType() == NodeType::MIDINODE){
 			j = dynamic_cast<const MidiNode&>(N);
 		}
+		if(N.getNodeType() == NodeType::CONFIGNODE){
+			j = dynamic_cast<const ConfigNode&>(N);
+		}
 	}
 	
 	inline void from_json(const json& j, Node& N){
 
 		if(j.at("nodeType") == NodeType::MIDINODE){
-			std::cout << j.at("nodeType") << std::endl;
 			N = j.template get<MidiNode>();
 		}
+		if(j.at("nodeType") == NodeType::CONFIGNODE){
+			N = j.template get<ConfigNode>();
+		}
 	}
 
 	inline void to_json(json& j, const SPTR_Node& N){
 		j = *N;
 	}
-	
+
 	inline void from_json(const json& j, std::shared_ptr<Node>& N){
 		std::cout << "SPTR_Node" << std::endl;
-		N.reset(new Node(j.get<Node>()));
+		if(N->getNodeType() == NodeType::MIDINODE){
+			N.reset(new MidiNode(j.get<MidiNode>()));	
+		}
+		if(N->getNodeType() == NodeType::CONFIGNODE){
+			N.reset(new ConfigNode(j.get<ConfigNode>()));	
+		}
 	}
 
 }
@@ -136,7 +153,7 @@ namespace VISEQ::GRAPH::NODES {
 namespace VISEQ::GRAPH {
 	inline void to_json(json& j, const GraphItem& G){
 		std::cout << "Movable" << std::endl;
-		j = json{{"id", G.id}, {"type", G.graphItemType}};
+		j = json{{"id", G.id}, {"type", G.gItemType}};
 	}
 
 	inline void to_json(json& j, const SPTR_GraphItem& G){
@@ -156,18 +173,18 @@ namespace VISEQ::BASE{
 	
 	inline void from_json(const json& j, Movable& G){
 		std::cout << "Movable" << std::endl;
-	//	j = json{{"position", G.position}};
+		j.at("position").get_to<Vec2Df>(G.position);
 	}
 
 	inline void from_json(json& j, const std::shared_ptr<Movable>& G){
-	//	j = *G; 
+		j = *G; 
 	}
 }
 
 namespace VISEQ::SIGNAL{
 	inline void to_json(json& j, const Signal& G){
 		std::map<std::string, int> fc = {{"r",G.color.r},{"g",G.color.g},{"b",G.color.b},{"a",G.color.a}};
-		j = json{{"color",fc},{"position", G.position},{"radius",G.radius},{"start",G.start->id},{"next",G.next->id},{"last",G.last->id},{"speed",G.speed},{"midi_note_offset",G.midi_note_offset},{"midi_cc_offset",G.midi_cc_offset},{"multiplier",G.multiplier}};
+		j = json{{"color",fc},{"position", G.position},{"radius",G.radius},{"start",G.start.lock()->id},{"next",G.next.lock()->id},{"last",G.last.lock()->id},{"speed",G.speed},{"midi_note_offset",G.midi_note_offset},{"midi_cc_offset",G.midi_cc_offset},{"multiplier",G.multiplier}};
 	}
 	
 	inline void from_json(const json& j, Signal& S){
@@ -190,7 +207,7 @@ namespace VISEQ::SIGNAL{
 	inline void to_json(json& j, const std::shared_ptr<Signal>& G){
 		j = *G; 
 	}
-	
+
 	inline void from_json(const json& j, std::shared_ptr<Signal>& S){
 		S.reset(new Signal(j.get<Signal>()));
 	}

src/state-manager.h

@@ -1,154 +0,0 @@
-#pragma once
-
-#include "datatypes.h"
-#include "graph-manager.h"
-#include "midi-node.h"
-#include "signal-manager.h"
-#include "ui.h"
-
-#include <algorithm>
-#include <iterator>
-#include <memory>
-#include <ranges>
-#include <vector>
-
-namespace VISEQ::APP {
-
-	class AppState{
-		public:
-			
-			AppState() : sm(&gm, &mutex), ui(&settings, &sm, &gm) {}
-
-			enum States {IDLE, CONFIG};
-			
-			AppSettings settings;
-
-			States state;
-
-			std::mutex mutex;
-
-			VISEQ::GRAPH::GraphManager gm;
-			VISEQ::SIGNAL::SignalManager sm;
-
-			UI::AppUI ui;
-
-			void updateMidiPorts(){
-				for(auto&n : gm.nodes | RANGE_FILTER([](VISEQ::GRAPH::NODES::SPTR_Node n){return n->getNodeType() == NodeType::MIDINODE;})){
-					auto nc = std::dynamic_pointer_cast<MidiNode>(n);
-					for(auto& mo : sm.midi.midi_out_ports){
-						if(!nc->midi_outs.contains(mo.number) && mo.enabled){
-							nc->midi_outs[mo.number] = {mo.number, mo.port.port_name, false};	
-						}
-						if(nc->midi_outs.contains(mo.number) && !mo.enabled){
-							nc->midi_outs.erase(mo.number);
-						}
-					}
-				}
-			}
-
-			void copyNodesAndConnections(VEC_SPTR_Node nodes, Vec2Df position){
-
-				VEC_SPTR_Edge copy_connections;
-				for(auto c : gm.edges){
-					if(std::ranges::contains(nodes, c->start) && std::ranges::contains(nodes, c->end)) {
-						copy_connections.push_back(std::make_shared<Edge>(*c));
-					}
-				}
-				std::cout << copy_connections.size() << std::endl;
-
-				for(auto old_node : nodes){
-					SPTR_Node new_node;
-
-					if(old_node->getNodeType() == NodeType::MIDINODE) {
-						new_node = gm.copyNode(std::dynamic_pointer_cast<MidiNode>(old_node), position + old_node->drag_offset);
-					} else {
-						new_node = gm.copyNode(old_node, position + old_node->drag_offset);
-					}
-
-					new_node->copied = false;
-					new_node->selected = true;
-
-					for(auto c : copy_connections){
-						if(c->start == old_node) {
-							c->start = new_node;
-							c->start->connections.push_back(c);
-						}
-						if(c->end == old_node) {
-							c->end = new_node;
-							c->end->connections.push_back(c);
-						}
-					}
-				}
-				std::ranges::copy(copy_connections.begin(), copy_connections.end(), std::back_inserter(gm.edges));
-			}
-
-			void removeNodes(VEC_SPTR_Node nodes){
-
-				for(auto n : gm.nodes){
-					n->highlighted = false;
-				}
-
-				auto erase_connections = gm.edges | RANGE_FILTER([nodes](SPTR_Edge c){ return std::ranges::contains(nodes, c->start) || std::ranges::contains(nodes, c->end);});
-
-				VEC_SPTR_Node adjacent_nodes;
-
-				for(auto c : erase_connections){
-					if(!c->start->selected) adjacent_nodes.push_back(c->start);
-					if(!c->end->selected) adjacent_nodes.push_back(c->end);
-				}
-
-				auto reroute_signals = sm.signals | RANGE_FILTER([nodes](SIGNAL::SPTR_Signal s){return std::ranges::contains(nodes, s->next);});
-
-				for(auto s : reroute_signals){
-					float dist = 10000000;
-					SPTR_Node next_node;
-					for(auto n : adjacent_nodes){
-						if(n->position.dist(s->position) < dist) {
-							dist = n->position.dist(s->position);
-							next_node = n;
-						}
-					}
-					s->next = next_node;
-					s->last = next_node;
-				}
-				
-				auto rebase_signals = sm.signals | RANGE_FILTER([nodes](SIGNAL::SPTR_Signal s){return std::ranges::contains(nodes, s->start);});
-				
-				for(auto s : rebase_signals){
-					s->start = s->next;
-				}
-
-				for(auto n : adjacent_nodes){
-					std::erase_if(n->connections, [n, nodes](VISEQ::GRAPH::EDGES::SPTR_Edge c){ return std::ranges::contains(nodes, c->start) || std::ranges::contains(nodes, c->end);});
-				}
-				
-				for(auto n : nodes){
-					std::erase_if(gm.edges, [n](SPTR_Edge c){ return c->start == n || c->end == n;});
-				}
-				std::erase_if(gm.nodes, [nodes](SPTR_Node n){ return std::ranges::contains(nodes, n);});
-			}
-			
-			void draw(Vec2Df mouse_pos, Camera2D camera){
-				mutex.lock();
-				updateMidiPorts();
-				mutex.unlock();
-				gm.drawNodes(mouse_pos, camera);
-				gm.drawEdges(mouse_pos, camera);
-				sm.drawSignals(mouse_pos, camera);
-			}
-
-			void drawUI(Vec2Df *mouse_pos, Camera2D *camera){
-				mutex.lock();
-				ui.draw(mouse_pos, camera);
-				mutex.unlock();
-			}
-	};
-
-	inline void to_json(json& j, const AppState& A){
-		j = json{{"graphmanager", A.gm}, {"signalmanager", A.sm}, {"settings",A.settings}};
-	}
-	
-	inline void from_json(const json& j, AppState& A){
-		j.at("graphmanager").get_to(A.gm); // = json{{"graphmanager", A.gm}, {"signalmanager", A.sm}};
-	}
-}

src/state.h

@@ -0,0 +1,160 @@
+#pragma once
+
+#include "interaction-event.h"
+#include "nlohmann/json.hpp"
+#include "raylib.h"
+#include "vmath.h"
+#include <memory>
+#include <queue>
+
+#define STATE state->istate
+#define SETTINGS state->settings
+#define SCREEN_MOUSE state->screen_mouse
+#define RAW_MOUSE state->raw_mouse
+#define MOD_MOUSE state->mod_mouse
+#define MOUSE_LEFT state->mouse_left
+#define MOUSE_RIGHT state->mouse_right
+#define MOUSE_MIDDLE state->mouse_middle
+#define KEYS_DOWN state->keys_down
+#define KEYS_PRESSED state->keys_pressed
+#define KEYS_RELEASED state->keys_released
+
+namespace VISEQ::APP{
+
+	struct AppSettings{
+		int width;
+		int height;
+		float grid;
+		float bpm;
+		float fps;
+		float speed = 16.0f;
+		int gui_selected_midi_out;
+		Color mode_colors[7] = {VS_COLOR_GREEN, VS_COLOR_SUN, VS_COLOR_PINK, VS_COLOR_ORANGE, VS_COLOR_PURPLE, VS_COLOR_LIGHTGREY, (Color){0,0,0,0}};
+	};
+	NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(AppSettings, width, height, grid, bpm, fps, speed, gui_selected_midi_out)
+
+	enum InteractionState {HOVER_CANVAS, HOVER_NODE, HOVER_CONNECTOR, ADD_NODES_MENU, DRAG_NODE, CONNECT_NODE, DRAW_SELECTION, SCALE_SELECTION, DELETE_SELECTED_NODES, COPY_SELECTED_NODES, PASTE_SELECTED_NODES};
+
+	inline std::vector<std::string> state_string = {"HOVER_CANVAS"," HOVER_NODE"," HOVER_CONNECTOR"," ADD_NODES_MENU"," DRAG_NODE"," CONNECT_NODE"," DRAW_SELECTION"," SCALE_SELECTION"," DELETE_SELECTED_NODES"," COPY_SELECTED_NODES"," PASTE_SELECTED_NODES"};
+	
+	struct MouseState{
+		bool down = false;
+		bool clicked = false;
+		bool released = false;
+	};
+
+	struct ModifierKeys{
+		bool ctrl = false;
+		bool shift = false;
+		bool alt = false;
+	};
+
+	class State{
+		public:
+			State(){}
+			State(State &state) = delete;
+			void operator=(const State &) = delete;
+			
+			AppSettings settings;
+
+			Vec2Df raw_mouse;
+			Vec2Df screen_mouse;
+			Vec2Df mod_mouse;
+
+			InteractionState istate = HOVER_CANVAS;
+			InteractionState old_istate = HOVER_CANVAS;
+
+			int node_mode = 0;
+			bool context_menu = false;
+
+			bool hovering = false;
+
+			int mouse_z = 0;
+
+			MouseState mouse_left;
+			MouseState mouse_right;
+			MouseState mouse_middle;
+
+			ModifierKeys keys_down;
+			ModifierKeys keys_pressed;
+			ModifierKeys keys_released;
+
+			Rectangle selection;
+			Rectangle bounding_box;
+
+			Vec2Df mouse_delta; 
+
+			Vec2Df selection_origin;
+
+			Color mode_color = settings.mode_colors[0];
+			
+			void pushEvent(InteractionEvent e){
+				event_queue.push_back(e);
+			}
+
+			InteractionEvent pullEvent(){
+				if(!event_queue.empty()){
+					InteractionEvent e = event_queue.front();
+					event_queue.pop_front();
+					return e;
+				}
+				return {nullptr, Interaction::NONE};
+			}
+	
+			void update(Camera2D camera){
+
+				if(istate != old_istate) std::cout << state_string[istate] << std::endl;
+
+				mouse_delta = {GetMouseDelta().x, GetMouseDelta().y};
+
+				settings.speed = (settings.grid * 16.0f) * (settings.bpm / 120.f);
+				
+				Vector2 mp = GetScreenToWorld2D(GetMousePosition(), camera);
+				Vec2Df mouse_pos = {(float)mp.x, (float)mp.y};
+		
+				mouse_left.down = IsMouseButtonDown(MOUSE_BUTTON_LEFT);
+				mouse_left.clicked = IsMouseButtonPressed(MOUSE_BUTTON_LEFT);
+				mouse_left.released = IsMouseButtonReleased(MOUSE_BUTTON_LEFT);
+				
+				mouse_right.down = IsMouseButtonDown(MOUSE_BUTTON_RIGHT);
+				mouse_right.clicked = IsMouseButtonPressed(MOUSE_BUTTON_RIGHT);
+				mouse_right.released = IsMouseButtonReleased(MOUSE_BUTTON_RIGHT);
+
+				keys_down.ctrl = IsKeyDown(KEY_LEFT_CONTROL) || IsKeyDown(KEY_RIGHT_CONTROL);
+				keys_down.shift = IsKeyDown(KEY_LEFT_SHIFT) || IsKeyDown(KEY_RIGHT_SHIFT);
+				keys_down.alt = IsKeyDown(KEY_LEFT_ALT) || IsKeyDown(KEY_RIGHT_ALT);
+				
+				keys_pressed.ctrl = IsKeyPressed(KEY_LEFT_CONTROL) || IsKeyPressed(KEY_RIGHT_CONTROL);
+				keys_pressed.shift = IsKeyPressed(KEY_LEFT_SHIFT) || IsKeyPressed(KEY_RIGHT_SHIFT);
+				keys_pressed.alt = IsKeyPressed(KEY_LEFT_ALT) || IsKeyPressed(KEY_RIGHT_ALT);
+				
+				keys_released.ctrl = IsKeyReleased(KEY_LEFT_CONTROL) || IsKeyReleased(KEY_RIGHT_CONTROL);
+				keys_released.shift = IsKeyReleased(KEY_LEFT_SHIFT) || IsKeyReleased(KEY_RIGHT_SHIFT);
+				keys_released.alt = IsKeyReleased(KEY_LEFT_ALT) || IsKeyReleased(KEY_RIGHT_ALT);
+
+				screen_mouse = {round(mouse_pos.x), round(mouse_pos.y)};
+				raw_mouse = {GetMousePosition().x, GetMousePosition().y};
+				mod_mouse = {round(mouse_pos.x), round(mouse_pos.y)};
+				
+				mode_color = settings.mode_colors[node_mode];
+
+				if(keys_down.ctrl) {
+					mod_mouse.x = round(mouse_pos.x / settings.grid) * settings.grid;
+					mod_mouse.y = round(mouse_pos.y / settings.grid) * settings.grid;
+				}
+				old_istate = istate;
+			}
+
+			inline static std::shared_ptr<State> instance;
+			static std::shared_ptr<State> get() {
+				if(!instance){
+					instance.reset(new State());
+				}
+				return instance;
+			}
+	};
+}
+
+namespace VISEQ{
+	using IState = VISEQ::APP::InteractionState;
+}

src/ui.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "state.h"
 #include "midi-node.h"
 #include "raylib.h"
 #include "raygui/raygui.h"
@@ -11,17 +12,17 @@
 
 #include <memory>
 #include <ranges>
-#include <set>
 
 namespace VISEQ::APP::UI{
 	class AppUI{
 		public:
 		AppUI() {}
-		AppUI(AppSettings *settings, SIGNAL::SignalManager *sm, GraphManager *gm) : settings(settings), gm(gm), sm(sm) {}
+		AppUI(std::shared_ptr<SIGNAL::SignalManager> sm, std::shared_ptr<GraphManager> gm) : gm(gm), sm(sm) {}
 
-		AppSettings *settings;
-		GraphManager *gm;
-		SIGNAL::SignalManager *sm;
+		std::shared_ptr<State> state = State::get();
+
+		std::shared_ptr<GraphManager> gm;
+		std::shared_ptr<SIGNAL::SignalManager> sm;
 
 		bool bpm_spinner_edit_mode = false;
 
@@ -31,7 +32,7 @@ namespace VISEQ::APP::UI{
 
 		void drawSideBar(){
 
-			GuiPanel((Rectangle){-1,-30,280,(float)settings->height + 31}, "");
+			GuiPanel((Rectangle){-1,-30,380,(float)state->settings.height + 31}, "");
 			const int s_controls = 25;
 			//GuiSetStyle(BUTTON, STATE_FOCUSED, 0xFF0000FF);
 			if(GuiButton((Rectangle){20, (float)s_controls, 80, 30}, "PLAY")) sm->play ? sm->pause() : sm->start();
@@ -40,11 +41,11 @@ namespace VISEQ::APP::UI{
 
 			const int s_bpm = s_controls + 45;
 			GuiLabel((Rectangle){20, (float)s_bpm, 120, 20}, "TIMING");
-			GuiLabel((Rectangle){200, (float)s_bpm, 40, 20}, std::format("{}",settings->bpm).c_str());
-			int _bpm = settings->bpm;
+			GuiLabel((Rectangle){200, (float)s_bpm, 40, 20}, std::format("{}",state->settings.bpm).c_str());
+			int _bpm = state->settings.bpm;
 //			GuiSlider((Rectangle){20, (float)s_bpm + 25, 240, 20}, "", "", &_bpm, 1, 300);
 			if(GuiSpinner((Rectangle){20, (float)s_bpm + 25, 240, 20}, "", &_bpm, 1, 300, bpm_spinner_edit_mode)) bpm_spinner_edit_mode = !bpm_spinner_edit_mode;
-			settings->bpm = _bpm;
+			state->settings.bpm = _bpm;
 
 			int s_midi = s_bpm + 75;
 			GuiLabel((Rectangle){20, (float)s_midi, 240, 20}, "MIDI OUT");
@@ -59,9 +60,7 @@ namespace VISEQ::APP::UI{
 			if(GuiButton((Rectangle){20, (float)s_midi + 45 + i*20.0f, 240, 20}, "ENABLE FOR ALL")) {
 				for(auto &midis : sm->midi.midi_out_ports){
 					if(midis.enabled){
-						for(auto n : gm->nodes){
-							if(n->getNodeType() == NodeType::MIDINODE) std::dynamic_pointer_cast<MidiNode>(n)->setMidiPort(midis.number, true);
-						}
+						gm->setMidiPortForAll(midis.number, true);
 					}
 				}
 			}
@@ -79,11 +78,11 @@ namespace VISEQ::APP::UI{
 				DrawCircle(55, s_signal+80 + signal_configs*20, 6.0F, s->color);
 
 				int s_speed = round(s->speed);
-				s->multiplier = settings->bpm / 120.0f;
-				float signal_bpm = round(settings->bpm * s->multiplier * (s->speed / settings->speed));
-				if(GuiSpinner((Rectangle){70, (float)s_signal+70 + signal_configs*20, 100, 20}, "", &s_speed, 1, 16 * settings->grid * 4, s->ui_edit_speed)) s->ui_edit_speed = !s->ui_edit_speed;
-				if(GuiButton((Rectangle){200,(float)s_signal+70 + signal_configs*20, 30, 20}, "1/2")) s_speed = settings->speed / 2; 
-				//if(GuiButton((Rectangle){200,(float)s_signal+70 + signal_configs*20, 30, 20},"1/4")) s_speed = settings->speed / 4; 
+				s->multiplier = state->settings.bpm / 120.0f;
+				float signal_bpm = round(state->settings.bpm * s->multiplier * (s->speed / state->settings.speed));
+				if(GuiSpinner((Rectangle){70, (float)s_signal+70 + signal_configs*20, 100, 20}, "", &s_speed, 1, 16 * state->settings.grid * 4, s->ui_edit_speed)) s->ui_edit_speed = !s->ui_edit_speed;
+				if(GuiButton((Rectangle){200,(float)s_signal+70 + signal_configs*20, 30, 20}, "1/2")) s_speed = state->settings.speed / 2; 
+				//if(GuiButton((Rectangle){200,(float)s_signal+70 + signal_configs*20, 30, 20},"1/4")) s_speed = state->settings.speed / 4; 
 				GuiLabel((Rectangle){195, (float)s_signal+70 + signal_configs*20, 30, 20}, std::format("{}",signal_bpm).c_str());
 				GuiToggle((Rectangle){240, (float)s_signal+70 + signal_configs*20, 20, 20},"P", &s->run); 
 				s->speed = s_speed;
@@ -93,26 +92,32 @@ namespace VISEQ::APP::UI{
 			int s_nodes = s_signal + 70 + signal_configs*20;
 			GuiLabel((Rectangle){20, (float)s_nodes + 30, 240, 20}, "NODES");
 			if(GuiButton((Rectangle){20, (float)s_nodes + 60, 240, 20}, "ADD RANDOM NODE")){
-				gm->addMidiNode(Vec2Df{200.0f, 200.0f});
+				gm->createMidiNode(Vec2Df{200.0f, 200.0f});
 			}
-			DrawText(std::format("{}", gm->nodes.size()).c_str(), 20, settings->height - 70, 15, VS_COLOR_WHITE);
-			DrawFPS(20, settings->height - 30);
+			DrawText(std::format("{}", gm->getNodesSize()).c_str(), 20, state->settings.height - 70, 15, VS_COLOR_WHITE);
+			DrawFPS(20, state->settings.height - 30);
+
+			std::string shorts[6] = {"NT","CC","PC","PB","AT","PP"};
+			for(int i = 0; i < 6; ++i){
+				Color col = state->settings.mode_colors[i];
+				Vec2Df pos = {state->settings.width - (6.0f*75.0f) + i*75.0f, state->settings.height - 75.0f};
+				DrawRing(pos, 30.0f, 34.0f, 0.0f, 360.0f, 24, state->node_mode == i ? VS_COLOR_WHITE : (Color){0,0,0,0}); 
+				DrawCircleV(pos, 30.0f, col);
+				DrawCenteredText(shorts[i], pos, 20, WHITE);
+			}
+		}
+	
+		void DrawCenteredText(std::string text, Vec2Df position, int size, Color color){	
+			float offset = MeasureText(text.c_str(), size);
+			DrawText(text.c_str(), position.x-offset/2.0f, position.y-(float)size/2.0f+1, size, color );
 		}
 		
-		void drawPropertiesBar(){
+		void drawContextMenu(Camera2D camera){
+			for(auto n : gm->getSelection() | std::views::filter([](std::shared_ptr<Node> n){ return n->config; })){
+				Vector2 np = GetWorldToScreen2D((Vector2){n->position.x, n->position.y}, camera);
 
-			float left = settings->width - 280.f;
-
-			GuiPanel((Rectangle){left,-30,280,(float)settings->height + 31}, "");
-			const int s_controls = 25;
-			
-		}
-
-		void drawPerNodeConfig(Camera2D *camera){
-			for(auto& n : gm->nodes | std::views::filter([](std::shared_ptr<Node> n){ return n->config; })){
-				Vector2 np = GetWorldToScreen2D((Vector2){n->position.x, n->position.y}, *camera);
-
-				n->config = !GuiWindowBox((Rectangle){np.x + 10, np.y + 10, 240, 440}, "config");
+				state->context_menu = !GuiWindowBox((Rectangle){np.x + 10, np.y + 10, 240, 440}, "config");
+				n->config = state->context_menu;
 
 				int option = n->distributionMode;
 				GuiToggleGroup((Rectangle){ np.x + 20, np.y + 40, 73, 20 }, "GEO;RR;RAND", &option);
@@ -140,68 +145,67 @@ namespace VISEQ::APP::UI{
 					GuiCheckBox((Rectangle){np.x + 160, np.y + y_channel, 20, 20}, "PITCH", &mn->send_pitch_bend);
 
 					int y_cc_note = y_channel + 120;
-					switch(settings->mode){
+					switch(state->node_mode){
 						case 0:{
 								   GuiLabel((Rectangle){np.x + 20, np.y + y_cc_note - 75, 220, 20}, "NOTE CHANNEL");
-								   GuiToggleGroup((Rectangle){np.x + 20, np.y + y_cc_note - 50, 25, 20}, "1;2;3;4;5;6;7;8\n9;10;11;12;13;14;15;16", &mn->midi_note_channel);
+								   GuiToggleGroup((Rectangle){np.x + 20, np.y + y_cc_note - 50, 25, 20}, "1;2;3;4;5;6;7;8\n9;10;11;12;13;14;15;16", &mn->midiNote.channel);
 
 								   GuiLabel((Rectangle){np.x + 20, np.y + y_cc_note , 100, 20}, "NOTE");
-								   float v = mn->midi_note;
+								   float v = mn->midiNote.note;
 								   GuiLabel((Rectangle){np.x + 210, np.y + y_cc_note , 20, 20}, MIDI::Notes[(int)round(v)].c_str());
-								   GuiLabel((Rectangle){np.x + 160, np.y + y_cc_note , 40, 20}, std::format("{}",mn->midi_note).c_str());
+								   GuiLabel((Rectangle){np.x + 160, np.y + y_cc_note , 40, 20}, std::format("{}",mn->midiNote.note).c_str());
 								   GuiSlider((Rectangle){np.x + 20, np.y + y_cc_note + 30, 220, 20}, "", "", &v, 0, 127);
-								   mn->midi_note = round(v);
+								   mn->midiNote.note = round(v);
 
 								   GuiLabel((Rectangle){np.x + 20, np.y + y_cc_note + 60, 100, 20}, "VELOCITY");
-								   v = mn->midi_velocity;
-								   GuiLabel((Rectangle){np.x + 210, np.y + y_cc_note + 60, 20, 20}, std::format("{}",mn->midi_velocity).c_str());
+								   v = mn->midiNote.velocity;
+								   GuiLabel((Rectangle){np.x + 210, np.y + y_cc_note + 60, 20, 20}, std::format("{}",mn->midiNote.velocity).c_str());
 								   GuiSlider((Rectangle){np.x + 20, np.y + y_cc_note + 90, 220, 20}, "", "", &v, 0, 127);
-								   mn->midi_velocity = round(v);
+								   mn->midiNote.velocity = round(v);
 
 								   GuiLabel((Rectangle){np.x + 20, np.y + y_cc_note + 120, 100, 20}, "GATE");
-								   v = mn->midi_gate;
-								   GuiLabel((Rectangle){np.x + 210, np.y + y_cc_note + 120, 20, 20}, std::format("{}",(float)mn->midi_gate/1000.0f).c_str());
+								   v = mn->midiNote.gate;
+								   GuiLabel((Rectangle){np.x + 210, np.y + y_cc_note + 120, 20, 20}, std::format("{}",(float)mn->midiNote.gate/1000.0f).c_str());
 								   GuiSlider((Rectangle){np.x + 20, np.y + y_cc_note + 150, 220, 20}, "", "", &v, 0, 30000);
-								   mn->midi_gate = round(v);
+								   mn->midiNote.gate= round(v);
 								   break;}
 						case 1:
 							   {
 								   GuiLabel((Rectangle){np.x + 20, np.y + y_cc_note - 75, 220, 20}, "CC CHANNEL");
-								   GuiToggleGroup((Rectangle){np.x + 20, np.y + y_cc_note - 50, 25, 20}, "1;2;3;4;5;6;7;8\n9;10;11;12;13;14;15;16", &mn->midi_cc_channel);
+								   GuiToggleGroup((Rectangle){np.x + 20, np.y + y_cc_note - 50, 25, 20}, "1;2;3;4;5;6;7;8\n9;10;11;12;13;14;15;16", &mn->midiCC.channel);
 
 								   GuiLabel((Rectangle){np.x + 20, np.y + y_cc_note , 100, 20}, "CC");
-								   float v = mn->midi_cc;
-								   GuiLabel((Rectangle){np.x + 160, np.y + y_cc_note , 40, 20}, std::format("{}",mn->midi_cc).c_str());
+								   float v = mn->midiCC.control;
+								   GuiLabel((Rectangle){np.x + 160, np.y + y_cc_note , 40, 20}, std::format("{}",mn->midiCC.control).c_str());
 								   GuiSlider((Rectangle){np.x + 20, np.y + y_cc_note + 30, 220, 20}, "", "", &v, 0, 127);
-								   mn->midi_cc = round(v);
+								   mn->midiCC.control = round(v);
 
 								   GuiLabel((Rectangle){np.x + 20, np.y + y_cc_note + 60, 100, 20}, "CC VALUE");
-								   v = mn->midi_cc_value;
-								   GuiLabel((Rectangle){np.x + 210, np.y + y_cc_note + 60, 20, 20}, std::format("{}",mn->midi_cc_value).c_str());
+								   v = mn->midiCC.value;
+								   GuiLabel((Rectangle){np.x + 210, np.y + y_cc_note + 60, 20, 20}, std::format("{}",mn->midiCC.value).c_str());
 								   GuiSlider((Rectangle){np.x + 20, np.y + y_cc_note + 90, 220, 20}, "", "", &v, 0, 127);
-								   mn->midi_cc_value = round(v);
+								   mn->midiCC.value = round(v);
 
 								   break;}
 						case 2:
 							   {
 								   GuiLabel((Rectangle){np.x + 20, np.y + y_cc_note - 75, 220, 20}, "PITCH BEND CHANNEL");
-								   GuiToggleGroup((Rectangle){np.x + 20, np.y + y_cc_note - 50, 25, 20}, "1;2;3;4;5;6;7;8\n9;10;11;12;13;14;15;16", &mn->midi_pitch_bend_channel);
+								   GuiToggleGroup((Rectangle){np.x + 20, np.y + y_cc_note - 50, 25, 20}, "1;2;3;4;5;6;7;8\n9;10;11;12;13;14;15;16", &mn->midiPitchBend.channel);
 
 								   GuiLabel((Rectangle){np.x + 20, np.y + y_cc_note , 100, 20}, "CC");
-								   float v = mn->midi_pitch_bend;
-								   GuiLabel((Rectangle){np.x + 160, np.y + y_cc_note , 40, 20}, std::format("{}",mn->midi_pitch_bend).c_str());
+								   float v = mn->midiPitchBend.value;
+								   GuiLabel((Rectangle){np.x + 160, np.y + y_cc_note , 40, 20}, std::format("{}",mn->midiPitchBend.value).c_str());
 								   GuiSlider((Rectangle){np.x + 20, np.y + y_cc_note + 30, 220, 20}, "", "", &v, 0, 16383);
-								   mn->midi_pitch_bend = round(v);
+								   mn->midiPitchBend.value = round(v);
 								   break;}
 					}
 				}
 			}
 		}
 
-		void draw(Vec2Df *mouse_pos, Camera2D *camera){
+		void draw(Vec2Df mouse_pos, Camera2D camera){
 			drawSideBar();
-			drawPropertiesBar();
-			drawPerNodeConfig(camera);
+			if(state->context_menu) drawContextMenu(camera);
 		}
 
 	};

src/vmath.h

@@ -61,6 +61,14 @@ namespace VISEQ::VMATH{
 				return Vec2D<T>{x,y} - (Vec2D<T>{x,y} - v)*0.5f;
 			}
 
+			Vec2D orbitAlongVector(Vec2D d, float r){
+				return Vec2D<T>{x,y} - ((Vec2D<T>{x,y} - d)).norm() * r;
+			}
+
+			Vec2D orbitAtAngle(float r, float angle){
+				return {x + sin(angle) * r, y + cos(angle) * r};
+			}
+
 			Vec2D& operator=(const Vec2D& vec){
 				if (this == &vec){
 					return *this;
@@ -162,6 +170,3 @@ namespace VISEQ::VMATH{
 
 using Vec2Df = VISEQ::VMATH::Vec2D<float>;
 
-
-
-