Merge pull request #51 from Reim-developer/dev

Implement `AbstractTableModel` & `ThemeManager` class

Author: Reim-developer

.github/workflows/linux.yml

@@ -25,6 +25,9 @@ jobs:
             chmod +x ${{ github.workspace }}/${{ env.CI_SCRIPT }}
             ./${{ env.CI_SCRIPT }} install-dependency
 
+        - name: Install Qt
+          uses: jurplel/install-qt-action@v4
+
         - name: Install Rust
           shell: bash
           run: |

.github/workflows/linux_dev.yml

@@ -26,14 +26,16 @@ jobs:
             curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
             echo "$HOME/.cargo/bin:$PATH" >> $GITHUB_PATH
           
-        - name: Install C++ libraries
+        - name: Install requirements
           shell: bash
           run: |
                sudo apt-get update
                sudo apt-get install -y \
                git cmake make ccache \
-               qt6-base-dev clang
+               clang 
 
+        - name: Install Qt
+          uses: jurplel/install-qt-action@v4
 
         - name: Add Rust components
           shell: bash

scripts/linux_deploy.sh

@@ -8,7 +8,7 @@ nproc=$(nproc)
 install_dependency() {
     sudo apt-get update
     sudo apt-get install -y git cmake \
-    qt6-base-dev clang 
+    clang 
 }
 
 function check() {

src/back_end/src/internal/app_config.rs

@@ -12,6 +12,8 @@ pub struct AppGuiSettings {
     pub foreground_color: String,
     pub background_button_color: String,
     pub foreground_button_color: String,
+    pub background_table_header_color: String,
+    pub foreground_table_header_color: String,
 }
 
 #[derive(Deserialize, Serialize)]
@@ -32,6 +34,8 @@ impl AppConfig {
             foreground_color: "#ffffff".to_string(),
             background_button_color: "#2f3136".to_string(),
             foreground_button_color: "#ffffff".to_string(),
+            background_table_header_color: "#2f3136".to_string(),
+            foreground_table_header_color: "#ffffff".to_string(),
         };
 
         Self {

src/back_end/src/raw_config/constant.rs

@@ -13,9 +13,13 @@ pub const BACKGROUND_COLOR: &str = "background_color";
 pub const FOREGROUND_COLOR: &str = "foreground_color";
 pub const BACKGROUND_COLOR_BUTTON: &str = "background_button_color";
 pub const FOREGROUND_COLOR_BUTTON: &str = "fore_background_color";
+pub const BACKGROUND_COLOR_TABLE_HEADER: &str = "background_table_header_color";
+pub const FOREGROUND_COLOR_TABLE_HEADER: &str = "foreground_table_header_color";
 
 /* Default application color fallback */
 pub const FALLBACK_BG_COLOR: &str = "#2f3136";
 pub const FALLBACK_FG_COLOR: &str = "#ffffff";
 pub const FALLBACK_BG_BUTTON_COLOR: &str = "#2f3136";
 pub const FALLBACK_FG_BUTTON_COLOR: &str = "#ffffff";
+pub const FALLBACK_BG_TABLE_HEADER_COLOR: &str = "#2f3136";
+pub const FALLBACK_FG_TABLE_HEADER_COLOR: &str = "#ffffff";

src/back_end/src/raw_config/raw_toml.rs

@@ -1,9 +1,10 @@
 use crate::raw_config::constant::{
     APP_GUI_SETTINGS, APP_SETTINGS, BACKGROUND_COLOR, BACKGROUND_COLOR_BUTTON,
-    FALLBACK_BG_BUTTON_COLOR, FALLBACK_BG_COLOR, FALLBACK_FG_BUTTON_COLOR,
-    FALLBACK_FG_COLOR, FOREGROUND_COLOR, FOREGROUND_COLOR_BUTTON,
-    HIDE_WHEN_CLOSED, HIDE_WHEN_CLOSED_FALLBACK, NOTIFICATION,
-    NOTIFICATION_FALLBACK,
+    BACKGROUND_COLOR_TABLE_HEADER, FALLBACK_BG_BUTTON_COLOR, FALLBACK_BG_COLOR,
+    FALLBACK_BG_TABLE_HEADER_COLOR, FALLBACK_FG_BUTTON_COLOR,
+    FALLBACK_FG_COLOR, FALLBACK_FG_TABLE_HEADER_COLOR, FOREGROUND_COLOR,
+    FOREGROUND_COLOR_BUTTON, FOREGROUND_COLOR_TABLE_HEADER, HIDE_WHEN_CLOSED,
+    HIDE_WHEN_CLOSED_FALLBACK, NOTIFICATION, NOTIFICATION_FALLBACK,
 };
 use std::{
     ffi::{CStr, CString, c_char},
@@ -23,6 +24,8 @@ pub struct RawAppGuiSettings {
     pub foreground_color: *mut c_char,
     pub background_button_color: *mut c_char,
     pub foreground_button_color: *mut c_char,
+    pub background_header_table_color: *mut c_char,
+    pub foreground_header_table_color: *mut c_char,
 }
 
 #[repr(C)]
@@ -109,6 +112,16 @@ pub unsafe extern "C" fn raw_exists_config(
         FOREGROUND_COLOR_BUTTON,
         FALLBACK_FG_BUTTON_COLOR,
     );
+    let bg_table_header_color = color_by_settings(
+        &toml_value,
+        BACKGROUND_COLOR_TABLE_HEADER,
+        FALLBACK_BG_TABLE_HEADER_COLOR,
+    );
+    let fg_table_header_color = color_by_settings(
+        &toml_value,
+        FOREGROUND_COLOR_TABLE_HEADER,
+        FALLBACK_FG_TABLE_HEADER_COLOR,
+    );
 
     let Ok(bg_cstr) = CString::new(bg_color) else {
         return Status::ConvertToCStringFailed;
@@ -126,6 +139,14 @@ pub unsafe extern "C" fn raw_exists_config(
         return Status::ConvertToCStringFailed;
     };
 
+    let Ok(bg_table_header_cstr) = CString::new(bg_table_header_color) else {
+        return Status::ConvertToCStringFailed;
+    };
+
+    let Ok(fg_table_header_cstr) = CString::new(fg_table_header_color) else {
+        return Status::ConvertToCStringFailed;
+    };
+
     if let Some(config) = unsafe { raw_cfg_out.as_mut() } {
         config.app_settings.hide_when_closed = app_settings.hide_when_closed;
         config.app_settings.notification = app_settings.notification;
@@ -135,6 +156,10 @@ pub unsafe extern "C" fn raw_exists_config(
             bg_btn_cstr.into_raw();
         config.app_gui_settings.foreground_button_color =
             fg_btn_cstr.into_raw();
+        config.app_gui_settings.background_header_table_color =
+            bg_table_header_cstr.into_raw();
+        config.app_gui_settings.foreground_header_table_color =
+            fg_table_header_cstr.into_raw();
 
         return RawReadAppConfigStatus::Ok;
     }
@@ -154,6 +179,12 @@ pub unsafe extern "C" fn raw_free_cstr_app_config(config: *mut RawAppConfig) {
                 CString::from_raw(cfg.app_gui_settings.background_button_color);
             let _ =
                 CString::from_raw(cfg.app_gui_settings.foreground_button_color);
+            let _ = CString::from_raw(
+                cfg.app_gui_settings.background_header_table_color,
+            );
+            let _ = CString::from_raw(
+                cfg.app_gui_settings.foreground_header_table_color,
+            );
         }
     }
 }

src/ffi/raw/config.hxx

@@ -41,6 +41,8 @@ typedef struct {
 	char *foreground_color;
 	char *background_button_color;
 	char *foreground_button_color;
+	char *background_table_header_color;
+	char *foreground_table_header_color;
 } RawAppGuiSettings;
 
 typedef struct {

src/front_end/include/abstract_table_model.hxx

@@ -0,0 +1,194 @@
+#ifndef ABSTRACT_TABLE_MODEL_HXX
+#define ABSTRACT_TABLE_MODEL_HXX
+
+#include <qabstractitemmodel.h>
+#include <qcontainerfwd.h>
+#include <qlist.h>
+#include <qnamespace.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+#include <qvariant.h>
+
+#include <algorithm>
+#include <climits>
+#include <cstdint>
+
+using std::min;
+using std::uint8_t;
+namespace Lazyboard::front_end {
+
+typedef struct TableItem {
+	QString time;
+	QString content;
+	QString content_type;
+	bool is_pinned = false;
+} TableItem;
+
+template <typename T>
+constexpr void unused(T &t) {
+	(void)t;
+}
+
+class AbstractTableModel : public QAbstractTableModel {
+	Q_OBJECT
+
+   public:
+	// clang-format off
+	enum Colum : uint8_t {
+		TIME = 0,
+		CONTENT = 1,
+		TYPE = 2,
+		PINNED,
+		COLUMN_COUNT,
+	};	// clang-format on
+
+	int rowCount(const QModelIndex &parent = QModelIndex()) const override {
+		unused(parent);
+		return static_cast<int>(min(table_item.size(), qsizetype(INT_MAX)));
+	}
+
+	int columnCount(const QModelIndex &parent = QModelIndex()) const override {
+		unused(parent);
+		return COLUMN_COUNT;
+	}
+
+	QVariant data(const QModelIndex &index,
+				  int role = Qt::DisplayRole) const override {
+		if (!index.isValid() || index.row() >= table_item.size() ||
+			index.row() < 0) {
+			return QVariant();
+		}
+
+		const TableItem &item = table_item[index.row()];
+
+		if (role == Qt::DisplayRole || role == Qt::EditRole) {
+			switch (index.column()) {
+				case TIME:
+					return item.time;
+
+				case CONTENT: {
+					const auto max_length = 20;
+					if (item.content.length() > max_length) {
+						auto content_length = item.content.length();
+
+						qsizetype remaining_length =
+							content_length - max_length;
+
+						QString truncated =
+							item.content.left(max_length) +
+							QString(" and %1 more...").arg(remaining_length);
+
+						return truncated;
+					}
+
+					return item.content;
+				}
+
+				case TYPE | PINNED:
+					return item.content_type;
+
+				default:
+					return {};
+			}
+		}
+
+		if (role == Qt::CheckStateRole && index.column() == PINNED) {
+			return item.is_pinned ? Qt::Checked : Qt::Unchecked;
+		}
+
+		return QVariant();
+	}
+
+	QVariant headerData(int section, Qt::Orientation orientation,
+						int role = Qt::DisplayRole) const override {
+		if (role != Qt::DisplayRole || orientation != Qt::Horizontal) {
+			return QVariant();
+		}
+
+		switch (section) {
+			case TIME:
+				return "Time";
+
+			case CONTENT:
+				return "Content";
+
+			case TYPE:
+				return "Type";
+
+			case PINNED:
+				return "Pinned";
+
+			default:
+				return QVariant();
+		}
+	}
+
+	Qt::ItemFlags flags(const QModelIndex &index) const override {
+		if (!index.isValid()) {
+			return Qt::NoItemFlags;
+		}
+
+		Qt::ItemFlags flag = QAbstractTableModel::flags(index);
+
+		if (index.column() == PINNED) {
+			flag |= Qt::ItemFlag::ItemIsUserCheckable |
+					Qt::ItemFlag::ItemIsEditable;
+		} else {
+			flag |= Qt::ItemIsEditable;
+		}
+
+		return flag;
+	}
+
+	bool setData(const QModelIndex &index, const QVariant &value,
+				 int role) override {
+		if (!index.isValid() || index.row() >= table_item.size()) {
+			return false;
+		}
+
+		TableItem &item = table_item[index.row()];
+
+		if (index.column() == PINNED && role == Qt::CheckStateRole) {
+			bool checked = (value.toInt() == Qt::Checked);
+
+			if (item.is_pinned != checked) {
+				item.is_pinned = checked;
+
+				emit dataChanged(index, index,
+								 {Qt::CheckStateRole, Qt::DisplayRole});
+
+				return true;
+			}
+		}
+
+		if (role == Qt::EditRole) {
+			switch (index.column()) {
+				case TIME:
+					item.time = value.toString();
+					break;
+
+				case CONTENT:
+					item.content = value.toString();
+					break;
+
+				case TYPE:
+					item.content_type = value.toString();
+					break;
+
+				default:
+					return false;
+			}
+
+			emit dataChanged(index, index, {Qt::DisplayRole, Qt::EditRole});
+			return true;
+		}
+
+		return false;
+	}
+
+   private:
+	QList<TableItem> table_item;
+};
+}  // namespace Lazyboard::front_end
+
+#endif	// ABSTRACT_TABLE_MODEL_HXX

src/front_end/include/error_debug.hxx

@@ -0,0 +1,30 @@
+#ifndef ERROR_DEBUG_HXX
+#define ERROR_DEBUG_HXX
+
+#if !defined(LAZY_DEBUG)
+	#error "Could not include 'error_debug' if 'LAZY_DEBUG' is disabled.
+#endif
+#include <cstdint>
+#include <map>
+#include <string_view>
+
+namespace Lazyboard::front_end {
+using std::map;
+using std::string_view;
+using std::uint8_t;
+
+// clang-format off
+enum class ErrorDebugType : uint8_t{
+	INVALID_HEX_COLOR = 1,
+};	// clang-format on
+
+inline const map<ErrorDebugType, string_view> &error_type() {
+	static const map<ErrorDebugType, string_view> error_type = {
+		{ErrorDebugType::INVALID_HEX_COLOR, "INVALID_HEX_COLOR"},
+	};
+
+	return error_type;
+}
+
+}  // namespace Lazyboard::front_end
+#endif	// ERROR_DEBUG_HXX