From: Olaf Wintermann <olaf.wintermann@gmail.com>
Date: Fri, 24 Apr 2026 13:35:08 +0000 (+0200)
Subject: add toolbar
X-Git-Url: https://uap-core.de/gitweb/?a=commitdiff_plain;h=HEAD;p=note.git

add toolbar
---

diff --git a/ui-rs/src/ui/ffi.rs b/ui-rs/src/ui/ffi.rs
index de01035..9719498 100644
--- a/ui-rs/src/ui/ffi.rs
+++ b/ui-rs/src/ui/ffi.rs
@@ -165,3 +165,18 @@ pub struct UiMenuToggleItemArgs {
 pub struct UiMenuItemListArgs {
     _private: [u8; 0],
 }
+
+#[repr(C)]
+pub struct UiToolbarItemArgs {
+    _private: [u8; 0],
+}
+
+#[repr(C)]
+pub struct UiToolbarToggleItemArgs {
+    _private: [u8; 0],
+}
+
+#[repr(C)]
+pub struct UiToolbarMenuArgs {
+    _private: [u8; 0],
+}
\ No newline at end of file
diff --git a/ui-rs/src/ui/menu.rs b/ui-rs/src/ui/menu.rs
index a92b6e1..547bc15 100644
--- a/ui-rs/src/ui/menu.rs
+++ b/ui-rs/src/ui/menu.rs
@@ -22,8 +22,8 @@ impl<T: UiModel + UiActions> AppContext<T> {
 }
 
 pub struct Menu<T: UiModel + UiActions> {
-    ctx: *mut ffi::UiContext,
-    _marker: PhantomData<T>,
+    pub ctx: *mut ffi::UiContext,
+    pub _marker: PhantomData<T>,
 }
 
 impl<T: UiModel + UiActions> Menu<T> {
@@ -210,7 +210,7 @@ extern "C" {
     fn ui_menu_itemlist_create(args: *const UiMenuItemListArgs);
     fn ui_menu_toggleitemlist_create(args: *const UiMenuItemListArgs);
     fn ui_menu_radioitemlist_create(args: *const UiMenuItemListArgs);
-    fn ui_menu_end();
+    pub fn ui_menu_end();
 
     fn ui_menuitem_args_new() -> *mut UiMenuItemArgs;
     fn ui_menuitem_args_set_label(args: *mut UiMenuItemArgs, label: *const c_char);
diff --git a/ui-rs/src/ui/mod.rs b/ui-rs/src/ui/mod.rs
index e608b3a..da0e6c3 100644
--- a/ui-rs/src/ui/mod.rs
+++ b/ui-rs/src/ui/mod.rs
@@ -9,6 +9,7 @@ mod text;
 pub mod event;
 pub mod list;
 mod menu;
+mod toolbar;
 
 pub use toolkit::*;
 pub use event::*;
diff --git a/ui-rs/src/ui/toolbar.rs b/ui-rs/src/ui/toolbar.rs
new file mode 100644
index 0000000..973b144
--- /dev/null
+++ b/ui-rs/src/ui/toolbar.rs
@@ -0,0 +1,271 @@
+#![allow(dead_code)]
+
+use std::ffi::{c_char, c_int, c_void, CString};
+use std::marker::PhantomData;
+use crate::ui::ffi::{UiCallback, UiMenuItemArgs, UiMenuToggleItemArgs, UiToolbarItemArgs, UiToolbarMenuArgs, UiToolbarToggleItemArgs};
+use crate::ui::{event, ffi, toolkit, AppContext, EventWrapper, UiActions, UiContext, UiModel};
+use crate::ui::menu::{ui_menu_end, Menu, MenuItemBuilder, ToggleItemCreate};
+
+pub enum ToolbarItemPosition {
+    Left = 0,
+    Center = 1,
+    Right = 2,
+    SidebarLeft = 3,
+    SidebarRight = 4,
+    RightPanelLeft = 5,
+    RightPanelCenter = 6,
+    RightPanelRight = 7,
+}
+
+impl<T: UiModel + UiActions> AppContext<T> {
+    pub fn toolbar_item(&self, name: &str) -> ToolbarItemBuilder<T> {
+        unsafe {
+            ToolbarItemBuilder {
+                args: ui_toolbar_item_args_new(),
+                ctx: toolkit::ui_global_context(),
+                name: CString::new(name).unwrap(),
+                _marker: PhantomData
+            }
+        }
+    }
+
+    pub fn toolbar_toggleitem(&self, name: &str) -> ToolbarToggleItemBuilder<T> {
+        unsafe {
+            ToolbarToggleItemBuilder {
+                args: ui_toolbar_toggleitem_args_new(),
+                ctx: toolkit::ui_global_context(),
+                name: CString::new(name).unwrap(),
+                _marker: PhantomData
+            }
+        }
+    }
+
+    pub fn toolbar_menuitem(&self, name: &str) -> ToolbarMenuItemBuilder<T> {
+        unsafe {
+            ToolbarMenuItemBuilder {
+                args: ui_toolbar_menu_args_new(),
+                ctx: toolkit::ui_global_context(),
+                name: CString::new(name).unwrap(),
+                _marker: PhantomData
+            }
+        }
+    }
+
+    pub fn toolbar_add_default(&self, name: &str, pos: ToolbarItemPosition) {
+        let cstr = CString::new(name).unwrap();
+        unsafe {
+            ui_toolbar_add_default(cstr.as_ptr(), pos as c_int);
+        }
+    }
+}
+
+pub struct ToolbarItemBuilder<T: UiModel + UiActions> {
+    args: *mut UiToolbarItemArgs,
+    ctx: *mut ffi::UiContext,
+    name: CString,
+    _marker: PhantomData<T>,
+}
+
+pub struct ToolbarToggleItemBuilder<T: UiModel + UiActions> {
+    args: *mut UiToolbarToggleItemArgs,
+    ctx: *mut ffi::UiContext,
+    name: CString,
+    _marker: PhantomData<T>,
+}
+
+pub struct ToolbarMenuItemBuilder<T: UiModel + UiActions> {
+    args: *mut UiToolbarMenuArgs,
+    ctx: *mut ffi::UiContext,
+    name: CString,
+    _marker: PhantomData<T>,
+}
+
+impl<T: UiModel + UiActions> ToolbarItemBuilder<T> {
+    pub fn create(&mut self) {
+        unsafe {
+            ui_toolbar_item_create(self.name.as_ptr(), self.args);
+        }
+    }
+    pub fn label(&mut self, label: &str) -> &mut Self {
+        unsafe {
+            let cstr = CString::new(label).unwrap();
+            ui_toolbar_item_args_set_label(self.args, cstr.as_ptr());
+        }
+        self
+    }
+
+    pub fn icon(&mut self, icon: &str) -> &mut Self {
+        unsafe {
+            let cstr = CString::new(icon).unwrap();
+            ui_toolbar_item_args_set_icon(self.args, cstr.as_ptr());
+        }
+        self
+    }
+
+    pub fn tooltip(&mut self, tooltip: &str) -> &mut Self {
+        unsafe {
+            let cstr = CString::new(tooltip).unwrap();
+            ui_toolbar_item_args_set_tooltip(self.args, cstr.as_ptr());
+        }
+        self
+    }
+
+    pub fn action(&mut self, action: &str) -> &mut Self {
+        unsafe {
+            let cstr = CString::new(action).unwrap();
+            ui_toolbar_item_args_set_action(self.args, cstr.as_ptr());
+        }
+        self
+    }
+
+    pub fn onclick<F>(&mut self, f: F) -> &mut Self
+    where F: FnMut(&mut event::Event<T>) + 'static {
+        let wrapper = Box::new(EventWrapper { callback: Box::new(f) });
+        let mut ctx = UiContext { ptr: self.ctx };
+        let ptr = ctx.reg_box(wrapper);
+        unsafe {
+            ui_toolbar_item_args_set_onclick(self.args, Some(event::event_wrapper::<T>));
+            ui_toolbar_item_args_set_onclickdata(self.args, ptr as *mut c_void);
+        }
+        self
+    }
+}
+
+impl<T: UiModel + UiActions> ToolbarToggleItemBuilder<T> {
+    pub fn create(&mut self) {
+        unsafe {
+            ui_toolbar_toggleitem_create(self.name.as_ptr(), self.args);
+        }
+    }
+    pub fn label(&mut self, label: &str) -> &mut Self {
+        unsafe {
+            let cstr = CString::new(label).unwrap();
+            ui_toolbar_toggleitem_args_set_label(self.args, cstr.as_ptr());
+        }
+        self
+    }
+
+    pub fn icon(&mut self, icon: &str) -> &mut Self {
+        unsafe {
+            let cstr = CString::new(icon).unwrap();
+            ui_toolbar_toggleitem_args_set_icon(self.args, cstr.as_ptr());
+        }
+        self
+    }
+
+    pub fn tooltip(&mut self, tooltip: &str) -> &mut Self {
+        unsafe {
+            let cstr = CString::new(tooltip).unwrap();
+            ui_toolbar_toggleitem_args_set_tooltip(self.args, cstr.as_ptr());
+        }
+        self
+    }
+
+    pub fn varname(&mut self, varname: &str) -> &mut Self {
+        unsafe {
+            let cstr = CString::new(varname).unwrap();
+            ui_toolbar_toggleitem_args_set_varname(self.args, cstr.as_ptr());
+        }
+        self
+    }
+
+    pub fn action(&mut self, action: &str) -> &mut Self {
+        unsafe {
+            let cstr = CString::new(action).unwrap();
+            ui_toolbar_toggleitem_args_set_action(self.args, cstr.as_ptr());
+        }
+        self
+    }
+
+    pub fn onchange<F>(&mut self, f: F) -> &mut Self
+    where F: FnMut(&mut event::Event<T>) + 'static {
+        let wrapper = Box::new(EventWrapper { callback: Box::new(f) });
+        let mut ctx = UiContext { ptr: self.ctx };
+        let ptr = ctx.reg_box(wrapper);
+        unsafe {
+            ui_toolbar_toggleitem_args_set_onchange(self.args, Some(event::event_wrapper::<T>));
+            ui_toolbar_toggleitem_args_set_onchangedata(self.args, ptr as *mut c_void);
+        }
+        self
+    }
+}
+
+
+impl<T: UiModel + UiActions> ToolbarMenuItemBuilder<T> {
+    pub fn create(&mut self) {
+        unsafe {
+            ui_toolbar_menu_create(self.name.as_ptr(), self.args);
+        }
+    }
+    pub fn label(&mut self, label: &str) -> &mut Self {
+        unsafe {
+            let cstr = CString::new(label).unwrap();
+            ui_toolbar_menu_args_set_label(self.args, cstr.as_ptr());
+        }
+        self
+    }
+
+    pub fn icon(&mut self, icon: &str) -> &mut Self {
+        unsafe {
+            let cstr = CString::new(icon).unwrap();
+            ui_toolbar_menu_args_set_icon(self.args, cstr.as_ptr());
+        }
+        self
+    }
+
+    pub fn tooltip(&mut self, tooltip: &str) -> &mut Self {
+        unsafe {
+            let cstr = CString::new(tooltip).unwrap();
+            ui_toolbar_menu_args_set_tooltip(self.args, cstr.as_ptr());
+        }
+        self
+    }
+
+    pub fn menu<F>(&mut self, f: F) -> &mut Self
+    where F: FnOnce(&mut Menu<T>) {
+        unsafe {
+            let mut menu = Menu::<T> {
+                ctx: toolkit::ui_global_context(),
+                _marker: PhantomData
+            };
+            f(&mut menu);
+            ui_menu_end();
+        }
+        self
+    }
+}
+
+
+extern "C" {
+    fn ui_toolbar_item_create(name: *const c_char, args: *const UiToolbarItemArgs);
+    fn ui_toolbar_toggleitem_create(name: *const c_char, args: *const UiToolbarToggleItemArgs);
+    fn ui_toolbar_menu_create(name: *const c_char, args: *const UiToolbarMenuArgs);
+    fn ui_toolbar_add_default(name: *const c_char, pos: c_int);
+
+    fn ui_toolbar_item_args_new() -> *mut UiToolbarItemArgs;
+    fn ui_toolbar_item_args_set_label(args: *mut UiToolbarItemArgs, label: *const c_char);
+    fn ui_toolbar_item_args_set_icon(args: *mut UiToolbarItemArgs, icon: *const c_char);
+    fn ui_toolbar_item_args_set_tooltip(args: *mut UiToolbarItemArgs, tooltip: *const c_char);
+    fn ui_toolbar_item_args_set_action(args: *mut UiToolbarItemArgs, action: *const c_char);
+    fn ui_toolbar_item_args_set_onclick(args: *mut UiToolbarItemArgs, onclick: UiCallback);
+    fn ui_toolbar_item_args_set_onclickdata(args: *mut UiToolbarItemArgs, data: *mut c_void);
+    fn ui_toolbar_item_args_set_states(args: *mut UiToolbarItemArgs, states: *mut c_int, numstates: c_int);
+    fn ui_toolbar_item_args_free(args: *mut UiToolbarItemArgs);
+
+    fn ui_toolbar_toggleitem_args_new() -> *mut UiToolbarToggleItemArgs;
+    fn ui_toolbar_toggleitem_args_set_label(args: *mut UiToolbarToggleItemArgs, label: *const c_char);
+    fn ui_toolbar_toggleitem_args_set_icon(args: *mut UiToolbarToggleItemArgs, icon: *const c_char);
+    fn ui_toolbar_toggleitem_args_set_tooltip(args: *mut UiToolbarToggleItemArgs, tooltip: *const c_char);
+    fn ui_toolbar_toggleitem_args_set_action(args: *mut UiToolbarToggleItemArgs, action: *const c_char);
+    fn ui_toolbar_toggleitem_args_set_varname(args: *mut UiToolbarToggleItemArgs, varname: *const c_char);
+    fn ui_toolbar_toggleitem_args_set_onchange(args: *mut UiToolbarToggleItemArgs, onclick: UiCallback);
+    fn ui_toolbar_toggleitem_args_set_onchangedata(args: *mut UiToolbarToggleItemArgs, data: *mut c_void);
+    fn ui_toolbar_toggleitem_args_set_states(args: *mut UiToolbarToggleItemArgs, states: *mut c_int, numstates: c_int);
+    fn ui_toolbar_toggleitem_args_free(args: *mut UiToolbarToggleItemArgs);
+
+    fn ui_toolbar_menu_args_new() -> *mut UiToolbarMenuArgs;
+    fn ui_toolbar_menu_args_set_label(args: *mut UiToolbarMenuArgs, label: *const c_char);
+    fn ui_toolbar_menu_args_set_icon(args: *mut UiToolbarMenuArgs, icon: *const c_char);
+    fn ui_toolbar_menu_args_set_tooltip(args: *mut UiToolbarMenuArgs, tooltip: *const c_char);
+    fn ui_toolbar_menu_args_free(args: *mut UiToolbarMenuArgs);
+}