feat: add global keyboard handle to the session-shell, allow to show and hide dashboard via shortcut

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;
 }

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

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;
         }

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];
+        keys_list = g_list_append(keys_list, (gpointer) key);
-        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);
     }
+    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];
+    if(state == WL_KEYBOARD_KEY_STATE_PRESSED)
-    uint32_t keycode = key + 8;
+    {
-    xkb_keysym_t sym = xkb_state_key_get_one_sym(self->xkb_state, keycode);
+        g_signal_emit_by_name(diya_shell_object_get_shell(self), DIYA_SIGNAL_SHELL_KEY_PRESSED, self->xkb_keymap, self->xkb_state, key, time);
-    xkb_keysym_get_name(sym, buf, sizeof(buf));
+    }
-    const char *action = state == WL_KEYBOARD_KEY_STATE_PRESSED ? "press" : "release";
+    else
-    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_signal_emit_by_name(diya_shell_object_get_shell(self), DIYA_SIGNAL_SHELL_KEY_RELEASED, self->xkb_keymap, self->xkb_state, key, time);
-    g_warning("\tutf8: '%s'", buf);
+    }
 }
 
 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)

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)
 

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);
+    DiyaDashboardWidget* dashboard = DIYA_DASHBOARD_WIDGET(diya_shell_window_new(DIYA_TYPE_DASHBOARD_WIDGET, 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));
     assert(dashboard);
-
+    DiyaTaskbarWidget* taskbar = DIYA_TASKBAR_WIDGET(diya_shell_window_new(DIYA_TYPE_TASKBAR_WIDGET, shell));
-    DiyaTaskbarWidget* taskbar = DIYA_TASKBAR_WIDGET(g_object_new (DIYA_TYPE_TASKBAR_WIDGET, "application", app, "shell",shell, NULL));
     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));
+}

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);
 

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());

src/session-shell.c

@@ -2,6 +2,8 @@
 
 #include <assert.h>
 #include <gtk4-session-lock.h>
+#include <xkbcommon/xkbcommon.h>
+
 #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;
+    GtkWindow *background;
-    DiyaLauncher* launcher;
+    DiyaLauncher *launcher;
-    GHashTable* windows;
+    GHashTable *windows;
-    GtkSessionLockInstance* lock;
+    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));
+    (void) xkb_keymap;
-    diya_session_shell_init_background(DIYA_SESSION_SHELL(shell));
+    (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_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_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_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);

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)

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)
 

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;
+}

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

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;
 }

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