Align tui and gui menubars.

Cargo.lock

@@ -298,6 +298,7 @@ dependencies = [
  "devicons",
  "dirs",
  "edtui",
+ "libclide",
  "libclide-macros",
  "log",
  "ratatui",
@@ -1164,6 +1165,18 @@ version = "0.2.182"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6800badb6cb2082ffd7b6a67e6125bb39f18782f793520caee8cb8846be06112"
 
+[[package]]
+name = "libclide"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "devicons",
+ "libclide-macros",
+ "log",
+ "strum",
+ "syntect",
+]
+
 [[package]]
 name = "libclide-macros"
 version = "0.1.0"

Cargo.toml

@@ -3,13 +3,9 @@ name = "clide"
 version = "0.1.0"
 edition = "2024"
 
-[[bin]]
-name = "clide"
-path = "src/bin/clide/main.rs"
-
 [workspace]
 resolver = "3"
-members = [".", "libclide-macros", ]
+members = [".", "libclide", "libclide-macros", ]
 
 [workspace.dependencies]
 anyhow = "1.0.100"
@@ -28,6 +24,7 @@ ratatui = "0.30.0"
 tui-tree-widget = "0.24.0"
 tui-logger = "0.18.1"
 edtui = "0.11.1"
+libclide = { path = "./libclide" }
 libclide-macros = { path = "./libclide-macros" }
 anyhow = { workspace = true }
 strum = { workspace = true }

README.md

@@ -21,7 +21,7 @@ And of course, [Rust](https://www.rust-lang.org/tools/install).
 curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
 ```
 
-This project requires at least Qt 6.7.3. To check your Qt version, you can use the following command
+This project requires at least Qt 6.7.3 To check your Qt version
 
 ```bash
 qmake6 -query QT_VERSION

build.rs

@@ -28,6 +28,6 @@ fn main() {
     .qt_module("Svg")
     .qt_module("Xml")
     .qrc("./resources.qrc")
-    .files(["src/bin/clide/gui/colors.rs", "src/bin/clide/gui/filesystem.rs"])
+    .files(["src/gui/colors.rs", "src/gui/filesystem.rs"])
     .build();
 }

libclide-macros/src/lib.rs

@@ -15,7 +15,7 @@ pub fn loggable(item: TokenStream) -> TokenStream {
     let (impl_generics, type_generics, where_clause) = generics.split_for_impl();
     let struct_name_str = struct_name.to_string();
     let expanded = quote! {
-        impl #impl_generics clide::logging::Loggable for #struct_name #type_generics #where_clause {
+        impl #impl_generics libclide::log::Loggable for #struct_name #type_generics #where_clause {
             const ID: &'static str = #struct_name_str;
         }
     };

libclide/Cargo.lock

@@ -0,0 +1,16 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "anyhow"
+version = "1.0.102"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
+
+[[package]]
+name = "libclide"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+]

libclide/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "libclide"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+anyhow = { workspace = true }
+strum = { workspace = true }
+log = { workspace = true }
+devicons = { workspace = true }
+libclide-macros = { path = "../libclide-macros" }
+syntect = "5.3.0"

libclide/src/fs.rs

@@ -0,0 +1,24 @@
+// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
+//
+// SPDX-License-Identifier: GNU General Public License v3.0 or later
+
+pub mod entry_meta;
+
+use anyhow::Context;
+pub use entry_meta::icon;
+use std::fs;
+use std::path::Path;
+
+pub fn read_file<P: AsRef<Path>>(p: P) -> anyhow::Result<String> {
+    let path = p.as_ref();
+    let meta =
+        fs::metadata(path).unwrap_or_else(|_| panic!("Failed to get file metadata {path:?}"));
+    if !meta.is_file() {
+        crate::warn!(target:"FileSystem", "Attempted to open file {path:?} that is not a valid file");
+        Err(anyhow::anyhow!(
+            "Attempted to open file {path:?} that is not a valid file"
+        ))?;
+    }
+    let path_str = path.to_string_lossy().to_string();
+    fs::read_to_string(path_str.as_str()).context(format!("Failed to read file {path:?}"))
+}

libclide/src/fs/entry_meta.rs

@@ -43,7 +43,7 @@ impl EntryMeta {
             .context(format!("Failed to get file name for path: {abs_path:?}"))?
             .to_string_lossy()
             .to_string();
-        let icon = icon(&abs_path);
+        let icon = crate::fs::icon(&abs_path);
         Ok(EntryMeta {
             abs_path,
             file_name,

libclide/src/lib.rs

@@ -3,5 +3,5 @@
 // SPDX-License-Identifier: GNU General Public License v3.0 or later
 
 pub mod fs;
-pub mod logging;
+pub mod log;
 pub mod theme;

libclide/src/log/macros.rs

@@ -11,14 +11,13 @@
 //!
 //! The Loggable trait can be implemented to automatically associate log messages with a struct.
 //! ```
-//! use clide::logging;
-//! use libclide_macros::Loggable;
+//! use libclide::log::Loggable;
 //!
 //! #[derive(Loggable)]
 //! struct MyStruct;
 //! impl MyStruct {
 //!      fn my_method(&self) {
-//!          clide::info!("This log message will use target Self::ID, which is 'MyStruct'");
+//!          libclide::info!("This log message will use target <Self as Loggable>::ID, which is 'MyStruct'");
 //!      }
 //!  }
 //! ```
@@ -26,51 +25,51 @@
 //! If the struct does not derive or implement Loggable, the target variant of the log macros must
 //! be used instead.
 //! ```
-//! clide::info!(target: "CustomTarget", "This log message will have the target 'CustomTarget'");
+//! libclide::info!(target: "CustomTarget", "This log message will have the target 'CustomTarget'");
 //! ```
 //!
 
 #[macro_export]
 macro_rules! info {
     (target: $target:expr, $($arg:tt)+) => ({
-        ::log::info!(target: $target, $($arg)+)
+        log::info!(target: $target, $($arg)+)
     });
 
-    ($($arg:tt)+) => (::log::info!(target: Self::ID, $($arg)+))
+    ($($arg:tt)+) => (log::info!(target: Self::ID, $($arg)+))
 }
 
 #[macro_export]
 macro_rules! debug {
     (target: $target:expr, $($arg:tt)+) => ({
-        ::log::debug!(target: $target, $($arg)+)
+        log::debug!(target: $target, $($arg)+)
     });
 
-    ($($arg:tt)+) => (::log::debug!(target: Self::ID, $($arg)+))
+    ($($arg:tt)+) => (log::debug!(target: Self::ID, $($arg)+))
 }
 
 #[macro_export]
 macro_rules! warn {
     (target: $target:expr, $($arg:tt)+) => ({
-        ::log::warn!(target: $target, $($arg)+)
+        log::warn!(target: $target, $($arg)+)
     });
 
-    ($($arg:tt)+) => (::log::warn!(target: Self::ID, $($arg)+))
+    ($($arg:tt)+) => (log::warn!(target: Self::ID, $($arg)+))
 }
 
 #[macro_export]
 macro_rules! error {
     (target: $target:expr, $($arg:tt)+) => ({
-        ::log::error!(target: $target, $($arg)+)
+        log::error!(target: $target, $($arg)+)
     });
 
-    ($($arg:tt)+) => (::log::error!(target: Self::ID, $($arg)+))
+    ($($arg:tt)+) => (log::error!(target: Self::ID, $($arg)+))
 }
 
 #[macro_export]
 macro_rules! trace {
     (target: $target:expr, $($arg:tt)+) => ({
-        ::log::trace!(target: $target, $($arg)+)
+        log::trace!(target: $target, $($arg)+)
     });
 
-    ($($arg:tt)+) => (::log::trace!(target: Self::ID, $($arg)+))
+    ($($arg:tt)+) => (log::trace!(target: Self::ID, $($arg)+))
 }

libclide/src/theme.rs

@@ -3,3 +3,4 @@
 // SPDX-License-Identifier: GNU General Public License v3.0 or later
 
 pub mod colors;
+pub mod highlighter;

libclide/src/theme/highlighter.rs

@@ -0,0 +1,66 @@
+use std::fs;
+use std::path::Path;
+use syntect::easy::HighlightLines;
+use syntect::highlighting::ThemeSet;
+use syntect::html::{IncludeBackground, append_highlighted_html_for_styled_line};
+use syntect::parsing::SyntaxSet;
+use syntect::util::LinesWithEndings;
+
+pub struct Highlighter {
+    path: String,
+    ss: SyntaxSet,
+    ts: ThemeSet,
+}
+
+impl Highlighter {
+    pub fn new<P: AsRef<Path>>(p: P) -> anyhow::Result<Highlighter> {
+        let path = p.as_ref();
+        let meta =
+            fs::metadata(path).unwrap_or_else(|_| panic!("Failed to get file metadata {path:?}"));
+        let ss = SyntaxSet::load_defaults_nonewlines();
+        let ts = ThemeSet::load_defaults();
+        if !meta.is_file() {
+            crate::error!(target:"FileSystem", "Attempted to open file {path:?} that is not a valid file");
+            Err(anyhow::anyhow!(
+                "Attempted to open file {path:?} that is not a valid file"
+            ))?;
+        }
+        Ok(Highlighter {
+            path: path.to_string_lossy().to_string(),
+            ss,
+            ts,
+        })
+    }
+
+    pub fn syntax_highlight_text<P: AsRef<str>>(&self, p: P) -> String {
+        let text = p.as_ref();
+        let theme = &self.ts.themes["base16-ocean.dark"];
+        let lang = self
+            .ss
+            .find_syntax_by_extension(
+                Path::new(self.path.as_str())
+                    .extension()
+                    .map(|s| s.to_str())
+                    .unwrap_or_else(|| Some("md"))
+                    .expect("Failed to get file extension"),
+            )
+            .unwrap_or_else(|| self.ss.find_syntax_plain_text());
+        let mut highlighter = HighlightLines::new(lang, theme);
+        // If you care about the background, see `start_highlighted_html_snippet(theme);`.
+        let mut output = String::from("<pre>\n");
+        for line in LinesWithEndings::from(text) {
+            let regions = highlighter
+                .highlight_line(line, &self.ss)
+                .expect("Failed to highlight");
+
+            append_highlighted_html_for_styled_line(
+                &regions[..],
+                IncludeBackground::No,
+                &mut output,
+            )
+            .expect("Failed to insert highlighted html");
+        }
+        output.push_str("</pre>\n");
+        output
+    }
+}

qml/Components/ClideLogger.qml

@@ -14,7 +14,6 @@ Rectangle {
 
     ListModel {
         id: model
-
     }
     ListView {
         id: listView
@@ -38,10 +37,10 @@ Rectangle {
 
         anchors.fill: parent
         model: model
+        verticalLayoutDirection: ListView.BottomToTop
 
         delegate: Text {
             color: listView.getLogColor(level)
-            font.family: "monospace"
             text: `[${level}] ${message}`
         }
 

qml/Components/ClideMenuBar.qml

@@ -18,22 +18,6 @@ MenuBar {
     ClideMenu {
         title: qsTr("&File")
 
-        ClideMenuItem {
-            action: Action {
-                id: actionNewProject
-
-                text: qsTr("&New Project...")
-            }
-        }
-        ClideMenuItem {
-            action: Action {
-                id: actionOpen
-
-                text: qsTr("&Open...")
-            }
-
-            onTriggered: FileSystem.setDirectory(FileSystem.filePath)
-        }
         ClideMenuItem {
             action: Action {
                 id: actionSave
@@ -41,6 +25,13 @@ MenuBar {
                 text: qsTr("&Save")
             }
         }
+        ClideMenuItem {
+            action: Action {
+                id: actionReload
+
+                text: qsTr("&Reload")
+            }
+        }
         MenuSeparator {
             background: Rectangle {
                 border.color: color
@@ -67,37 +58,9 @@ MenuBar {
 
         ClideMenuItem {
             action: Action {
-                id: actionUndo
+                id: actionCloseTab
 
-                text: qsTr("&Undo")
-            }
-        }
-        ClideMenuItem {
-            action: Action {
-                id: actionRedo
-
-                text: qsTr("&Redo")
-            }
-        }
-        ClideMenuItem {
-            action: Action {
-                id: actionCut
-
-                text: qsTr("&Cut")
-            }
-        }
-        ClideMenuItem {
-            action: Action {
-                id: actionCopy
-
-                text: qsTr("&Copy")
-            }
-        }
-        ClideMenuItem {
-            action: Action {
-                id: actionPaste
-
-                text: qsTr("&Paste")
+                text: qsTr("&Close Tab")
             }
         }
     }
@@ -132,13 +95,6 @@ MenuBar {
     ClideMenu {
         title: qsTr("&Help")
 
-        ClideMenuItem {
-            action: Action {
-                id: actionDocumentation
-
-                text: qsTr("&Documentation")
-            }
-        }
         ClideMenuItem {
             action: Action {
                 id: actionAbout

src/bin/clide/cli.rs

@@ -1,43 +0,0 @@
-// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
-//
-// SPDX-License-Identifier: GNU General Public License v3.0 or later
-
-pub mod app_context;
-
-use crate::cli::app_context::RunMode;
-use anyhow::{Result, anyhow};
-use clap::Parser;
-
-/// Extendable command-line driven development environment written in Rust using the Qt UI framework.
-/// If no flags are provided, the GUI editor is launched in a separate process.
-/// If no path is provided, the current directory is used.
-#[derive(Parser, Debug)]
-#[structopt(name = "clide", verbatim_doc_comment)]
-pub struct Cli {
-    /// The root directory for the project to open with the clide editor.
-    #[arg(value_parser = clap::value_parser!(std::path::PathBuf))]
-    pub path: Option<std::path::PathBuf>,
-
-    /// Run clide in headless mode.
-    #[arg(value_name = "tui", short, long)]
-    pub tui: bool,
-
-    /// Run the clide GUI in the current process, blocking the terminal and showing all output streams.
-    #[arg(value_name = "gui", short, long)]
-    pub gui: bool,
-}
-
-impl Cli {
-    pub fn run_mode(&self) -> Result<RunMode> {
-        let mut modes = Vec::new();
-        self.tui.then(|| modes.push(RunMode::Tui));
-        self.gui.then(|| modes.push(RunMode::GuiAttached));
-        match &modes[..] {
-            [] => Ok(RunMode::Gui),
-            [mode] => Ok(*mode),
-            multiple => Err(anyhow!(
-                "More than one run mode found {multiple:?} please select one."
-            )),
-        }
-    }
-}

src/bin/clide/cli/app_context.rs

@@ -1,36 +0,0 @@
-// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
-//
-// SPDX-License-Identifier: GNU General Public License v3.0 or later
-
-use crate::cli::Cli;
-use anyhow::{Context, Result};
-
-pub struct AppContext {
-    pub path: std::path::PathBuf,
-    pub run_mode: RunMode,
-}
-
-impl AppContext {
-    pub fn new(cli: Cli) -> Result<Self> {
-        let path = match &cli.path {
-            // If the CLI was provided a directory, convert it to absolute.
-            Some(path) => std::path::absolute(path)?,
-            // If no path was provided, use the current directory.
-            None => std::env::current_dir().context("Failed to obtain current directory")?,
-        };
-        clide::info!(target:"main()", "Root path detected: {path:?}");
-
-        Ok(Self {
-            path,
-            run_mode: cli.run_mode()?,
-        })
-    }
-}
-
-#[derive(Copy, Clone, Debug, Default)]
-pub enum RunMode {
-    #[default]
-    Gui,
-    GuiAttached,
-    Tui,
-}

src/bin/clide/main.rs

@@ -1,33 +0,0 @@
-// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
-//
-// SPDX-License-Identifier: GNU General Public License v3.0 or later
-
-mod cli;
-mod gui;
-mod tui;
-
-use anyhow::{Context, Result};
-use clap::Parser;
-use cli::Cli;
-use cli::app_context::{AppContext, RunMode};
-use std::process::{Command, Stdio};
-
-fn main() -> Result<()> {
-    let args = Cli::parse();
-    let app_context = AppContext::new(args)?;
-    match app_context.run_mode {
-        RunMode::GuiAttached => gui::run(app_context),
-        RunMode::Tui => tui::run(app_context),
-        RunMode::Gui => {
-            clide::trace!(target:"main()", "Starting GUI in a new process");
-            Command::new(std::env::current_exe()?)
-                .args(["--gui", app_context.path.to_str().unwrap()])
-                .stdout(Stdio::null())
-                .stderr(Stdio::null())
-                .stdin(Stdio::null())
-                .spawn()
-                .context("Failed to start GUI")
-                .map(|_| ())
-        }
-    }
-}

src/fs.rs

@@ -1,7 +0,0 @@
-// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
-//
-// SPDX-License-Identifier: GNU General Public License v3.0 or later
-
-pub mod entry_meta;
-
-pub use entry_meta::icon;

src/gui.rs

@@ -2,16 +2,15 @@
 //
 // SPDX-License-Identifier: GNU General Public License v3.0 or later
 
-pub mod colors;
-pub mod filesystem;
-pub mod icon_provider;
-
-use crate::cli::app_context::AppContext;
+use crate::AppContext;
 use anyhow::Result;
 use cxx_qt_lib::{QMapPair, QMapPair_QString_QVariant, QString, QVariant};
 
+pub mod colors;
+pub mod filesystem;
+
 pub fn run(app_context: AppContext) -> Result<()> {
-    clide::trace!(target:"gui::run()", "Starting the GUI editor at {:?}", app_context.path);
+    libclide::trace!(target:"gui::run()", "Starting the GUI editor at {:?}", app_context.path);
 
     use cxx_qt_lib::{QGuiApplication, QQmlApplicationEngine, QUrl};
 

src/gui/colors.rs

@@ -2,8 +2,8 @@
 //
 // SPDX-License-Identifier: GNU General Public License v3.0 or later
 
-use clide::theme::colors::Colors;
 use cxx_qt_lib::QColor;
+use libclide::theme::colors::Colors;
 
 #[cxx_qt::bridge]
 pub mod qobject {

src/gui/filesystem.rs

@@ -4,13 +4,9 @@
 
 use cxx_qt_lib::{QModelIndex, QString};
 use dirs;
+use libclide::error;
+use libclide::theme::highlighter::Highlighter;
 use std::fs;
-use std::path::Path;
-use syntect::easy::HighlightLines;
-use syntect::highlighting::ThemeSet;
-use syntect::html::{IncludeBackground, append_highlighted_html_for_styled_line};
-use syntect::parsing::SyntaxSet;
-use syntect::util::LinesWithEndings;
 
 #[cxx_qt::bridge]
 pub mod qobject {
@@ -70,49 +66,15 @@ impl Default for FileSystemImpl {
 
 impl qobject::FileSystem {
     fn read_file(&self, path: &QString) -> QString {
-        if path.is_empty() {
-            return QString::default();
-        }
-        let meta = fs::metadata(path.to_string())
-            .unwrap_or_else(|_| panic!("Failed to get file metadata {path:?}"));
-        if !meta.is_file() {
-            clide::warn!(target:"FileSystem", "Attempted to open file {path:?} that is not a valid file");
-            return QString::default();
-        }
-        let path_str = path.to_string();
-        if let Ok(lines) = fs::read_to_string(path_str.as_str()) {
-            let ss = SyntaxSet::load_defaults_nonewlines();
-            let ts = ThemeSet::load_defaults();
-            let theme = &ts.themes["base16-ocean.dark"];
-            let lang = ss
-                .find_syntax_by_extension(
-                    Path::new(path_str.as_str())
-                        .extension()
-                        .map(|s| s.to_str())
-                        .unwrap_or_else(|| Some("md"))
-                        .expect("Failed to get file extension"),
-                )
-                .unwrap_or_else(|| ss.find_syntax_plain_text());
-            let mut highlighter = HighlightLines::new(lang, theme);
-            // If you care about the background, see `start_highlighted_html_snippet(theme);`.
-            let mut output = String::from("<pre>\n");
-            for line in LinesWithEndings::from(lines.as_str()) {
-                let regions = highlighter
-                    .highlight_line(line, &ss)
-                    .expect("Failed to highlight");
-
-                append_highlighted_html_for_styled_line(
-                    &regions[..],
-                    IncludeBackground::No,
-                    &mut output,
-                )
-                .expect("Failed to insert highlighted html");
-            }
-
-            output.push_str("</pre>\n");
-            QString::from(output)
+        let text = libclide::fs::read_file(path.to_string()).unwrap_or_else(|_| {
+            error!(target: "qobject::FileSystem", "Failed to read file at path {path:?}");
+            String::default()
+        });
+        if let Ok(highlighter) = Highlighter::new(path.to_string()) {
+            QString::from(highlighter.syntax_highlight_text(text))
         } else {
-            QString::default()
+            error!(target: "qobject::FileSystem", "Failed to create highlighter");
+            QString::from(text)
         }
     }
 
@@ -141,6 +103,6 @@ impl qobject::FileSystem {
     }
 
     fn icon(self: std::pin::Pin<&mut Self>, path: &QString) -> QString {
-        QString::from(clide::fs::icon(path.to_string().as_str()).to_string())
+        QString::from(libclide::fs::icon(path.to_string().as_str()).to_string())
     }
 }

src/main.rs

@@ -0,0 +1,93 @@
+// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
+//
+// SPDX-License-Identifier: GNU General Public License v3.0 or later
+
+use anyhow::{Context, Result, anyhow};
+use clap::Parser;
+use std::process::{Command, Stdio};
+
+pub mod gui;
+pub mod tui;
+/// Extendable command-line driven development environment written in Rust using the Qt UI framework.
+/// If no flags are provided, the GUI editor is launched in a separate process.
+/// If no path is provided, the current directory is used.
+#[derive(Parser, Debug)]
+#[structopt(name = "clide", verbatim_doc_comment)]
+struct Cli {
+    /// The root directory for the project to open with the clide editor.
+    #[arg(value_parser = clap::value_parser!(std::path::PathBuf))]
+    pub path: Option<std::path::PathBuf>,
+
+    /// Run clide in headless mode.
+    #[arg(value_name = "tui", short, long)]
+    pub tui: bool,
+
+    /// Run the clide GUI in the current process, blocking the terminal and showing all output streams.
+    #[arg(value_name = "gui", short, long)]
+    pub gui: bool,
+}
+
+impl Cli {
+    fn run_mode(&self) -> Result<RunMode> {
+        let mut modes = Vec::new();
+        self.tui.then(|| modes.push(RunMode::Tui));
+        self.gui.then(|| modes.push(RunMode::GuiAttached));
+        match &modes[..] {
+            [] => Ok(RunMode::Gui),
+            [mode] => Ok(*mode),
+            multiple => Err(anyhow!(
+                "More than one run mode found {multiple:?} please select one."
+            )),
+        }
+    }
+}
+
+pub struct AppContext {
+    pub path: std::path::PathBuf,
+    pub run_mode: RunMode,
+}
+
+impl AppContext {
+    fn new(cli: Cli) -> Result<Self> {
+        let path = match &cli.path {
+            // If the CLI was provided a directory, convert it to absolute.
+            Some(path) => std::path::absolute(path)?,
+            // If no path was provided, use the current directory.
+            None => std::env::current_dir().context("Failed to obtain current directory")?,
+        };
+        libclide::info!(target:"main()", "Root path detected: {path:?}");
+
+        Ok(Self {
+            path,
+            run_mode: cli.run_mode()?,
+        })
+    }
+}
+
+#[derive(Copy, Clone, Debug, Default)]
+pub enum RunMode {
+    #[default]
+    Gui,
+    GuiAttached,
+    Tui,
+}
+
+fn main() -> Result<()> {
+    let args = Cli::parse();
+    let app_context = AppContext::new(args)?;
+    match app_context.run_mode {
+        RunMode::GuiAttached => gui::run(app_context),
+        RunMode::Tui => tui::run(app_context),
+        RunMode::Gui => {
+            libclide::trace!(target:"main()", "Starting GUI in a new process");
+            Command::new(std::env::current_exe()?)
+                .args(["--gui", app_context.path.to_str().unwrap()])
+                .stdout(Stdio::null())
+                .stderr(Stdio::null())
+                .stdin(Stdio::null())
+                .spawn()
+                .context("Failed to start GUI")
+                .map(|_| ())
+        }
+    }
+}

src/tui.rs

@@ -2,19 +2,19 @@
 //
 // SPDX-License-Identifier: GNU General Public License v3.0 or later
 
-pub mod about;
-pub mod app;
-pub mod component;
-pub mod editor;
-pub mod editor_tab;
-pub mod explorer;
-pub mod logger;
-pub mod menu_bar;
+mod about;
+mod app;
+mod component;
+mod editor;
+mod editor_tab;
+mod explorer;
+mod logger;
+mod menu_bar;
 
-use crate::cli::app_context::AppContext;
-use ::log::LevelFilter;
+use crate::AppContext;
 use anyhow::{Context, Result};
-use clide::logging::Loggable;
+use libclide::log::Loggable;
+use log::LevelFilter;
 use ratatui::Terminal;
 use ratatui::backend::CrosstermBackend;
 use ratatui::crossterm::event::{
@@ -36,7 +36,7 @@ struct Tui {
 }
 
 pub fn run(app_context: AppContext) -> Result<()> {
-    clide::trace!(target: "clide::tui::run", "Starting TUI");
+    libclide::trace!(target: "clide::tui::run", "Starting TUI");
     Tui::new(app_context)?.start()
 }
 
@@ -44,7 +44,7 @@ impl Tui {
     fn new(app_context: AppContext) -> Result<Self> {
         init_logger(LevelFilter::Trace)?;
         set_default_level(LevelFilter::Trace);
-        clide::debug!("Logging initialized");
+        libclide::debug!("Logging initialized");
 
         let mut dir = env::temp_dir();
         dir.push("clide.log");
@@ -56,7 +56,7 @@ impl Tui {
         .output_file(false)
         .output_separator(':');
         set_log_file(file_options);
-        clide::debug!("Logging to file: {dir:?}");
+        libclide::debug!("Logging to file: {dir:?}");
 
         Ok(Self {
             terminal: Terminal::new(CrosstermBackend::new(stdout()))?,
@@ -65,7 +65,7 @@ impl Tui {
     }
 
     fn start(self) -> Result<()> {
-        clide::info!("Starting the TUI editor at {:?}", self.root_path);
+        libclide::info!("Starting the TUI editor at {:?}", self.root_path);
         ratatui::crossterm::execute!(
             stdout(),
             EnterAlternateScreen,
@@ -82,7 +82,7 @@ impl Tui {
     }
 
     fn stop() -> Result<()> {
-        clide::info!("Stopping the TUI editor");
+        libclide::info!("Stopping the TUI editor");
         disable_raw_mode()?;
         ratatui::crossterm::execute!(
             stdout(),

src/tui/about.rs

@@ -2,18 +2,18 @@
 //
 // SPDX-License-Identifier: GNU General Public License v3.0 or later
 
-use clide::logging::Loggable;
+use libclide::log::Loggable;
 use ratatui::buffer::Buffer;
 use ratatui::layout::{Constraint, Direction, Layout, Rect};
 use ratatui::text::{Line, Span};
 use ratatui::widgets::{Block, Borders, Clear, Padding, Paragraph, Widget, Wrap};
 
-#[derive(Loggable, Default)]
+#[derive(Loggable)]
 pub struct About {}
 
 impl About {
     pub fn new() -> Self {
-        // clide::trace!("Building {}", Self::id());
+        // libclide::trace!("Building {}", Self::id());
         Self {}
     }
 }

src/tui/app.rs

@@ -8,8 +8,8 @@ use crate::tui::editor_tab::EditorTab;
 use crate::tui::explorer::Explorer;
 use crate::tui::logger::Logger;
 use crate::tui::menu_bar::MenuBar;
-use clide::logging::Loggable;
 use anyhow::{Context, Result};
+use libclide::log::Loggable;
 use ratatui::DefaultTerminal;
 use ratatui::buffer::Buffer;
 use ratatui::crossterm::event;
@@ -42,7 +42,7 @@ pub struct App<'a> {
 
 impl<'a> App<'a> {
     pub fn new(root_path: PathBuf) -> Result<Self> {
-        clide::trace!("Building");
+        libclide::trace!("Building {}", Self::ID);
         let app = Self {
             editor_tab: EditorTab::new(),
             explorer: Explorer::new(&root_path)?,
@@ -56,13 +56,13 @@ impl<'a> App<'a> {
 
     /// Logic that should be executed once on application startup.
     pub fn start(&mut self) -> Result<()> {
-        clide::trace!("Starting App");
+        libclide::trace!("Starting App");
         Ok(())
     }
 
     pub fn run(mut self, mut terminal: DefaultTerminal) -> Result<()> {
         self.start()?;
-        clide::trace!("Entering App run loop");
+        libclide::trace!("Entering App run loop");
         loop {
             terminal.draw(|f| {
                 f.render_widget(&mut self, f.area());
@@ -88,7 +88,7 @@ impl<'a> App<'a> {
                 Some(editor) => editor.component_state.help_text.clone(),
                 None => {
                     if !self.editor_tab.is_empty() {
-                        clide::error!("Failed to get Editor while drawing bottom status bar");
+                        libclide::error!("Failed to get Editor while drawing bottom status bar");
                     }
                     "Failed to get current Editor while getting widget help text".to_string()
                 }
@@ -112,26 +112,26 @@ impl<'a> App<'a> {
     }
 
     fn clear_focus(&mut self) {
-        clide::info!("Clearing all widget focus");
+        libclide::info!("Clearing all widget focus");
         self.explorer.component_state.set_focus(Focus::Inactive);
         self.explorer.component_state.set_focus(Focus::Inactive);
         self.logger.component_state.set_focus(Focus::Inactive);
         self.menu_bar.component_state.set_focus(Focus::Inactive);
         match self.editor_tab.current_editor_mut() {
             None => {
-                clide::error!("Failed to get current Editor while clearing focus")
+                libclide::error!("Failed to get current Editor while clearing focus")
             }
             Some(editor) => editor.component_state.set_focus(Focus::Inactive),
         }
     }
 
     fn change_focus(&mut self, focus: AppComponent) {
-        clide::info!("Changing widget focus to {:?}", focus);
+        libclide::info!("Changing widget focus to {:?}", focus);
         self.clear_focus();
         match focus {
             AppComponent::Editor => match self.editor_tab.current_editor_mut() {
                 None => {
-                    clide::error!("Failed to get current Editor while changing focus")
+                    libclide::error!("Failed to get current Editor while changing focus")
                 }
                 Some(editor) => editor.component_state.set_focus(Focus::Active),
             },
@@ -274,13 +274,15 @@ impl<'a> Component for App<'a> {
             Action::Quit | Action::Handled => Ok(action),
             Action::Save => match self.editor_tab.current_editor_mut() {
                 None => {
-                    clide::error!("Failed to get current editor while handling App Action::Save");
+                    libclide::error!(
+                        "Failed to get current editor while handling App Action::Save"
+                    );
                     Ok(Action::Noop)
                 }
                 Some(editor) => match editor.save() {
                     Ok(_) => Ok(Action::Handled),
                     Err(e) => {
-                        clide::error!("Failed to save editor contents: {e}");
+                        libclide::error!("Failed to save editor contents: {e}");
                         Ok(Action::Noop)
                     }
                 },
@@ -299,14 +301,14 @@ impl<'a> Component for App<'a> {
                 Err(_) => Ok(Action::Noop),
             },
             Action::ReloadFile => {
-                clide::trace!("Reloading file for current editor");
+                libclide::trace!("Reloading file for current editor");
                 if let Some(editor) = self.editor_tab.current_editor_mut() {
                     editor
                         .reload_contents()
                         .map(|_| Action::Handled)
                         .context("Failed to handle Action::ReloadFile")
                 } else {
-                    clide::error!(
+                    libclide::error!(
                         "Failed to get current editor while handling App Action::ReloadFile"
                     );
                     Ok(Action::Noop)

src/tui/component.rs

@@ -5,10 +5,10 @@
 #![allow(dead_code, unused_variables)]
 
 use crate::tui::component::Focus::Inactive;
-use clide::logging::Loggable;
-use clide::theme::colors::Colors;
 use Focus::Active;
 use anyhow::Result;
+use libclide::log::Loggable;
+use libclide::theme::colors::Colors;
 use ratatui::crossterm::event::{Event, KeyEvent, MouseEvent};
 use ratatui::style::Color;
 
@@ -75,7 +75,7 @@ impl ComponentState {
     }
 
     fn new() -> Self {
-        clide::trace!(target:Self::id(), "Building {}", Self::id());
+        libclide::trace!(target:Self::id(), "Building {}", Self::id());
         Self {
             focus: Active,
             vis: Visibility::Visible,

src/tui/editor.rs

@@ -3,11 +3,11 @@
 // SPDX-License-Identifier: GNU General Public License v3.0 or later
 
 use crate::tui::component::{Action, Component, ComponentState, Focus, FocusState};
-use clide::logging::Loggable;
 use anyhow::{Context, Result, bail};
 use edtui::{
     EditorEventHandler, EditorState, EditorTheme, EditorView, LineNumbers, Lines, SyntaxHighlighter,
 };
+use libclide::log::Loggable;
 use ratatui::buffer::Buffer;
 use ratatui::crossterm::event::{Event, KeyCode, KeyEvent, KeyModifiers};
 use ratatui::layout::{Alignment, Rect};
@@ -27,7 +27,7 @@ pub struct Editor {
 
 impl Editor {
     pub fn new(path: &std::path::Path) -> Self {
-        clide::trace!("Building {}", <Self as Loggable>::ID);
+        libclide::trace!("Building {}", <Self as Loggable>::ID);
         Editor {
             state: EditorState::default(),
             event_handler: EditorEventHandler::default(),
@@ -41,10 +41,10 @@ impl Editor {
     }
 
     pub fn reload_contents(&mut self) -> Result<()> {
-        clide::trace!("Reloading editor file contents {:?}", self.file_path);
+        libclide::trace!("Reloading editor file contents {:?}", self.file_path);
         match self.file_path.clone() {
             None => {
-                clide::error!("Failed to reload editor contents with None file_path");
+                libclide::error!("Failed to reload editor contents with None file_path");
                 bail!("Failed to reload editor contents with None file_path")
             }
             Some(path) => self.set_contents(&path),
@@ -52,7 +52,7 @@ impl Editor {
     }
 
     pub fn set_contents(&mut self, path: &std::path::Path) -> Result<()> {
-        clide::trace!("Setting Editor contents from path {:?}", path);
+        libclide::trace!("Setting Editor contents from path {:?}", path);
         if let Ok(contents) = std::fs::read_to_string(path) {
             let lines: Vec<_> = contents
                 .lines()
@@ -68,10 +68,10 @@ impl Editor {
 
     pub fn save(&self) -> Result<()> {
         if let Some(path) = &self.file_path {
-            clide::trace!("Saving Editor contents {:?}", path);
+            libclide::trace!("Saving Editor contents {:?}", path);
             return std::fs::write(path, self.state.lines.to_string()).map_err(|e| e.into());
         };
-        clide::error!("Failed saving Editor contents; file_path was None");
+        libclide::error!("Failed saving Editor contents; file_path was None");
         bail!("File not saved. No file path set.")
     }
 }

src/tui/editor_tab.rs

@@ -2,21 +2,21 @@
 //
 // SPDX-License-Identifier: GNU General Public License v3.0 or later
 
+use crate::tui::component::{Action, Component, Focus, FocusState};
 use crate::tui::editor::Editor;
-use clide::logging::Loggable;
 use anyhow::{Context, Result, anyhow};
+use libclide::log::Loggable;
 use ratatui::buffer::Buffer;
 use ratatui::crossterm::event::{Event, KeyCode, KeyEvent, KeyModifiers};
 use ratatui::layout::Rect;
 use ratatui::prelude::{Color, Style};
 use ratatui::widgets::{Block, Borders, Padding, Tabs, Widget};
 use std::collections::HashMap;
-use crate::tui::component::{Action, Component, Focus, FocusState};
 
 // Render the tabs with keys as titles
 // Tab keys can be file names.
 // Render the editor using the key as a reference for lookup
-#[derive(Loggable, Default)]
+#[derive(Loggable)]
 pub struct EditorTab {
     pub(crate) editors: HashMap<String, Editor>,
     tab_order: Vec<String>,
@@ -25,7 +25,7 @@ pub struct EditorTab {
 
 impl EditorTab {
     pub fn new() -> Self {
-        clide::trace!("Building {}", <Self as Loggable>::ID);
+        libclide::trace!("Building {}", <Self as Loggable>::ID);
         Self {
             editors: HashMap::new(),
             tab_order: Vec::new(),
@@ -35,7 +35,7 @@ impl EditorTab {
 
     pub fn next_editor(&mut self) {
         let next = (self.current_editor + 1) % self.tab_order.len();
-        clide::trace!(
+        libclide::trace!(
             "Moving from {} to next editor tab at {}",
             self.current_editor,
             next
@@ -49,7 +49,7 @@ impl EditorTab {
             .current_editor
             .checked_sub(1)
             .unwrap_or(self.tab_order.len() - 1);
-        clide::trace!(
+        libclide::trace!(
             "Moving from {} to previous editor tab at {}",
             self.current_editor,
             prev
@@ -62,7 +62,7 @@ impl EditorTab {
         match self.tab_order.get(index) {
             None => {
                 if !self.tab_order.is_empty() {
-                    clide::error!("Failed to get editor tab key with invalid index {index}");
+                    libclide::error!("Failed to get editor tab key with invalid index {index}");
                 }
                 None
             }
@@ -80,7 +80,7 @@ impl EditorTab {
     }
 
     pub fn set_current_tab_focus(&mut self, focus: Focus) {
-        clide::trace!(
+        libclide::trace!(
             "Setting current tab {} focus to {:?}",
             self.current_editor,
             focus
@@ -89,10 +89,10 @@ impl EditorTab {
     }
 
     pub fn set_tab_focus(&mut self, focus: Focus, index: usize) {
-        clide::trace!("Setting tab {} focus to {:?}", index, focus);
+        libclide::trace!("Setting tab {} focus to {:?}", index, focus);
         if focus == Focus::Active && index != self.current_editor {
             // If we are setting another tab to active, disable the current one.
-            clide::trace!(
+            libclide::trace!(
                 "New tab {} focus set to Active; Setting current tab {} to Inactive",
                 index,
                 self.current_editor
@@ -101,11 +101,11 @@ impl EditorTab {
         }
         match self.get_editor_key(index) {
             None => {
-                clide::error!("Failed setting tab focus for invalid key {index}");
+                libclide::error!("Failed setting tab focus for invalid key {index}");
             }
             Some(key) => match self.editors.get_mut(&key) {
                 None => {
-                    clide::error!(
+                    libclide::error!(
                         "Failed to update tab focus at index {} with invalid key: {}",
                         self.current_editor,
                         self.tab_order[self.current_editor]
@@ -117,12 +117,12 @@ impl EditorTab {
     }
 
     pub fn open_tab(&mut self, path: &std::path::Path) -> Result<()> {
-        clide::trace!("Opening new EditorTab with path {:?}", path);
+        libclide::trace!("Opening new EditorTab with path {:?}", path);
         if self
             .editors
             .contains_key(&path.to_string_lossy().to_string())
         {
-            clide::warn!("EditorTab already opened with this file");
+            libclide::warn!("EditorTab already opened with this file");
             return Ok(());
         }
 
@@ -147,12 +147,12 @@ impl EditorTab {
             .to_owned();
         match self.editors.remove(&key) {
             None => {
-                clide::error!("Failed to remove editor tab {key} with invalid index {index}")
+                libclide::error!("Failed to remove editor tab {key} with invalid index {index}")
             }
             Some(_) => {
                 self.prev_editor();
                 self.tab_order.remove(index);
-                clide::info!("Closed editor tab {key} at index {index}")
+                libclide::info!("Closed editor tab {key} at index {index}")
             }
         }
         Ok(())

src/tui/explorer.rs

@@ -4,8 +4,8 @@
 
 use crate::tui::component::{Action, Component, ComponentState, Focus, FocusState};
 use anyhow::{Context, Result, bail};
-use clide::fs::entry_meta::EntryMeta;
-use clide::logging::Loggable;
+use libclide::fs::entry_meta::EntryMeta;
+use libclide::log::Loggable;
 use ratatui::buffer::Buffer;
 use ratatui::crossterm::event::{Event, KeyCode, KeyEvent, MouseEvent, MouseEventKind};
 use ratatui::layout::{Alignment, Position, Rect};
@@ -26,7 +26,7 @@ pub struct Explorer<'a> {
 
 impl<'a> Explorer<'a> {
     pub fn new(path: &PathBuf) -> Result<Self> {
-        clide::trace!("Building {}", <Self as Loggable>::ID);
+        libclide::trace!("Building {}", <Self as Loggable>::ID);
         let explorer = Explorer {
             root_path: EntryMeta::new(path)?,
             tree_items: Self::build_tree_from_path(path)?,
@@ -62,8 +62,7 @@ impl<'a> Explorer<'a> {
                 } else {
                     children.push(TreeItem::new_leaf(
                         entry_meta.abs_path.clone(),
-                        format!("{}", entry_meta.file_name.as_str()),
-                        // format!("{} {}", entry_meta.icon.icon, entry_meta.file_name.as_str()),
+                        format!("{} {}", entry_meta.icon.icon, entry_meta.file_name.as_str()),
                     ));
                 }
             }
@@ -73,8 +72,7 @@ impl<'a> Explorer<'a> {
         // For a file tree this is fine because we shouldn't list the same object twice.
         TreeItem::new(
             path_meta.abs_path.clone(),
-            format!("{}", path_meta.file_name.as_str()),
-            // format!("{} {}", path_meta.icon.icon, path_meta.file_name.as_str()),
+            format!("{} {}", path_meta.icon.icon, path_meta.file_name.as_str()),
             children,
         )
         .context(format!(

src/tui/logger.rs

@@ -3,7 +3,7 @@
 // SPDX-License-Identifier: GNU General Public License v3.0 or later
 
 use crate::tui::component::{Action, Component, ComponentState, Focus, FocusState};
-use clide::logging::Loggable;
+use libclide::log::Loggable;
 use log::LevelFilter;
 use ratatui::buffer::Buffer;
 use ratatui::crossterm::event::{Event, KeyCode, KeyEvent};
@@ -12,9 +12,9 @@ use ratatui::style::{Color, Style};
 use ratatui::widgets::Widget;
 use tui_logger::{TuiLoggerLevelOutput, TuiLoggerSmartWidget, TuiWidgetEvent, TuiWidgetState};
 
-/// Any logging written as info!(target:self.id(), "message") will work with this logger.
+/// Any log written as info!(target:self.id(), "message") will work with this logger.
 /// The logger is bound to info!, debug!, error!, trace! macros within Tui::new().
-#[derive(Loggable, Default)]
+#[derive(Loggable)]
 pub struct Logger {
     state: TuiWidgetState,
     pub(crate) component_state: ComponentState,
@@ -22,7 +22,7 @@ pub struct Logger {
 
 impl Logger {
     pub fn new() -> Self {
-        clide::trace!("Building {}", <Self as Loggable>::ID);
+        libclide::trace!("Building {}", <Self as Loggable>::ID);
         let state = TuiWidgetState::new();
         state.transition(TuiWidgetEvent::HideKey);
         Self {

src/tui/menu_bar.rs

@@ -6,8 +6,8 @@ use crate::tui::component::{Action, Component, ComponentState, FocusState};
 use crate::tui::menu_bar::MenuBarItemOption::{
     About, CloseTab, Exit, Reload, Save, ShowHideExplorer, ShowHideLogger,
 };
-use clide::logging::Loggable;
 use anyhow::Context;
+use libclide::log::Loggable;
 use ratatui::buffer::Buffer;
 use ratatui::crossterm::event::{KeyCode, KeyEvent};
 use ratatui::layout::Rect;
@@ -18,10 +18,10 @@ use ratatui::widgets::{
 };
 use strum::{EnumIter, FromRepr, IntoEnumIterator};
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, FromRepr, EnumIter, Default)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, FromRepr, EnumIter)]
 enum MenuBarItem {
-    #[default]
     File,
+    Edit,
     View,
     Help,
 }
@@ -69,19 +69,21 @@ impl MenuBarItem {
             MenuBarItem::File => "File",
             MenuBarItem::View => "View",
             MenuBarItem::Help => "Help",
+            MenuBarItem::Edit => "Edit",
         }
     }
 
     pub fn options(&self) -> &[MenuBarItemOption] {
         match self {
-            MenuBarItem::File => &[Save, CloseTab, Reload, Exit],
+            MenuBarItem::File => &[Save, Reload, Exit],
+            MenuBarItem::Edit => &[CloseTab],
             MenuBarItem::View => &[ShowHideExplorer, ShowHideLogger],
             MenuBarItem::Help => &[About],
         }
     }
 }
 
-#[derive(Debug, Loggable, Default)]
+#[derive(Debug, Loggable)]
 pub struct MenuBar {
     selected: MenuBarItem,
     opened: Option<MenuBarItem>,
@@ -92,7 +94,7 @@ pub struct MenuBar {
 impl MenuBar {
     const DEFAULT_HELP: &str = "(←/h)/(→/l): Select option | Enter: Choose selection";
     pub fn new() -> Self {
-        clide::trace!("Building");
+        libclide::trace!("Building");
         Self {
             selected: MenuBarItem::File,
             opened: None,