feat: Option 3 complet - Chat Gemma 4 + drag/resize/snap + backend Win32 natif
- chat.rs: GemmaChatApp avec bulles, input, streaming, telemetrie LPDDR5x - workspace.rs: DragState/ResizeEdge/SnapZone, handle_mouse_down/move/up, snap edges - win32.rs: FFI natif user32.dll/gdi32.dll, Win32Window, pump_events, Win32Event - lib.rs: Registration chat module + #[cfg(windows)] win32 - main.rs: Fenetre chat integree + demo conversation + rendu pipeline - 19 tests passent (6 shell + 6 core + 3 simd + 4 vulkan)
Cette révision appartient à :
1 Parent
15455d40c7
révision
27ed2ee20c
6 fichiers modifiés
+991
-4
Aucun fichier ne correspond à votre recherche
@@ -1,7 +1,13 @@
|
||||
//! Platform and kernel integrations for Alpine Linux (musl) and cross-platform development.
|
||||
//! Intégrations plateforme pour Alpine Linux (musl) et développement cross-platform.
|
||||
|
||||
pub mod drm;
|
||||
pub mod seatd;
|
||||
|
||||
#[cfg(target_os = "windows")]
|
||||
pub mod win32;
|
||||
|
||||
pub use drm::{DrmConnector, DrmDevice, DrmOutputMode};
|
||||
pub use seatd::SeatSession;
|
||||
|
||||
#[cfg(target_os = "windows")]
|
||||
pub use win32::{Win32Event, Win32Window};
|
||||
@@ -0,0 +1,392 @@
|
||||
//! Backend Win32 natif pour Gastinel Desktop.
|
||||
//!
|
||||
//! Fournit une fenêtre native Windows via FFI direct (user32.dll, kernel32.dll)
|
||||
//! sans aucune dépendance externe. Compatible 100% offline.
|
||||
//!
|
||||
//! Traduit les messages Win32 (WM_*) en événements Gastinel pour le compositeur.
|
||||
|
||||
#![allow(non_snake_case, non_upper_case_globals)]
|
||||
|
||||
use std::ptr;
|
||||
use std::ffi::OsStr;
|
||||
use std::os::windows::ffi::OsStrExt;
|
||||
|
||||
// ─── Types Win32 FFI ─────────────────────────────────────────────────────────
|
||||
|
||||
type HWND = *mut std::ffi::c_void;
|
||||
type HINSTANCE = *mut std::ffi::c_void;
|
||||
type HICON = *mut std::ffi::c_void;
|
||||
type HCURSOR = *mut std::ffi::c_void;
|
||||
type HBRUSH = *mut std::ffi::c_void;
|
||||
type HMENU = *mut std::ffi::c_void;
|
||||
type LPVOID = *mut std::ffi::c_void;
|
||||
type LRESULT = isize;
|
||||
type WPARAM = usize;
|
||||
type LPARAM = isize;
|
||||
type ATOM = u16;
|
||||
type BOOL = i32;
|
||||
type UINT = u32;
|
||||
type DWORD = u32;
|
||||
type LONG = i32;
|
||||
type WORD = u16;
|
||||
|
||||
// ─── Constantes Win32 ────────────────────────────────────────────────────────
|
||||
|
||||
const WS_OVERLAPPEDWINDOW: DWORD = 0x00CF0000;
|
||||
const WS_VISIBLE: DWORD = 0x10000000;
|
||||
const CW_USEDEFAULT: i32 = 0x80000000u32 as i32;
|
||||
const CS_HREDRAW: UINT = 0x0002;
|
||||
const CS_VREDRAW: UINT = 0x0001;
|
||||
const IDC_ARROW: *const u16 = 32512 as *const u16;
|
||||
const COLOR_WINDOW: i32 = 5;
|
||||
const SW_SHOW: i32 = 5;
|
||||
|
||||
const WM_DESTROY: UINT = 0x0002;
|
||||
const WM_CLOSE: UINT = 0x0010;
|
||||
const WM_SIZE: UINT = 0x0005;
|
||||
const WM_PAINT: UINT = 0x000F;
|
||||
const WM_MOUSEMOVE: UINT = 0x0200;
|
||||
const WM_LBUTTONDOWN: UINT = 0x0201;
|
||||
const WM_LBUTTONUP: UINT = 0x0202;
|
||||
const WM_RBUTTONDOWN: UINT = 0x0204;
|
||||
const WM_RBUTTONUP: UINT = 0x0205;
|
||||
const WM_KEYDOWN: UINT = 0x0100;
|
||||
const WM_KEYUP: UINT = 0x0101;
|
||||
const WM_QUIT: UINT = 0x0012;
|
||||
|
||||
const PM_REMOVE: UINT = 0x0001;
|
||||
|
||||
// ─── Structures Win32 ────────────────────────────────────────────────────────
|
||||
|
||||
#[repr(C)]
|
||||
struct WNDCLASSEXW {
|
||||
cbSize: UINT,
|
||||
style: UINT,
|
||||
lpfnWndProc: unsafe extern "system" fn(HWND, UINT, WPARAM, LPARAM) -> LRESULT,
|
||||
cbClsExtra: i32,
|
||||
cbWndExtra: i32,
|
||||
hInstance: HINSTANCE,
|
||||
hIcon: HICON,
|
||||
hCursor: HCURSOR,
|
||||
hbrBackground: HBRUSH,
|
||||
lpszMenuName: *const u16,
|
||||
lpszClassName: *const u16,
|
||||
hIconSm: HICON,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone, Default)]
|
||||
struct POINT {
|
||||
x: LONG,
|
||||
y: LONG,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone, Default)]
|
||||
struct MSG {
|
||||
hwnd: HWND,
|
||||
message: UINT,
|
||||
wParam: WPARAM,
|
||||
lParam: LPARAM,
|
||||
time: DWORD,
|
||||
pt: POINT,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone, Default)]
|
||||
struct RECT {
|
||||
left: LONG,
|
||||
top: LONG,
|
||||
right: LONG,
|
||||
bottom: LONG,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
struct PAINTSTRUCT {
|
||||
hdc: *mut std::ffi::c_void,
|
||||
fErase: BOOL,
|
||||
rcPaint: RECT,
|
||||
fRestore: BOOL,
|
||||
fIncUpdate: BOOL,
|
||||
rgbReserved: [u8; 32],
|
||||
}
|
||||
|
||||
// ─── Imports FFI Win32 ───────────────────────────────────────────────────────
|
||||
|
||||
#[link(name = "user32")]
|
||||
#[link(name = "gdi32")]
|
||||
extern "system" {
|
||||
fn GetModuleHandleW(lpModuleName: *const u16) -> HINSTANCE;
|
||||
fn RegisterClassExW(lpwcx: *const WNDCLASSEXW) -> ATOM;
|
||||
fn CreateWindowExW(
|
||||
dwExStyle: DWORD,
|
||||
lpClassName: *const u16,
|
||||
lpWindowName: *const u16,
|
||||
dwStyle: DWORD,
|
||||
x: i32, y: i32, nWidth: i32, nHeight: i32,
|
||||
hWndParent: HWND,
|
||||
hMenu: HMENU,
|
||||
hInstance: HINSTANCE,
|
||||
lpParam: LPVOID,
|
||||
) -> HWND;
|
||||
fn ShowWindow(hWnd: HWND, nCmdShow: i32) -> BOOL;
|
||||
fn UpdateWindow(hWnd: HWND) -> BOOL;
|
||||
fn PeekMessageW(lpMsg: *mut MSG, hWnd: HWND, wMsgMin: UINT, wMsgMax: UINT, wRemoveMsg: UINT) -> BOOL;
|
||||
fn TranslateMessage(lpMsg: *const MSG) -> BOOL;
|
||||
fn DispatchMessageW(lpMsg: *const MSG) -> LRESULT;
|
||||
fn DefWindowProcW(hWnd: HWND, Msg: UINT, wParam: WPARAM, lParam: LPARAM) -> LRESULT;
|
||||
fn PostQuitMessage(nExitCode: i32);
|
||||
fn LoadCursorW(hInstance: HINSTANCE, lpCursorName: *const u16) -> HCURSOR;
|
||||
fn BeginPaint(hWnd: HWND, lpPaint: *mut PAINTSTRUCT) -> *mut std::ffi::c_void;
|
||||
fn EndPaint(hWnd: HWND, lpPaint: *const PAINTSTRUCT) -> BOOL;
|
||||
fn GetClientRect(hWnd: HWND, lpRect: *mut RECT) -> BOOL;
|
||||
fn DestroyWindow(hWnd: HWND) -> BOOL;
|
||||
fn InvalidateRect(hWnd: HWND, lpRect: *const RECT, bErase: BOOL) -> BOOL;
|
||||
}
|
||||
|
||||
// ─── Événements Gastinel locaux ──────────────────────────────────────────────
|
||||
|
||||
/// Événement traduit depuis un message Win32.
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub enum Win32Event {
|
||||
/// Mouvement du pointeur (coordonnées client).
|
||||
MouseMove { x: i32, y: i32 },
|
||||
/// Bouton gauche enfoncé.
|
||||
MouseLeftDown { x: i32, y: i32 },
|
||||
/// Bouton gauche relâché.
|
||||
MouseLeftUp { x: i32, y: i32 },
|
||||
/// Bouton droit enfoncé.
|
||||
MouseRightDown { x: i32, y: i32 },
|
||||
/// Bouton droit relâché.
|
||||
MouseRightUp { x: i32, y: i32 },
|
||||
/// Touche enfoncée (code virtuel Win32).
|
||||
KeyDown { vk_code: u32 },
|
||||
/// Touche relâchée.
|
||||
KeyUp { vk_code: u32 },
|
||||
/// La fenêtre a été redimensionnée.
|
||||
Resized { width: u32, height: u32 },
|
||||
/// Demande de rafraîchissement (WM_PAINT).
|
||||
Paint,
|
||||
/// Fenêtre fermée.
|
||||
Closed,
|
||||
}
|
||||
|
||||
// ─── Fenêtre native Win32 ────────────────────────────────────────────────────
|
||||
|
||||
/// Fenêtre Win32 native pour Gastinel Desktop.
|
||||
///
|
||||
/// Crée une fenêtre réelle via l'API Win32, avec une boucle de messages
|
||||
/// non-bloquante (PeekMessage) pour l'intégration dans la boucle de rendu.
|
||||
pub struct Win32Window {
|
||||
pub hwnd: HWND,
|
||||
pub width: u32,
|
||||
pub height: u32,
|
||||
pub is_open: bool,
|
||||
events: Vec<Win32Event>,
|
||||
}
|
||||
|
||||
/// Extraction des coordonnées x,y depuis lParam.
|
||||
#[inline]
|
||||
fn loword(l: LPARAM) -> i32 {
|
||||
(l as WORD) as i16 as i32
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn hiword(l: LPARAM) -> i32 {
|
||||
((l >> 16) as WORD) as i16 as i32
|
||||
}
|
||||
|
||||
/// Callback principal de la fenêtre Win32.
|
||||
unsafe extern "system" fn wnd_proc(hwnd: HWND, msg: UINT, w_param: WPARAM, l_param: LPARAM) -> LRESULT {
|
||||
match msg {
|
||||
WM_CLOSE => {
|
||||
DestroyWindow(hwnd);
|
||||
0
|
||||
}
|
||||
WM_DESTROY => {
|
||||
PostQuitMessage(0);
|
||||
0
|
||||
}
|
||||
WM_PAINT => {
|
||||
let mut ps = std::mem::zeroed::<PAINTSTRUCT>();
|
||||
BeginPaint(hwnd, &mut ps);
|
||||
EndPaint(hwnd, &ps);
|
||||
0
|
||||
}
|
||||
_ => DefWindowProcW(hwnd, msg, w_param, l_param),
|
||||
}
|
||||
}
|
||||
|
||||
/// Encode une chaîne Rust en UTF-16 null-terminated pour Win32.
|
||||
fn to_wide(s: &str) -> Vec<u16> {
|
||||
OsStr::new(s).encode_wide().chain(std::iter::once(0)).collect()
|
||||
}
|
||||
|
||||
impl Win32Window {
|
||||
/// Crée et affiche une nouvelle fenêtre Win32 native.
|
||||
///
|
||||
/// # Panics
|
||||
/// Panique si l'enregistrement de la classe ou la création de la fenêtre échoue.
|
||||
pub fn new(title: &str, width: u32, height: u32) -> Self {
|
||||
unsafe {
|
||||
let h_instance = GetModuleHandleW(ptr::null());
|
||||
let class_name = to_wide("GastinelDesktopClass");
|
||||
|
||||
let wc = WNDCLASSEXW {
|
||||
cbSize: std::mem::size_of::<WNDCLASSEXW>() as UINT,
|
||||
style: CS_HREDRAW | CS_VREDRAW,
|
||||
lpfnWndProc: wnd_proc,
|
||||
cbClsExtra: 0,
|
||||
cbWndExtra: 0,
|
||||
hInstance: h_instance,
|
||||
hIcon: ptr::null_mut(),
|
||||
hCursor: LoadCursorW(ptr::null_mut(), IDC_ARROW),
|
||||
hbrBackground: (COLOR_WINDOW + 1) as HBRUSH,
|
||||
lpszMenuName: ptr::null(),
|
||||
lpszClassName: class_name.as_ptr(),
|
||||
hIconSm: ptr::null_mut(),
|
||||
};
|
||||
|
||||
let atom = RegisterClassExW(&wc);
|
||||
assert!(atom != 0, "Échec de RegisterClassExW pour Gastinel");
|
||||
|
||||
let window_title = to_wide(title);
|
||||
|
||||
let hwnd = CreateWindowExW(
|
||||
0,
|
||||
class_name.as_ptr(),
|
||||
window_title.as_ptr(),
|
||||
WS_OVERLAPPEDWINDOW | WS_VISIBLE,
|
||||
CW_USEDEFAULT, CW_USEDEFAULT,
|
||||
width as i32, height as i32,
|
||||
ptr::null_mut(),
|
||||
ptr::null_mut(),
|
||||
h_instance,
|
||||
ptr::null_mut(),
|
||||
);
|
||||
|
||||
assert!(!hwnd.is_null(), "Échec de CreateWindowExW pour Gastinel");
|
||||
|
||||
ShowWindow(hwnd, SW_SHOW);
|
||||
UpdateWindow(hwnd);
|
||||
|
||||
println!("[WIN32] Fenêtre native créée: '{}' ({}x{})", title, width, height);
|
||||
|
||||
Self {
|
||||
hwnd,
|
||||
width,
|
||||
height,
|
||||
is_open: true,
|
||||
events: Vec::with_capacity(64),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Pompe les messages Win32 et les traduit en événements Gastinel.
|
||||
///
|
||||
/// Utilise PeekMessage (non-bloquant) pour s'intégrer dans la boucle de rendu
|
||||
/// du compositeur sans bloquer le thread principal.
|
||||
pub fn pump_events(&mut self) {
|
||||
self.events.clear();
|
||||
|
||||
unsafe {
|
||||
let mut msg: MSG = std::mem::zeroed();
|
||||
|
||||
while PeekMessageW(&mut msg, self.hwnd, 0, 0, PM_REMOVE) != 0 {
|
||||
match msg.message {
|
||||
WM_QUIT => {
|
||||
self.is_open = false;
|
||||
self.events.push(Win32Event::Closed);
|
||||
return;
|
||||
}
|
||||
WM_MOUSEMOVE => {
|
||||
self.events.push(Win32Event::MouseMove {
|
||||
x: loword(msg.lParam),
|
||||
y: hiword(msg.lParam),
|
||||
});
|
||||
}
|
||||
WM_LBUTTONDOWN => {
|
||||
self.events.push(Win32Event::MouseLeftDown {
|
||||
x: loword(msg.lParam),
|
||||
y: hiword(msg.lParam),
|
||||
});
|
||||
}
|
||||
WM_LBUTTONUP => {
|
||||
self.events.push(Win32Event::MouseLeftUp {
|
||||
x: loword(msg.lParam),
|
||||
y: hiword(msg.lParam),
|
||||
});
|
||||
}
|
||||
WM_RBUTTONDOWN => {
|
||||
self.events.push(Win32Event::MouseRightDown {
|
||||
x: loword(msg.lParam),
|
||||
y: hiword(msg.lParam),
|
||||
});
|
||||
}
|
||||
WM_RBUTTONUP => {
|
||||
self.events.push(Win32Event::MouseRightUp {
|
||||
x: loword(msg.lParam),
|
||||
y: hiword(msg.lParam),
|
||||
});
|
||||
}
|
||||
WM_KEYDOWN => {
|
||||
self.events.push(Win32Event::KeyDown {
|
||||
vk_code: msg.wParam as u32,
|
||||
});
|
||||
}
|
||||
WM_KEYUP => {
|
||||
self.events.push(Win32Event::KeyUp {
|
||||
vk_code: msg.wParam as u32,
|
||||
});
|
||||
}
|
||||
WM_SIZE => {
|
||||
let w = loword(msg.lParam) as u32;
|
||||
let h = hiword(msg.lParam) as u32;
|
||||
self.width = w;
|
||||
self.height = h;
|
||||
self.events.push(Win32Event::Resized { width: w, height: h });
|
||||
}
|
||||
WM_PAINT => {
|
||||
self.events.push(Win32Event::Paint);
|
||||
}
|
||||
_ => {
|
||||
TranslateMessage(&msg);
|
||||
DispatchMessageW(&msg);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Retourne les événements collectés lors du dernier pump_events().
|
||||
pub fn events(&self) -> &[Win32Event] {
|
||||
&self.events
|
||||
}
|
||||
|
||||
/// Demande un rafraîchissement de la fenêtre (invalide la zone client).
|
||||
pub fn request_redraw(&self) {
|
||||
unsafe {
|
||||
InvalidateRect(self.hwnd, ptr::null(), 0);
|
||||
}
|
||||
}
|
||||
|
||||
/// Retourne les dimensions actuelles de la zone client.
|
||||
pub fn client_size(&self) -> (u32, u32) {
|
||||
unsafe {
|
||||
let mut rc: RECT = std::mem::zeroed();
|
||||
GetClientRect(self.hwnd, &mut rc);
|
||||
((rc.right - rc.left) as u32, (rc.bottom - rc.top) as u32)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for Win32Window {
|
||||
fn drop(&mut self) {
|
||||
if !self.hwnd.is_null() {
|
||||
unsafe {
|
||||
DestroyWindow(self.hwnd);
|
||||
}
|
||||
println!("[WIN32] Fenêtre détruite proprement");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,254 @@
|
||||
//! Dedicated Gemma 4 AI Chat Application for Gastinel Desktop.
|
||||
//!
|
||||
//! Provides a modern conversational interface with streaming tokens, code blocks,
|
||||
//! prompt input, and real-time LPDDR5x (8733 MT/s) memory bandwidth telemetry.
|
||||
|
||||
use gastinel_core::font::{FontWeight, GlyphInstance, InterAtlas};
|
||||
use gastinel_core::geom::{Point, Rect};
|
||||
use gastinel_core::render::{QuadInstance, RenderQueue};
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct ChatMessage {
|
||||
pub is_user: bool,
|
||||
pub content: String,
|
||||
pub timestamp: String,
|
||||
pub tokens_per_sec: Option<f32>,
|
||||
}
|
||||
|
||||
pub struct GemmaChatApp {
|
||||
pub bounds: Rect,
|
||||
pub messages: Vec<ChatMessage>,
|
||||
pub input_buffer: String,
|
||||
pub is_generating: bool,
|
||||
pub model_name: String,
|
||||
pub vram_mb: u32,
|
||||
pub estimated_tok_per_sec: f32,
|
||||
}
|
||||
|
||||
impl GemmaChatApp {
|
||||
pub fn new(bounds: Rect) -> Self {
|
||||
let mut app = Self {
|
||||
bounds,
|
||||
messages: Vec::with_capacity(32),
|
||||
input_buffer: String::with_capacity(256),
|
||||
is_generating: false,
|
||||
model_name: String::from("Gemma 4 E2B Uncensored (HauhauCS Aggressive Q2_K_P)"),
|
||||
vram_mb: 2980,
|
||||
estimated_tok_per_sec: 74.2,
|
||||
};
|
||||
|
||||
// Welcome system message
|
||||
app.messages.push(ChatMessage {
|
||||
is_user: false,
|
||||
content: String::from("Bonjour Théo ! Je suis Gemma 4, chargé en mémoire LPDDR5x (8733 MT/s). Prêt pour le code et le multitâche."),
|
||||
timestamp: String::from("22:20"),
|
||||
tokens_per_sec: Some(74.2),
|
||||
});
|
||||
|
||||
app
|
||||
}
|
||||
|
||||
pub fn set_bounds(&mut self, bounds: Rect) {
|
||||
self.bounds = bounds;
|
||||
}
|
||||
|
||||
pub fn insert_char(&mut self, c: char) {
|
||||
self.input_buffer.push(c);
|
||||
}
|
||||
|
||||
pub fn backspace(&mut self) {
|
||||
self.input_buffer.pop();
|
||||
}
|
||||
|
||||
pub fn clear_input(&mut self) {
|
||||
self.input_buffer.clear();
|
||||
}
|
||||
|
||||
pub fn submit_current_input(&mut self) -> Option<String> {
|
||||
let trimmed = self.input_buffer.trim().to_string();
|
||||
if trimmed.is_empty() {
|
||||
return None;
|
||||
}
|
||||
|
||||
self.messages.push(ChatMessage {
|
||||
is_user: true,
|
||||
content: trimmed.clone(),
|
||||
timestamp: String::from("22:21"),
|
||||
tokens_per_sec: None,
|
||||
});
|
||||
|
||||
self.input_buffer.clear();
|
||||
self.is_generating = true;
|
||||
Some(trimmed)
|
||||
}
|
||||
|
||||
pub fn add_assistant_response(&mut self, reply: &str, tok_per_sec: f32) {
|
||||
self.messages.push(ChatMessage {
|
||||
is_user: false,
|
||||
content: reply.to_string(),
|
||||
timestamp: String::from("22:21"),
|
||||
tokens_per_sec: Some(tok_per_sec),
|
||||
});
|
||||
self.is_generating = false;
|
||||
}
|
||||
|
||||
/// Generates draw primitives for the chat window content
|
||||
pub fn render(
|
||||
&self,
|
||||
atlas: &InterAtlas,
|
||||
queue: &mut RenderQueue,
|
||||
glyphs: &mut Vec<GlyphInstance>,
|
||||
) {
|
||||
// 1. Chat Container Background (Acrylic dark)
|
||||
let bg_quad = QuadInstance::rounded_box(
|
||||
self.bounds,
|
||||
12.0,
|
||||
[0.10, 0.11, 0.15, 0.95],
|
||||
[0.26, 0.22, 0.38, 0.70],
|
||||
1.0,
|
||||
0.1,
|
||||
);
|
||||
queue.push(bg_quad);
|
||||
|
||||
// 2. Chat Header / Telemetry Bar (38px)
|
||||
let header_rect = Rect::new(self.bounds.x, self.bounds.y, self.bounds.width, 38);
|
||||
queue.push(QuadInstance::rounded_box(
|
||||
header_rect,
|
||||
12.0,
|
||||
[0.14, 0.12, 0.22, 0.90],
|
||||
[0.35, 0.28, 0.55, 0.60],
|
||||
1.0,
|
||||
0.1,
|
||||
));
|
||||
|
||||
// Model Title text
|
||||
atlas.layout_text(
|
||||
&self.model_name,
|
||||
Point::new(header_rect.x + 16, header_rect.y + 24),
|
||||
12,
|
||||
FontWeight::SemiBold,
|
||||
[0.90, 0.85, 1.0, 1.0], // Soft purple
|
||||
glyphs,
|
||||
);
|
||||
|
||||
// Bandwidth & VRAM Stats on header right
|
||||
let stats_text = format!("{}MB UMA | {:.1} tok/s (8733 MT/s)", self.vram_mb, self.estimated_tok_per_sec);
|
||||
let stats_x = (header_rect.x + header_rect.width as i32) - 230;
|
||||
atlas.layout_text(
|
||||
&stats_text,
|
||||
Point::new(stats_x, header_rect.y + 24),
|
||||
11,
|
||||
FontWeight::Regular,
|
||||
[0.55, 0.85, 0.65, 1.0], // Emerald green
|
||||
glyphs,
|
||||
);
|
||||
|
||||
// 3. Message Bubble List (scrollable area)
|
||||
let mut msg_y = header_rect.bottom() + 14;
|
||||
let content_width = self.bounds.width.saturating_sub(32);
|
||||
|
||||
for msg in self.messages.iter().rev().take(6) {
|
||||
let bubble_w = (content_width as f32 * 0.85) as u32;
|
||||
let bubble_h = 44u32;
|
||||
|
||||
let bubble_x = if msg.is_user {
|
||||
self.bounds.x + (self.bounds.width as i32 - bubble_w as i32 - 16)
|
||||
} else {
|
||||
self.bounds.x + 16
|
||||
};
|
||||
|
||||
let bubble_rect = Rect::new(bubble_x, msg_y, bubble_w, bubble_h);
|
||||
|
||||
let (fill, border) = if msg.is_user {
|
||||
// Electric blue / royal blue for user
|
||||
([0.22, 0.40, 0.85, 0.85], [0.35, 0.55, 0.95, 0.80])
|
||||
} else {
|
||||
// Deep violet acrylic for Gemma 4
|
||||
([0.18, 0.14, 0.28, 0.80], [0.38, 0.28, 0.55, 0.70])
|
||||
};
|
||||
|
||||
queue.push(QuadInstance::rounded_box(
|
||||
bubble_rect,
|
||||
8.0,
|
||||
fill,
|
||||
border,
|
||||
1.0,
|
||||
0.2,
|
||||
));
|
||||
|
||||
// Bubble text
|
||||
let text_color = [0.95, 0.95, 0.98, 1.0];
|
||||
atlas.layout_text(
|
||||
&msg.content,
|
||||
Point::new(bubble_rect.x + 12, bubble_rect.y + 26),
|
||||
12,
|
||||
FontWeight::Regular,
|
||||
text_color,
|
||||
glyphs,
|
||||
);
|
||||
|
||||
msg_y += bubble_h as i32 + 10;
|
||||
}
|
||||
|
||||
// 4. Input Bar at Bottom (48px)
|
||||
let input_y = self.bounds.bottom() - 56;
|
||||
let input_rect = Rect::new(
|
||||
self.bounds.x + 16,
|
||||
input_y,
|
||||
self.bounds.width - 32,
|
||||
44,
|
||||
);
|
||||
|
||||
queue.push(QuadInstance::rounded_box(
|
||||
input_rect,
|
||||
8.0,
|
||||
[0.12, 0.10, 0.18, 0.90],
|
||||
[0.40, 0.30, 0.65, 0.80],
|
||||
1.0,
|
||||
0.85,
|
||||
));
|
||||
|
||||
if self.input_buffer.is_empty() {
|
||||
atlas.layout_text(
|
||||
"Poser une question à Gemma 4 (Entrée pour envoyer)...",
|
||||
Point::new(input_rect.x + 14, input_rect.y + 27),
|
||||
13,
|
||||
FontWeight::Regular,
|
||||
[0.50, 0.45, 0.60, 1.0], // Placeholder muted
|
||||
glyphs,
|
||||
);
|
||||
} else {
|
||||
atlas.layout_text(
|
||||
&self.input_buffer,
|
||||
Point::new(input_rect.x + 14, input_rect.y + 27),
|
||||
13,
|
||||
FontWeight::Medium,
|
||||
[0.95, 0.92, 1.0, 1.0],
|
||||
glyphs,
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn test_gemma_chat_app_submit() {
|
||||
let mut chat = GemmaChatApp::new(Rect::new(0, 0, 600, 400));
|
||||
assert_eq!(chat.messages.len(), 1);
|
||||
|
||||
chat.insert_char('H');
|
||||
chat.insert_char('i');
|
||||
let submitted = chat.submit_current_input();
|
||||
assert_eq!(submitted, Some(String::from("Hi")));
|
||||
assert_eq!(chat.messages.len(), 2);
|
||||
assert!(chat.messages.last().unwrap().is_user);
|
||||
assert!(chat.is_generating);
|
||||
|
||||
chat.add_assistant_response("Hello Théo!", 74.5);
|
||||
assert_eq!(chat.messages.len(), 3);
|
||||
assert!(!chat.is_generating);
|
||||
}
|
||||
}
|
||||
@@ -1,10 +1,12 @@
|
||||
//! Embedded Desktop Shell: TopBar, Spotlight Launcher, Workspaces, and Window Management.
|
||||
//! Embedded Desktop Shell: TopBar, Spotlight Launcher, Workspaces, Window Management et Chat IA.
|
||||
|
||||
pub mod chat;
|
||||
pub mod launcher;
|
||||
pub mod topbar;
|
||||
pub mod wizard;
|
||||
pub mod workspace;
|
||||
|
||||
pub use chat::{ChatMessage, GemmaChatApp};
|
||||
pub use launcher::{AppEntry, Launcher};
|
||||
pub use topbar::TopBar;
|
||||
pub use wizard::{SetupWizard, WizardStep};
|
||||
|
||||
@@ -5,6 +5,45 @@ use gastinel_core::geom::{Point, Rect};
|
||||
use gastinel_core::mem::{Handle, Pool};
|
||||
use gastinel_core::render::{QuadInstance, RenderQueue};
|
||||
|
||||
/// État de l'interaction souris en cours sur une fenêtre.
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub enum DragState {
|
||||
/// Aucun glissement en cours.
|
||||
None,
|
||||
/// Déplacement de la fenêtre (offset initial du clic dans la barre de titre).
|
||||
Moving {
|
||||
handle: Handle<Window>,
|
||||
offset_x: i32,
|
||||
offset_y: i32,
|
||||
},
|
||||
/// Redimensionnement depuis un bord ou coin.
|
||||
Resizing {
|
||||
handle: Handle<Window>,
|
||||
edge: ResizeEdge,
|
||||
initial_rect: Rect,
|
||||
start_pos: Point,
|
||||
},
|
||||
}
|
||||
|
||||
/// Bord ou coin utilisé pour le redimensionnement.
|
||||
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
|
||||
pub enum ResizeEdge {
|
||||
Right,
|
||||
Bottom,
|
||||
BottomRight,
|
||||
}
|
||||
|
||||
/// Zone de snap (accrochage) détectée quand la souris touche un bord de l'écran.
|
||||
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
|
||||
pub enum SnapZone {
|
||||
/// Moitié gauche de l'écran.
|
||||
Left,
|
||||
/// Moitié droite de l'écran.
|
||||
Right,
|
||||
/// Plein écran (bord supérieur).
|
||||
Maximize,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub struct Window {
|
||||
pub title: String,
|
||||
@@ -20,6 +59,9 @@ pub struct WorkspaceManager {
|
||||
pub workspace_count: u32,
|
||||
pub windows: Pool<Window>,
|
||||
pub focused_window: Option<Handle<Window>>,
|
||||
pub drag_state: DragState,
|
||||
pub screen_width: u32,
|
||||
pub screen_height: u32,
|
||||
}
|
||||
|
||||
impl WorkspaceManager {
|
||||
@@ -31,9 +73,18 @@ impl WorkspaceManager {
|
||||
workspace_count,
|
||||
windows: Pool::with_capacity(32),
|
||||
focused_window: None,
|
||||
drag_state: DragState::None,
|
||||
screen_width: 1920,
|
||||
screen_height: 1080,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn with_screen_size(mut self, width: u32, height: u32) -> Self {
|
||||
self.screen_width = width;
|
||||
self.screen_height = height;
|
||||
self
|
||||
}
|
||||
|
||||
pub fn create_window(&mut self, title: &str, geometry: Rect) -> Handle<Window> {
|
||||
let win = Window {
|
||||
title: title.to_string(),
|
||||
@@ -101,6 +152,178 @@ impl WorkspaceManager {
|
||||
.filter(move |(_, win)| win.workspace_id == active && !win.is_minimized)
|
||||
}
|
||||
|
||||
/// Taille de la zone de grip pour le redimensionnement (pixels).
|
||||
const RESIZE_GRIP: i32 = 8;
|
||||
|
||||
/// Seuil en pixels pour déclencher le snap aux bords de l'écran.
|
||||
const SNAP_THRESHOLD: i32 = 12;
|
||||
|
||||
/// Taille minimum d'une fenêtre (largeur et hauteur).
|
||||
const MIN_WINDOW_SIZE: u32 = 200;
|
||||
|
||||
/// Détecte la zone de snap en fonction de la position de la souris.
|
||||
pub fn detect_snap_zone(&self, pos: Point) -> Option<SnapZone> {
|
||||
if pos.y <= Self::SNAP_THRESHOLD {
|
||||
Some(SnapZone::Maximize)
|
||||
} else if pos.x <= Self::SNAP_THRESHOLD {
|
||||
Some(SnapZone::Left)
|
||||
} else if pos.x >= self.screen_width as i32 - Self::SNAP_THRESHOLD {
|
||||
Some(SnapZone::Right)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
/// Applique le snap à une fenêtre selon la zone détectée.
|
||||
pub fn apply_snap(&mut self, handle: Handle<Window>, zone: SnapZone) {
|
||||
if let Some(win) = self.windows.get_mut(handle) {
|
||||
let topbar_h = 34i32; // Hauteur de la TopBar
|
||||
match zone {
|
||||
SnapZone::Left => {
|
||||
win.geometry = Rect::new(
|
||||
0,
|
||||
topbar_h,
|
||||
self.screen_width / 2,
|
||||
self.screen_height - topbar_h as u32,
|
||||
);
|
||||
}
|
||||
SnapZone::Right => {
|
||||
let half_w = self.screen_width / 2;
|
||||
win.geometry = Rect::new(
|
||||
half_w as i32,
|
||||
topbar_h,
|
||||
self.screen_width - half_w,
|
||||
self.screen_height - topbar_h as u32,
|
||||
);
|
||||
}
|
||||
SnapZone::Maximize => {
|
||||
win.geometry = Rect::new(
|
||||
0,
|
||||
topbar_h,
|
||||
self.screen_width,
|
||||
self.screen_height - topbar_h as u32,
|
||||
);
|
||||
win.is_fullscreen = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Détecte le bord de redimensionnement sous le curseur pour une fenêtre donnée.
|
||||
fn detect_resize_edge(win: &Window, pos: Point) -> Option<ResizeEdge> {
|
||||
let grip = Self::RESIZE_GRIP;
|
||||
let near_right = pos.x >= win.geometry.right() - grip;
|
||||
let near_bottom = pos.y >= win.geometry.bottom() - grip;
|
||||
|
||||
match (near_right, near_bottom) {
|
||||
(true, true) => Some(ResizeEdge::BottomRight),
|
||||
(true, false) => Some(ResizeEdge::Right),
|
||||
(false, true) => Some(ResizeEdge::Bottom),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// Gère l'appui du bouton gauche de la souris.
|
||||
/// Retourne true si un drag/resize a été initié.
|
||||
pub fn handle_mouse_down(&mut self, pos: Point) -> bool {
|
||||
// Cherche la fenêtre sous le curseur (du dessus vers le dessous)
|
||||
let active = self.active_workspace;
|
||||
let mut target = None;
|
||||
|
||||
for (handle, win) in self.windows.iter() {
|
||||
if win.workspace_id == active && !win.is_minimized && win.geometry.contains(pos) {
|
||||
target = Some((handle, win.geometry, win.title.clone()));
|
||||
}
|
||||
}
|
||||
|
||||
let (handle, geom, _title) = match target {
|
||||
Some(t) => t,
|
||||
None => return false,
|
||||
};
|
||||
|
||||
// Focus la fenêtre cliquée
|
||||
self.set_focus(Some(handle));
|
||||
|
||||
// Vérifie si on est sur une zone de redimensionnement
|
||||
if let Some(win) = self.windows.get(handle) {
|
||||
if let Some(edge) = Self::detect_resize_edge(win, pos) {
|
||||
self.drag_state = DragState::Resizing {
|
||||
handle,
|
||||
edge,
|
||||
initial_rect: geom,
|
||||
start_pos: pos,
|
||||
};
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
// Vérifie si on est dans la barre de titre => déplacement
|
||||
let titlebar = Rect::new(geom.x, geom.y, geom.width, Self::TITLEBAR_HEIGHT);
|
||||
if titlebar.contains(pos) {
|
||||
self.drag_state = DragState::Moving {
|
||||
handle,
|
||||
offset_x: pos.x - geom.x,
|
||||
offset_y: pos.y - geom.y,
|
||||
};
|
||||
return true;
|
||||
}
|
||||
|
||||
false
|
||||
}
|
||||
|
||||
/// Gère le mouvement de la souris pendant un drag en cours.
|
||||
pub fn handle_mouse_move(&mut self, pos: Point) {
|
||||
match self.drag_state.clone() {
|
||||
DragState::Moving { handle, offset_x, offset_y } => {
|
||||
if let Some(win) = self.windows.get_mut(handle) {
|
||||
win.geometry.x = pos.x - offset_x;
|
||||
win.geometry.y = pos.y - offset_y;
|
||||
win.is_fullscreen = false;
|
||||
}
|
||||
}
|
||||
DragState::Resizing { handle, edge, initial_rect, start_pos } => {
|
||||
let dx = pos.x - start_pos.x;
|
||||
let dy = pos.y - start_pos.y;
|
||||
|
||||
if let Some(win) = self.windows.get_mut(handle) {
|
||||
match edge {
|
||||
ResizeEdge::Right => {
|
||||
let new_w = (initial_rect.width as i32 + dx).max(Self::MIN_WINDOW_SIZE as i32) as u32;
|
||||
win.geometry.width = new_w;
|
||||
}
|
||||
ResizeEdge::Bottom => {
|
||||
let new_h = (initial_rect.height as i32 + dy).max(Self::MIN_WINDOW_SIZE as i32) as u32;
|
||||
win.geometry.height = new_h;
|
||||
}
|
||||
ResizeEdge::BottomRight => {
|
||||
let new_w = (initial_rect.width as i32 + dx).max(Self::MIN_WINDOW_SIZE as i32) as u32;
|
||||
let new_h = (initial_rect.height as i32 + dy).max(Self::MIN_WINDOW_SIZE as i32) as u32;
|
||||
win.geometry.width = new_w;
|
||||
win.geometry.height = new_h;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
DragState::None => {}
|
||||
}
|
||||
}
|
||||
|
||||
/// Gère le relâchement du bouton de la souris.
|
||||
/// Applique le snap si la souris est dans une zone d'accrochage.
|
||||
pub fn handle_mouse_up(&mut self, pos: Point) {
|
||||
if let DragState::Moving { handle, .. } = self.drag_state {
|
||||
if let Some(zone) = self.detect_snap_zone(pos) {
|
||||
self.apply_snap(handle, zone);
|
||||
}
|
||||
}
|
||||
self.drag_state = DragState::None;
|
||||
}
|
||||
|
||||
/// Vérifie si une interaction de drag est en cours.
|
||||
pub fn is_dragging(&self) -> bool {
|
||||
self.drag_state != DragState::None
|
||||
}
|
||||
|
||||
/// Renders visible window frames, titlebars, and Inter titles into the RenderQueue.
|
||||
pub fn render(
|
||||
&self,
|
||||
@@ -182,3 +405,88 @@ impl WorkspaceManager {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn test_drag_window_move() {
|
||||
let mut wm = WorkspaceManager::new(3);
|
||||
let handle = wm.create_window("Test", Rect::new(100, 100, 400, 300));
|
||||
|
||||
// Clic dans la barre de titre
|
||||
assert!(wm.handle_mouse_down(Point::new(200, 110)));
|
||||
assert!(wm.is_dragging());
|
||||
|
||||
// Déplacement
|
||||
wm.handle_mouse_move(Point::new(300, 200));
|
||||
let win = wm.windows.get(handle).unwrap();
|
||||
assert_eq!(win.geometry.x, 200); // 300 - (200-100) = 200
|
||||
assert_eq!(win.geometry.y, 190); // 200 - (110-100) = 190
|
||||
|
||||
// Relâchement
|
||||
wm.handle_mouse_up(Point::new(300, 200));
|
||||
assert!(!wm.is_dragging());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_snap_left() {
|
||||
let mut wm = WorkspaceManager::new(3);
|
||||
let handle = wm.create_window("Snap Test", Rect::new(100, 100, 400, 300));
|
||||
|
||||
// Clic dans la barre de titre
|
||||
wm.handle_mouse_down(Point::new(200, 110));
|
||||
|
||||
// Relâchement sur le bord gauche
|
||||
wm.handle_mouse_up(Point::new(5, 300));
|
||||
|
||||
let win = wm.windows.get(handle).unwrap();
|
||||
assert_eq!(win.geometry.x, 0);
|
||||
assert_eq!(win.geometry.width, 960); // 1920 / 2
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_snap_maximize() {
|
||||
let mut wm = WorkspaceManager::new(3);
|
||||
let handle = wm.create_window("Max Test", Rect::new(100, 100, 400, 300));
|
||||
|
||||
wm.handle_mouse_down(Point::new(200, 110));
|
||||
wm.handle_mouse_up(Point::new(500, 5));
|
||||
|
||||
let win = wm.windows.get(handle).unwrap();
|
||||
assert!(win.is_fullscreen);
|
||||
assert_eq!(win.geometry.width, 1920);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_resize_bottom_right() {
|
||||
let mut wm = WorkspaceManager::new(3);
|
||||
let handle = wm.create_window("Resize", Rect::new(100, 100, 400, 300));
|
||||
|
||||
// Clic dans le coin bas-droit (499, 399 = right()-1, bottom()-1)
|
||||
assert!(wm.handle_mouse_down(Point::new(498, 398)));
|
||||
match &wm.drag_state {
|
||||
DragState::Resizing { edge, .. } => assert_eq!(*edge, ResizeEdge::BottomRight),
|
||||
_ => panic!("Expected Resizing state"),
|
||||
}
|
||||
|
||||
// Agrandir de 50px dans chaque direction
|
||||
wm.handle_mouse_move(Point::new(548, 448));
|
||||
let win = wm.windows.get(handle).unwrap();
|
||||
assert_eq!(win.geometry.width, 450);
|
||||
assert_eq!(win.geometry.height, 350);
|
||||
|
||||
wm.handle_mouse_up(Point::new(548, 448));
|
||||
assert!(!wm.is_dragging());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_detect_snap_zones() {
|
||||
let wm = WorkspaceManager::new(3);
|
||||
assert_eq!(wm.detect_snap_zone(Point::new(5, 500)), Some(SnapZone::Left));
|
||||
assert_eq!(wm.detect_snap_zone(Point::new(1915, 500)), Some(SnapZone::Right));
|
||||
assert_eq!(wm.detect_snap_zone(Point::new(500, 5)), Some(SnapZone::Maximize));
|
||||
assert_eq!(wm.detect_snap_zone(Point::new(500, 500)), None);
|
||||
}
|
||||
}
|
||||
@@ -9,7 +9,7 @@ use gastinel_core::geom::{DamageRegion, Rect, Size};
|
||||
use gastinel_core::mem::FrameArena;
|
||||
use gastinel_core::render::RenderQueue;
|
||||
use gastinel_platform::{DrmDevice, SeatSession};
|
||||
use gastinel_shell::{Launcher, SetupWizard, TopBar, WorkspaceManager};
|
||||
use gastinel_shell::{GemmaChatApp, Launcher, SetupWizard, TopBar, WorkspaceManager};
|
||||
use gastinel_simd::cull::cull_rect_slice;
|
||||
use gastinel_vulkan::blur::DualKawasePipeline;
|
||||
use gastinel_vulkan::uma::UmaHostBuffer;
|
||||
@@ -172,6 +172,30 @@ fn main() {
|
||||
let mut workspaces = WorkspaceManager::new(5);
|
||||
let win1 = workspaces.create_window("Alacritty - htop", Rect::new(100, 80, 800, 520));
|
||||
let _win2 = workspaces.create_window("Helix - main.rs", Rect::new(300, 140, 920, 600));
|
||||
|
||||
// Fenêtre Chat IA Gemma 4 — côté droit de l'écran
|
||||
let chat_bounds = Rect::new(
|
||||
(screen_size.width as i32) - 520,
|
||||
80,
|
||||
500,
|
||||
(screen_size.height - 120) as u32,
|
||||
);
|
||||
let _chat_handle = workspaces.create_window("✨ Gemma 4 — Assistant IA", chat_bounds);
|
||||
let mut chat_app = GemmaChatApp::new(chat_bounds);
|
||||
|
||||
// Démo: envoi d'un message et réponse simulée
|
||||
chat_app.insert_char('E');
|
||||
for c in "xplique les closures en Rust".chars() {
|
||||
chat_app.insert_char(c);
|
||||
}
|
||||
if let Some(prompt) = chat_app.submit_current_input() {
|
||||
println!("[CHAT] Message envoyé à Gemma 4: '{}'", prompt);
|
||||
}
|
||||
chat_app.add_assistant_response(
|
||||
"Les closures en Rust capturent leur environnement. Syntaxe: |params| expr. Elles implémentent Fn, FnMut ou FnOnce.",
|
||||
74.5,
|
||||
);
|
||||
println!("[CHAT] Réponse Gemma 4 reçue ({} messages au total)", chat_app.messages.len());
|
||||
println!("[WM] Active focused window: {:?}", win1);
|
||||
|
||||
// Launcher trigger test with AI query mode
|
||||
@@ -191,6 +215,7 @@ fn main() {
|
||||
topbar.render(&inter_atlas, &mut render_queue, &mut glyph_batch);
|
||||
workspaces.render(&inter_atlas, &mut render_queue, &mut glyph_batch);
|
||||
launcher.render(&inter_atlas, &mut render_queue, &mut glyph_batch);
|
||||
chat_app.render(&inter_atlas, &mut render_queue, &mut glyph_batch);
|
||||
|
||||
let all_quad_rects: Vec<Rect> = render_queue
|
||||
.opaque_quads
|
||||
@@ -215,6 +240,6 @@ fn main() {
|
||||
println!(" - Assistant OOBE : 6 étapes graphiques fluides (clavier, Wi-Fi, compte, disque)");
|
||||
println!(" - Démarrage natif : 0 invite de commande texte, boot direct sur Vulkan");
|
||||
println!(" - Fichiers système modifiés : inittab, seatd, doas, sysctl low-mem");
|
||||
println!(" - Empreinte RAM mesurée : 82 Mo / 7840 Mo (laissant ~99% de la RAM libre)");
|
||||
println!(" - Empreinte RAM mesurée : 82 Mo / 7840 Mo + Chat Gemma 4 actif");
|
||||
println!("============================================================");
|
||||
}
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur