From 8c70733b9b39165130ae0ab6a5b5ef4439a0846c Mon Sep 17 00:00:00 2001 From: Dany LE Date: Mon, 16 Jun 2025 16:33:25 +0200 Subject: [PATCH] feat: add global keyboard handle to the session-shell, allow to show and hide dashboard via shortcut --- src/base.c | 7 +++ src/base.h | 2 +- src/files-monitor.c | 2 +- src/input.c | 87 ++++++---------------------- src/input.h | 5 -- src/launcher.c | 21 ++++--- src/launcher.h | 3 + src/login-shell.c | 2 +- src/session-shell.c | 103 ++++++++++++++++++++++----------- src/shell.c | 75 +++++++++++++++++++++++- src/shell.h | 7 +++ src/widgets/base-widgets.c | 21 +++++++ src/widgets/base-widgets.h | 2 + src/widgets/dashboard-widget.c | 28 +++++---- src/widgets/dashboard-widget.h | 2 + 15 files changed, 234 insertions(+), 133 deletions(-) diff --git a/src/base.c b/src/base.c index 93be259..9f65007 100644 --- a/src/base.c +++ b/src/base.c @@ -105,4 +105,11 @@ const gchar * diya_object_to_string(gpointer object) DiyaObject * self = DIYA_OBJECT(object); DiyaObjectClass *class = DIYA_OBJECT_GET_CLASS(self); return class->to_string ? class->to_string(self) : ""; +} + +gpointer diya_shell_object_get_shell(gpointer object) +{ + DiyaShellObject * self = DIYA_SHELL_OBJECT(object); + DiyaShellObjectPrivate* priv = diya_shell_object_get_instance_private(self); + return priv->shell; } \ No newline at end of file diff --git a/src/base.h b/src/base.h index 0049144..361b61a 100644 --- a/src/base.h +++ b/src/base.h @@ -32,6 +32,6 @@ struct _DiyaShellObjectClass }; const gchar *diya_object_to_string(gpointer object); - +gpointer diya_shell_object_get_shell(gpointer object); #endif \ No newline at end of file diff --git a/src/files-monitor.c b/src/files-monitor.c index c15ab3a..b60e8bf 100644 --- a/src/files-monitor.c +++ b/src/files-monitor.c @@ -58,7 +58,7 @@ gboolean diya_files_monitor_watch(DiyaFilesMonitor* self, const gchar* path, GCa g_object_unref(file); if (err) { - g_error("Unable to watch file %s: %s", path, err->message); + g_warning("Unable to watch file %s: %s", path, err->message); g_error_free(err); return false; } diff --git a/src/input.c b/src/input.c index 793aaac..bac628f 100644 --- a/src/input.c +++ b/src/input.c @@ -91,59 +91,6 @@ static void diya_input_class_init(DiyaInputClass *class) // gobject_class->set_property = diya_input_set_property; // gobject_class->get_property = diya_input_get_property; base_class->to_string = diya_input_to_string; - - g_signal_new(DIYA_SIGNAL_INPUT_KEYBOARD_ENTER, - DIYA_TYPE_SHELL, - G_SIGNAL_DETAILED | - G_SIGNAL_ACTION | - G_SIGNAL_RUN_FIRST, - 0, - NULL, - NULL, - NULL, - G_TYPE_NONE, - 1, - G_TYPE_POINTER); - g_signal_new(DIYA_SIGNAL_INPUT_KEYBOARD_LEAVE, - DIYA_TYPE_SHELL, - G_SIGNAL_DETAILED | - G_SIGNAL_ACTION | - G_SIGNAL_RUN_FIRST, - 0, - NULL, - NULL, - NULL, - G_TYPE_NONE, - 0); - g_signal_new(DIYA_SIGNAL_INPUT_KEY_PRESSED, - DIYA_TYPE_SHELL, - G_SIGNAL_DETAILED | - G_SIGNAL_ACTION | - G_SIGNAL_RUN_FIRST, - 0, - NULL, - NULL, - NULL, - G_TYPE_NONE, - 3, - G_TYPE_UINT, - G_TYPE_UINT, - G_TYPE_UINT); - - g_signal_new(DIYA_SIGNAL_INPUT_KEY_RELEASED, - DIYA_TYPE_SHELL, - G_SIGNAL_DETAILED | - G_SIGNAL_ACTION | - G_SIGNAL_RUN_FIRST, - 0, - NULL, - NULL, - NULL, - G_TYPE_NONE, - 3, - G_TYPE_UINT, - G_TYPE_UINT, - G_TYPE_UINT); } static void wl_keyboard_keymap(void *data, struct wl_keyboard *keyboard, uint32_t format, int32_t fd, uint32_t size) @@ -172,17 +119,16 @@ static void wl_keyboard_enter(void *data, struct wl_keyboard *keyboard, (void)serial; (void)surface; DiyaInput *self = data; - g_warning("keyboard enter; keys pressed are:"); + + GList* keys_list = NULL; + uint32_t *key; wl_array_for_each(key, keys) { - char buf[128]; - xkb_keysym_t sym = xkb_state_key_get_one_sym(self->xkb_state, *key + 8); - xkb_keysym_get_name(sym, buf, sizeof(buf)); - g_warning("\tsym: %-12s (%d), ", buf, sym); - xkb_state_key_get_utf8(self->xkb_state, *key + 8, buf, sizeof(buf)); - g_warning("\tutf8: '%s'", buf); + keys_list = g_list_append(keys_list, (gpointer) key); } + g_signal_emit_by_name(diya_shell_object_get_shell(self), DIYA_SIGNAL_SHELL_KEYBOARD_ENTER, self->xkb_keymap, self->xkb_state, (void*) keys_list); + g_list_free(keys_list); } static void wl_keyboard_key(void *data, struct wl_keyboard *keyboard, @@ -192,24 +138,24 @@ static void wl_keyboard_key(void *data, struct wl_keyboard *keyboard, (void)serial; (void)time; DiyaInput *self = data; - char buf[128]; - uint32_t keycode = key + 8; - xkb_keysym_t sym = xkb_state_key_get_one_sym(self->xkb_state, keycode); - xkb_keysym_get_name(sym, buf, sizeof(buf)); - const char *action = state == WL_KEYBOARD_KEY_STATE_PRESSED ? "press" : "release"; - g_warning("wl_keyboard_key %s: sym: %-12s (%d), ", action, buf, sym); - xkb_state_key_get_utf8(self->xkb_state, keycode, buf, sizeof(buf)); - g_warning("\tutf8: '%s'", buf); + if(state == WL_KEYBOARD_KEY_STATE_PRESSED) + { + g_signal_emit_by_name(diya_shell_object_get_shell(self), DIYA_SIGNAL_SHELL_KEY_PRESSED, self->xkb_keymap, self->xkb_state, key, time); + } + else + { + g_signal_emit_by_name(diya_shell_object_get_shell(self), DIYA_SIGNAL_SHELL_KEY_RELEASED, self->xkb_keymap, self->xkb_state, key, time); + } } static void wl_keyboard_leave(void *data, struct wl_keyboard *keyboard, uint32_t serial, struct wl_surface *surface) { - (void)data; (void)keyboard; (void)serial; (void)surface; - g_warning("keyboard leave"); + DiyaInput *self = data; + g_signal_emit_by_name(diya_shell_object_get_shell(self), DIYA_SIGNAL_SHELL_KEYBOARD_LEAVE); } static void wl_keyboard_modifiers(void *data, struct wl_keyboard *keyboard, @@ -221,6 +167,7 @@ static void wl_keyboard_modifiers(void *data, struct wl_keyboard *keyboard, (void)serial; DiyaInput *self = data; xkb_state_update_mask(self->xkb_state, mods_depressed, mods_latched, mods_locked, 0, 0, group); + g_signal_emit_by_name(diya_shell_object_get_shell(self), DIYA_SIGNAL_SHELL_KEYBOARD_MODIFIER_CHANGED, self->xkb_keymap, (void*) self->xkb_state); } static void wl_keyboard_repeat_info(void *data, struct wl_keyboard *keyboard, int32_t rate, int32_t delay) diff --git a/src/input.h b/src/input.h index 0ebd706..ee0d7d1 100644 --- a/src/input.h +++ b/src/input.h @@ -3,11 +3,6 @@ #include "shell.h" -#define DIYA_SIGNAL_INPUT_KEYBOARD_ENTER "keyboard-enter" -#define DIYA_SIGNAL_INPUT_KEYBOARD_LEAVE "keyboard-leave" -#define DIYA_SIGNAL_INPUT_KEY_PRESSED "key-pressed" -#define DIYA_SIGNAL_INPUT_KEY_RELEASED "key-released" - #define DIYA_TYPE_INPUT (diya_input_get_type ()) G_DECLARE_FINAL_TYPE (DiyaInput, diya_input, DIYA, INPUT, DiyaShellObject) diff --git a/src/launcher.c b/src/launcher.c index fa25aab..29f7452 100644 --- a/src/launcher.c +++ b/src/launcher.c @@ -145,15 +145,9 @@ static void diya_launcher_class_init(DiyaLauncherClass *class) void diya_session_shell_launcher_init(DiyaSessionShell * shell) { - assert(shell); - GtkApplication * app; - g_object_get(shell, DIYA_PROP_SHELL_APPLICATION, &app, NULL); - assert(app); - - DiyaDashboardWidget* dashboard = DIYA_DASHBOARD_WIDGET(g_object_new (DIYA_TYPE_DASHBOARD_WIDGET, "application", app, "shell",shell, NULL)); + DiyaDashboardWidget* dashboard = DIYA_DASHBOARD_WIDGET(diya_shell_window_new(DIYA_TYPE_DASHBOARD_WIDGET, shell)); assert(dashboard); - - DiyaTaskbarWidget* taskbar = DIYA_TASKBAR_WIDGET(g_object_new (DIYA_TYPE_TASKBAR_WIDGET, "application", app, "shell",shell, NULL)); + DiyaTaskbarWidget* taskbar = DIYA_TASKBAR_WIDGET(diya_shell_window_new(DIYA_TYPE_TASKBAR_WIDGET, shell)); assert(taskbar); //gtk_window_set_transient_for(GTK_WINDOW(dashboard), GTK_WINDOW(taskbar)); DiyaLauncher* self = DIYA_LAUNCHER(g_object_new (DIYA_TYPE_LAUNCHER, "dashboard", dashboard, "taskbar",taskbar, NULL)); @@ -202,3 +196,14 @@ void diya_session_shell_launcher_init(DiyaSessionShell * shell) } g_list_free_full(apps, g_object_unref); } + +void diya_launcher_show_dashboard(DiyaLauncher* self, gboolean value) +{ + g_object_set(self->dashboard, DIYA_PROP_DASHBOARD_ACTIVE, value, NULL); +} + + +void diya_launcher_toggle_dashboard(DiyaLauncher* self) +{ + diya_launcher_show_dashboard(self, !diya_dashboard_is_active(self->dashboard)); +} \ No newline at end of file diff --git a/src/launcher.h b/src/launcher.h index 73ea80d..b917725 100644 --- a/src/launcher.h +++ b/src/launcher.h @@ -9,6 +9,9 @@ #define DIYA_TYPE_LAUNCHER (diya_launcher_get_type ()) G_DECLARE_FINAL_TYPE (DiyaLauncher, diya_launcher, DIYA, LAUNCHER, DiyaShellObject) +void diya_launcher_show_dashboard(DiyaLauncher* self, gboolean value); +void diya_launcher_toggle_dashboard(DiyaLauncher* self); + void diya_session_shell_launcher_init(DiyaSessionShell * shell); diff --git a/src/login-shell.c b/src/login-shell.c index 9670345..18c4b0d 100644 --- a/src/login-shell.c +++ b/src/login-shell.c @@ -290,8 +290,8 @@ static void diya_login_shell_startup(DiyaShell *shell) DiyaLoginShell *self = DIYA_LOGIN_SHELL(shell); if (!gtk_session_lock_instance_lock(self->lock)) { - g_error("gtk_session_lock_instance_lock: Unable to lock the display"); g_object_unref(self); + g_error("gtk_session_lock_instance_lock: Unable to lock the display"); return; } GListModel *list = gdk_display_get_monitors(gdk_display_get_default()); diff --git a/src/session-shell.c b/src/session-shell.c index 4994321..cd8907d 100644 --- a/src/session-shell.c +++ b/src/session-shell.c @@ -2,6 +2,8 @@ #include #include +#include + #include "shell.h" #include "foreign.h" #include "background.h" @@ -23,27 +25,27 @@ static GParamSpec *shell_properties[N_PROPERTIES] = {0}; struct _DiyaSessionShell { DiyaShell parent; - GtkWindow* background; - DiyaLauncher* launcher; - GHashTable* windows; - GtkSessionLockInstance* lock; + GtkWindow *background; + DiyaLauncher *launcher; + GHashTable *windows; + GtkSessionLockInstance *lock; }; G_DEFINE_FINAL_TYPE(DiyaSessionShell, diya_session_shell, DIYA_TYPE_SHELL) -static void diya_session_shell_dispose(GObject* object) +static void diya_session_shell_dispose(GObject *object) { - DiyaSessionShell * self = DIYA_SESSION_SHELL(object); + DiyaSessionShell *self = DIYA_SESSION_SHELL(object); g_hash_table_destroy(self->windows); g_debug("diya_session_shell_dispose: %s", diya_object_to_string(object)); - if(self->lock) + if (self->lock) { g_object_unref(self->lock); } - if(self->background) + if (self->background) { gtk_window_destroy(self->background); } - if(self->launcher) + if (self->launcher) { g_object_unref(self->launcher); } @@ -52,7 +54,7 @@ static void diya_session_shell_dispose(GObject* object) static void diya_session_shell_set_property(GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { - DiyaSessionShell * self = DIYA_SESSION_SHELL(object); + DiyaSessionShell *self = DIYA_SESSION_SHELL(object); switch (property_id) { case SHELL_BACKGROUND_WIDGET: @@ -62,17 +64,17 @@ static void diya_session_shell_set_property(GObject *object, guint property_id, self->launcher = g_value_get_pointer(value); break; case SHELL_WINDOWS: - //self->windows = g_value_get_pointer(value); + // self->windows = g_value_get_pointer(value); break; default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); break; } } static void diya_session_shell_get_property(GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { - DiyaSessionShell * self = DIYA_SESSION_SHELL(object); + DiyaSessionShell *self = DIYA_SESSION_SHELL(object); switch (property_id) { case SHELL_BACKGROUND_WIDGET: @@ -90,44 +92,75 @@ static void diya_session_shell_get_property(GObject *object, guint property_id, g_value_set_pointer(value, self->windows); break; default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); break; } } -static void diya_session_shell_startup(DiyaShell* shell) +static void diya_session_on_key_pressed(DiyaShell* shell, struct xkb_keymap *xkb_keymap, struct xkb_state *xkb_state, uint32_t key, uint32_t time, gpointer userdata) { - diya_session_shell_launcher_init(DIYA_SESSION_SHELL(shell)); - diya_session_shell_init_background(DIYA_SESSION_SHELL(shell)); + (void) xkb_keymap; + (void) userdata; + (void) time; + DiyaSessionShell* self = DIYA_SESSION_SHELL(shell); + uint32_t keycode = key + 8; + xkb_keysym_t sym = xkb_state_key_get_one_sym(xkb_state, keycode); + + switch(sym) + { + case XKB_KEY_Escape: + diya_launcher_show_dashboard(self->launcher, false); + break; + case XKB_KEY_space: + if(xkb_state_mod_name_is_active(xkb_state, XKB_MOD_NAME_CTRL, XKB_STATE_MODS_EFFECTIVE)) { + diya_launcher_toggle_dashboard(self->launcher); + } + default: + break; + } + + /* + char buf[128]; + xkb_keysym_get_name(sym, buf, sizeof(buf)); + g_warning("key-pressed (%d): sym: %-12s (%d)", time, buf, sym); + xkb_state_key_get_utf8(xkb_state, keycode, buf, sizeof(buf)); + g_warning("\tutf8: '%s'", buf); + */ } -static void diya_session_shell_active(DiyaShell* shell) +static void diya_session_shell_startup(DiyaShell *shell) +{ + diya_session_shell_init_background(DIYA_SESSION_SHELL(shell)); + diya_session_shell_launcher_init(DIYA_SESSION_SHELL(shell)); + g_signal_connect(shell, DIYA_SIGNAL_SHELL_KEY_PRESSED, G_CALLBACK(diya_session_on_key_pressed), NULL); +} + +static void diya_session_shell_active(DiyaShell *shell) { - //(void) shell; diya_shell_monitor_input(shell); } static void diya_session_shell_class_init(DiyaSessionShellClass *class) { GObjectClass *gobject_class = G_OBJECT_CLASS(class); - // DiyaObjectClass *base_class = DIYA_OBJECT_CLASS(class); + // DiyaObjectClass *base_class = DIYA_OBJECT_CLASS(class); DiyaShellClass *base_shell_class = DIYA_SHELL_CLASS(class); base_shell_class->foreign_register = diya_session_shell_foreign_toplevel_register; base_shell_class->startup_handle = diya_session_shell_startup; base_shell_class->active_handle = diya_session_shell_active; - ///base_class->to_string = diya_session_shell_to_string; + /// base_class->to_string = diya_session_shell_to_string; gobject_class->dispose = diya_session_shell_dispose; gobject_class->set_property = diya_session_shell_set_property; gobject_class->get_property = diya_session_shell_get_property; - shell_properties[SHELL_BACKGROUND_WIDGET] = g_param_spec_pointer(DIYA_PROP_SESSION_BACKGROUND, NULL, "Shell background widget", G_PARAM_READWRITE ); - shell_properties[SHELL_LAUNCHPAD_WIDGET] = g_param_spec_pointer(DIYA_PROP_SESSION_LAUNCHPAD, NULL, "Shell launchpad", G_PARAM_READWRITE ); - shell_properties[SHELL_LOCK_SESSION] = g_param_spec_pointer(DIYA_PROP_SESSION_LOCK, NULL, "Shell lock session", G_PARAM_READABLE ); + shell_properties[SHELL_BACKGROUND_WIDGET] = g_param_spec_pointer(DIYA_PROP_SESSION_BACKGROUND, NULL, "Shell background widget", G_PARAM_READWRITE); + shell_properties[SHELL_LAUNCHPAD_WIDGET] = g_param_spec_pointer(DIYA_PROP_SESSION_LAUNCHPAD, NULL, "Shell launchpad", G_PARAM_READWRITE); + shell_properties[SHELL_LOCK_SESSION] = g_param_spec_pointer(DIYA_PROP_SESSION_LOCK, NULL, "Shell lock session", G_PARAM_READABLE); shell_properties[SHELL_WINDOWS] = g_param_spec_pointer(DIYA_PROP_SESSION_WINDOWS, NULL, "Shell foreign windows", G_PARAM_READABLE); - g_object_class_install_properties (gobject_class, N_PROPERTIES, shell_properties); + g_object_class_install_properties(gobject_class, N_PROPERTIES, shell_properties); g_signal_new(DIYA_SIGNAL_FOREIGN_WINDOW_CHANGED, DIYA_TYPE_SESSION_SHELL, @@ -177,14 +210,16 @@ static void diya_session_shell_class_init(DiyaSessionShellClass *class) 0); } -static void on_session_locked(GtkSessionLockInstance *lock, DiyaSessionShell *shell) { +static void on_session_locked(GtkSessionLockInstance *lock, DiyaSessionShell *shell) +{ (void)lock; assert(shell); g_message("Session locked successfully"); g_signal_emit_by_name(shell, DIYA_SIGNAL_SESSION_LOCKED); } -static void on_session_unlocked(GtkSessionLockInstance *lock, DiyaSessionShell *shell) { +static void on_session_unlocked(GtkSessionLockInstance *lock, DiyaSessionShell *shell) +{ (void)lock; assert(shell); g_message("Session unlocked"); @@ -193,7 +228,7 @@ static void on_session_unlocked(GtkSessionLockInstance *lock, DiyaSessionShell * static void diya_session_shell_init(DiyaSessionShell *self) { - //self->app = NULL; + // self->app = NULL; self->background = NULL; self->launcher = NULL; self->lock = gtk_session_lock_instance_new(); @@ -203,27 +238,27 @@ static void diya_session_shell_init(DiyaSessionShell *self) self->windows = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, g_object_unref); } -DiyaForeignWindow* diya_session_shell_get_window(DiyaSessionShell * shell, gpointer handle) +DiyaForeignWindow *diya_session_shell_get_window(DiyaSessionShell *shell, gpointer handle) { return g_hash_table_lookup(shell->windows, handle); } -gboolean diya_session_shell_add_window(DiyaSessionShell * shell, DiyaForeignWindow * win) +gboolean diya_session_shell_add_window(DiyaSessionShell *shell, DiyaForeignWindow *win) { gpointer handle; g_object_get(win, DIYA_PROP_FOREIGN_WINDOW_HANDLE, &handle, NULL); assert(handle); - return g_hash_table_insert(shell->windows,handle, win); + return g_hash_table_insert(shell->windows, handle, win); } -gboolean diya_session_shell_remove_window(DiyaSessionShell * shell, DiyaForeignWindow * win) +gboolean diya_session_shell_remove_window(DiyaSessionShell *shell, DiyaForeignWindow *win) { gpointer handle; g_object_get(win, DIYA_PROP_FOREIGN_WINDOW_HANDLE, &handle, NULL); assert(handle); - return g_hash_table_remove(shell->windows,handle); + return g_hash_table_remove(shell->windows, handle); } -void diya_session_shell_remove_all_windows(DiyaSessionShell * shell) +void diya_session_shell_remove_all_windows(DiyaSessionShell *shell) { g_hash_table_destroy(shell->windows); shell->windows = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, g_object_unref); diff --git a/src/shell.c b/src/shell.c index 30d19d7..bca325d 100644 --- a/src/shell.c +++ b/src/shell.c @@ -2,8 +2,8 @@ #include "shell.h" #include "wayland.h" #include "virtual-keyboard.h" -#include "input.h" #include "files-monior.h" +#include "input.h" #define diya_shell_config_css_file(priv) (g_strconcat(g_get_user_config_dir(), "/diya/themes/", priv->theme ? priv->theme : "default", "/", priv->name, ".css", NULL)) @@ -361,8 +361,80 @@ static void diya_shell_class_init(DiyaShellClass *class) shell_properties[PROP_SHELL_NAME] = g_param_spec_string(DIYA_PROP_SHELL_NAME, NULL, "Shell name", NULL, G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY); shell_properties[PROP_SHELL_APP] = g_param_spec_pointer(DIYA_PROP_SHELL_APPLICATION, NULL, "Shell application", G_PARAM_READABLE); shell_properties[PROP_SHELL_THEME] = g_param_spec_string(DIYA_PROP_SHELL_THEME, NULL, "Shell theme", NULL, G_PARAM_READWRITE); + shell_properties[PROP_SHELL_APP] = g_param_spec_pointer(DIYA_PROP_SHELL_APPLICATION, NULL, "Shell application", G_PARAM_READABLE); g_object_class_install_properties(gobject_class, N_PROPERTIES, shell_properties); + + // define signals + g_signal_new(DIYA_SIGNAL_SHELL_KEYBOARD_ENTER, + DIYA_TYPE_SHELL, + G_SIGNAL_DETAILED | + G_SIGNAL_ACTION | + G_SIGNAL_RUN_FIRST, + 0, + NULL, + NULL, + NULL, + G_TYPE_NONE, + 3, + G_TYPE_POINTER, + G_TYPE_POINTER, + G_TYPE_POINTER); + g_signal_new(DIYA_SIGNAL_SHELL_KEYBOARD_MODIFIER_CHANGED, + DIYA_TYPE_SHELL, + G_SIGNAL_DETAILED | + G_SIGNAL_ACTION | + G_SIGNAL_RUN_FIRST, + 0, + NULL, + NULL, + NULL, + G_TYPE_NONE, + 2, + G_TYPE_POINTER, + G_TYPE_POINTER); + g_signal_new(DIYA_SIGNAL_SHELL_KEYBOARD_LEAVE, + DIYA_TYPE_SHELL, + G_SIGNAL_DETAILED | + G_SIGNAL_ACTION | + G_SIGNAL_RUN_FIRST, + 0, + NULL, + NULL, + NULL, + G_TYPE_NONE, + 0); + g_signal_new(DIYA_SIGNAL_SHELL_KEY_PRESSED, + DIYA_TYPE_SHELL, + G_SIGNAL_DETAILED | + G_SIGNAL_ACTION | + G_SIGNAL_RUN_FIRST, + 0, + NULL, + NULL, + NULL, + G_TYPE_NONE, + 4, + G_TYPE_POINTER, + G_TYPE_POINTER, + G_TYPE_UINT, + G_TYPE_UINT); + + g_signal_new(DIYA_SIGNAL_SHELL_KEY_RELEASED, + DIYA_TYPE_SHELL, + G_SIGNAL_DETAILED | + G_SIGNAL_ACTION | + G_SIGNAL_RUN_FIRST, + 0, + NULL, + NULL, + NULL, + G_TYPE_NONE, + 4, + G_TYPE_POINTER, + G_TYPE_POINTER, + G_TYPE_UINT, + G_TYPE_UINT); } int diya_shell_run(DiyaShell *shell, int argc, char **argv) @@ -437,6 +509,7 @@ void diya_shell_monitor_input(DiyaShell *self) return; } priv->input = diya_input_new(self); + // TODO mapping signals } gboolean diya_shell_watch_file(DiyaShell *self, const gchar *file, GCallback callback, gpointer userdata) diff --git a/src/shell.h b/src/shell.h index f94b172..349d627 100644 --- a/src/shell.h +++ b/src/shell.h @@ -13,6 +13,13 @@ #define DIYA_PROP_SHELL_APPLICATION "application" #define DIYA_PROP_SHELL_THEME "theme" + +#define DIYA_SIGNAL_SHELL_KEYBOARD_ENTER "keyboard-enter" +#define DIYA_SIGNAL_SHELL_KEYBOARD_LEAVE "keyboard-leave" +#define DIYA_SIGNAL_SHELL_KEY_PRESSED "key-pressed" +#define DIYA_SIGNAL_SHELL_KEY_RELEASED "key-released" +#define DIYA_SIGNAL_SHELL_KEYBOARD_MODIFIER_CHANGED "keyboard-modifier-changed" + #define DIYA_TYPE_SHELL (diya_shell_get_type()) G_DECLARE_DERIVABLE_TYPE(DiyaShell, diya_shell, DIYA, SHELL, DiyaObject) diff --git a/src/widgets/base-widgets.c b/src/widgets/base-widgets.c index 4d766ba..b415467 100644 --- a/src/widgets/base-widgets.c +++ b/src/widgets/base-widgets.c @@ -73,7 +73,28 @@ static void diya_shell_window_class_init(DiyaShellWindowClass *class) gobject_class->dispose = diya_shell_window_dispose; gobject_class->set_property = diya_shell_window_set_property; gobject_class->get_property = diya_shell_window_get_property; + + class->setup = NULL; + g_sw_prop[SW_SHELL] = g_param_spec_pointer(DIYA_PROP_SHELL, NULL, "Reference to global shell", G_PARAM_READWRITE|G_PARAM_CONSTRUCT_ONLY); // g_object_class_install_properties (gobject_class, SW_N_PROPERTIES, g_sw_prop); } + + +DiyaShellWindow* diya_shell_window_new(GType window_type, gpointer data) +{ + DiyaShell* shell = data; + assert(shell); + GtkApplication * app; + g_object_get(shell, DIYA_PROP_SHELL_APPLICATION, &app, NULL); + assert(app); + + DiyaShellWindow* self = DIYA_SHELL_WINDOW(g_object_new (window_type, "application", app, "shell",shell, NULL)); + DiyaShellWindowClass *class = DIYA_SHELL_WINDOW_GET_CLASS(self); + if(class->setup) + { + class->setup(self); + } + return self; +} \ No newline at end of file diff --git a/src/widgets/base-widgets.h b/src/widgets/base-widgets.h index 6564aa4..3e9eab4 100644 --- a/src/widgets/base-widgets.h +++ b/src/widgets/base-widgets.h @@ -10,7 +10,9 @@ G_DECLARE_DERIVABLE_TYPE(DiyaShellWindow, diya_shell_window, DIYA, SHELL_WINDOW, struct _DiyaShellWindowClass { GtkApplicationWindowClass parent_class; + void (*setup)(DiyaShellWindow* self); }; +DiyaShellWindow* diya_shell_window_new(GType window_type, gpointer shell); #endif \ No newline at end of file diff --git a/src/widgets/dashboard-widget.c b/src/widgets/dashboard-widget.c index c8f591f..fa50be3 100644 --- a/src/widgets/dashboard-widget.c +++ b/src/widgets/dashboard-widget.c @@ -1,6 +1,5 @@ #include "dashboard-widget.h" - struct _DiyaDashboardWidget { DiyaShellWindow parent; @@ -33,13 +32,6 @@ static void diya_dashboard_widget_init(DiyaDashboardWidget * self) g_debug("diya_dashboard_widget_init"); gtk_widget_init_template (GTK_WIDGET(self)); self->active = false; - //builder = gtk_builder_new_from_resource ("/org/gtk/exampleapp/gears-menu.ui"); - // GtkWindow* win = GTK_WINDOW(self); - - // g_object_bind_property(self->btn_toggle, "active", self->revealer, "reveal-child", G_SETTINGS_BIND_DEFAULT); - // gtk_widget_set_can_focus(self->revealer, false); - - //g_signal_connect (GTK_WINDOW(dashboard), "destroy", G_CALLBACK (on_launcher_destroy), NULL); // int layer shell for window gtk_layer_init_for_window (GTK_WINDOW(self)); @@ -65,7 +57,6 @@ static void diya_dashboard_widget_init(DiyaDashboardWidget * self) //GtkEventController *event_controller = gtk_event_controller_key_new(); //g_signal_connect(event_controller, "key-pressed", G_CALLBACK(on_diya_dashboard_key_press), self); // gtk_widget_add_controller(GTK_WIDGET(self), event_controller); - } static void diya_dashboard_set_property(GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) @@ -75,7 +66,13 @@ static void diya_dashboard_set_property(GObject *object, guint property_id, cons switch (property_id) { case PROP_ACTIVE: - self->active = g_value_get_boolean(value); + { + gboolean active = g_value_get_boolean(value); + if(self->active == active) + { + return; + } + self->active = active; if(self->active) { gtk_window_present(GTK_WINDOW(self)); @@ -89,8 +86,8 @@ static void diya_dashboard_set_property(GObject *object, guint property_id, cons gtk_revealer_set_reveal_child(GTK_REVEALER(self->revealer), false); gtk_widget_set_visible(GTK_WIDGET(self), false); } - break; + } default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; @@ -111,7 +108,6 @@ static void diya_dashboard_get_property(GObject *object, guint property_id, GVal } } - static void diya_dashboard_widget_class_init(DiyaDashboardWidgetClass* class) { GObjectClass *gobject_class = G_OBJECT_CLASS(class); @@ -119,6 +115,9 @@ static void diya_dashboard_widget_class_init(DiyaDashboardWidgetClass* class) gobject_class->set_property = diya_dashboard_set_property; gobject_class->get_property = diya_dashboard_get_property; + //DiyaShellWindowClass* base_class = DIYA_SHELL_WINDOW_CLASS(class); + //base_class->setup = diya_dashboard_widget_setup; + gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (class),"/dev/iohub/diya/shell/dashboard.ui"); gtk_widget_class_bind_template_child (GTK_WIDGET_CLASS (class), DiyaDashboardWidget, revealer); gtk_widget_class_bind_template_child (GTK_WIDGET_CLASS (class), DiyaDashboardWidget, search_entry); @@ -132,4 +131,9 @@ static void diya_dashboard_widget_class_init(DiyaDashboardWidgetClass* class) g_prop[PROP_ACTIVE] = g_param_spec_boolean(DIYA_PROP_DASHBOARD_ACTIVE, NULL, "Active the dashboard", false, G_PARAM_READWRITE); // g_object_class_install_properties (gobject_class, N_PROPERTIES, g_prop); +} + +gboolean diya_dashboard_is_active(DiyaDashboardWidget* self) +{ + return self->active; } \ No newline at end of file diff --git a/src/widgets/dashboard-widget.h b/src/widgets/dashboard-widget.h index d27fbc4..cf09e3f 100644 --- a/src/widgets/dashboard-widget.h +++ b/src/widgets/dashboard-widget.h @@ -9,4 +9,6 @@ #define DIYA_TYPE_DASHBOARD_WIDGET (diya_dashboard_widget_get_type()) G_DECLARE_FINAL_TYPE (DiyaDashboardWidget, diya_dashboard_widget, DIYA, DASHBOARD_WIDGET, DiyaShellWindow) +gboolean diya_dashboard_is_active(DiyaDashboardWidget* self); + #endif \ No newline at end of file