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"

.gitea/workflows/build.yaml

@@ -1,28 +0,0 @@
-name: Build
-
-on:
-  push:
-    branches:
-      - main
-    tags:
-      - 'v*'
-  pull_request:
-
-jobs:
-  Build:
-    name: Build
-    runs-on: ubuntu-latest
-    steps:
-      - name: Install Rust
-        run: |
-          curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
-
-      - name: Install Python
-        run: |
-          apt update - y
-          apt install python3 -y
-
-      - name: Install Qt
-        uses: jurplel/install-qt-action@v4
-        with:
-          version: '6.7.3'

.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

Cargo.lock

@@ -299,6 +299,7 @@ dependencies = [
  "dirs",
  "edtui",
  "libclide",
+ "libclide-macros",
  "log",
  "ratatui",
  "strum",
@@ -1169,6 +1170,19 @@ name = "libclide"
 version = "0.1.0"
 dependencies = [
  "anyhow",
+ "devicons",
+ "libclide-macros",
+ "log",
+ "strum",
+]
+
+[[package]]
+name = "libclide-macros"
+version = "0.1.0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
 ]
 
 [[package]]

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"
-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.
 

build.rs

@@ -1,7 +1,7 @@
 use cxx_qt_build::{CxxQtBuilder, QmlModule};
 
 fn main() {
-    CxxQtBuilder::new_qml_module(QmlModule::new("clide.module").qml_files(&[
+    CxxQtBuilder::new_qml_module(QmlModule::new("clide.module").qml_files([
         "qml/ClideApplicationView.qml",
         "qml/ClideEditorView.qml",
         "qml/ClideExplorerView.qml",

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.toml

@@ -4,4 +4,8 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-anyhow = "1.0.102"
+anyhow = { workspace = true }
+strum = { workspace = true }
+log = { workspace = true }
+devicons = { workspace = true }
+libclide-macros = { path = "../libclide-macros" }

libclide/src/fs.rs

@@ -3,3 +3,5 @@
 // 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

@@ -2,14 +2,16 @@
 //
 // SPDX-License-Identifier: GNU General Public License v3.0 or later
 
-use std::path::{Path, PathBuf};
 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 {
@@ -35,16 +37,28 @@ impl EntryMeta {
     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 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

@@ -3,3 +3,5 @@
 // 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:?}"))
+    }
+}

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(),
+            hovered: QColor::try_from(Colors::HOVERED).unwrap(),
-            unhovered: QColor::try_from("#3c3f41").unwrap(),
+            unhovered: QColor::try_from(Colors::UNHOVERED).unwrap(),
-            pressed: QColor::try_from("#4b4f51").unwrap(),
+            pressed: QColor::try_from(Colors::PRESSED).unwrap(),
-            menubar: QColor::try_from("#262626").unwrap(),
+            menubar: QColor::try_from(Colors::MENUBAR).unwrap(),
-            menubar_border: QColor::try_from("#575757").unwrap(),
+            menubar_border: QColor::try_from(Colors::MENUBAR_BORDER).unwrap(),
-            scrollbar: QColor::try_from("#4b4f51").unwrap(),
+            scrollbar: QColor::try_from(Colors::SCROLLBAR).unwrap(),
-            scrollbar_active: QColor::try_from("#4b4f51").unwrap(),
+            scrollbar_active: QColor::try_from(Colors::SCROLLBAR_ACTIVE).unwrap(),
-            scrollbar_gutter: QColor::try_from("#3b3b3b").unwrap(),
+            scrollbar_gutter: QColor::try_from(Colors::SCROLLBAR_GUTTER).unwrap(),
-            linenumber: QColor::try_from("#94989b").unwrap(),
+            linenumber: QColor::try_from(Colors::LINENUMBER).unwrap(),
-            active: QColor::try_from("#a9acb0").unwrap(),
+            active: QColor::try_from(Colors::ACTIVE).unwrap(),
-            inactive: QColor::try_from("#FFF").unwrap(),
+            inactive: QColor::try_from(Colors::INACTIVE).unwrap(),
-            editor_background: QColor::try_from("#1E1F22").unwrap(),
+            editor_background: QColor::try_from(Colors::EDITOR_BACKGROUND).unwrap(),
-            editor_text: QColor::try_from("#acaea3").unwrap(),
+            editor_text: QColor::try_from(Colors::EDITOR_TEXT).unwrap(),
-            editor_highlighted_text: QColor::try_from("#ccced3").unwrap(),
+            editor_highlighted_text: QColor::try_from(Colors::EDITOR_HIGHLIGHTED_TEXT).unwrap(),
-            editor_highlight: QColor::try_from("#ccced3").unwrap(),
+            editor_highlight: QColor::try_from(Colors::EDITOR_HIGHLIGHT).unwrap(),
-            gutter: QColor::try_from("#1e1f22").unwrap(),
+            gutter: QColor::try_from(Colors::GUTTER).unwrap(),
-            explorer_hovered: QColor::try_from("#4c5053").unwrap(),
+            explorer_hovered: QColor::try_from(Colors::EXPLORER_HOVERED).unwrap(),
-            explorer_text: QColor::try_from("#FFF").unwrap(),
+            explorer_text: QColor::try_from(Colors::EXPLORER_TEXT).unwrap(),
-            explorer_text_selected: QColor::try_from("#262626").unwrap(),
+            explorer_text_selected: QColor::try_from(Colors::EXPLORER_TEXT_SELECTED).unwrap(),
-            explorer_background: QColor::try_from("#1E1F22").unwrap(),
+            explorer_background: QColor::try_from(Colors::EXPLORER_BACKGROUND).unwrap(),
-            explorer_folder: QColor::try_from("#54585b").unwrap(),
+            explorer_folder: QColor::try_from(Colors::EXPLORER_FOLDER).unwrap(),
-            explorer_folder_open: QColor::try_from("#393B40").unwrap(),
+            explorer_folder_open: QColor::try_from(Colors::EXPLORER_FOLDER_OPEN).unwrap(),
-            terminal_background: QColor::try_from("#111111").unwrap(),
+            terminal_background: QColor::try_from(Colors::TERMINAL_BACKGROUND).unwrap(),
-            info_log: QColor::try_from("#C4FFFF").unwrap(),
+            info_log: QColor::try_from(Colors::INFO_LOG).unwrap(),
-            debug_log: QColor::try_from("#9148AF").unwrap(),
+            debug_log: QColor::try_from(Colors::DEBUG_LOG).unwrap(),
-            warn_log: QColor::try_from("#C4A958").unwrap(),
+            warn_log: QColor::try_from(Colors::WARN_LOG).unwrap(),
-            error_log: QColor::try_from("#ff5555").unwrap(),
+            error_log: QColor::try_from(Colors::ERROR_LOG).unwrap(),
-            trace_log: QColor::try_from("#ffaa00").unwrap(),
+            trace_log: QColor::try_from(Colors::TRACE_LOG).unwrap(),
         }
     }
 }

src/gui/filesystem.rs

@@ -3,9 +3,7 @@
 // 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;
@@ -76,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();
@@ -114,7 +112,7 @@ impl qobject::FileSystem {
             output.push_str("</pre>\n");
             QString::from(output)
         } else {
-            return QString::default();
+            QString::default()
         }
     }
 
@@ -126,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)
@@ -143,13 +141,6 @@ impl qobject::FileSystem {
     }
 
     fn icon(self: std::pin::Pin<&mut Self>, path: &QString) -> QString {
-        let str = path.to_string();
+        QString::from(libclide::fs::icon(path.to_string().as_str()).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())
     }
 }

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.render(kilroy_rect, buf);
-        Clear::default().render(chunks[1], 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,
+    Editor,
-    AppExplorer,
+    Explorer,
-    AppLogger,
+    Logger,
-    AppMenuBar,
+    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(),
+            AppComponent::Explorer => self.explorer.component_state.help_text.clone(),
-            AppLogger => self.logger.component_state.help_text.clone(),
+            AppComponent::Logger => self.logger.component_state.help_text.clone(),
-            AppMenuBar => self.menu_bar.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),
+            AppComponent::Explorer => self.explorer.component_state.set_focus(Focus::Active),
-            AppLogger => self.logger.component_state.set_focus(Focus::Active),
+            AppComponent::Logger => self.logger.component_state.set_focus(Focus::Active),
-            AppMenuBar => self.menu_bar.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())?,
+            AppComponent::Editor => self.editor_tab.handle_event(event.clone())?,
-            AppExplorer => self.explorer.handle_event(event.clone())?,
+            AppComponent::Explorer => self.explorer.handle_event(event.clone())?,
-            AppLogger => self.logger.handle_event(event.clone())?,
+            AppComponent::Logger => self.logger.handle_event(event.clone())?,
-            AppMenuBar => self.menu_bar.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 let Some(mouse) = event.as_mouse_event()
-            if mouse.kind == MouseEventKind::Down(MouseButton::Left) {
+            && mouse.kind == MouseEventKind::Down(MouseButton::Left)
-                if let Some(editor) = self.editor_tab.current_editor_mut() {
+        {
-                    editor.handle_mouse_events(mouse)?;
+            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)?;
             }
+            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,
+            Active => Color::from_u32(Colors::css_to_u32(Colors::ACTIVE)),
-            Inactive => Color::White,
+            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)? {
+            if let Action::Handled = self.handle_key_events(key_event)? {
-                Action::Handled => return Ok(Action::Handled),
+                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!(
+            libclide::trace!(
-                target:Self::ID,
                 "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!(
+                    libclide::error!(
-                        target:Self::ID,
                         "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,7 +4,9 @@
 
 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};
@@ -14,9 +16,8 @@ use ratatui::widgets::{Block, Borders, StatefulWidget, Widget};
 use std::fs;
 use std::path::{Path, PathBuf};
 use tui_tree_widget::{Tree, TreeItem, TreeState};
-use libclide::fs::entry_meta::EntryMeta;
 
-#[derive(Debug)]
+#[derive(Debug, Loggable)]
 pub struct Explorer<'a> {
     root_path: EntryMeta,
     tree_items: TreeItem<'a, String>,
@@ -25,13 +26,11 @@ pub struct Explorer<'a> {
 }
 
 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: EntryMeta::new(&path)?,
+            root_path: EntryMeta::new(path)?,
-            tree_items: Self::build_tree_from_path(path.to_owned())?,
+            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 |",
@@ -64,17 +63,17 @@ impl<'a> Explorer<'a> {
                 } else {
                     children.push(TreeItem::new_leaf(
                         entry_meta.abs_path.clone(),
-                        entry_meta.file_name.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.
+        // 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(
             path_meta.abs_path.clone(),
-            path_meta.file_name.clone(),
+            format!("{} {}", path_meta.icon.icon, path_meta.file_name.as_str()),
             children,
         )
         .context(format!(
@@ -96,7 +95,7 @@ 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()) {
+        if let Ok(tree) = Tree::new(self.tree_items.children()) {
             StatefulWidget::render(
                 tree.block(
                     Block::default()
@@ -130,23 +129,21 @@ impl<'a> Component for Explorer<'a> {
                 _ => {}
             }
         }
-        if let Some(mouse_event) = event.as_mouse_event() {
+        if let Some(mouse_event) = event.as_mouse_event()
-            match self.handle_mouse_events(mouse_event)? {
+            && let Action::Handled = self.handle_mouse_events(mouse_event)?
-                Action::Handled => return Ok(Action::Handled),
+        {
-                _ => {}
+            return Ok(Action::Handled);
-            }
         }
         Ok(Action::Pass)
     }
 
     fn handle_key_events(&mut self, key: KeyEvent) -> Result<Action> {
-        if key.code == KeyCode::Enter {
+        if key.code == KeyCode::Enter
-            if let Ok(selected) = self.selected() {
+            && let Ok(selected) = self.selected()
-                if Path::new(&selected).is_file() {
+            && Path::new(&selected).is_file()
-                    return Ok(Action::OpenTab);
+        {
-                }
+            // Open a tab if the selected item is a file.
-            }
+            return Ok(Action::OpenTab);
-            // Otherwise fall through and handle Enter in the next match case.
         }
 
         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);
+        // trace!("Building Rect under MenuBar popup {}", rect);
-        rect
     }
 }