remove old statetracker gui

8 files changed, 0 insertions, 929 deletions

diff --git a/examples/statetracker/src/command.rs b/examples/statetracker/src/command.rs
deleted file mode 100644
index b10aa90..0000000
--- a/examples/statetracker/src/command.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-use druid::{Selector, SingleUse};
-use libquassel::message::{objects::Alias, InitData, SyncMessage};
-
-use crate::server::Direction;
-
-pub const CONNECT: Selector = Selector::new("connect");
-pub const ADD_MESSAGE: Selector<SingleUse<crate::Message>> = Selector::new("add_message");
-
-pub const ALIASMANAGER_ADD_ALIAS: Selector<SingleUse<Alias>> =
-    Selector::new("aliasmanager_add_alias");
-
-pub const SYNCMESSAGE: Selector<SingleUse<(Direction, SyncMessage)>> = Selector::new("syncmessage");
-pub const INITDATA: Selector<SingleUse<(Direction, InitData)>> = Selector::new("initdata");
diff --git a/examples/statetracker/src/connect.rs b/examples/statetracker/src/connect.rs
deleted file mode 100644
index 7b207cd..0000000
--- a/examples/statetracker/src/connect.rs
+++ /dev/null
@@ -1,90 +0,0 @@
-use std::thread;
-
-use druid::ExtEventSink;
-use futures::StreamExt;
-use libquassel::frame::QuasselCodec;
-use tokio::{
-    io::{AsyncReadExt, AsyncWriteExt},
-    net::{TcpListener, TcpStream},
-};
-use tokio_util::codec::Framed;
-use tracing::debug;
-
-use crate::{
-    server::{ClientState, Direction, Server},
-    StateTracker,
-};
-
-impl StateTracker {
-    pub fn connect(&mut self, ctx: ExtEventSink) {
-        debug!("starting connect");
-
-        let server = self.server.clone();
-
-        thread::spawn(move || {
-            let rt = tokio::runtime::Runtime::new().unwrap();
-
-            rt.block_on(async move {
-                let mut s_server = TcpStream::connect(format!(
-                    "{}:{}",
-                    server.settings.host, server.settings.port
-                ))
-                .await
-                .unwrap();
-
-                let _connack = server.init(&mut s_server).await.unwrap();
-
-                let codec = QuasselCodec::builder().compression(false).new_codec();
-                let framed = Framed::new(s_server, codec);
-                let (s_sink, s_stream) = framed.split();
-
-                let listener = TcpListener::bind((server.listen_host, server.listen_port))
-                    .await
-                    .unwrap();
-                let (mut client, _) = listener.accept().await.unwrap();
-
-                //
-                // Setup Listener
-                //
-
-                {
-                    let (mut c_stream, mut c_sink) = client.split();
-
-                    let mut init = [0; 12];
-                    let n = c_stream.peek(&mut init).await.unwrap();
-                    c_stream.read(&mut init[..n]).await.unwrap();
-                    let init = libquassel::message::Init::parse(&init);
-                    debug!("send init bytes: {:?}", init);
-
-                    c_sink.write(&[0x0, 0x0, 0x0, 0x2]).await.unwrap();
-                }
-
-                let codec = QuasselCodec::builder().compression(false).new_codec();
-                let framed = Framed::new(client, codec);
-                let (c_sink, c_stream) = framed.split();
-
-                // Start Processing
-
-                let s_state = ClientState::Handshake;
-                let c_state = ClientState::Handshake;
-
-                tokio::join!(
-                    Server::run(
-                        s_stream,
-                        c_sink,
-                        s_state,
-                        ctx.clone(),
-                        Direction::ServerToClient
-                    ),
-                    Server::run(
-                        c_stream,
-                        s_sink,
-                        c_state,
-                        ctx.clone(),
-                        Direction::ClientToServer
-                    )
-                );
-            });
-        });
-    }
-}
diff --git a/examples/statetracker/src/formatter.rs b/examples/statetracker/src/formatter.rs
deleted file mode 100644
index dc81887..0000000
--- a/examples/statetracker/src/formatter.rs
+++ /dev/null
@@ -1,48 +0,0 @@
-use druid::text::{Formatter, Validation, ValidationError};
-
-pub struct U16Formatter;
-
-impl Formatter<u16> for U16Formatter {
-    fn format(&self, value: &u16) -> String {
-        value.to_string()
-    }
-
-    fn validate_partial_input(&self, input: &str, _sel: &druid::text::Selection) -> Validation {
-        if input.is_empty() {
-            return Validation::success();
-        }
-
-        if input.len() > 6 {
-            return Validation::failure(U16ValidationError::WrongNumberOfCharacters);
-        }
-
-        match input.parse::<u16>() {
-            Ok(_) => Validation::success(),
-            Err(err) => Validation::failure(err),
-        }
-    }
-
-    fn value(&self, input: &str) -> Result<u16, ValidationError> {
-        if input.is_empty() || input.len() > 5 {
-            return Err(ValidationError::new(
-                U16ValidationError::WrongNumberOfCharacters,
-            ));
-        }
-
-        input.parse().map_err(|err| ValidationError::new(err))
-    }
-}
-
-#[derive(Debug, Clone)]
-pub enum U16ValidationError {
-    WrongNumberOfCharacters,
-}
-
-impl std::fmt::Display for U16ValidationError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        // TODO set correct display based on actual value
-        write!(f, "U16ValidationError::WrongNumberOfCharacters")
-    }
-}
-
-impl std::error::Error for U16ValidationError {}
diff --git a/examples/statetracker/src/main.rs b/examples/statetracker/src/main.rs
deleted file mode 100644
index 38b4950..0000000
--- a/examples/statetracker/src/main.rs
+++ /dev/null
@@ -1,241 +0,0 @@
-use std::{collections::HashMap, sync::Arc};
-
-use druid::{
-    widget::{Align, Either, Flex, Label, List, Split},
-    AppDelegate, Command,
-};
-use druid::{AppLauncher, Data, Env, Lens, LocalizedString, Widget, WidgetExt, WindowDesc};
-use widgets::{AliasManagerWidget, BufferViewWidget};
-
-use libquassel::message::{objects::AliasManager, StatefulSyncableClient, SyncProxy};
-use libquassel::message::{
-    objects::{self, BufferViewManager},
-    StatefulSyncableServer,
-};
-
-use tracing::debug;
-use tracing_subscriber::prelude::*;
-
-use crate::server::{Direction, Message, ServerWidget};
-
-const SPACING: f64 = 10.0;
-
-const VERTICAL_WIDGET_SPACING: f64 = 20.0;
-const WINDOW_TITLE: LocalizedString<StateTracker> = LocalizedString::new("StateTracker");
-
-mod widgets;
-
-mod command;
-mod connect;
-mod formatter;
-mod server;
-
-#[derive(Clone, Data, Lens)]
-struct StateTracker {
-    server: server::Server,
-    messages: Arc<Vec<server::Message>>,
-    alias_manager: Arc<AliasManager>,
-    buffer_view_manager: Arc<BufferViewManager>,
-    connected: bool,
-    #[data(ignore)]
-    syncer: Syncer,
-}
-
-impl StateTracker {
-    fn new() -> StateTracker {
-        let (sync_channel, rpc_channel) = SyncProxy::init(1024);
-
-        StateTracker {
-            server: server::Server::default(),
-            messages: Arc::new(Vec::new()),
-            alias_manager: Arc::new(AliasManager {
-                aliases: Vec::new(),
-            }),
-            buffer_view_manager: Arc::new(BufferViewManager {
-                buffer_view_configs: HashMap::new(),
-            }),
-            connected: false,
-            syncer: Syncer {
-                sync_channel,
-                rpc_channel,
-            },
-        }
-    }
-
-    fn widget() -> impl Widget<StateTracker> {
-        let either = Either::new(
-            |server, _env| server.connected,
-            Split::columns(
-                Flex::column()
-                    .with_child(Label::new("AliasManager"))
-                    .with_child(AliasManagerWidget::new().lens(StateTracker::alias_manager))
-                    .with_spacer(SPACING)
-                    .with_child(Label::new("BufferViewManager"))
-                    .with_child(BufferViewWidget::new().lens(StateTracker::buffer_view_manager)),
-                List::new(|| {
-                    Label::new(|item: &Message, _env: &_| format!("{:#?}", item)).padding(10.0)
-                })
-                .scroll()
-                .vertical()
-                .lens(StateTracker::messages),
-            )
-            .expand(),
-            ServerWidget::new()
-                .fix_width(200.0)
-                .lens(StateTracker::server),
-        );
-
-        let layout = Flex::column()
-            .with_flex_child(either, 1.0)
-            .with_spacer(VERTICAL_WIDGET_SPACING);
-
-        Align::centered(layout)
-    }
-}
-
-impl Default for StateTracker {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-struct StateTrackerDelegate;
-impl AppDelegate<StateTracker> for StateTrackerDelegate {
-    fn command(
-        &mut self,
-        ctx: &mut druid::DelegateCtx,
-        _target: druid::Target,
-        cmd: &Command,
-        data: &mut StateTracker,
-        _env: &Env,
-    ) -> druid::Handled {
-        if let Some(_) = cmd.get(command::CONNECT) {
-            debug!("got CONNECT command");
-
-            data.connect(ctx.get_external_handle());
-            data.connected = true;
-
-            return druid::Handled::Yes;
-        } else if let Some(msg) = cmd.get(command::ADD_MESSAGE) {
-            let list = Arc::make_mut(&mut data.messages);
-            list.push(msg.take().unwrap());
-        } else if let Some(alias) = cmd.get(command::ALIASMANAGER_ADD_ALIAS) {
-            let mut alias_manager = Arc::make_mut(&mut data.alias_manager).clone();
-            alias_manager.add_alias(alias.take().unwrap());
-            data.alias_manager = Arc::new(alias_manager);
-        } else if let Some(initdata) = cmd.get(command::INITDATA) {
-            let (_, initdata) = initdata.take().unwrap();
-
-            debug!("got InitData {:#?}", initdata);
-
-            match initdata.init_data {
-                objects::Types::AliasManager(alias_manager) => {
-                    data.alias_manager = Arc::new(alias_manager)
-                }
-                objects::Types::BufferViewManager(buffer_view_manager) => {
-                    data.buffer_view_manager = Arc::new(buffer_view_manager)
-                }
-                objects::Types::BufferViewConfig(config) => {
-                    let id: i32 = initdata.object_name.parse().unwrap();
-
-                    let mut buffer_view_manager =
-                        Arc::make_mut(&mut data.buffer_view_manager).clone();
-
-                    buffer_view_manager.buffer_view_configs.insert(id, config);
-
-                    data.buffer_view_manager = Arc::new(buffer_view_manager)
-                }
-                _ => (),
-            }
-        } else if let Some(msg) = cmd.get(command::SYNCMESSAGE) {
-            let (direction, msg) = msg.take().unwrap();
-
-            debug!("direction: {:#?}, msg: {:#?}", direction, msg);
-
-            match msg.class_name.as_str() {
-                "AliasManager" => {
-                    let mut alias_manager = Arc::make_mut(&mut data.alias_manager).clone();
-
-                    if direction == Direction::ServerToClient {
-                        // StatefulSyncableClient::sync(&mut alias_manager, msg);
-                    } else {
-                        StatefulSyncableServer::sync(&mut alias_manager, msg);
-                    }
-
-                    data.alias_manager = Arc::new(alias_manager);
-                }
-                "BufferViewConfig" => {
-                    let mut buffer_view_manager =
-                        Arc::make_mut(&mut data.buffer_view_manager).clone();
-
-                    let id: i32 = msg.object_name.parse().unwrap();
-
-                    let buffer_view_config = buffer_view_manager
-                        .buffer_view_configs
-                        .get_mut(&id)
-                        .unwrap();
-
-                    if direction == Direction::ServerToClient {
-                        // StatefulSyncableClient::sync(buffer_view_config, msg);
-                    } else {
-                        StatefulSyncableServer::sync(buffer_view_config, msg);
-                    }
-
-                    data.buffer_view_manager = Arc::new(buffer_view_manager);
-                }
-
-                _ => (),
-            }
-        }
-
-        druid::Handled::No
-    }
-}
-
-// impl Session for StateTracker {
-//     fn alias_manager(&mut self) -> &mut AliasManager {
-//         &mut Arc::make_mut(&mut self.alias_manager).clone()
-//     }
-// }
-
-// TODO make this somehow deref or smth
-#[derive(Clone)]
-pub struct Syncer {
-    sync_channel: crossbeam_channel::Receiver<libquassel::message::SyncMessage>,
-    rpc_channel: crossbeam_channel::Receiver<libquassel::message::RpcCall>,
-}
-
-fn main() {
-    // tracing_subscriber::fmt::fmt()
-    //     .with_span_events(tracing_subscriber::fmt::format::FmtSpan::ACTIVE)
-    //     .init();
-
-    let filter = tracing_subscriber::filter::Targets::new()
-        .with_default(tracing::Level::TRACE)
-        .with_target("druid", tracing::metadata::LevelFilter::OFF);
-
-    let env_filter = tracing_subscriber::EnvFilter::from_default_env();
-
-    tracing_subscriber::registry()
-        .with(
-            tracing_subscriber::fmt::layer()
-                .with_span_events(tracing_subscriber::fmt::format::FmtSpan::ACTIVE),
-        )
-        .with(filter)
-        .with(env_filter)
-        .init();
-
-    // describe the main window
-    let main_window = WindowDesc::new(StateTracker::widget())
-        .title(WINDOW_TITLE)
-        .window_size((400.0, 400.0));
-
-    // create the initial app state
-    let initial_state = StateTracker::new();
-
-    // start the application
-    AppLauncher::with_window(main_window)
-        .delegate(StateTrackerDelegate)
-        .launch(initial_state)
-        .expect("Failed to launch application");
-}
diff --git a/examples/statetracker/src/server.rs b/examples/statetracker/src/server.rs
deleted file mode 100644
index 2341fb8..0000000
--- a/examples/statetracker/src/server.rs
+++ /dev/null
@@ -1,336 +0,0 @@
-use anyhow::{bail, Error};
-
-use druid::{
-    widget::{
-        Align, Button, Checkbox, Container, Controller, ControllerHost, Flex, Label, TextBox,
-    },
-    Command, Data, ExtEventSink, Lens, SingleUse, Target, Widget, WidgetExt,
-};
-
-use libquassel::{
-    deserialize::Deserialize,
-    frame::QuasselCodec,
-    message::{self, ConnAck, HandshakeMessage, Init},
-};
-
-use futures::{
-    stream::{SplitSink, SplitStream},
-    SinkExt, StreamExt,
-};
-use tokio::{
-    io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt},
-    net::TcpStream,
-};
-use tokio_util::codec::Framed;
-
-use tracing::{debug, trace};
-
-use crate::{command, formatter};
-
-#[derive(Clone, Debug, Data, Lens)]
-pub struct ServerSettings {
-    pub tls: bool,
-    pub compression: bool,
-    pub host: String,
-    pub port: u16,
-    pub username: String,
-    pub password: String,
-}
-
-impl Default for ServerSettings {
-    fn default() -> Self {
-        ServerSettings {
-            tls: false,
-            compression: false,
-            host: String::from("localhost"),
-            port: 4242,
-            username: String::default(),
-            password: String::default(),
-        }
-    }
-}
-
-#[derive(Clone, Data, Lens)]
-pub struct Server {
-    pub server_name: String,
-    pub listen_port: u16,
-    pub listen_host: String,
-    pub settings: ServerSettings,
-}
-
-#[derive(Debug)]
-pub enum ClientState {
-    Handshake,
-    Connected,
-}
-
-#[derive(Clone, Debug)]
-pub enum Message {
-    Handshake(HandshakeMessage),
-    SignalProxy(message::Message),
-}
-
-impl Data for Message {
-    fn same(&self, other: &Self) -> bool {
-        if let Self::Handshake(_) = self {
-            if let Self::Handshake(_) = other {
-                return true;
-            } else {
-                return false;
-            }
-        } else if let Self::SignalProxy(_) = self {
-            if let Self::SignalProxy(_) = other {
-                return true;
-            } else {
-                return false;
-            }
-        } else {
-            return false;
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub enum Direction {
-    ServerToClient,
-    ClientToServer,
-}
-
-impl Server {
-    pub async fn init(
-        &self,
-        stream: &mut (impl AsyncRead + AsyncWrite + Unpin),
-    ) -> Result<ConnAck, Error> {
-        let init = Init::new()
-            .tls(self.settings.tls)
-            .compression(self.settings.compression);
-
-        stream.write(&init.serialize()).await?;
-
-        let mut buf = [0; 4];
-        stream.read(&mut buf).await?;
-
-        let (_, connack) = ConnAck::parse(&buf).unwrap();
-        Ok(connack)
-    }
-
-    pub async fn run(
-        mut stream: SplitStream<Framed<TcpStream, QuasselCodec>>,
-        mut sink: SplitSink<Framed<TcpStream, QuasselCodec>, Vec<u8>>,
-        mut state: ClientState,
-        ctx: ExtEventSink,
-        direction: Direction,
-    ) {
-        // Start event loop
-        while let Some(msg) = stream.next().await {
-            let msg = msg.unwrap();
-            sink.send(msg.to_vec()).await.unwrap();
-            let msg = match state {
-                ClientState::Handshake => {
-                    Server::handle_login_message(&msg, &mut state, direction, ctx.clone())
-                        .await
-                        .unwrap()
-                }
-                ClientState::Connected => Server::handle_message(&msg, direction, ctx.clone())
-                    .await
-                    .unwrap(),
-            };
-
-            ctx.submit_command(command::ADD_MESSAGE, SingleUse::new(msg), Target::Global)
-                .unwrap();
-        }
-    }
-
-    async fn handle_login_message(
-        buf: &[u8],
-        state: &mut ClientState,
-        _direction: Direction,
-        _ctx: ExtEventSink,
-    ) -> Result<Message, Error> {
-        use libquassel::HandshakeDeserialize;
-
-        trace!(target: "handshakemessage", "Received bytes: {:x?}", buf);
-        match HandshakeMessage::parse(buf) {
-            Ok((_size, res)) => {
-                // info!("{}: {:#?}", direction, res);
-
-                match res {
-                    HandshakeMessage::SessionInit(_) => *state = ClientState::Connected,
-                    HandshakeMessage::ClientLogin(_) => *state = ClientState::Connected,
-                    _ => {}
-                }
-
-                return Ok(Message::Handshake(res));
-            }
-            Err(e) => bail!("failed to parse handshake message {}", e),
-        }
-    }
-
-    async fn handle_message(
-        buf: &[u8],
-        direction: Direction,
-        ctx: ExtEventSink,
-    ) -> Result<Message, Error> {
-        use libquassel::deserialize::*;
-        trace!(target: "message", "Received bytes: {:x?}", buf);
-
-        match message::Message::parse(buf) {
-            Ok((_size, res)) => {
-                let re = res.clone();
-
-                #[allow(unused_variables)]
-                match res {
-                    message::Message::SyncMessage(msg) => ctx
-                        .submit_command(
-                            command::SYNCMESSAGE,
-                            SingleUse::new((direction, msg)),
-                            Target::Global,
-                        )
-                        .unwrap(),
-                    message::Message::RpcCall(msg) => (),
-                    message::Message::InitRequest(msg) => debug!("Got InitRequest: {:#?}", msg),
-                    message::Message::InitData(msg) => ctx
-                        .submit_command(
-                            command::INITDATA,
-                            SingleUse::new((direction, msg)),
-                            Target::Global,
-                        )
-                        .unwrap(),
-                    message::Message::HeartBeat(msg) => (),
-                    message::Message::HeartBeatReply(msg) => (),
-                }
-
-                return Ok(Message::SignalProxy(re));
-            }
-            Err(e) => {
-                bail!("failed to parse message {}", e);
-            }
-        }
-    }
-}
-
-impl Default for Server {
-    fn default() -> Self {
-        Server {
-            server_name: String::default(),
-            listen_port: 4243,
-            listen_host: String::from("localhost"),
-            settings: ServerSettings::default(),
-        }
-    }
-}
-
-impl std::fmt::Debug for Server {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let mut fmt = f.debug_struct("Server");
-        fmt.field("settings", &self.settings);
-        fmt.field("name", &self.server_name).finish()
-    }
-}
-
-pub struct ServerWidget {}
-
-impl ServerWidget {
-    pub fn new() -> ControllerHost<impl Widget<Server>, ServerWidget> {
-        let layout = Flex::column()
-            .with_child(Label::new("Connect").align_left())
-            .with_spacer(crate::SPACING)
-            .with_child(
-                TextBox::new()
-                    .with_placeholder("Server Name")
-                    .expand_width()
-                    .lens(Server::server_name),
-            )
-            .with_spacer(crate::SPACING)
-            .with_child(
-                Container::new(
-                    Flex::column()
-                        .with_child(
-                            Flex::row()
-                                .with_flex_child(
-                                    TextBox::new()
-                                        .with_placeholder("Host")
-                                        .expand_width()
-                                        .lens(ServerSettings::host),
-                                    2.0,
-                                )
-                                .with_spacer(crate::SPACING)
-                                .with_flex_child(
-                                    TextBox::new()
-                                        .with_formatter(formatter::U16Formatter)
-                                        .lens(ServerSettings::port),
-                                    1.0,
-                                )
-                                .expand_width(),
-                        )
-                        .with_spacer(crate::SPACING)
-                        .with_child(
-                            Flex::row()
-                                .with_child(Checkbox::new("TLS").lens(ServerSettings::tls))
-                                .with_flex_spacer(1.0)
-                                .with_child(
-                                    Checkbox::new("Compression").lens(ServerSettings::compression),
-                                ),
-                        )
-                        .with_spacer(crate::SPACING * 2.0)
-                        .with_child(Label::new("Login").align_left())
-                        .with_spacer(crate::SPACING)
-                        .with_child(
-                            TextBox::new()
-                                .with_placeholder("Username")
-                                .expand_width()
-                                .lens(ServerSettings::username),
-                        )
-                        .with_spacer(crate::SPACING)
-                        .with_child(
-                            TextBox::new()
-                                .with_placeholder("Password")
-                                .expand_width()
-                                .lens(ServerSettings::password),
-                        ),
-                )
-                .lens(Server::settings),
-            )
-            .with_spacer(crate::SPACING)
-            .with_child(Label::new("Listen").align_left())
-            .with_spacer(crate::SPACING)
-            .with_child(
-                Flex::row()
-                    .with_flex_child(
-                        TextBox::new()
-                            .with_placeholder("Address")
-                            .expand_width()
-                            .lens(Server::listen_host),
-                        2.0,
-                    )
-                    .with_spacer(crate::SPACING)
-                    .with_flex_child(
-                        TextBox::new()
-                            .with_placeholder("Port")
-                            .with_formatter(formatter::U16Formatter)
-                            .lens(Server::listen_port),
-                        1.0,
-                    )
-                    .expand_width(),
-            )
-            .with_spacer(crate::SPACING)
-            .with_child(
-                Button::new("Connect")
-                    .on_click(move |ctx, _, _| {
-                        debug!("connect button pressed, sending command");
-                        ctx.submit_command(Command::new(
-                            command::CONNECT,
-                            (),
-                            druid::Target::Global,
-                        ))
-                    })
-                    .align_right(),
-            );
-
-        let widget = Align::centered(layout);
-
-        ControllerHost::new(widget, ServerWidget {})
-    }
-}
-
-impl<T, W: Widget<T>> Controller<T, W> for ServerWidget {}
diff --git a/examples/statetracker/src/widgets/aliasmanager.rs b/examples/statetracker/src/widgets/aliasmanager.rs
deleted file mode 100644
index afa8c91..0000000
--- a/examples/statetracker/src/widgets/aliasmanager.rs
+++ /dev/null
@@ -1,91 +0,0 @@
-use std::sync::Arc;
-
-use druid::widget::{Align, Label};
-use druid::{lens, Lens, Point, WidgetPod};
-use druid::{widget::Flex, Widget};
-
-use libquassel::message::objects::AliasManager;
-
-pub struct AliasManagerWidget {
-    inner: WidgetPod<Arc<AliasManager>, Box<dyn Widget<Arc<AliasManager>>>>,
-}
-
-impl AliasManagerWidget {
-    pub fn new() -> Self {
-        let widget = WidgetPod::new(Flex::column()).boxed();
-
-        AliasManagerWidget { inner: widget }
-    }
-}
-
-impl Widget<Arc<AliasManager>> for AliasManagerWidget {
-    fn event(
-        &mut self,
-        ctx: &mut druid::EventCtx,
-        event: &druid::Event,
-        data: &mut Arc<AliasManager>,
-        env: &druid::Env,
-    ) {
-        self.inner.event(ctx, event, data, env)
-    }
-
-    fn lifecycle(
-        &mut self,
-        ctx: &mut druid::LifeCycleCtx,
-        event: &druid::LifeCycle,
-        data: &Arc<AliasManager>,
-        env: &druid::Env,
-    ) {
-        self.inner.lifecycle(ctx, event, data, env)
-    }
-
-    fn update(
-        &mut self,
-        ctx: &mut druid::UpdateCtx,
-        _old_data: &Arc<AliasManager>,
-        data: &Arc<AliasManager>,
-        _env: &druid::Env,
-    ) {
-        let aliases = lens!(AliasManager, aliases);
-
-        let mut names: Flex<Arc<AliasManager>> = Flex::column();
-        let mut sign: Flex<Arc<AliasManager>> = Flex::column();
-        let mut expansions: Flex<Arc<AliasManager>> = Flex::column();
-
-        // TODO optimise this whole thing
-        aliases.with(data, |aliases| {
-            for alias in aliases {
-                names.add_child(Align::right(Label::new(alias.name.clone())));
-                sign.add_child(Label::new("=>"));
-                expansions.add_child(Align::left(Label::new(alias.expansion.clone())));
-            }
-        });
-
-        let widget: Flex<Arc<AliasManager>> = Flex::row()
-            .with_flex_child(names, 1.0)
-            .with_flex_child(sign, 1.0)
-            .with_flex_child(expansions, 1.0);
-
-        self.inner = WidgetPod::new(widget).boxed();
-
-        ctx.children_changed();
-        ctx.request_layout();
-        ctx.request_paint();
-    }
-
-    fn layout(
-        &mut self,
-        ctx: &mut druid::LayoutCtx,
-        bc: &druid::BoxConstraints,
-        data: &Arc<AliasManager>,
-        env: &druid::Env,
-    ) -> druid::Size {
-        let size = self.inner.layout(ctx, bc, data, env);
-        self.inner.set_origin(ctx, data, env, Point::ZERO);
-        return size;
-    }
-
-    fn paint(&mut self, ctx: &mut druid::PaintCtx, data: &Arc<AliasManager>, env: &druid::Env) {
-        self.inner.paint(ctx, data, env)
-    }
-}
diff --git a/examples/statetracker/src/widgets/bufferview.rs b/examples/statetracker/src/widgets/bufferview.rs
deleted file mode 100644
index e5384e2..0000000
--- a/examples/statetracker/src/widgets/bufferview.rs
+++ /dev/null
@@ -1,105 +0,0 @@
-use std::sync::Arc;
-
-use druid::widget::{Label};
-use druid::{lens, Lens, Point, WidgetPod};
-use druid::{widget::Flex, Widget};
-
-use libquassel::message::objects::BufferViewManager;
-
-pub struct BufferViewWidget {
-    inner: WidgetPod<Arc<BufferViewManager>, Box<dyn Widget<Arc<BufferViewManager>>>>,
-}
-
-impl BufferViewWidget {
-    pub fn new() -> Self {
-        let widget = WidgetPod::new(Flex::column()).boxed();
-
-        BufferViewWidget { inner: widget }
-    }
-}
-
-impl Widget<Arc<BufferViewManager>> for BufferViewWidget {
-    fn event(
-        &mut self,
-        ctx: &mut druid::EventCtx,
-        event: &druid::Event,
-        data: &mut Arc<BufferViewManager>,
-        env: &druid::Env,
-    ) {
-        self.inner.event(ctx, event, data, env)
-    }
-
-    fn lifecycle(
-        &mut self,
-        ctx: &mut druid::LifeCycleCtx,
-        event: &druid::LifeCycle,
-        data: &Arc<BufferViewManager>,
-        env: &druid::Env,
-    ) {
-        self.inner.lifecycle(ctx, event, data, env)
-    }
-
-    fn update(
-        &mut self,
-        ctx: &mut druid::UpdateCtx,
-        _old_data: &Arc<BufferViewManager>,
-        data: &Arc<BufferViewManager>,
-        _env: &druid::Env,
-    ) {
-        let buffer_view_configs = lens!(BufferViewManager, buffer_view_configs);
-
-        let mut names: Flex<Arc<BufferViewManager>> = Flex::row();
-        let mut buffers: Flex<Arc<BufferViewManager>> = Flex::row();
-        let mut removed_buffers: Flex<Arc<BufferViewManager>> = Flex::row();
-        let mut temporarily_removed_buffers: Flex<Arc<BufferViewManager>> = Flex::row();
-        // let mut expansions: Flex<Arc<BufferViewManager>> = Flex::column();
-
-        // TODO optimise this whole thing
-        buffer_view_configs.with(data, |configs| {
-            for (_id, config) in configs {
-                names.add_child(Label::new(config.buffer_view_name.clone()));
-                buffers.add_child(Label::new(format!("{:?}", config.buffers)));
-                removed_buffers.add_child(Label::new(format!("{:?}", config.removed_buffers)));
-                temporarily_removed_buffers.add_child(Label::new(format!(
-                    "{:?}",
-                    config.temporarily_removed_buffers
-                )));
-                // expansions.add_child(Align::left(Label::new(alias.expansion.clone())));
-            }
-        });
-
-        let widget: Flex<Arc<BufferViewManager>> = Flex::column()
-            .with_flex_child(names, 1.0)
-            .with_flex_child(buffers, 1.0)
-            .with_flex_child(removed_buffers, 1.0)
-            .with_flex_child(temporarily_removed_buffers, 1.0);
-        //     .with_flex_child(expansions, 1.0);
-
-        self.inner = WidgetPod::new(widget).boxed();
-
-        ctx.children_changed();
-        ctx.request_layout();
-        ctx.request_paint();
-    }
-
-    fn layout(
-        &mut self,
-        ctx: &mut druid::LayoutCtx,
-        bc: &druid::BoxConstraints,
-        data: &Arc<BufferViewManager>,
-        env: &druid::Env,
-    ) -> druid::Size {
-        let size = self.inner.layout(ctx, bc, data, env);
-        self.inner.set_origin(ctx, data, env, Point::ZERO);
-        return size;
-    }
-
-    fn paint(
-        &mut self,
-        ctx: &mut druid::PaintCtx,
-        data: &Arc<BufferViewManager>,
-        env: &druid::Env,
-    ) {
-        self.inner.paint(ctx, data, env)
-    }
-}
diff --git a/examples/statetracker/src/widgets/mod.rs b/examples/statetracker/src/widgets/mod.rs
deleted file mode 100644
index c837e5d..0000000
--- a/examples/statetracker/src/widgets/mod.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-mod aliasmanager;
-mod bufferview;
-
-pub use aliasmanager::*;
-pub use bufferview::*;