Loggable trait and derive macro.

The shim is there but it isn't used yet.

.cargo/config.toml

@@ -1,6 +1,2 @@
 [build]
 rustflags = [ "-C", "link-arg=-fuse-ld=lld", ]
-
-[env]
-QMAKE="/opt/Qt/6.7.3/gcc_64/bin/qmake6"
-LD_LIBRARY_PATH="/opt/Qt/6.7.3/gcc_64/lib"

.github/actions/setup-qt/action.yml

@@ -0,0 +1,20 @@
+name: "Setup Qt"
+description: "Install clide dependencies"
+inputs:
+  qt-version:
+    description: "Qt version to install"
+    required: true
+
+runs:
+  using: "composite"
+  steps:
+    - name: Install apt packages
+      run: |
+        sudo apt update -y
+        sudo apt install -y build-essential cmake curl libgl1-mesa-dev python3 python3-pip
+      shell: bash
+
+    - name: Install Qt
+      uses: jurplel/install-qt-action@v4
+      with:
+        version: ${{ inputs.qt-version }}

.github/workflows/check.yaml

@@ -0,0 +1,97 @@
+name: Check
+
+on:
+  push:
+    branches:
+      - '**'
+    tags:
+      - 'v*'
+  pull_request:
+
+env:
+  QT_VERSION: 6.7.3
+
+jobs:
+  Build:
+    name: Build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Setup Qt
+        uses: ./.github/actions/setup-qt
+        with:
+          qt-version: ${{ env.QT_VERSION }}
+
+      - name: Build libclide
+        run: |
+          cargo b -p libclide --release
+      - name: Build libclide-macros
+        run: |
+          cargo b -p libclide-macros --release
+      - name: Build clide
+        run: |
+          cargo b --release
+
+  Test:
+    name: Test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Setup Qt
+        uses: ./.github/actions/setup-qt
+        with:
+          qt-version: ${{ env.QT_VERSION }}
+
+      - name: Test libclide
+        run: |
+          cargo test -p libclide
+      - name: Test libclide-macros
+        run: |
+          cargo test -p libclide-macros
+      - name: Test clide
+        run: |
+          cargo test
+
+  Lint:
+    name: Lint
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Setup Qt
+        uses: ./.github/actions/setup-qt
+        with:
+          qt-version: ${{ env.QT_VERSION }}
+
+      - name: Lint libclide
+        run: |
+          cargo clippy -p libclide -- -D warnings
+      - name: Lint libclide-macros
+        run: |
+          cargo clippy -p libclide-macros -- -D warnings
+      - name: Lint clide
+        run: |
+          cargo clippy -- -D warnings
+
+  Format:
+    name: Format
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Setup Qt
+        uses: ./.github/actions/setup-qt
+        with:
+          qt-version: ${{ env.QT_VERSION }}
+
+      - name: Format libclide
+        run: |
+          cargo fmt -p libclide --verbose -- --check
+      - name: Format libclide-macros
+        run: |
+          cargo fmt -p libclide-macros -- --check
+      - name: Format clide
+        run: |
+          cargo fmt --verbose -- --check

.gitignore

@@ -1,4 +1,5 @@
 **/target/**
 **/.qtcreator/**
 **/.idea/**
-**/*.autosave/**
+**/*.autosave/**
+**/.qmlls.ini

Cargo.toml

@@ -3,22 +3,33 @@ name = "clide"
 version = "0.1.0"
 edition = "2024"
 
+[workspace]
+resolver = "3"
+members = [".", "libclide", "libclide-macros", ]
+
+[workspace.dependencies]
+anyhow = "1.0.100"
+strum = "0.27.2"
+log = { version = "0.4.27", features = [] }
+devicons = "0.6.12"
+
 [dependencies]
 cxx = "1.0.95"
 cxx-qt = "0.8.0"
 cxx-qt-lib = { version = "0.8.0", features = ["qt_full", "qt_gui", "qt_qml"] }
-log = { version = "0.4.27", features = [] }
 dirs = "6.0.0"
 syntect = "5.2.0"
 clap = { version = "4.5.54", features = ["derive"] }
 ratatui = "0.30.0"
-anyhow = "1.0.100"
 tui-tree-widget = "0.24.0"
 tui-logger = "0.18.1"
 edtui = "0.11.1"
-strum = "0.27.2"
-uuid = { version = "1.19.0", features = ["v4"] }
-devicons = "0.6.12"
+libclide = { path = "./libclide" }
+libclide-macros = { path = "./libclide-macros" }
+anyhow = { workspace = true }
+strum = { workspace = true }
+log = { workspace = true }
+devicons = { workspace = true }
 
 [build-dependencies]
 # The link_qt_object_files feature is required for statically linking Qt 6.

README.md

@@ -1,5 +1,7 @@
 # CLIDE
 
+[![Check](https://github.com/shaunrd0/clide/actions/workflows/check.yaml/badge.svg)](https://github.com/shaunrd0/clide/actions/workflows/check.yaml)
+
 CLIDE is an extendable command-line driven development environment written in Rust using the Qt UI framework that supports both full and headless Linux environments.
 The GUI is written in QML compiled through Rust using the cxx-qt crate, while the TUI was implemented using the ratatui crate.
 
@@ -107,6 +109,8 @@ cargo run
 clide
 ```
 
+![image](./resources/gui.png)
+
 ## Development
 
 It's recommended to use RustRover or Qt Creator for development.

build.rs

@@ -1,21 +1,22 @@
 use cxx_qt_build::{CxxQtBuilder, QmlModule};
 
 fn main() {
-    CxxQtBuilder::new_qml_module(QmlModule::new("clide.module").qml_files(&[
-        "qml/main.qml",
-        "qml/ClideAboutWindow.qml",
-        "qml/ClideTreeView.qml",
-        "qml/ClideProjectView.qml",
-        "qml/ClideEditor.qml",
+    CxxQtBuilder::new_qml_module(QmlModule::new("clide.module").qml_files([
+        "qml/ClideApplicationView.qml",
         "qml/ClideEditorView.qml",
-        "qml/ClideMenuBar.qml",
-        "qml/ClideLogger.qml",
-        "qml/Components/ClideScrollBar.qml",
-        "qml/Components/ClideHandle.qml",
-        "qml/Components/ClideMenu.qml",
-        "qml/Components/ClideMenuItem.qml",
+        "qml/ClideExplorerView.qml",
+        "qml/ClideTreeView.qml",
+        "qml/Components/ClideAboutWindow.qml",
         "qml/Components/ClideBreadCrumbs.qml",
+        "qml/Components/ClideEditor.qml",
+        "qml/Components/ClideHandle.qml",
+        "qml/Components/ClideLogger.qml",
+        "qml/Components/ClideMenu.qml",
+        "qml/Components/ClideMenuBar.qml",
+        "qml/Components/ClideMenuItem.qml",
+        "qml/Components/ClideScrollBar.qml",
         "qml/Logger/Logger.qml",
+        "qml/main.qml",
     ]))
     // Link Qt's Network library
     // - Qt Core is always linked

libclide-macros/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "libclide-macros"
+version = "0.1.0"
+edition = "2024"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+syn = { version = "2", features = ["full"] }
+quote = "1"
+proc-macro2 = "1"

libclide-macros/src/lib.rs

@@ -0,0 +1,24 @@
+// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
+//
+// SPDX-License-Identifier: GNU General Public License v3.0 or later
+
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::{ItemStruct, parse_macro_input};
+
+#[proc_macro_derive(Loggable)]
+pub fn loggable(item: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(item as ItemStruct);
+    let struct_name = &input.ident;
+    let generics = &input.generics;
+
+    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 libclide::log::Loggable for #struct_name #type_generics #where_clause {
+            const ID: &'static str = #struct_name_str;
+        }
+    };
+
+    TokenStream::from(expanded)
+}

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,11 @@
+[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" }

libclide/src/fs.rs

@@ -0,0 +1,7 @@
+// 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;

libclide/src/fs/entry_meta.rs

@@ -0,0 +1,64 @@
+// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
+//
+// SPDX-License-Identifier: GNU General Public License v3.0 or later
+
+use anyhow::{Context, Result};
+use devicons::FileIcon;
+use std::path::{Path, PathBuf};
+
+#[derive(Debug)]
+pub struct EntryMeta {
+    pub abs_path: String,
+    pub file_name: String,
+    pub is_dir: bool,
+    pub icon: FileIcon,
+}
+
+impl EntryMeta {
+    /// Normalizes a path, returning an absolute from the root of the filesystem.
+    /// Does not resolve symlinks and extracts `./` or `../` segments.
+    fn normalize<P: AsRef<Path>>(p: P) -> PathBuf {
+        let path = p.as_ref();
+        let mut buf = PathBuf::new();
+
+        for comp in path.components() {
+            match comp {
+                std::path::Component::ParentDir => {
+                    buf.pop();
+                }
+                std::path::Component::CurDir => {}
+                _ => buf.push(comp),
+            }
+        }
+
+        buf
+    }
+
+    pub fn new<P: AsRef<Path>>(p: P) -> Result<Self> {
+        let path = p.as_ref();
+        let is_dir = path.is_dir();
+        let abs_path = Self::normalize(path).to_string_lossy().to_string();
+        let file_name = Path::new(&abs_path)
+            .file_name()
+            .context(format!("Failed to get file name for path: {abs_path:?}"))?
+            .to_string_lossy()
+            .to_string();
+        let icon = crate::fs::icon(&abs_path);
+        Ok(EntryMeta {
+            abs_path,
+            file_name,
+            is_dir,
+            icon,
+        })
+    }
+}
+
+pub fn icon<P: AsRef<str>>(p: P) -> FileIcon {
+    let path = p.as_ref();
+    if Path::new(&path).is_dir() {
+        // Ensures directories are given a folder icon and not mistakenly resolved to a language.
+        // For example, a directory named `cpp` would otherwise return a C++ icon.
+        return FileIcon::from("dir/");
+    }
+    FileIcon::from(path)
+}

libclide/src/lib.rs

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

libclide/src/log.rs

@@ -0,0 +1,9 @@
+// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
+//
+// SPDX-License-Identifier: GNU General Public License v3.0 or later
+
+pub mod macros;
+
+pub trait Loggable {
+    const ID: &'static str;
+}

libclide/src/log/macros.rs

@@ -0,0 +1,75 @@
+// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
+//
+// SPDX-License-Identifier: GNU General Public License v3.0 or later
+
+//! Logging targets allow filtering of log messages by their source. By default, the log crate sets
+//! the target to the module path where the log macro was invoked if no target is provided.
+//!
+//! These macros essentially disable using the default target and instead require the target to be
+//! explicitly set. This is to avoid implicit pooling of log messages under the same default target,
+//! which can make it difficult to filter log messages by their source.
+//!
+//! The Loggable trait can be implemented to automatically associate log messages with a struct.
+//! ```
+//! use libclide_macros::Loggable;
+//!
+//! #[derive(Loggable)]
+//! struct MyStruct;
+//! impl MyStruct {
+//!      fn my_method(&self) {
+//!          libclide::info!("This log message will use target <Self as Loggable>::ID, which is 'MyStruct'");
+//!      }
+//!  }
+//! ```
+//!
+//! If the struct does not derive or implement Loggable, the target variant of the log macros must
+//! be used instead.
+//! ```
+//! 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)+)
+    });
+
+    ($($arg:tt)+) => (log::info!(target: <Self as libclide::log::Loggable>::ID, $($arg)+))
+}
+
+#[macro_export]
+macro_rules! debug {
+    (target: $target:expr, $($arg:tt)+) => ({
+        log::debug!(target: $target, $($arg)+)
+    });
+
+    ($($arg:tt)+) => (log::debug!(target: <Self as libclide::log::Loggable>::ID, $($arg)+))
+}
+
+#[macro_export]
+macro_rules! warn {
+    (target: $target:expr, $($arg:tt)+) => ({
+        log::warn!(target: $target, $($arg)+)
+    });
+
+    ($($arg:tt)+) => (log::warn!(target: <Self as libclide::log::Loggable>::ID, $($arg)+))
+}
+
+#[macro_export]
+macro_rules! error {
+    (target: $target:expr, $($arg:tt)+) => ({
+        log::error!(target: $target, $($arg)+)
+    });
+
+    ($($arg:tt)+) => (log::error!(target: <Self as libclide::log::Loggable>::ID, $($arg)+))
+}
+
+#[macro_export]
+macro_rules! trace {
+    (target: $target:expr, $($arg:tt)+) => ({
+        log::trace!(target: $target, $($arg)+)
+    });
+
+    ($($arg:tt)+) => (log::trace!(target: <Self as libclide::log::Loggable>::ID, $($arg)+))
+}

libclide/src/theme.rs

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

libclide/src/theme/colors.rs

@@ -0,0 +1,54 @@
+// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
+//
+// SPDX-License-Identifier: GNU General Public License v3.0 or later
+
+/// Colors shared between the TUI and GUI for the current theme.
+pub struct Colors {}
+impl Colors {
+    pub const HOVERED: &str = "#303234";
+    pub const UNHOVERED: &str = "#3c3f41";
+    pub const PRESSED: &str = "#4b4f51";
+    pub const MENUBAR: &str = "#262626";
+    pub const MENUBAR_BORDER: &str = "#575757";
+    pub const SCROLLBAR: &str = "#4b4f51";
+    pub const SCROLLBAR_ACTIVE: &str = "#4b4f51";
+    pub const SCROLLBAR_GUTTER: &str = "#3b3b3b";
+    pub const LINENUMBER: &str = "#94989b";
+    pub const ACTIVE: &str = "#d1d33f";
+    pub const INACTIVE: &str = "#FFF";
+    pub const EDITOR_BACKGROUND: &str = "#1E1F22";
+    pub const EDITOR_TEXT: &str = "#acaea3";
+    pub const EDITOR_HIGHLIGHTED_TEXT: &str = "#ccced3";
+    pub const EDITOR_HIGHLIGHT: &str = "#ccced3";
+    pub const GUTTER: &str = "#1e1f22";
+    pub const EXPLORER_HOVERED: &str = "#4c5053";
+    pub const EXPLORER_TEXT: &str = "#FFF";
+    pub const EXPLORER_TEXT_SELECTED: &str = "#262626";
+    pub const EXPLORER_BACKGROUND: &str = "#1E1F22";
+    pub const EXPLORER_FOLDER: &str = "#54585b";
+    pub const EXPLORER_FOLDER_OPEN: &str = "#393B40";
+    pub const TERMINAL_BACKGROUND: &str = "#111111";
+    pub const INFO_LOG: &str = "#C4FFFF";
+    pub const DEBUG_LOG: &str = "#9148AF";
+    pub const WARN_LOG: &str = "#C4A958";
+    pub const ERROR_LOG: &str = "#ff5555";
+    pub const TRACE_LOG: &str = "#ffaa00";
+
+    /// Converts a CSS hex color string (e.g., "#RRGGBB" or "#RGB") to u32 in 0x00RRGGBB format.
+    pub fn css_to_u32(css: &str) -> u32 {
+        let hex = css.trim_start_matches('#');
+        // Expand shorthand #RGB to #RRGGBB
+        let hex_full = match hex.len() {
+            3 => hex
+                .chars()
+                .map(|c| std::iter::repeat_n(c, 2).collect::<String>())
+                .collect::<String>(),
+            6 => hex.to_string(),
+            _ => panic!("Invalid hex color length: {hex:?}"),
+        };
+        // Parse the hex string as u32, masking to ensure the top (alpha) byte is 0x00.
+        u32::from_str_radix(&hex_full, 16)
+            .map(|rgb| rgb & 0x00FF_FFFF)
+            .unwrap_or_else(|e| panic!("Failed to parse hex: {e:?}"))
+    }
+}

qml/ClideApplicationView.qml

@@ -0,0 +1,46 @@
+// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
+//
+// SPDX-License-Identifier: GNU General Public License v3.0 or later
+
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Layouts
+
+import clide.module 1.0
+import Logger 1.0
+
+SplitView {
+    id: root
+
+    // Path to the directory of the project opened in clide.
+    required property string projectDir
+
+    anchors.fill: parent
+
+    // Customized handle to drag between the Navigation and the Editor.
+    handle: ClideHandle {
+        hovered: SplitHandle.hovered
+        pressed: SplitHandle.pressed
+    }
+
+    ClideExplorerView {
+        SplitView.fillHeight: true
+        SplitView.preferredWidth: 200
+        projectDir: root.projectDir
+
+        // Open files when clicked in the explorer.
+        onFileClicked: path => {
+            Logger.trace("Setting editor path from ClideExplorerView signal: " + path)
+            clideEditorView.filePath = path;
+        }
+    }
+    ClideEditorView {
+        id: clideEditorView
+
+        SplitView.fillHeight: true
+        SplitView.fillWidth: true
+        // Provide a path to the file currently open in the text editor.
+        // Initialized using the Default trait in Rust QML singleton FileSystem.
+        filePath: FileSystem.filePath
+    }
+}

qml/ClideEditor.qml

@@ -1,136 +0,0 @@
-// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
-//
-// SPDX-License-Identifier: GNU General Public License v3.0 or later
-
-import QtQuick
-import QtQuick.Controls
-import QtQuick.Layouts
-
-import clide.module 1.0
-import Logger 1.0
-
-RowLayout {
-    // We use a flickable to synchronize the position of the editor and
-    // the line numbers. This is necessary because the line numbers can
-    // extend the available height.
-    Flickable {
-        id: lineNumbers
-
-        Layout.fillHeight: true
-        Layout.fillWidth: false
-        // Calculating the width correctly is important as the number grows.
-        // We need to ensure space required to show N line number digits.
-        // We use log10 to find how many digits are needed in a line number.
-        // log10(9) ~= .95; log10(10) = 1.0; log10(100) = 2.0  ...etc
-        // We +1 to ensure space for at least 1 digit, as floor(1.95) = 1.
-        // The +10 is additional spacing and can be adjusted.
-        Layout.preferredWidth: fontMetrics.averageCharacterWidth * (Math.floor(Math.log10(textArea.lineCount)) + 1) + 10
-        contentY: editorFlickable.contentY
-        interactive: false
-
-        Column {
-            anchors.fill: parent
-            topPadding: textArea.topPadding
-
-            Repeater {
-                id: repeatedLineNumbers
-
-                // TODO: Bug where text wrapping shows as new line number.
-                model: textArea.lineCount
-
-                // This Item is used for each line number in the gutter.
-                delegate: Item {
-                    required property int index
-
-                    // Calculates the height of each line in the text area.
-                    height: textArea.contentHeight / textArea.lineCount
-                    width: parent.width
-
-                    // Show the line number.
-                    Label {
-                        id: numbers
-
-                        color: RustColors.linenumber
-                        font: textArea.font
-                        height: parent.height
-                        horizontalAlignment: Text.AlignLeft
-                        text: parent.index + 1
-                        verticalAlignment: Text.AlignVCenter
-                        width: parent.width - indicator.width
-
-                        background: Rectangle {
-                            color: RustColors.terminal_background
-                        }
-                    }
-                    // Draw edge along the right side of the line number.
-                    Rectangle {
-                        id: indicator
-
-                        anchors.left: numbers.right
-                        color: RustColors.linenumber
-                        height: parent.height
-                        width: 1
-                    }
-                }
-            }
-        }
-    }
-    Flickable {
-        id: editorFlickable
-
-        Layout.fillHeight: true
-        Layout.fillWidth: true
-        boundsBehavior: Flickable.StopAtBounds
-        height: 650
-
-        ScrollBar.horizontal: ClideScrollBar {
-        }
-        ScrollBar.vertical: ClideScrollBar {
-        }
-        TextArea.flickable: TextArea {
-            id: textArea
-
-            antialiasing: true
-            focus: true
-            persistentSelection: true
-            selectByMouse: true
-            selectedTextColor: RustColors.editor_highlighted_text
-            selectionColor: RustColors.editor_highlight
-            text: FileSystem.readFile(root.filePath)
-            textFormat: Qt.AutoText
-            wrapMode: TextArea.Wrap
-
-            onLinkActivated: function (link) {
-                Qt.openUrlExternally(link);
-            }
-
-            // TODO: Handle saving
-            // Component.onCompleted: {
-            //     if (Qt.application.arguments.length === 2)
-            //         textDocument.source = "file:" + Qt.application.arguments[1]
-            //     else
-            //         textDocument.source = "qrc:/texteditor.html"
-            // }
-            // textDocument.onStatusChanged: {
-            //     // a message lookup table using computed properties:
-            //     // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer
-            //     const statusMessages = {
-            //         [ TextDocument.ReadError ]: qsTr("Failed to load “%1”"),
-            //         [ TextDocument.WriteError ]: qsTr("Failed to save “%1”"),
-            //         [ TextDocument.NonLocalFileError ]: qsTr("Not a local file: “%1”"),
-            //     }
-            //     const err = statusMessages[textDocument.status]
-            //     if (err) {
-            //         errorDialog.text = err.arg(textDocument.source)
-            //         errorDialog.open()
-            //     }
-            // }
-        }
-
-        FontMetrics {
-            id: fontMetrics
-
-            font: textArea.font
-        }
-    }
-}

qml/ClideEditorView.qml

@@ -9,38 +9,41 @@ import QtQuick.Layouts
 import clide.module 1.0
 import Logger 1.0
 
-SplitView {
+Rectangle {
     id: root
 
     // The path to the file to show in the text editor.
-    // This is updated by a signal caught within ClideProjectView.
-    // Initialized by the Default trait for the Rust QML singleton FileSystem.
+    // This is updated by a signal caught within ClideApplicationView.
     required property string filePath
 
-    Layout.fillHeight: true
-    Layout.fillWidth: true
-    orientation: Qt.Vertical
+    clip: true
+    color: "transparent"
+    radius: 20
 
-    // Customized handle to drag between the Editor and the Console.
-    handle: ClideHandle {
-        pressed: SplitHandle.pressed
-        hovered: SplitHandle.hovered
-    }
+    SplitView {
+        anchors.fill: parent
+        orientation: Qt.Vertical
+        spacing: 3
 
-    Component.onCompleted: {
-        // Show logging is working.
-        Logger.info("Info logs");
-        Logger.warn("Warning logs");
-        Logger.debug("Debug logs");
-        Logger.error("Error logs");
-        Logger.trace("Trace logs");
-    }
+        // Customized handle to drag between the Editor and the Console.
+        handle: ClideHandle {
+            hovered: SplitHandle.hovered
+            pressed: SplitHandle.pressed
+        }
 
-    ClideEditor{
-        id: clideEditor
-    }
-    ClideLogger {
-        id: areaConsole
+        Component.onCompleted: {
+            // Show logging is working.
+            Logger.info("Info logs");
+            Logger.warn("Warning logs");
+            Logger.debug("Debug logs");
+            Logger.error("Error logs");
+            Logger.trace("Trace logs");
+        }
 
+        ClideEditor {
+            SplitView.preferredHeight: 650
+        }
+        ClideLogger {
+        }
     }
 }

qml/ClideExplorerView.qml

@@ -0,0 +1,62 @@
+// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
+//
+// SPDX-License-Identifier: GNU General Public License v3.0 or later
+
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Layouts
+
+import clide.module 1.0
+import Logger 1.0
+
+Rectangle {
+    id: root
+
+    required property string projectDir
+
+    signal fileClicked(string path)
+
+    clip: true
+    color: RustColors.explorer_background
+    topLeftRadius: 10
+
+    ColumnLayout {
+        anchors.fill: parent
+        spacing: 5
+
+        ClideBreadCrumbs {
+            id: breadCrumb
+
+            Layout.fillWidth: true
+            Layout.leftMargin: 15
+            Layout.rightMargin: 15
+            Layout.topMargin: 10
+            path: clideTreeView.rootDirectory
+
+            onCrumbClicked: path => {
+                Logger.trace("Crumb clicked: " + path);
+                clideTreeView.rootDirectory = path;
+            }
+            onResetRoot: {
+                clideTreeView.rootDirectory = clideTreeView.originalRootDirectory;
+            }
+        }
+        ClideTreeView {
+            id: clideTreeView
+
+            Layout.fillHeight: true
+            Layout.fillWidth: true
+
+            // Path to the directory opened in the file explorer.
+            originalRootDirectory: root.projectDir
+            rootDirectory: root.projectDir
+
+            // Pass the signal to the parent component using another signal.
+            onFileClicked: path => root.fileClicked(path)
+            onRootDirectoryChanged: {
+                Logger.log("Setting root directory: " + clideTreeView.rootDirectory);
+                breadCrumb.path = clideTreeView.rootDirectory;
+            }
+        }
+    }
+}

qml/ClideProjectView.qml

@@ -1,92 +0,0 @@
-// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
-//
-// SPDX-License-Identifier: GNU General Public License v3.0 or later
-
-import QtQuick
-import QtQuick.Controls
-import QtQuick.Layouts
-
-import clide.module 1.0
-import Logger 1.0
-
-SplitView {
-    id: root
-
-    // Path to the directory of the project opened in clide.
-    required property string projectDir
-
-    Layout.fillHeight: true
-    Layout.fillWidth: true
-    anchors.fill: parent
-
-    // Customized handle to drag between the Navigation and the Editor.
-    handle: Rectangle {
-        id: verticalSplitHandle
-
-        border.color: SplitHandle.pressed ? RustColors.pressed : SplitHandle.hovered ? RustColors.hovered : RustColors.gutter
-        color: SplitHandle.pressed ? RustColors.pressed : SplitHandle.hovered ? RustColors.hovered : RustColors.gutter
-        implicitWidth: 8
-        radius: 2.5
-
-        // Execute these behaviors when the color is changed.
-        Behavior on color {
-            ColorAnimation {
-                duration: 400
-            }
-        }
-    }
-
-    Rectangle {
-        id: navigationView
-
-        SplitView.fillHeight: true
-        SplitView.maximumWidth: 250
-        SplitView.minimumWidth: 0
-        SplitView.preferredWidth: 200
-        color: RustColors.explorer_background
-        radius: 20
-
-        ColumnLayout {
-            spacing: 2
-
-            ClideBreadCrumbs {
-                id: breadCrumb
-
-                Layout.bottomMargin: 5
-                Layout.leftMargin: 15
-                Layout.topMargin: 5
-                path: clideTreeView.rootDirectory
-
-                onCrumbClicked: path => {
-                    Logger.trace("Crumb clicked: " + path);
-                    clideTreeView.rootDirectory = path;
-                }
-            }
-            ClideTreeView {
-                id: clideTreeView
-
-                height: navigationView.height
-
-                // Path to the directory opened in the file explorer.
-                originalRootDirectory: root.projectDir
-                rootDirectory: root.projectDir
-                width: navigationView.width
-
-                onFileClicked: path => clideEditor.filePath = path
-                onRootDirectoryChanged: {
-                    Logger.log("Setting root directory: " + clideTreeView.rootDirectory);
-                    breadCrumb.path = clideTreeView.rootDirectory;
-                }
-            }
-        }
-    }
-    ClideEditorView {
-        id: clideEditor
-
-        SplitView.fillWidth: true
-
-        // Provide a path to the file currently open in the text editor.
-        // Initialized using the Default trait in Rust QML singleton FileSystem.
-        filePath: FileSystem.filePath
-    }
-}

qml/ClideTreeView.qml

@@ -10,38 +10,30 @@ import clide.module 1.0
 import Logger 1.0
 
 TreeView {
-    id: fileSystemTreeView
+    id: root
 
     property int lastIndex: -1
     required property string originalRootDirectory
     property string rootDirectory
+    property int rootIndent: 25
 
     signal fileClicked(string filePath)
 
     boundsBehavior: Flickable.StopAtBounds
     boundsMovement: Flickable.StopAtBounds
     clip: true
-    leftMargin: 25
+
+    // The model is implemented in filesystem.rs
     model: FileSystem
-    rootIndex: FileSystem.setDirectory(fileSystemTreeView.rootDirectory)
+    // Set the root directory on the Rust model, returning the QModeIndex to use for the root of the tree view widget.
+    rootIndex: FileSystem.setDirectory(root.rootDirectory)
 
     // Provide our own custom ScrollIndicator for the TreeView.
-    ScrollIndicator.vertical: ScrollIndicator {
-        active: true
-        implicitWidth: 15
-
-        contentItem: Rectangle {
-            color: RustColors.scrollbar
-            implicitHeight: 6
-            implicitWidth: 6
-            opacity: fileSystemTreeView.movingVertically ? 0.5 : 0.0
-
-            Behavior on opacity {
-                OpacityAnimator {
-                    duration: 500
-                }
-            }
-        }
+    ScrollBar.horizontal: ClideScrollBar {
+        sizeModifier: 3
+    }
+    ScrollBar.vertical: ClideScrollBar {
+        sizeModifier: 3
     }
 
     // The delegate represents a single entry in the filesystem.
@@ -53,38 +45,40 @@ TreeView {
         required property int index
 
         implicitHeight: 25
-        implicitWidth: fileSystemTreeView.width > 0 ? fileSystemTreeView.width : 250
+        implicitWidth: root.width
         indentation: 12
 
         background: Rectangle {
             color: current ? RustColors.explorer_folder_open : "transparent"
-            radius: 2.5
+            radius: 20
+            width: root.width
         }
+        // Item name.
         contentItem: Text {
-            anchors.left: directoryIcon.right
+            anchors.left: itemIcon.right
             anchors.leftMargin: 5
             color: RustColors.explorer_text
             text: treeDelegate.fileName
         }
+        // Item Icon.
         indicator: Label {
-            id: directoryIcon
+            id: itemIcon
 
             anchors.verticalCenter: parent.verticalCenter
             antialiasing: true
+            enabled: false
+            focus: false
             font.family: localFont.font.family
             font.pixelSize: 18
             smooth: true
-            text: fileSystemTreeView.model.icon(filePath)
-            x: treeDelegate.leftMargin + (treeDelegate.depth * treeDelegate.indentation) + (indicator.visible ? indicator.width : 0)
+            // Get the icon from Rust implementation.
+            text: root.model.icon(filePath)
+            x: root.rootIndent + (treeDelegate.depth * treeDelegate.indentation) + (carrotIndicator.visible ? carrotIndicator.width : 0)
         }
 
-        FontLoader {
-            id: localFont
-
-            source: "qrc:/fonts/saucecodepro-xlight.ttf"
-        }
+        // Directory carrot indicator.
         Label {
-            id: indicator
+            id: carrotIndicator
 
             anchors.verticalCenter: parent.verticalCenter
             font.family: localFont.font.family
@@ -92,12 +86,11 @@ TreeView {
             font.weight: localFont.font.weight
             text: expanded ? "⮟" : "⮞"
             visible: isTreeNode && hasChildren
-            x: padding + (depth * indentation)
+            x: (root.rootIndent - implicitWidth) + (depth * indentation)
         }
+        // Apply colorization effects to the icon for the item.
         MultiEffect {
-            id: iconOverlay
-
-            anchors.fill: directoryIcon
+            anchors.fill: itemIcon
             brightness: 1.0
             colorization: 1.0
             colorizationColor: {
@@ -110,7 +103,7 @@ TreeView {
                 else
                     return RustColors.explorer_folder;
             }
-            source: directoryIcon
+            source: itemIcon
         }
         HoverHandler {
             id: hoverHandler
@@ -124,10 +117,10 @@ TreeView {
                 switch (button) {
                 case Qt.LeftButton:
                     if (treeDelegate.hasChildren) {
-                        fileSystemTreeView.toggleExpanded(treeDelegate.row);
+                        root.toggleExpanded(treeDelegate.row);
                     } else {
                         // If this model item doesn't have children, it means it's representing a file.
-                        fileSystemTreeView.fileClicked(treeDelegate.filePath);
+                        root.fileClicked(treeDelegate.filePath);
                     }
                     break;
                 case Qt.RightButton:
@@ -146,7 +139,7 @@ TreeView {
 
                     onTriggered: {
                         Logger.debug("Setting new root directory: " + treeDelegate.filePath);
-                        fileSystemTreeView.rootDirectory = treeDelegate.filePath;
+                        root.rootDirectory = treeDelegate.filePath;
                     }
                 }
             }
@@ -155,8 +148,8 @@ TreeView {
                     text: qsTr("Reset root")
 
                     onTriggered: {
-                        Logger.log("Resetting root directory: " + fileSystemTreeView.originalRootDirectory);
-                        fileSystemTreeView.rootDirectory = fileSystemTreeView.originalRootDirectory;
+                        Logger.log("Resetting root directory: " + root.originalRootDirectory);
+                        root.rootDirectory = root.originalRootDirectory;
                     }
                 }
             }
@@ -164,4 +157,10 @@ TreeView {
     }
     selectionModel: ItemSelectionModel {
     }
+
+    FontLoader {
+        id: localFont
+
+        source: "qrc:/fonts/saucecodepro-xlight.ttf"
+    }
 }

qml/Components/ClideBreadCrumbs.qml

@@ -1,3 +1,7 @@
+// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
+//
+// SPDX-License-Identifier: GNU General Public License v3.0 or later
+
 import QtQuick 2.15
 import QtQuick.Controls 2.15
 import QtQuick.Layouts 1.15
@@ -5,7 +9,7 @@ import QtQuick.Layouts 1.15
 import clide.module 1.0
 import Logger 1.0
 
-Item {
+Rectangle {
     id: root
 
     property var fullPaths: []
@@ -13,36 +17,30 @@ Item {
     property var segments: []
 
     signal crumbClicked(string path)
+    signal resetRoot
 
-    function rebuildSegments() {
-        var cleaned = path;
+    function rebuildSegments(): string {
+        let cleaned = path;
         if (cleaned.endsWith("/"))
             cleaned = cleaned.slice(0, -1);
-        var parts = cleaned.split("/");
-        root.segments = [];
-        root.fullPaths = [];
-        var current = "";
         Logger.trace("Building segments for path: " + cleaned);
-        for (var i = 0; i < parts.length; ++i) {
-            if (parts[i] === "") {
-                current = "/";
-                root.segments.push("/");
-                root.fullPaths.push("/");
-            } else {
-                if (current === "/")
-                    current += parts[i];
-                else
-                    current += "/" + parts[i];
-                Logger.trace("Pushing path: " + parts[i] + " Current: " + current);
-                root.segments.push(parts[i]);
-                root.fullPaths.push(current);
-            }
+        segments = ["/"];
+        fullPaths = ["/"];
+        let parts = cleaned.split("/");
+        let current = "";
+        // We already pushed the root `/` path during initialization, so skip index 0.
+        for (let i = 1; i < parts.length; ++i) {
+            current += "/" + parts[i];
+            Logger.trace("Pushing path: " + parts[i] + " Current: " + current);
+            segments.push(parts[i]);
+            fullPaths.push(current);
         }
-        rep.model = root.segments;
+        // Update the model used in the Repeater to show the new segments.
+        repeater.model = segments;
     }
 
-    anchors.leftMargin: 20
-    height: breadcrumbRow.implicitHeight
+    color: "transparent"
+    implicitHeight: breadcrumbRow.implicitHeight
     width: parent.width
 
     Component.onCompleted: rebuildSegments()
@@ -51,28 +49,32 @@ Item {
     Flow {
         id: breadcrumbRow
 
+        anchors.fill: parent
+        spacing: 2
+        width: parent.width
+
         Repeater {
-            id: rep
+            id: repeater
 
             model: root.segments
 
             delegate: Text {
-                id: linkText
-
+                required property int index
                 required property string modelData
 
-                function getText() {
+                function getText(): string {
                     if (modelData === "/") {
                         return modelData;
                     }
-                    Logger.trace("Getting valid text:" + modelData);
                     return modelData + "/";
                 }
 
+                // Show blue underlined hyperlink text if the mouse is hovering a segment.
                 color: mouseArea.containsMouse ? "#2a7fff" : RustColors.explorer_text
                 font.underline: mouseArea.containsMouse
                 text: getText()
 
+                // Click events for each path segment call signal so the parent can set the file explorer root path.
                 MouseArea {
                     id: mouseArea
 
@@ -80,8 +82,8 @@ Item {
                     hoverEnabled: true
 
                     onClicked: {
-                        console.log("Breadcrumb clicked:", root.fullPaths[root.segments.indexOf(modelData)]);
-                        root.crumbClicked(root.fullPaths[root.segments.indexOf(modelData)]);
+                        Logger.info(index + "] Breadcrumb clicked:" + root.fullPaths[index]);
+                        crumbClicked(root.fullPaths[index]);
                     }
                 }
             }
@@ -90,7 +92,7 @@ Item {
     TapHandler {
         acceptedButtons: Qt.RightButton
 
-        onSingleTapped: (eventPoint, button) => contextMenu.popup()
+        onSingleTapped: contextMenu.popup()
     }
     ClideMenu {
         id: contextMenu
@@ -100,8 +102,8 @@ Item {
                 text: qsTr("Reset root")
 
                 onTriggered: {
-                    Logger.log("Resetting root directory: " + clideTreeView.originalRootDirectory);
-                    clideTreeView.rootDirectory = clideTreeView.originalRootDirectory;
+                    Logger.info("Resetting root directory from ClideBreadCrumbs");
+                    resetRoot();
                 }
             }
         }

qml/Components/ClideEditor.qml

@@ -0,0 +1,116 @@
+// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
+//
+// SPDX-License-Identifier: GNU General Public License v3.0 or later
+
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Layouts
+
+import clide.module 1.0
+import Logger 1.0
+
+Rectangle {
+    color: RustColors.editor_background
+
+    RowLayout {
+        anchors.fill: parent
+
+        // We use a flickable to synchronize the position of the editor and
+        // the line numbers. This is necessary because the line numbers can
+        // extend the available height.
+        Flickable {
+            id: lineNumbers
+
+            Layout.fillHeight: true
+            Layout.fillWidth: false
+            // Calculating the width correctly is important as the number grows.
+            // We need to ensure space required to show N line number digits.
+            // We use log10 to find how many digits are needed in a line number.
+            // log10(9) ~= .95; log10(10) = 1.0; log10(100) = 2.0  ...etc
+            // We +1 to ensure space for at least 1 digit, as floor(1.95) = 1.
+            // The +10 is additional spacing and can be adjusted.
+            Layout.preferredWidth: fontMetrics.averageCharacterWidth * (Math.floor(Math.log10(textArea.lineCount)) + 1) + 10
+            contentY: editorFlickable.contentY
+            interactive: false
+
+            Column {
+                anchors.fill: parent
+                topPadding: textArea.topPadding
+
+                Repeater {
+                    id: repeatedLineNumbers
+
+                    // TODO: Bug where text wrapping shows as new line number.
+                    model: textArea.lineCount
+
+                    // This Item is used for each line number in the gutter.
+                    delegate: Item {
+                        required property int index
+
+                        // Calculates the height of each line in the text area.
+                        height: textArea.contentHeight / textArea.lineCount
+                        width: parent.width
+
+                        // Show the line number.
+                        Label {
+                            id: numbers
+
+                            color: RustColors.linenumber
+                            font: textArea.font
+                            height: parent.height
+                            horizontalAlignment: Text.AlignLeft
+                            text: parent.index + 1
+                            verticalAlignment: Text.AlignVCenter
+                            width: parent.width - indicator.width
+                        }
+                        // Draw an edge along the right side of the line number.
+                        Rectangle {
+                            id: indicator
+
+                            anchors.left: numbers.right
+                            color: RustColors.linenumber
+                            height: parent.height
+                            width: 1
+                        }
+                    }
+                }
+            }
+        }
+        Flickable {
+            id: editorFlickable
+
+            Layout.fillHeight: true
+            Layout.fillWidth: true
+            boundsBehavior: Flickable.StopAtBounds
+            height: 650
+
+            ScrollBar.horizontal: ClideScrollBar {
+            }
+            ScrollBar.vertical: ClideScrollBar {
+            }
+            TextArea.flickable: TextArea {
+                id: textArea
+
+                antialiasing: true
+                focus: true
+                persistentSelection: true
+                selectByMouse: true
+                selectedTextColor: RustColors.editor_highlighted_text
+                selectionColor: RustColors.editor_highlight
+                text: FileSystem.readFile(root.filePath)
+                textFormat: Qt.AutoText
+                wrapMode: TextArea.Wrap
+
+                onLinkActivated: function (link) {
+                    Qt.openUrlExternally(link);
+                }
+            }
+
+            FontMetrics {
+                id: fontMetrics
+
+                font: textArea.font
+            }
+        }
+    }
+}

qml/Components/ClideHandle.qml

@@ -16,7 +16,7 @@ Rectangle {
         } else if (hovered) {
             return RustColors.hovered;
         } else {
-            return "black";
+            return "transparent";
         }
     }
     required property bool hovered
@@ -25,6 +25,7 @@ Rectangle {
     border.color: currentColor
     color: currentColor
     implicitHeight: 8
+    implicitWidth: 8
     radius: 2.5
     opacity: root.hovered ? 1.0 : 0.0
 

qml/Components/ClideLogger.qml

@@ -8,15 +8,14 @@ import QtQuick.Controls
 import clide.module 1.0
 import Logger 1.0
 
-Item {
+Rectangle {
+    color: RustColors.terminal_background
+    radius: 10
+
     ListModel {
         id: model
 
     }
-    Rectangle {
-        anchors.fill: parent
-        color: "#111"
-    }
     ListView {
         id: listView
 
@@ -38,7 +37,6 @@ Item {
         }
 
         anchors.fill: parent
-        clip: true
         model: model
 
         delegate: Text {

qml/Components/ClideMenu.qml

@@ -1,3 +1,7 @@
+// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
+//
+// SPDX-License-Identifier: GNU General Public License v3.0 or later
+
 import QtQuick
 import QtQuick.Controls.Basic
 

qml/Components/ClideMenuBar.qml

@@ -11,7 +11,6 @@ MenuBar {
     // Background for this MenuBar.
     background: Rectangle {
         color: RustColors.menubar
-        radius: 20.0
     }
 
     //

qml/Components/ClideMenuItem.qml

@@ -1,3 +1,7 @@
+// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
+//
+// SPDX-License-Identifier: GNU General Public License v3.0 or later
+
 import QtQuick
 import QtQuick.Controls.Basic
 

qml/Components/ClideScrollBar.qml

@@ -11,9 +11,10 @@ ScrollBar {
     id: scrollBar
 
     // Height, opacitiy, width
-    property int h: scrollBar.interactive ? 4 * 2 : 4
+    property int h: scrollBar.interactive ? sizeModifier * 2 : sizeModifier
     property int o: scrollBar.active && scrollBar.size < 1.0 ? 1.0 : 0.0
-    property int w: scrollBar.interactive ? 4 * 2 : 4
+    property int sizeModifier: 4
+    property int w: scrollBar.interactive ? sizeModifier * 2 : sizeModifier
 
     // Scroll bar gutter
     background: Rectangle {
@@ -25,6 +26,7 @@ ScrollBar {
 
         // Fade the scrollbar gutter when inactive.
         opacity: scrollBar.o
+        radius: 20
 
         Behavior on opacity {
             OpacityAnimator {
@@ -55,6 +57,7 @@ ScrollBar {
 
         // Fade the scrollbar when inactive.
         opacity: scrollBar.o
+        radius: 20
 
         // Smooth transition between color changes based on the state above.
         Behavior on color {

qml/Components/qmldir

@@ -3,3 +3,7 @@ ClideHandle ClideHandle.qml
 ClideMenu ClideMenu.qml
 ClideMenuItem ClideMenuItem.qml
 ClideBreadCrumbs ClideBreadCrumbs.qml
+ClideAboutWindow ClideAboutWindow.qml
+ClideEditor ClideEditor.qml
+ClideLogger ClideLogger.qml
+ClideMenuBar ClideMenuBar.qml

qml/main.qml

@@ -15,22 +15,29 @@ ApplicationWindow {
     required property string appContextPath
 
     height: 800
-    title: "CLIDE"
+    title: "Clide"
     visible: true
     width: 1200
 
     menuBar: ClideMenuBar {
     }
 
-    MessageDialog {
-        id: errorDialog
+    Rectangle {
+        color: RustColors.menubar
+        width: appView.implicitWidth
+        height: appView.implicitHeight
 
-        title: qsTr("Error")
-    }
-    ClideProjectView {
-        id: clideProjectView
+        ClideApplicationView {
+            id: appView
+            projectDir: appWindow.appContextPath
+            implicitHeight: appWindow.height
+            implicitWidth: appWindow.width
 
-        projectDir: appWindow.appContextPath
+            anchors.right: parent.right
+            anchors.bottom: parent.bottom
+            anchors.leftMargin: 20
+            anchors.topMargin: 10
+        }
     }
 }
 

src/gui.rs

@@ -5,13 +5,12 @@
 use crate::AppContext;
 use anyhow::Result;
 use cxx_qt_lib::{QMapPair, QMapPair_QString_QVariant, QString, QVariant};
-use log::trace;
 
 pub mod colors;
 pub mod filesystem;
 
 pub fn run(app_context: AppContext) -> Result<()> {
-    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,10 @@
 //
 // SPDX-License-Identifier: GNU General Public License v3.0 or later
 
-#[cxx_qt::bridge]
+use cxx_qt_lib::QColor;
+use libclide::theme::colors::Colors;
 
+#[cxx_qt::bridge]
 pub mod qobject {
     unsafe extern "C++" {
         include!("cxx-qt-lib/qcolor.h");
@@ -46,8 +48,6 @@ pub mod qobject {
     }
 }
 
-use cxx_qt_lib::QColor;
-
 pub struct RustColorsImpl {
     hovered: QColor,
     unhovered: QColor,
@@ -82,34 +82,34 @@ pub struct RustColorsImpl {
 impl Default for RustColorsImpl {
     fn default() -> Self {
         Self {
-            hovered: QColor::try_from("#303234").unwrap(),
-            unhovered: QColor::try_from("#3c3f41").unwrap(),
-            pressed: QColor::try_from("#4b4f51").unwrap(),
-            menubar: QColor::try_from("#262626").unwrap(),
-            menubar_border: QColor::try_from("#575757").unwrap(),
-            scrollbar: QColor::try_from("#4b4f51").unwrap(),
-            scrollbar_active: QColor::try_from("#4b4f51").unwrap(),
-            scrollbar_gutter: QColor::try_from("#3b3b3b").unwrap(),
-            linenumber: QColor::try_from("#94989b").unwrap(),
-            active: QColor::try_from("#a9acb0").unwrap(),
-            inactive: QColor::try_from("#FFF").unwrap(),
-            editor_background: QColor::try_from("#111111").unwrap(),
-            editor_text: QColor::try_from("#acaea3").unwrap(),
-            editor_highlighted_text: QColor::try_from("#ccced3").unwrap(),
-            editor_highlight: QColor::try_from("#ccced3").unwrap(),
-            gutter: QColor::try_from("#1e1f22").unwrap(),
-            explorer_hovered: QColor::try_from("#4c5053").unwrap(),
-            explorer_text: QColor::try_from("#FFF").unwrap(),
-            explorer_text_selected: QColor::try_from("#262626").unwrap(),
-            explorer_background: QColor::try_from("#1E1F22").unwrap(),
-            explorer_folder: QColor::try_from("#54585b").unwrap(),
-            explorer_folder_open: QColor::try_from("#393B40").unwrap(),
-            terminal_background: QColor::try_from("#111111").unwrap(),
-            info_log: QColor::try_from("#C4FFFF").unwrap(),
-            debug_log: QColor::try_from("#9148AF").unwrap(),
-            warn_log: QColor::try_from("#C4A958").unwrap(),
-            error_log: QColor::try_from("#ff5555").unwrap(),
-            trace_log: QColor::try_from("#ffaa00").unwrap(),
+            hovered: QColor::try_from(Colors::HOVERED).unwrap(),
+            unhovered: QColor::try_from(Colors::UNHOVERED).unwrap(),
+            pressed: QColor::try_from(Colors::PRESSED).unwrap(),
+            menubar: QColor::try_from(Colors::MENUBAR).unwrap(),
+            menubar_border: QColor::try_from(Colors::MENUBAR_BORDER).unwrap(),
+            scrollbar: QColor::try_from(Colors::SCROLLBAR).unwrap(),
+            scrollbar_active: QColor::try_from(Colors::SCROLLBAR_ACTIVE).unwrap(),
+            scrollbar_gutter: QColor::try_from(Colors::SCROLLBAR_GUTTER).unwrap(),
+            linenumber: QColor::try_from(Colors::LINENUMBER).unwrap(),
+            active: QColor::try_from(Colors::ACTIVE).unwrap(),
+            inactive: QColor::try_from(Colors::INACTIVE).unwrap(),
+            editor_background: QColor::try_from(Colors::EDITOR_BACKGROUND).unwrap(),
+            editor_text: QColor::try_from(Colors::EDITOR_TEXT).unwrap(),
+            editor_highlighted_text: QColor::try_from(Colors::EDITOR_HIGHLIGHTED_TEXT).unwrap(),
+            editor_highlight: QColor::try_from(Colors::EDITOR_HIGHLIGHT).unwrap(),
+            gutter: QColor::try_from(Colors::GUTTER).unwrap(),
+            explorer_hovered: QColor::try_from(Colors::EXPLORER_HOVERED).unwrap(),
+            explorer_text: QColor::try_from(Colors::EXPLORER_TEXT).unwrap(),
+            explorer_text_selected: QColor::try_from(Colors::EXPLORER_TEXT_SELECTED).unwrap(),
+            explorer_background: QColor::try_from(Colors::EXPLORER_BACKGROUND).unwrap(),
+            explorer_folder: QColor::try_from(Colors::EXPLORER_FOLDER).unwrap(),
+            explorer_folder_open: QColor::try_from(Colors::EXPLORER_FOLDER_OPEN).unwrap(),
+            terminal_background: QColor::try_from(Colors::TERMINAL_BACKGROUND).unwrap(),
+            info_log: QColor::try_from(Colors::INFO_LOG).unwrap(),
+            debug_log: QColor::try_from(Colors::DEBUG_LOG).unwrap(),
+            warn_log: QColor::try_from(Colors::WARN_LOG).unwrap(),
+            error_log: QColor::try_from(Colors::ERROR_LOG).unwrap(),
+            trace_log: QColor::try_from(Colors::TRACE_LOG).unwrap(),
         }
     }
 }

src/gui/filesystem.rs

@@ -3,16 +3,12 @@
 // SPDX-License-Identifier: GNU General Public License v3.0 or later
 
 use cxx_qt_lib::{QModelIndex, QString};
-use devicons::FileIcon;
 use dirs;
-use log::warn;
 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, start_highlighted_html_snippet,
-};
+use syntect::html::{IncludeBackground, append_highlighted_html_for_styled_line};
 use syntect::parsing::SyntaxSet;
 use syntect::util::LinesWithEndings;
 
@@ -59,7 +55,6 @@ pub mod qobject {
     }
 }
 
-// TODO: Implement a provider for QFileSystemModel::setIconProvider for icons.
 pub struct FileSystemImpl {
     file_path: QString,
 }
@@ -79,9 +74,9 @@ impl qobject::FileSystem {
             return QString::default();
         }
         let meta = fs::metadata(path.to_string())
-            .expect(format!("Failed to get file metadata {path:?}").as_str());
+            .unwrap_or_else(|_| panic!("Failed to get file metadata {path:?}"));
         if !meta.is_file() {
-            warn!(target:"FileSystem", "Attempted to open file {path:?} that is not a valid file");
+            libclide::warn!(target:"FileSystem", "Attempted to open file {path:?} that is not a valid file");
             return QString::default();
         }
         let path_str = path.to_string();
@@ -99,7 +94,8 @@ impl qobject::FileSystem {
                 )
                 .unwrap_or_else(|| ss.find_syntax_plain_text());
             let mut highlighter = HighlightLines::new(lang, theme);
-            let (mut output, _bg) = start_highlighted_html_snippet(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)
@@ -116,7 +112,7 @@ impl qobject::FileSystem {
             output.push_str("</pre>\n");
             QString::from(output)
         } else {
-            return QString::default();
+            QString::default()
         }
     }
 
@@ -128,7 +124,7 @@ impl qobject::FileSystem {
     fn set_directory(self: std::pin::Pin<&mut Self>, path: &QString) -> QModelIndex {
         if !path.is_empty()
             && fs::metadata(path.to_string())
-                .expect(format!("Failed to get metadata for path {path:?}").as_str())
+                .unwrap_or_else(|_| panic!("Failed to get metadata for path {path:?}"))
                 .is_dir()
         {
             self.set_root_path(path)
@@ -145,13 +141,6 @@ impl qobject::FileSystem {
     }
 
     fn icon(self: std::pin::Pin<&mut Self>, path: &QString) -> QString {
-        let str = path.to_string();
-        if Path::new(&str).is_dir() {
-            // Ensures directories are given a folder icon and not mistakenly resolved to a language.
-            // For example, a directory named `cpp` would otherwise return a C++ icon.
-            return QString::from(FileIcon::from("dir/").to_string())
-        }
-        let icon = FileIcon::from(str);
-        QString::from(icon.to_string())
+        QString::from(libclide::fs::icon(path.to_string().as_str()).to_string())
     }
 }

src/main.rs

@@ -4,7 +4,6 @@
 
 use anyhow::{Context, Result, anyhow};
 use clap::Parser;
-use log::{info, trace};
 use std::process::{Command, Stdio};
 
 pub mod gui;
@@ -56,7 +55,7 @@ impl AppContext {
             // If no path was provided, use the current directory.
             None => std::env::current_dir().context("Failed to obtain current directory")?,
         };
-        info!(target:"main()", "Root path detected: {path:?}");
+        libclide::info!(target:"main()", "Root path detected: {path:?}");
 
         Ok(Self {
             path,
@@ -80,9 +79,9 @@ fn main() -> Result<()> {
         RunMode::GuiAttached => gui::run(app_context),
         RunMode::Tui => tui::run(app_context),
         RunMode::Gui => {
-            trace!(target:"main()", "Starting GUI in a new process");
+            libclide::trace!(target:"main()", "Starting GUI in a new process");
             Command::new(std::env::current_exe()?)
-                .args(&["--gui", app_context.path.to_str().unwrap()])
+                .args(["--gui", app_context.path.to_str().unwrap()])
                 .stdout(Stdio::null())
                 .stderr(Stdio::null())
                 .stdin(Stdio::null())

src/tui.rs

@@ -13,7 +13,8 @@ mod menu_bar;
 
 use crate::AppContext;
 use anyhow::{Context, Result};
-use log::{LevelFilter, debug, info, trace};
+use libclide_macros::Loggable;
+use log::LevelFilter;
 use ratatui::Terminal;
 use ratatui::backend::CrosstermBackend;
 use ratatui::crossterm::event::{
@@ -28,24 +29,22 @@ use tui_logger::{
     TuiLoggerFile, TuiLoggerLevelOutput, init_logger, set_default_level, set_log_file,
 };
 
+#[derive(Loggable)]
 struct Tui {
     terminal: Terminal<CrosstermBackend<Stdout>>,
     root_path: std::path::PathBuf,
 }
 
 pub fn run(app_context: AppContext) -> Result<()> {
-    trace!(target:Tui::ID, "Starting TUI");
+    libclide::trace!(target: "clide::tui::run", "Starting TUI");
     Tui::new(app_context)?.start()
 }
 
 impl Tui {
-    pub const ID: &str = "Tui";
-
     fn new(app_context: AppContext) -> Result<Self> {
-        trace!(target:Self::ID, "Building {}", Self::ID);
         init_logger(LevelFilter::Trace)?;
         set_default_level(LevelFilter::Trace);
-        debug!(target:Self::ID, "Logging initialized");
+        libclide::debug!("Logging initialized");
 
         let mut dir = env::temp_dir();
         dir.push("clide.log");
@@ -57,7 +56,7 @@ impl Tui {
         .output_file(false)
         .output_separator(':');
         set_log_file(file_options);
-        debug!(target:Self::ID, "Logging to file: {dir:?}");
+        libclide::debug!("Logging to file: {dir:?}");
 
         Ok(Self {
             terminal: Terminal::new(CrosstermBackend::new(stdout()))?,
@@ -66,7 +65,7 @@ impl Tui {
     }
 
     fn start(self) -> Result<()> {
-        info!(target:Self::ID, "Starting the TUI editor at {:?}", self.root_path);
+        libclide::info!("Starting the TUI editor at {:?}", self.root_path);
         ratatui::crossterm::execute!(
             stdout(),
             EnterAlternateScreen,
@@ -83,7 +82,7 @@ impl Tui {
     }
 
     fn stop() -> Result<()> {
-        info!(target:Self::ID, "Stopping the TUI editor");
+        libclide::info!("Stopping the TUI editor");
         disable_raw_mode()?;
         ratatui::crossterm::execute!(
             stdout(),

src/tui/about.rs

@@ -2,19 +2,18 @@
 //
 // SPDX-License-Identifier: GNU General Public License v3.0 or later
 
+use libclide_macros::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)]
 pub struct About {}
 
 impl About {
-    #[allow(unused)]
-    pub const ID: &str = "About";
-
     pub fn new() -> Self {
-        // trace!(target:Self::id(), "Building {}", Self::id());
+        // libclide::trace!("Building {}", Self::id());
         Self {}
     }
 }
@@ -68,8 +67,8 @@ impl Widget for About {
             .map(|l| Line::from(Span::raw(*l)))
             .collect();
 
-        Clear::default().render(kilroy_rect, buf);
-        Clear::default().render(chunks[1], buf);
+        Clear.render(kilroy_rect, buf);
+        Clear.render(chunks[1], buf);
         Paragraph::new(about_lines)
             .block(
                 Block::default()

src/tui/app.rs

@@ -3,15 +3,14 @@
 // SPDX-License-Identifier: GNU General Public License v3.0 or later
 
 use crate::tui::about::About;
-use crate::tui::app::AppComponent::{AppEditor, AppExplorer, AppLogger};
 use crate::tui::component::{Action, Component, Focus, FocusState, Visibility, VisibleState};
 use crate::tui::editor_tab::EditorTab;
 use crate::tui::explorer::Explorer;
 use crate::tui::logger::Logger;
 use crate::tui::menu_bar::MenuBar;
-use AppComponent::AppMenuBar;
 use anyhow::{Context, Result};
-use log::{error, info, trace};
+use libclide::log::Loggable;
+use libclide_macros::Loggable;
 use ratatui::DefaultTerminal;
 use ratatui::buffer::Buffer;
 use ratatui::crossterm::event;
@@ -26,12 +25,13 @@ use std::time::Duration;
 
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum AppComponent {
-    AppEditor,
-    AppExplorer,
-    AppLogger,
-    AppMenuBar,
+    Editor,
+    Explorer,
+    Logger,
+    MenuBar,
 }
 
+#[derive(Loggable)]
 pub struct App<'a> {
     editor_tab: EditorTab,
     explorer: Explorer<'a>,
@@ -42,16 +42,14 @@ pub struct App<'a> {
 }
 
 impl<'a> App<'a> {
-    pub const ID: &'static str = "App";
-
     pub fn new(root_path: PathBuf) -> Result<Self> {
-        trace!(target:Self::ID, "Building {}", Self::ID);
+        libclide::trace!("Building {}", <Self as Loggable>::ID);
         let app = Self {
             editor_tab: EditorTab::new(),
             explorer: Explorer::new(&root_path)?,
             logger: Logger::new(),
             menu_bar: MenuBar::new(),
-            last_active: AppEditor,
+            last_active: AppComponent::Editor,
             about: false,
         };
         Ok(app)
@@ -59,13 +57,13 @@ impl<'a> App<'a> {
 
     /// Logic that should be executed once on application startup.
     pub fn start(&mut self) -> Result<()> {
-        trace!(target:Self::ID, "Starting App");
+        libclide::trace!("Starting App");
         Ok(())
     }
 
     pub fn run(mut self, mut terminal: DefaultTerminal) -> Result<()> {
         self.start()?;
-        trace!(target:Self::ID, "Entering App run loop");
+        libclide::trace!("Entering App run loop");
         loop {
             terminal.draw(|f| {
                 f.render_widget(&mut self, f.area());
@@ -87,18 +85,18 @@ impl<'a> App<'a> {
     fn draw_bottom_status(&self, area: Rect, buf: &mut Buffer) {
         // Determine help text from the most recently focused component.
         let help = match self.last_active {
-            AppEditor => match self.editor_tab.current_editor() {
+            AppComponent::Editor => match self.editor_tab.current_editor() {
                 Some(editor) => editor.component_state.help_text.clone(),
                 None => {
                     if !self.editor_tab.is_empty() {
-                        error!(target:Self::ID, "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()
                 }
             },
-            AppExplorer => self.explorer.component_state.help_text.clone(),
-            AppLogger => self.logger.component_state.help_text.clone(),
-            AppMenuBar => self.menu_bar.component_state.help_text.clone(),
+            AppComponent::Explorer => self.explorer.component_state.help_text.clone(),
+            AppComponent::Logger => self.logger.component_state.help_text.clone(),
+            AppComponent::MenuBar => self.menu_bar.component_state.help_text.clone(),
         };
         Paragraph::new(
             concat!(
@@ -115,32 +113,32 @@ impl<'a> App<'a> {
     }
 
     fn clear_focus(&mut self) {
-        info!(target:Self::ID, "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 => {
-                error!(target:Self::ID, "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) {
-        info!(target:Self::ID, "Changing widget focus to {:?}", focus);
+        libclide::info!("Changing widget focus to {:?}", focus);
         self.clear_focus();
         match focus {
-            AppEditor => match self.editor_tab.current_editor_mut() {
+            AppComponent::Editor => match self.editor_tab.current_editor_mut() {
                 None => {
-                    error!(target:Self::ID, "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),
             },
-            AppExplorer => self.explorer.component_state.set_focus(Focus::Active),
-            AppLogger => self.logger.component_state.set_focus(Focus::Active),
-            AppMenuBar => self.menu_bar.component_state.set_focus(Focus::Active),
+            AppComponent::Explorer => self.explorer.component_state.set_focus(Focus::Active),
+            AppComponent::Logger => self.logger.component_state.set_focus(Focus::Active),
+            AppComponent::MenuBar => self.menu_bar.component_state.set_focus(Focus::Active),
         }
         self.last_active = focus;
     }
@@ -255,21 +253,21 @@ impl<'a> Component for App<'a> {
         }
         // Handle events for all components.
         let action = match self.last_active {
-            AppEditor => self.editor_tab.handle_event(event.clone())?,
-            AppExplorer => self.explorer.handle_event(event.clone())?,
-            AppLogger => self.logger.handle_event(event.clone())?,
-            AppMenuBar => self.menu_bar.handle_event(event.clone())?,
+            AppComponent::Editor => self.editor_tab.handle_event(event.clone())?,
+            AppComponent::Explorer => self.explorer.handle_event(event.clone())?,
+            AppComponent::Logger => self.logger.handle_event(event.clone())?,
+            AppComponent::MenuBar => self.menu_bar.handle_event(event.clone())?,
         };
 
         // Components should always handle mouse events for click interaction.
-        if let Some(mouse) = event.as_mouse_event() {
-            if mouse.kind == MouseEventKind::Down(MouseButton::Left) {
-                if let Some(editor) = self.editor_tab.current_editor_mut() {
-                    editor.handle_mouse_events(mouse)?;
-                }
-                self.explorer.handle_mouse_events(mouse)?;
-                self.logger.handle_mouse_events(mouse)?;
+        if let Some(mouse) = event.as_mouse_event()
+            && mouse.kind == MouseEventKind::Down(MouseButton::Left)
+        {
+            if let Some(editor) = self.editor_tab.current_editor_mut() {
+                editor.handle_mouse_events(mouse)?;
             }
+            self.explorer.handle_mouse_events(mouse)?;
+            self.logger.handle_mouse_events(mouse)?;
         }
 
         // Handle actions returned from widgets that may need context on other widgets or app state.
@@ -277,13 +275,15 @@ impl<'a> Component for App<'a> {
             Action::Quit | Action::Handled => Ok(action),
             Action::Save => match self.editor_tab.current_editor_mut() {
                 None => {
-                    error!(target:Self::ID, "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) => {
-                        error!(target:Self::ID, "Failed to save editor contents: {e}");
+                        libclide::error!("Failed to save editor contents: {e}");
                         Ok(Action::Noop)
                     }
                 },
@@ -302,14 +302,16 @@ impl<'a> Component for App<'a> {
                 Err(_) => Ok(Action::Noop),
             },
             Action::ReloadFile => {
-                trace!(target:Self::ID, "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 {
-                    error!(target:Self::ID, "Failed to get current editor while handling App Action::ReloadFile");
+                    libclide::error!(
+                        "Failed to get current editor while handling App Action::ReloadFile"
+                    );
                     Ok(Action::Noop)
                 }
             }
@@ -349,7 +351,7 @@ impl<'a> Component for App<'a> {
                 kind: KeyEventKind::Press,
                 state: _state,
             } => {
-                self.change_focus(AppExplorer);
+                self.change_focus(AppComponent::Explorer);
                 Ok(Action::Handled)
             }
             KeyEvent {
@@ -358,7 +360,7 @@ impl<'a> Component for App<'a> {
                 kind: KeyEventKind::Press,
                 state: _state,
             } => {
-                self.change_focus(AppEditor);
+                self.change_focus(AppComponent::Editor);
                 Ok(Action::Handled)
             }
             KeyEvent {
@@ -367,7 +369,7 @@ impl<'a> Component for App<'a> {
                 kind: KeyEventKind::Press,
                 state: _state,
             } => {
-                self.change_focus(AppLogger);
+                self.change_focus(AppComponent::Logger);
                 Ok(Action::Handled)
             }
             KeyEvent {
@@ -376,7 +378,7 @@ impl<'a> Component for App<'a> {
                 kind: KeyEventKind::Press,
                 state: _state,
             } => {
-                self.change_focus(AppMenuBar);
+                self.change_focus(AppComponent::MenuBar);
                 Ok(Action::Handled)
             }
             KeyEvent {

src/tui/component.rs

@@ -7,7 +7,8 @@
 use crate::tui::component::Focus::Inactive;
 use Focus::Active;
 use anyhow::Result;
-use log::trace;
+use libclide::theme::colors::Colors;
+use libclide_macros::Loggable;
 use ratatui::crossterm::event::{Event, KeyEvent, MouseEvent};
 use ratatui::style::Color;
 
@@ -61,7 +62,7 @@ pub trait Component {
     }
 }
 
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone, Default, Loggable)]
 pub struct ComponentState {
     pub(crate) focus: Focus,
     pub(crate) vis: Visibility,
@@ -74,7 +75,7 @@ impl ComponentState {
     }
 
     fn new() -> Self {
-        trace!(target:Self::id(), "Building {}", Self::id());
+        libclide::trace!(target:Self::id(), "Building {}", Self::id());
         Self {
             focus: Active,
             vis: Visibility::Visible,
@@ -98,8 +99,8 @@ pub enum Focus {
 impl Focus {
     pub(crate) fn get_active_color(&self) -> Color {
         match self {
-            Active => Color::LightYellow,
-            Inactive => Color::White,
+            Active => Color::from_u32(Colors::css_to_u32(Colors::ACTIVE)),
+            Inactive => Color::from_u32(Colors::css_to_u32(Colors::INACTIVE)),
         }
     }
 }

src/tui/editor.rs

@@ -7,7 +7,8 @@ use anyhow::{Context, Result, bail};
 use edtui::{
     EditorEventHandler, EditorState, EditorTheme, EditorView, LineNumbers, Lines, SyntaxHighlighter,
 };
-use log::{error, trace};
+use libclide::log::Loggable;
+use libclide_macros::Loggable;
 use ratatui::buffer::Buffer;
 use ratatui::crossterm::event::{Event, KeyCode, KeyEvent, KeyModifiers};
 use ratatui::layout::{Alignment, Rect};
@@ -16,19 +17,18 @@ use ratatui::widgets::{Block, Borders, Padding, Widget};
 use std::path::PathBuf;
 use syntect::parsing::SyntaxSet;
 
+#[derive(Loggable)]
 pub struct Editor {
     pub state: EditorState,
     pub event_handler: EditorEventHandler,
-    pub file_path: Option<std::path::PathBuf>,
+    pub file_path: Option<PathBuf>,
     syntax_set: SyntaxSet,
     pub(crate) component_state: ComponentState,
 }
 
 impl Editor {
-    pub const ID: &str = "Editor";
-
     pub fn new(path: &std::path::Path) -> Self {
-        trace!(target:Self::ID, "Building {}", Self::ID);
+        libclide::trace!("Building {}", <Self as Loggable>::ID);
         Editor {
             state: EditorState::default(),
             event_handler: EditorEventHandler::default(),
@@ -42,10 +42,10 @@ impl Editor {
     }
 
     pub fn reload_contents(&mut self) -> Result<()> {
-        trace!(target:Self::ID, "Reloading editor file contents {:?}", self.file_path);
+        libclide::trace!("Reloading editor file contents {:?}", self.file_path);
         match self.file_path.clone() {
             None => {
-                error!(target:Self::ID, "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),
@@ -53,7 +53,7 @@ impl Editor {
     }
 
     pub fn set_contents(&mut self, path: &std::path::Path) -> Result<()> {
-        trace!(target:Self::ID, "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()
@@ -69,10 +69,10 @@ impl Editor {
 
     pub fn save(&self) -> Result<()> {
         if let Some(path) = &self.file_path {
-            trace!(target:Self::ID, "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());
         };
-        error!(target:Self::ID, "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.")
     }
 }
@@ -115,9 +115,8 @@ impl Component for Editor {
     fn handle_event(&mut self, event: Event) -> Result<Action> {
         if let Some(key_event) = event.as_key_event() {
             // Handle events here that should not be passed on to the vim emulation handler.
-            match self.handle_key_events(key_event)? {
-                Action::Handled => return Ok(Action::Handled),
-                _ => {}
+            if let Action::Handled = self.handle_key_events(key_event)? {
+                return Ok(Action::Handled);
             }
         }
         self.event_handler.on_event(event, &mut self.state);

src/tui/editor_tab.rs

@@ -5,7 +5,8 @@
 use crate::tui::component::{Action, Component, Focus, FocusState};
 use crate::tui::editor::Editor;
 use anyhow::{Context, Result, anyhow};
-use log::{error, info, trace, warn};
+use libclide::log::Loggable;
+use libclide_macros::Loggable;
 use ratatui::buffer::Buffer;
 use ratatui::crossterm::event::{Event, KeyCode, KeyEvent, KeyModifiers};
 use ratatui::layout::Rect;
@@ -16,6 +17,7 @@ use std::collections::HashMap;
 // 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)]
 pub struct EditorTab {
     pub(crate) editors: HashMap<String, Editor>,
     tab_order: Vec<String>,
@@ -23,10 +25,8 @@ pub struct EditorTab {
 }
 
 impl EditorTab {
-    pub const ID: &str = "EditorTab";
-
     pub fn new() -> Self {
-        trace!(target:Self::ID, "Building {}", Self::ID);
+        libclide::trace!("Building {}", <Self as Loggable>::ID);
         Self {
             editors: HashMap::new(),
             tab_order: Vec::new(),
@@ -36,7 +36,11 @@ impl EditorTab {
 
     pub fn next_editor(&mut self) {
         let next = (self.current_editor + 1) % self.tab_order.len();
-        trace!(target:Self::ID, "Moving from {} to next editor tab at {}", self.current_editor, next);
+        libclide::trace!(
+            "Moving from {} to next editor tab at {}",
+            self.current_editor,
+            next
+        );
         self.set_tab_focus(Focus::Active, next);
         self.current_editor = next;
     }
@@ -46,7 +50,11 @@ impl EditorTab {
             .current_editor
             .checked_sub(1)
             .unwrap_or(self.tab_order.len() - 1);
-        trace!(target:Self::ID, "Moving from {} to previous editor tab at {}", self.current_editor, prev);
+        libclide::trace!(
+            "Moving from {} to previous editor tab at {}",
+            self.current_editor,
+            prev
+        );
         self.set_tab_focus(Focus::Active, prev);
         self.current_editor = prev;
     }
@@ -55,7 +63,7 @@ impl EditorTab {
         match self.tab_order.get(index) {
             None => {
                 if !self.tab_order.is_empty() {
-                    error!(target:Self::ID, "Failed to get editor tab key with invalid index {index}");
+                    libclide::error!("Failed to get editor tab key with invalid index {index}");
                 }
                 None
             }
@@ -73,16 +81,19 @@ impl EditorTab {
     }
 
     pub fn set_current_tab_focus(&mut self, focus: Focus) {
-        trace!(target:Self::ID, "Setting current tab {} focus to {:?}", self.current_editor, focus);
+        libclide::trace!(
+            "Setting current tab {} focus to {:?}",
+            self.current_editor,
+            focus
+        );
         self.set_tab_focus(focus, self.current_editor)
     }
 
     pub fn set_tab_focus(&mut self, focus: Focus, index: usize) {
-        trace!(target:Self::ID, "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.
-            trace!(
-                target:Self::ID,
+            libclide::trace!(
                 "New tab {} focus set to Active; Setting current tab {} to Inactive",
                 index,
                 self.current_editor
@@ -91,12 +102,11 @@ impl EditorTab {
         }
         match self.get_editor_key(index) {
             None => {
-                error!(target:Self::ID, "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 => {
-                    error!(
-                        target:Self::ID,
+                    libclide::error!(
                         "Failed to update tab focus at index {} with invalid key: {}",
                         self.current_editor,
                         self.tab_order[self.current_editor]
@@ -108,12 +118,12 @@ impl EditorTab {
     }
 
     pub fn open_tab(&mut self, path: &std::path::Path) -> Result<()> {
-        trace!(target:Self::ID, "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())
         {
-            warn!(target:Self::ID, "EditorTab already opened with this file");
+            libclide::warn!("EditorTab already opened with this file");
             return Ok(());
         }
 
@@ -138,12 +148,12 @@ impl EditorTab {
             .to_owned();
         match self.editors.remove(&key) {
             None => {
-                error!(target:Self::ID, "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);
-                info!(target:Self::ID, "Closed editor tab {key} at index {index}")
+                libclide::info!("Closed editor tab {key} at index {index}")
             }
         }
         Ok(())

src/tui/explorer.rs

@@ -4,34 +4,33 @@
 
 use crate::tui::component::{Action, Component, ComponentState, Focus, FocusState};
 use anyhow::{Context, Result, bail};
-use log::trace;
+use libclide::fs::entry_meta::EntryMeta;
+use libclide::log::Loggable;
+use libclide_macros::Loggable;
 use ratatui::buffer::Buffer;
 use ratatui::crossterm::event::{Event, KeyCode, KeyEvent, MouseEvent, MouseEventKind};
 use ratatui::layout::{Alignment, Position, Rect};
 use ratatui::prelude::Style;
 use ratatui::style::{Color, Modifier};
 use ratatui::widgets::{Block, Borders, StatefulWidget, Widget};
-use std::ffi::OsStr;
 use std::fs;
 use std::path::{Path, PathBuf};
 use tui_tree_widget::{Tree, TreeItem, TreeState};
 
-#[derive(Debug)]
+#[derive(Debug, Loggable)]
 pub struct Explorer<'a> {
-    pub(crate) root_path: PathBuf,
+    root_path: EntryMeta,
     tree_items: TreeItem<'a, String>,
     tree_state: TreeState<String>,
     pub(crate) component_state: ComponentState,
 }
 
 impl<'a> Explorer<'a> {
-    pub const ID: &'static str = "Explorer";
-
     pub fn new(path: &PathBuf) -> Result<Self> {
-        trace!(target:Self::ID, "Building {}", Self::ID);
+        libclide::trace!("Building {}", <Self as Loggable>::ID);
         let explorer = Explorer {
-            root_path: path.to_owned(),
-            tree_items: Self::build_tree_from_path(path.to_owned())?,
+            root_path: EntryMeta::new(path)?,
+            tree_items: Self::build_tree_from_path(path)?,
             tree_state: TreeState::default(),
             component_state: ComponentState::default().with_help_text(concat!(
                 "(↑/k)/(↓/j): Select item | ←/h: Close folder | →/l: Open folder |",
@@ -41,46 +40,46 @@ impl<'a> Explorer<'a> {
         Ok(explorer)
     }
 
-    fn build_tree_from_path(path: PathBuf) -> Result<TreeItem<'static, String>> {
+    /// Builds the file tree from a path using recursion.
+    /// The identifiers used for the TreeItems are normalized. Symlinks are not resolved.
+    /// Resolving symlinks would cause collisions on the TreeItem unique identifiers within the set.
+    fn build_tree_from_path<P: AsRef<Path>>(p: P) -> Result<TreeItem<'static, String>> {
+        let path = p.as_ref();
         let mut children = vec![];
-        let clean_path = fs::canonicalize(path)?;
-        if let Ok(entries) = fs::read_dir(&clean_path) {
+        let path_meta = EntryMeta::new(path)?;
+        if let Ok(entries) = fs::read_dir(&path_meta.abs_path) {
             let mut paths = entries
                 .map(|res| res.map(|e| e.path()))
                 .collect::<Result<Vec<_>, std::io::Error>>()
                 .context(format!(
                     "Failed to build vector of paths under directory: {:?}",
-                    clean_path
+                    &path_meta.abs_path
                 ))?;
             paths.sort();
-            for path in paths {
-                if path.is_dir() {
-                    children.push(Self::build_tree_from_path(path)?);
+            for entry_path in paths {
+                let entry_meta = EntryMeta::new(&entry_path)?;
+                if entry_meta.is_dir {
+                    children.push(Self::build_tree_from_path(&entry_meta.abs_path)?);
                 } else {
-                    if let Ok(path) = fs::canonicalize(&path) {
-                        let path_str = path.to_string_lossy().to_string();
-                        children.push(TreeItem::new_leaf(
-                            path_str + uuid::Uuid::new_v4().to_string().as_str(),
-                            path.file_name()
-                                .context("Failed to get file name from path.")?
-                                .to_string_lossy()
-                                .to_string(),
-                        ));
-                    }
+                    children.push(TreeItem::new_leaf(
+                        entry_meta.abs_path.clone(),
+                        format!("{} {}", entry_meta.icon.icon, entry_meta.file_name.as_str()),
+                    ));
                 }
             }
         }
 
+        // Note: The first argument is a unique identifier, where no. 2 TreeItems may share the same.
+        // For a file tree this is fine because we shouldn't list the same object twice.
         TreeItem::new(
-            clean_path.to_string_lossy().to_string() + uuid::Uuid::new_v4().to_string().as_str(),
-            clean_path
-                .file_name()
-                .context(format!("Failed to get file name from path: {clean_path:?}"))?
-                .to_string_lossy()
-                .to_string(),
+            path_meta.abs_path.clone(),
+            format!("{} {}", path_meta.icon.icon, path_meta.file_name.as_str()),
             children,
         )
-        .context(format!("Failed to build tree from path: {clean_path:?}"))
+        .context(format!(
+            "Failed to build tree from path: {:?}",
+            path_meta.abs_path
+        ))
     }
 
     pub fn selected(&self) -> Result<String> {
@@ -96,16 +95,12 @@ impl<'a> Explorer<'a> {
 
 impl<'a> Widget for &mut Explorer<'a> {
     fn render(self, area: Rect, buf: &mut Buffer) {
-        if let Ok(tree) = Tree::new(&self.tree_items.children()) {
-            let file_name = self
-                .root_path
-                .file_name()
-                .unwrap_or_else(|| OsStr::new("Unknown"));
+        if let Ok(tree) = Tree::new(self.tree_items.children()) {
             StatefulWidget::render(
                 tree.block(
                     Block::default()
                         .borders(Borders::ALL)
-                        .title(file_name.to_string_lossy())
+                        .title(self.root_path.file_name.clone())
                         .border_style(Style::default().fg(self.component_state.get_active_color()))
                         .title_style(Style::default().fg(Color::Green))
                         .title_alignment(Alignment::Center),
@@ -134,23 +129,21 @@ impl<'a> Component for Explorer<'a> {
                 _ => {}
             }
         }
-        if let Some(mouse_event) = event.as_mouse_event() {
-            match self.handle_mouse_events(mouse_event)? {
-                Action::Handled => return Ok(Action::Handled),
-                _ => {}
-            }
+        if let Some(mouse_event) = event.as_mouse_event()
+            && let Action::Handled = self.handle_mouse_events(mouse_event)?
+        {
+            return Ok(Action::Handled);
         }
         Ok(Action::Pass)
     }
 
     fn handle_key_events(&mut self, key: KeyEvent) -> Result<Action> {
-        if key.code == KeyCode::Enter {
-            if let Ok(selected) = self.selected() {
-                if Path::new(&selected).is_file() {
-                    return Ok(Action::OpenTab);
-                }
-            }
-            // Otherwise fall through and handle Enter in the next match case.
+        if key.code == KeyCode::Enter
+            && let Ok(selected) = self.selected()
+            && Path::new(&selected).is_file()
+        {
+            // Open a tab if the selected item is a file.
+            return Ok(Action::OpenTab);
         }
 
         let changed = match key.code {

src/tui/logger.rs

@@ -3,7 +3,9 @@
 // SPDX-License-Identifier: GNU General Public License v3.0 or later
 
 use crate::tui::component::{Action, Component, ComponentState, Focus, FocusState};
-use log::{LevelFilter, trace};
+use libclide::log::Loggable;
+use libclide_macros::Loggable;
+use log::LevelFilter;
 use ratatui::buffer::Buffer;
 use ratatui::crossterm::event::{Event, KeyCode, KeyEvent};
 use ratatui::layout::Rect;
@@ -13,16 +15,15 @@ use tui_logger::{TuiLoggerLevelOutput, TuiLoggerSmartWidget, TuiWidgetEvent, Tui
 
 /// 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)]
 pub struct Logger {
     state: TuiWidgetState,
     pub(crate) component_state: ComponentState,
 }
 
 impl Logger {
-    pub const ID: &str = "Logger";
-
     pub fn new() -> Self {
-        trace!(target:Self::ID, "Building {}", Self::ID);
+        libclide::trace!("Building {}", <Self as Loggable>::ID);
         let state = TuiWidgetState::new();
         state.transition(TuiWidgetEvent::HideKey);
         Self {

src/tui/menu_bar.rs

@@ -7,7 +7,7 @@ use crate::tui::menu_bar::MenuBarItemOption::{
     About, CloseTab, Exit, Reload, Save, ShowHideExplorer, ShowHideLogger,
 };
 use anyhow::Context;
-use log::trace;
+use libclide_macros::Loggable;
 use ratatui::buffer::Buffer;
 use ratatui::crossterm::event::{KeyCode, KeyEvent};
 use ratatui::layout::Rect;
@@ -80,6 +80,7 @@ impl MenuBarItem {
     }
 }
 
+#[derive(Debug, Loggable)]
 pub struct MenuBar {
     selected: MenuBarItem,
     opened: Option<MenuBarItem>,
@@ -88,11 +89,9 @@ pub struct MenuBar {
 }
 
 impl MenuBar {
-    pub const ID: &str = "MenuBar";
-
     const DEFAULT_HELP: &str = "(←/h)/(→/l): Select option | Enter: Choose selection";
     pub fn new() -> Self {
-        trace!(target:Self::ID, "Building {}", Self::ID);
+        libclide::trace!("Building");
         Self {
             selected: MenuBarItem::File,
             opened: None,
@@ -131,7 +130,7 @@ impl MenuBar {
         opened: MenuBarItem,
     ) {
         let popup_area = Self::rect_under_option(title_bar_anchor, area, 27, 10);
-        Clear::default().render(popup_area, buf);
+        Clear.render(popup_area, buf);
         let options = opened.options().iter().map(|i| ListItem::new(i.id()));
         StatefulWidget::render(
             List::new(options)
@@ -150,15 +149,14 @@ impl MenuBar {
     }
 
     fn rect_under_option(anchor: Rect, area: Rect, width: u16, height: u16) -> Rect {
-        let rect = Rect {
+        Rect {
             x: anchor.x,
             y: anchor.y + anchor.height,
             width: width.min(area.width),
             height,
-        };
+        }
         // TODO: X offset for item option? It's fine as-is, but it might look nicer.
-        // trace!(target:Self::ID, "Building Rect under MenuBar popup {}", rect);
-        rect
+        // trace!("Building Rect under MenuBar popup {}", rect);
     }
 }