dany/diya-shell
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

feat: implement the base classes for launcher + input

Browse Source 
- Base classes for lancher: Dashboard + Taskbar
- Allow the shell to monitor directly wayland seat keyboard (on demand)
This commit is contained in:
DL 2025-06-13 19:34:12 +02:00
parent e6515cca06
commit b10cfab3ba
27 changed files with 949 additions and 131 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
meson.build
View File

@ -60,8 +60,9 @@ base = [
'src/base.c',
'src/shell.c',
'src/wayland.c',
'src/vkb/virtual-keyboard.c',
'src/vkb/virtual-keyboard-widgets.c',
'src/input.c',
'src/virtual-keyboard.c',
'src/widgets/virtual-keyboard-widgets.c',
wayland_targets
]
@ -72,7 +73,11 @@ dm_src = [
'src/session-shell.c',
'src/foreign.c',
'src/session-lock.c',
'src/session.c']
'src/session.c',
'src/widgets/base-widgets.c',
'src/widgets/taskbar-widget.c',
'src/widgets/dashboard-widget.c',
]
buil_dep = [gtk, gtk_layer_shell, wayland_client, xkbcommon]

2
resources/gresource-session.xml
View File

@ -4,5 +4,7 @@
<file alias="dev.iohub.diya.session-shell.css">resources/session-shell.css</file>
<file alias="virtual-keyboard.css">resources/virtual-keyboard.css</file>
<file alias="default.keymap">resources/default.keymap</file>
<file alias="dashboard.ui">resources/ui/dashboard.ui</file>
<file alias="taskbar.ui">resources/ui/taskbar.ui</file>
</gresource>
</gresources>

8
resources/session-shell.css
View File

@ -1,9 +1,15 @@
@import url("resource:///dev/iohub/diya/shell/virtual-keyboard.css");
#diya_shell_launcher
diya-taskbar
{
background-color: orange;
}
diya-dashboard
{
background-color: blue;
}
#diya_shell_background
{
background-image:url("file:///etc/xdg/labwc/wpp.jpg");

59
resources/ui/dashboard.ui Normal file
View File

@ -0,0 +1,59 @@
<?xml version="1.0" encoding="UTF-8"?>
<interface>
<template class="DiyaDashboardWidget" parent="DiyaShellWindow">
<!--property name="title" translatable="yes">Example Application</property-->
<!--property name="default-width">600</property>
<property name="default-height">400</property-->
<child>
<object class="GtkBox">
<property name="orientation">vertical</property>
<child>
<object class="GtkRevealer" id="revealer">
<property name="transition-type">slide-up</property>
<property name="reveal-child">0</property>
<child>
<object class="GtkBox">
<property name="orientation">vertical</property>
<child>
<object class="GtkBox" id="header">
<property name="orientation">horizontal</property>
<child>
<object class="GtkSearchEntry" id="search_entry">
<property name="hexpand">1</property>
<!--signal name="search-changed" handler="search_text_changed"/-->
</object>
</child>
<child>
<object class="GtkMenuButton" id="gears">
<property name="direction">none</property>
</object>
</child>
</object>
</child>
<child>
<object class="GtkLabel" id="tmp">
<property name="visible">1</property>
<property name="vexpand">1</property>
<property name="label" translatable="yes">content</property>
</object>
</child>
</object>
</child>
</object>
</child>
<child>
<object class="GtkBox" id="taskbar">
<property name="orientation">horizontal</property>
<child>
<object class="GtkToggleButton" id="btn_user">
<property name="visible">1</property>
<property name="label" translatable="yes">User</property>
<!--signal name="toggled" handler="diya_dashboard_toggle"/-->
</object>
</child>
</object>
</child>
</object>
</child>
</template>
</interface>

20
resources/ui/taskbar.ui Normal file
View File

@ -0,0 +1,20 @@
<?xml version="1.0" encoding="UTF-8"?>
<interface>
<template class="DiyaTaskbarWidget" parent="DiyaShellWindow">
<!--property name="title" translatable="yes">Example Application</property-->
<!--property name="default-width">600</property>
<property name="default-height">400</property-->
<child>
<object class="GtkBox" id="taskbar">
<property name="orientation">horizontal</property>
<child>
<object class="GtkToggleButton" id="btn_toggle">
<property name="visible">1</property>
<property name="label" translatable="yes">Diya</property>
<!--signal name="toggled" handler="diya_dashboard_toggle"/-->
</object>
</child>
</object>
</child>
</template>
</interface>

5
src/base.c
View File

@ -22,6 +22,11 @@ static void diya_object_init(DiyaObject *self)
(void) self;
}
/**
* @brief Implementation of DiyaShellObject
*
*/
enum
{
SO_NO_PROP,

1
src/base.h
View File

@ -31,4 +31,5 @@ struct _DiyaShellObjectClass
const gchar *diya_object_to_string(gpointer object);
#endif

5
src/foreign.c
View File

@ -367,3 +367,8 @@ void diya_foreign_window_set_state(DiyaForeignWindow* self, enum diya_win_state
}
}
}
bool diya_foreign_window_is_toplevel(DiyaForeignWindow* self)
{
return self->parent_win == NULL;
}

1
src/foreign.h
View File

@ -16,4 +16,5 @@ void diya_session_shell_foreign_toplevel_register(struct wl_registry *registry,
DiyaShell* diya_foreign_window_get_shell(DiyaForeignWindow* window);
void diya_foreign_window_set_state(DiyaForeignWindow* window, enum diya_win_state state, bool value);
bool diya_foreign_window_is_toplevel(DiyaForeignWindow* window);
#endif

233
src/input.c Normal file
View File

@ -0,0 +1,233 @@
#include "input.h"
#include <wayland-client-protocol.h>
#include <gdk/wayland/gdkwayland.h>
#include <assert.h>
#include <xkbcommon/xkbcommon.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/mman.h>
#include <gio/gio.h>
#include "wlr-foreign-toplevel-management-unstable-v1.h"
#include "virtual-keyboard-unstable-v1.h"
#include "wayland.h"
struct _DiyaInput
{
DiyaShellObject parent;
gchar *name;
struct wl_keyboard *keyboard;
struct wl_seat *seat;
struct xkb_state *xkb_state;
struct xkb_context *xkb_context;
struct xkb_keymap *xkb_keymap;
};
G_DEFINE_FINAL_TYPE(DiyaInput, diya_input, DIYA_TYPE_SHELL_OBJECT)
static void diya_input_dispose(GObject *object)
{
g_debug("diya_input_dispose: %s", diya_object_to_string(object));
DiyaInput *self = DIYA_INPUT(object);
if (self->name)
{
g_free(self->name);
self->name = NULL;
}
if (self->keyboard)
{
wl_keyboard_release(self->keyboard);
self->keyboard = NULL;
}
if (self->xkb_keymap)
{
xkb_keymap_unref(self->xkb_keymap);
self->xkb_keymap = NULL;
}
if (self->xkb_state)
{
xkb_state_unref(self->xkb_state);
self->xkb_state = NULL;
}
if (self->xkb_context)
{
xkb_context_unref(self->xkb_context);
self->xkb_context = NULL;
}
G_OBJECT_CLASS(diya_input_parent_class)->dispose(object);
}
static void diya_input_init(DiyaInput *self)
{
self->name = NULL;
self->keyboard = NULL;
self->xkb_state = NULL;
self->xkb_context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
self->xkb_keymap = NULL;
}
static const gchar *diya_input_to_string(DiyaObject *object)
{
DiyaInput *self = DIYA_INPUT(object);
if (self->name)
{
return self->name;
}
return "unknown";
}
static void diya_input_class_init(DiyaInputClass *class)
{
GObjectClass *gobject_class = G_OBJECT_CLASS(class);
DiyaObjectClass *base_class = DIYA_OBJECT_CLASS(class);
gobject_class->dispose = diya_input_dispose;
// gobject_class->set_property = diya_input_set_property;
// gobject_class->get_property = diya_input_get_property;
base_class->to_string = diya_input_to_string;
}
static void wl_keyboard_keymap(void *data, struct wl_keyboard *keyboard, uint32_t format, int32_t fd, uint32_t size)
{
(void) keyboard;
DiyaInput *self = data;
assert(format == WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1);
char *map_shm = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);
assert(map_shm != MAP_FAILED);
struct xkb_keymap *xkb_keymap = xkb_keymap_new_from_string(self->xkb_context, map_shm, XKB_KEYMAP_FORMAT_TEXT_V1, XKB_KEYMAP_COMPILE_NO_FLAGS);
munmap(map_shm, size);
close(fd);
struct xkb_state *xkb_state = xkb_state_new(xkb_keymap);
xkb_keymap_unref(self->xkb_keymap);
xkb_state_unref(self->xkb_state);
self->xkb_keymap = xkb_keymap;
self->xkb_state = xkb_state;
}
static void wl_keyboard_enter(void *data, struct wl_keyboard *keyboard,
uint32_t serial, struct wl_surface *surface,
struct wl_array *keys)
{
(void) keyboard;
(void) serial;
(void) surface;
DiyaInput *self = data;
g_warning("keyboard enter; keys pressed are:");
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);
}
}
static void wl_keyboard_key(void *data, struct wl_keyboard *keyboard,
uint32_t serial, uint32_t time, uint32_t key, uint32_t state)
{
(void) 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);
}
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");
}
static void wl_keyboard_modifiers(void *data, struct wl_keyboard *keyboard,
uint32_t serial, uint32_t mods_depressed,
uint32_t mods_latched, uint32_t mods_locked,
uint32_t group)
{
(void) keyboard;
(void) serial;
DiyaInput *self = data;
xkb_state_update_mask(self->xkb_state,mods_depressed, mods_latched, mods_locked, 0, 0, group);
}
static void wl_keyboard_repeat_info(void *data, struct wl_keyboard *keyboard,int32_t rate, int32_t delay)
{
(void) data;
(void) keyboard;
(void) rate;
(void) delay;
}
static const struct wl_keyboard_listener wl_keyboard_listener = {
.keymap = wl_keyboard_keymap,
.enter = wl_keyboard_enter,
.leave = wl_keyboard_leave,
.key = wl_keyboard_key,
.modifiers = wl_keyboard_modifiers,
.repeat_info = wl_keyboard_repeat_info,
};
static void wl_seat_capabilities(void *data, struct wl_seat *seat, uint32_t capabilities)
{
DiyaInput *self = data;
bool have_keyboard = capabilities & WL_SEAT_CAPABILITY_KEYBOARD;
if (have_keyboard && self->keyboard == NULL)
{
self->keyboard = wl_seat_get_keyboard(seat);
wl_keyboard_add_listener(self->keyboard, &wl_keyboard_listener, self);
}
else if (!have_keyboard && self->keyboard != NULL)
{
wl_keyboard_release(self->keyboard);
self->keyboard = NULL;
}
}
static void wl_seat_name(void *data, struct wl_seat *seat, const char *name)
{
(void) seat;
DiyaInput *self = data;
if (self->name)
{
return;
}
g_info("Attach to seat: %s", name);
self->name = g_strdup(name);
}
static const struct wl_seat_listener wl_seat_listener = {
.capabilities = wl_seat_capabilities,
.name = wl_seat_name,
};
DiyaInput *diya_input_new(DiyaShell *shell)
{
assert(shell);
DiyaInput *self = g_object_new(DIYA_TYPE_INPUT, "shell", shell, NULL);
DiyaWayland *wayland = diya_shell_get_wayland(shell);
assert(wayland);
struct wl_seat *seat = diya_wayland_get_seat(wayland);
wl_seat_add_listener(seat, &wl_seat_listener, self);
return self;
}

10
src/input.h Normal file
View File

@ -0,0 +1,10 @@
#ifndef DIYA_INPUT_H
#define DIYA_INPUT_H
#include "base.h"
#include "shell.h"
#define DIYA_TYPE_INPUT (diya_input_get_type ())
G_DECLARE_FINAL_TYPE (DiyaInput, diya_input, DIYA, INPUT, DiyaShellObject)
DiyaInput* diya_input_new(DiyaShell* shell);
#endif

163
src/launcher.c
View File

@ -1,16 +1,30 @@
#include "launcher.h"
#include "foreign.h"
#include "session-lock.h"
#include <wayland-client-protocol.h>
#include <gdk/wayland/gdkwayland.h>
#include <assert.h>
#include "launcher.h"
#include "widgets/dashboard-widget.h"
#include "widgets/taskbar-widget.h"
#include "foreign.h"
#include "wayland.h"
#define NAMESPACE "diya_shell_launcher"
static void on_launcher_destroy(GtkWindow *window, GApplication *_data)
struct _DiyaLauncher
{
(void) window;
(void)_data;
//g_application_quit (G_APPLICATION (gtk_window_get_application (window)));
}
DiyaShellObject parent;
DiyaDashboardWidget* dashboard;
DiyaTaskbarWidget* taskbar;
};
G_DEFINE_FINAL_TYPE(DiyaLauncher, diya_launcher, DIYA_TYPE_SHELL_OBJECT)
enum
{
NO_PROP,
PROP_DASHBOARD,
PROP_TASKBAR,
N_PROPERTIES
};
static GParamSpec *g_prop[N_PROPERTIES] = {0};
static void on_foreign_window_change(DiyaSessionShell* shell, DiyaForeignWindow * win, gpointer data)
{
@ -28,12 +42,6 @@ static void on_foreign_window_removed(DiyaSessionShell* shell, DiyaForeignWindow
g_warning("on_foreign_window_removed: WINDOW REMOVED %s, shell %s", diya_object_to_string(DIYA_OBJECT(win)), diya_object_to_string(DIYA_OBJECT(shell)));
}
static void session_lock(GtkWidget *widget,gpointer data)
{
(void) widget;
g_warning("Enter session lock");
diya_session_shell_lock(data);
}
static void show_windows(GtkWidget *widget,gpointer data)
{
@ -55,37 +63,107 @@ static void show_windows(GtkWidget *widget,gpointer data)
}
}
static void diya_launcher_dispose(GObject* object)
{
(void) object;
DiyaLauncher * self = DIYA_LAUNCHER(object);
g_debug("diya_launcher_dispose: %s", diya_object_to_string(object));
if(self->dashboard)
{
gtk_window_destroy(GTK_WINDOW(self->dashboard));
}
if(self->taskbar)
{
gtk_window_destroy(GTK_WINDOW(self->taskbar));
}
G_OBJECT_CLASS(diya_launcher_parent_class)->dispose(object);
}
static void diya_launcher_init(DiyaLauncher * self)
{
self->taskbar = NULL;
self->dashboard = NULL;
}
static const gchar* diya_launcher_to_string(DiyaObject* object)
{
(void) object;
return "DiyaLauncher";
}
static void diya_launcher_set_property(GObject *object, guint property_id, const GValue *value, GParamSpec *pspec)
{
DiyaLauncher * self = DIYA_LAUNCHER(object);
switch (property_id)
{
case PROP_DASHBOARD:
self->dashboard = g_value_get_pointer(value);
break;
case PROP_TASKBAR:
self->taskbar = g_value_get_pointer(value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void diya_launcher_get_property(GObject *object, guint property_id, GValue *value, GParamSpec *pspec)
{
DiyaLauncher * self = DIYA_LAUNCHER(object);
switch (property_id)
{
case PROP_DASHBOARD:
g_value_set_pointer(value, self->dashboard);
break;
case PROP_TASKBAR:
g_value_set_pointer(value, self->taskbar);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void diya_launcher_class_init(DiyaLauncherClass *class)
{
GObjectClass *gobject_class = G_OBJECT_CLASS(class);
DiyaObjectClass *base_class = DIYA_OBJECT_CLASS(class);
gobject_class->dispose = diya_launcher_dispose;
gobject_class->set_property = diya_launcher_set_property;
gobject_class->get_property = diya_launcher_get_property;
base_class->to_string = diya_launcher_to_string;
g_prop[PROP_DASHBOARD] = g_param_spec_pointer("dashboard", NULL, "Launcher dashboard", G_PARAM_READWRITE|G_PARAM_CONSTRUCT_ONLY);
g_prop[PROP_TASKBAR] = g_param_spec_pointer("taskbar", NULL, "Launcher taskbar", G_PARAM_READWRITE|G_PARAM_CONSTRUCT_ONLY);
g_object_class_install_properties (gobject_class, N_PROPERTIES, g_prop);
}
void diya_session_shell_launcher_init(DiyaSessionShell * shell)
{
assert(shell);
GtkApplication * app;
g_object_get(shell, "application", &app, NULL);
assert(app);
GtkWindow *gtk_window = GTK_WINDOW (gtk_application_window_new (app));
assert(gtk_window);
g_object_set(shell, "launchpad", gtk_window, NULL);
g_signal_connect (gtk_window, "destroy", G_CALLBACK (on_launcher_destroy), NULL);
// int layer shell for window
gtk_layer_init_for_window (gtk_window);
// anchor window to all edges
gtk_layer_set_anchor (gtk_window, GTK_LAYER_SHELL_EDGE_LEFT, true);
gtk_layer_set_anchor (gtk_window, GTK_LAYER_SHELL_EDGE_RIGHT, true);
gtk_layer_set_anchor (gtk_window, GTK_LAYER_SHELL_EDGE_TOP, false);
gtk_layer_set_anchor (gtk_window, GTK_LAYER_SHELL_EDGE_BOTTOM, true);
DiyaDashboardWidget* dashboard = DIYA_DASHBOARD_WIDGET(g_object_new (DIYA_TYPE_DASHBOARD_WIDGET, "application", app, "shell",shell, NULL));
assert(dashboard);
// set margin on window
for (int i = 0; i < GTK_LAYER_SHELL_EDGE_ENTRY_NUMBER; i++)
gtk_layer_set_margin (gtk_window, i, 0);
gtk_layer_set_layer (gtk_window, GTK_LAYER_SHELL_LAYER_TOP);
gtk_layer_set_keyboard_mode (gtk_window, GTK_LAYER_SHELL_KEYBOARD_MODE_ON_DEMAND);
gtk_layer_set_namespace (gtk_window, NAMESPACE);
// the top launcher shall be exclusive
gtk_layer_auto_exclusive_zone_enable (gtk_window);
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));
assert(self);
g_object_bind_property(taskbar, "show-dashboard", dashboard, "active", G_BINDING_BIDIRECTIONAL);
g_object_set(shell, "launchpad", self, NULL);
//g_signal_connect (GTK_WINDOW(dashboard), "destroy", G_CALLBACK (on_launcher_destroy), NULL);
gtk_widget_set_name(GTK_WIDGET(gtk_window),NAMESPACE);
gtk_window_set_default_size(gtk_window, 48, 48);
/*
GtkWidget *box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
gtk_box_set_homogeneous (GTK_BOX (box), TRUE);
gtk_window_set_child (GTK_WINDOW (gtk_window), box);
@ -98,8 +176,15 @@ void diya_session_shell_launcher_init(DiyaSessionShell * shell)
button = gtk_button_new_with_label ("show all windows");
g_signal_connect (button, "clicked", G_CALLBACK (show_windows), shell);
gtk_box_append (GTK_BOX (box), button);
//g_signal_connect (gtk_window, "orientation-changed", G_CALLBACK (on_orientation_changed), /*data*/NULL);
gtk_window_present (GTK_WINDOW (gtk_window));
button = gtk_button_new_with_label ("Dashboard");
g_signal_connect (button, "clicked", G_CALLBACK (show_dashboard), shell);
gtk_box_append (GTK_BOX (box), button);
//g_signal_connect (gtk_window, "orientation-changed", G_CALLBACK (on_orientation_changed), NULL);
*/
gtk_window_present (GTK_WINDOW (taskbar));
g_signal_connect (shell, "foreign-window-changed", G_CALLBACK (on_foreign_window_change), NULL);
g_signal_connect (shell, "foreign-window-removed", G_CALLBACK (on_foreign_window_removed), NULL);

3
src/launcher.h
View File

@ -3,6 +3,9 @@
#include "session-shell.h"
#define DIYA_TYPE_LAUNCHER (diya_launcher_get_type ())
G_DECLARE_FINAL_TYPE (DiyaLauncher, diya_launcher, DIYA, LAUNCHER, DiyaShellObject)
void diya_session_shell_launcher_init(DiyaSessionShell * shell);

2
src/login-shell.c
View File

@ -3,7 +3,7 @@
#include <gio/gio.h>
#include "login-shell.h"
#include "vkb/virtual-keyboard-widgets.h"
#include "widgets/virtual-keyboard-widgets.h"
#define DBUS_SERVER_NAME "dev.iohub.diya.SessionManager"
#define DBUS_SERVER_PATH "/dev/iohub/diya/SessionManager"

7
src/session-shell.c
View File

@ -24,7 +24,7 @@ struct _DiyaSessionShell
{
DiyaShell parent;
GtkWindow* background;
GtkWindow* launcher;
DiyaLauncher* launcher;
GHashTable* windows;
GtkSessionLockInstance* lock;
};
@ -45,7 +45,7 @@ static void diya_session_shell_dispose(GObject* object)
}
if(self->launcher)
{
gtk_window_destroy(self->launcher);
g_object_unref(self->launcher);
}
G_OBJECT_CLASS(diya_session_shell_parent_class)->dispose(object);
}
@ -103,8 +103,7 @@ static void diya_session_shell_startup(DiyaShell* shell)
static void diya_session_shell_active(DiyaShell* shell)
{
(void) shell;
// diya_session_shell_lock(DIYA_SESSION_SHELL(shell));
diya_shell_monitor_input(shell);
}
static void diya_session_shell_class_init(DiyaSessionShellClass *class)

23
src/shell.c
View File

@ -1,7 +1,8 @@
#include <glib-unix.h>
#include "shell.h"
#include "wayland.h"
#include "vkb/virtual-keyboard.h"
#include "virtual-keyboard.h"
#include "input.h"
enum
{
NO_PROP,
@ -13,7 +14,6 @@ enum
static GParamSpec *shell_properties[N_PROPERTIES] = {0};
typedef struct _DiyaShellPrivate
{
DiyaObject parent;
@ -22,12 +22,11 @@ typedef struct _DiyaShellPrivate
gchar *name;
GHashTable *vkbs;
GtkCssProvider *css_provider;
DiyaInput *input;
} DiyaShellPrivate;
G_DEFINE_TYPE_WITH_PRIVATE(DiyaShell, diya_shell, DIYA_TYPE_OBJECT);
static void diya_shell_dispose(GObject *object)
{
g_debug("diya_shell_dispose: %s", diya_object_to_string(object));
@ -46,6 +45,10 @@ static void diya_shell_dispose(GObject* object)
{
g_object_unref(priv->css_provider);
}
if (priv->input)
{
g_object_unref(priv->input);
}
g_hash_table_destroy(priv->vkbs);
G_OBJECT_CLASS(diya_shell_parent_class)->dispose(object);
if (priv->app)
@ -148,7 +151,6 @@ static gboolean diya_shell_sigint_handle(gpointer data)
return true;
}
static gboolean diya_shell_sighub_handle(DiyaShell *self)
{
// reload css file
@ -217,7 +219,6 @@ static void diya_shell_get_property(GObject *object, guint property_id, GValue *
}
}
static void diya_shell_init(DiyaShell *self)
{
DiyaShellPrivate *priv = diya_shell_get_instance_private(self);
@ -226,6 +227,7 @@ static void diya_shell_init(DiyaShell *self)
priv->name = NULL;
priv->vkbs = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, g_object_unref);
priv->css_provider = NULL;
priv->input = NULL;
}
DiyaWayland *diya_shell_get_wayland(DiyaShell *shell)
@ -328,3 +330,12 @@ DiyaVirtualKeyboard* diya_shell_get_virtual_keyboard(DiyaShell* shell, const gch
return vkb;
}
void diya_shell_monitor_input(DiyaShell *self)
{
DiyaShellPrivate *priv = diya_shell_get_instance_private(self);
if (priv->input)
{
return;
}
priv->input = diya_input_new(self);
}

1
src/shell.h
View File

@ -33,6 +33,7 @@ DiyaWayland * diya_shell_get_wayland(DiyaShell* shell);
GtkApplication* diya_shell_get_application(DiyaShell* shell);
const char* diya_shell_get_name(DiyaShell* shell);
DiyaVirtualKeyboard* diya_shell_get_virtual_keyboard(DiyaShell* shell, const gchar* name);
void diya_shell_monitor_input(DiyaShell* shell);
int diya_shell_run(DiyaShell* shell, int argc, char **argv);
#endif

0
src/vkb/virtual-keyboard.c → src/virtual-keyboard.c
View File

0
src/vkb/virtual-keyboard.h → src/virtual-keyboard.h
View File

79
src/widgets/base-widgets.c Normal file
View File

@ -0,0 +1,79 @@
#include "base-widgets.h"
#include "shell.h"
/**
* @brief Implementation of DiyaShellWindow
*
*/
enum
{
SW_NO_PROP,
SW_SHELL,
SW_N_PROPERTIES
};
static GParamSpec *g_sw_prop[SW_N_PROPERTIES] = {0};
typedef struct _DiyaShellWindowPrivate
{
GtkApplicationWindow parent;
DiyaShell * shell;
} DiyaShellWindowPrivate;
G_DEFINE_TYPE_WITH_PRIVATE(DiyaShellWindow, diya_shell_window, GTK_TYPE_APPLICATION_WINDOW)
static void diya_shell_window_dispose(GObject* object)
{
g_debug("diya_shell_window_dispose");
G_OBJECT_CLASS(diya_shell_window_parent_class)->dispose(object);
}
static void diya_shell_window_set_property(GObject *object, guint property_id, const GValue *value, GParamSpec *pspec)
{
DiyaShellWindow * self = DIYA_SHELL_WINDOW(object);
DiyaShellWindowPrivate* priv = diya_shell_window_get_instance_private(self);
switch (property_id)
{
case SW_SHELL:
priv->shell = g_value_get_pointer(value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void diya_shell_window_get_property(GObject *object, guint property_id, GValue *value, GParamSpec *pspec)
{
DiyaShellWindow * self = DIYA_SHELL_WINDOW(object);
DiyaShellWindowPrivate* priv = diya_shell_window_get_instance_private(self);
switch (property_id)
{
case SW_SHELL:
g_value_set_pointer(value, priv->shell);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void diya_shell_window_init(DiyaShellWindow *self)
{
DiyaShellWindowPrivate* priv = diya_shell_window_get_instance_private(self);
priv->shell = NULL;
}
static void diya_shell_window_class_init(DiyaShellWindowClass *class)
{
GObjectClass *gobject_class = G_OBJECT_CLASS(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;
g_sw_prop[SW_SHELL] = g_param_spec_pointer("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);
}

16
src/widgets/base-widgets.h Normal file
View File

@ -0,0 +1,16 @@
#ifndef DIYA_BASE_WIDGETS_H
#define DIYA_BASE_WIDGETS_H
#include <glib-object.h>
#include <assert.h>
#include <gtk/gtk.h>
#define DIYA_TYPE_SHELL_WINDOW (diya_shell_window_get_type())
G_DECLARE_DERIVABLE_TYPE(DiyaShellWindow, diya_shell_window, DIYA, SHELL_WINDOW, GtkApplicationWindow)
struct _DiyaShellWindowClass
{
GtkApplicationWindowClass parent_class;
};
#endif

129
src/widgets/dashboard-widget.c Normal file
View File

@ -0,0 +1,129 @@
#include "dashboard-widget.h"
struct _DiyaDashboardWidget
{
DiyaShellWindow parent;
GtkWidget *revealer;
GtkWidget *search_entry;
bool active;
};
enum
{
NO_PROP,
PROP_ACTIVE,
N_PROPERTIES
};
static GParamSpec *g_prop[N_PROPERTIES] = {0};
G_DEFINE_TYPE (DiyaDashboardWidget, diya_dashboard_widget, DIYA_TYPE_SHELL_WINDOW)
static void diya_dashboard_widget_dispose(GObject* object)
{
(void) object;
g_debug("diya_dashboard_widget_dispose");
G_OBJECT_CLASS(diya_dashboard_widget_parent_class)->dispose(object);
}
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));
// anchor window to all edges
gtk_layer_set_anchor (GTK_WINDOW(self), GTK_LAYER_SHELL_EDGE_LEFT, true);
gtk_layer_set_anchor (GTK_WINDOW(self), GTK_LAYER_SHELL_EDGE_RIGHT, true);
gtk_layer_set_anchor (GTK_WINDOW(self), GTK_LAYER_SHELL_EDGE_TOP, true);
gtk_layer_set_anchor (GTK_WINDOW(self), GTK_LAYER_SHELL_EDGE_BOTTOM, true);
gtk_layer_set_namespace(GTK_WINDOW(self), "diya-dashboard");
// set margin on window
for (int i = 0; i < GTK_LAYER_SHELL_EDGE_ENTRY_NUMBER; i++)
gtk_layer_set_margin (GTK_WINDOW(self), i, 0);
gtk_layer_set_layer (GTK_WINDOW(self), GTK_LAYER_SHELL_LAYER_TOP);
//gtk_layer_set_keyboard_mode (GTK_WINDOW(self), GTK_LAYER_SHELL_KEYBOARD_MODE_ON_DEMAND);
// the top launcher shall be exclusive
//gtk_layer_auto_exclusive_zone_enable (GTK_WINDOW(self));
gtk_layer_set_keyboard_mode(GTK_WINDOW(self), GTK_LAYER_SHELL_KEYBOARD_MODE_ON_DEMAND);
// gtk_widget_set_can_focus(GTK_WIDGET(self), true);
//gtk_widget_set_name(GTK_WIDGET(dashboard),NAMESPACE);
//gtk_window_set_default_size(GTK_WINDOW(dashboard), 48, 48);
}
static void diya_dashboard_set_property(GObject *object, guint property_id, const GValue *value, GParamSpec *pspec)
{
DiyaDashboardWidget * self = DIYA_DASHBOARD_WIDGET(object);
switch (property_id)
{
case PROP_ACTIVE:
self->active = g_value_get_boolean(value);
if(self->active)
{
gtk_window_present(GTK_WINDOW(self));
// gtk_widget_set_visible(GTK_WIDGET(self), true);
gtk_revealer_set_reveal_child(GTK_REVEALER(self->revealer), true);
gtk_window_set_focus(GTK_WINDOW(self), self->search_entry);
// gtk_widget_grab_focus( GTK_WIDGET(self->search_entry));
}
else
{
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;
}
}
static void diya_dashboard_get_property(GObject *object, guint property_id, GValue *value, GParamSpec *pspec)
{
DiyaDashboardWidget * self = DIYA_DASHBOARD_WIDGET(object);
switch (property_id)
{
case PROP_ACTIVE:
g_value_set_boolean(value, self->active);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void diya_dashboard_widget_class_init(DiyaDashboardWidgetClass* class)
{
GObjectClass *gobject_class = G_OBJECT_CLASS(class);
gobject_class->dispose = diya_dashboard_widget_dispose;
gobject_class->set_property = diya_dashboard_set_property;
gobject_class->get_property = diya_dashboard_get_property;
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);
//gtk_widget_class_bind_template_callback (GTK_WIDGET_CLASS (class), diya_dashboard_toggle);
gtk_widget_class_set_css_name(GTK_WIDGET_CLASS(class), "diya-dashboard");
//gtk_widget_class_bind_template_child(GTK_WIDGET_CLASS (class), ExampleAppWindow, stack);
//gtk_widget_class_bind_template_callback (GTK_WIDGET_CLASS (class), search_text_changed);
g_prop[PROP_ACTIVE] = g_param_spec_boolean("active", NULL, "Active the dashboard", false, G_PARAM_READWRITE); //
g_object_class_install_properties (gobject_class, N_PROPERTIES, g_prop);
}

10
src/widgets/dashboard-widget.h Normal file
View File

@ -0,0 +1,10 @@
#ifndef DIYA_DASHBOARD_WIDGET_H
#define DIYA_DASHBOARD_WIDGET_H
#include "session-shell.h"
#include "base-widgets.h"
#define DIYA_TYPE_DASHBOARD_WIDGET (diya_dashboard_widget_get_type())
G_DECLARE_FINAL_TYPE (DiyaDashboardWidget, diya_dashboard_widget, DIYA, DASHBOARD_WIDGET, DiyaShellWindow)
#endif

128
src/widgets/taskbar-widget.c Normal file
View File

@ -0,0 +1,128 @@
#include "taskbar-widget.h"
struct _DiyaTaskbarWidget
{
DiyaShellWindow parent;
GtkWidget *btn_toggle;
bool active_dashboard;
};
enum
{
NO_PROP,
PROP_SHOW_DASHBOARD,
N_PROPERTIES
};
static GParamSpec *g_prop[N_PROPERTIES] = {0};
G_DEFINE_TYPE (DiyaTaskbarWidget, diya_taskbar_widget, DIYA_TYPE_SHELL_WINDOW)
static void diya_taskbar_widget_dispose(GObject* object)
{
(void) object;
g_debug("diya_taskbar_widget_dispose");
G_OBJECT_CLASS(diya_taskbar_widget_parent_class)->dispose(object);
}
static void diya_taskbar_widget_init(DiyaTaskbarWidget * self)
{
g_debug("diya_taskbar_widget_init");
gtk_widget_init_template (GTK_WIDGET(self));
self->active_dashboard = 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(taskbar), "destroy", G_CALLBACK (on_launcher_destroy), NULL);
// int layer shell for window
gtk_layer_init_for_window (GTK_WINDOW(self));
// anchor window to all edges
gtk_layer_set_anchor (GTK_WINDOW(self), GTK_LAYER_SHELL_EDGE_LEFT, true);
gtk_layer_set_anchor (GTK_WINDOW(self), GTK_LAYER_SHELL_EDGE_RIGHT, true);
gtk_layer_set_anchor (GTK_WINDOW(self), GTK_LAYER_SHELL_EDGE_TOP, false);
gtk_layer_set_anchor (GTK_WINDOW(self), GTK_LAYER_SHELL_EDGE_BOTTOM, true);
gtk_layer_set_namespace(GTK_WINDOW(self), "diya-taskbar");
// set margin on window
for (int i = 0; i < GTK_LAYER_SHELL_EDGE_ENTRY_NUMBER; i++)
gtk_layer_set_margin (GTK_WINDOW(self), i, 0);
gtk_layer_set_layer (GTK_WINDOW(self), GTK_LAYER_SHELL_LAYER_TOP);
gtk_layer_set_keyboard_mode (GTK_WINDOW(self), GTK_LAYER_SHELL_KEYBOARD_MODE_ON_DEMAND);
// the top launcher shall be exclusive
gtk_layer_auto_exclusive_zone_enable (GTK_WINDOW(self));
g_object_bind_property(self->btn_toggle, "active", self, "show-dashboard", G_BINDING_BIDIRECTIONAL);
}
static void diya_taskbar_set_property(GObject *object, guint property_id, const GValue *value, GParamSpec *pspec)
{
DiyaTaskbarWidget * self = DIYA_TASKBAR_WIDGET(object);
switch (property_id)
{
case PROP_SHOW_DASHBOARD:
self->active_dashboard = g_value_get_boolean(value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void diya_taskbar_get_property(GObject *object, guint property_id, GValue *value, GParamSpec *pspec)
{
DiyaTaskbarWidget * self = DIYA_TASKBAR_WIDGET(object);
switch (property_id)
{
case PROP_SHOW_DASHBOARD:
g_value_set_boolean(value, self->active_dashboard);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
/*
static void diya_dashboard_toggle(GtkToggleButton* btn, DiyaTaskbarWidget* self)
{
g_warning("TODDLDLDL");
if(gtk_toggle_button_get_active(btn))
{
gtk_layer_set_exclusive_zone(GTK_WINDOW(self), 0);
}
else
{
gtk_layer_auto_exclusive_zone_enable (GTK_WINDOW(self));
}
}
*/
static void diya_taskbar_widget_class_init(DiyaTaskbarWidgetClass* class)
{
GObjectClass *gobject_class = G_OBJECT_CLASS(class);
gobject_class->dispose = diya_taskbar_widget_dispose;
gobject_class->set_property = diya_taskbar_set_property;
gobject_class->get_property = diya_taskbar_get_property;
gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (class),"/dev/iohub/diya/shell/taskbar.ui");
gtk_widget_class_bind_template_child (GTK_WIDGET_CLASS (class), DiyaTaskbarWidget, btn_toggle);
// gtk_widget_class_bind_template_callback (GTK_WIDGET_CLASS (class), diya_dashboard_toggle);
gtk_widget_class_set_css_name(GTK_WIDGET_CLASS(class), "diya-taskbar");
//gtk_widget_class_bind_template_child(GTK_WIDGET_CLASS (class), ExampleAppWindow, stack);
//gtk_widget_class_bind_template_callback (GTK_WIDGET_CLASS (class), search_text_changed);
g_prop[PROP_SHOW_DASHBOARD] = g_param_spec_boolean("show-dashboard", NULL, "Show/hide dashboard", false, G_PARAM_READWRITE); //
g_object_class_install_properties (gobject_class, N_PROPERTIES, g_prop);
}

10
src/widgets/taskbar-widget.h Normal file
View File

@ -0,0 +1,10 @@
#ifndef DIYA_TASKBAR_WIDGET_H
#define DIYA_TASKBAR_WIDGET_H
#include "session-shell.h"
#include "base-widgets.h"
#define DIYA_TYPE_TASKBAR_WIDGET (diya_taskbar_widget_get_type())
G_DECLARE_FINAL_TYPE (DiyaTaskbarWidget, diya_taskbar_widget, DIYA, TASKBAR_WIDGET, DiyaShellWindow)
#endif

0
src/vkb/virtual-keyboard-widgets.c → src/widgets/virtual-keyboard-widgets.c
View File

0
src/vkb/virtual-keyboard-widgets.h → src/widgets/virtual-keyboard-widgets.h
View File