From: Olaf Wintermann Date: Thu, 11 Sep 2025 18:35:01 +0000 (+0200) Subject: add spinbox X-Git-Url: https://uap-core.de/gitweb/?a=commitdiff_plain;h=25e1168070f78d7b43f7e2282feebc78024bb7f9;p=rssreader.git add spinbox --- diff --git a/ui-java/src/main/java/de/unixwork/ui/ArgFuncs.java b/ui-java/src/main/java/de/unixwork/ui/ArgFuncs.java index a76f888..748935d 100644 --- a/ui-java/src/main/java/de/unixwork/ui/ArgFuncs.java +++ b/ui-java/src/main/java/de/unixwork/ui/ArgFuncs.java @@ -391,6 +391,26 @@ class ArgFuncs { MethodHandle textfield_args_set_groups; MethodHandle textfield_args_free; + MethodHandle spinbox_args_new; + MethodHandle spinbox_args_set_fill; + MethodHandle spinbox_args_set_hexpand; + MethodHandle spinbox_args_set_vexpand; + MethodHandle spinbox_args_set_hfill; + MethodHandle spinbox_args_set_vfill; + MethodHandle spinbox_args_set_override_defaults; + MethodHandle spinbox_args_set_colspan; + MethodHandle spinbox_args_set_rowspan; + MethodHandle spinbox_args_set_name; + MethodHandle spinbox_args_set_style_class; + MethodHandle spinbox_args_set_onchange; + MethodHandle spinbox_args_set_onchangedata; + MethodHandle spinbox_args_set_varname; + MethodHandle spinbox_args_set_intvalue; + MethodHandle spinbox_args_set_doublevalue; + MethodHandle spinbox_args_set_rangevalue; + MethodHandle spinbox_args_set_groups; + MethodHandle spinbox_args_free; + MethodHandle webview_args_new; MethodHandle webview_args_set_fill; MethodHandle webview_args_set_hexpand; @@ -801,6 +821,26 @@ class ArgFuncs { MemorySegment ui_textfield_args_set_groups_addr = lib.find("ui_textfield_args_set_groups").orElseThrow(); MemorySegment ui_textfield_args_free_addr = lib.find("ui_textfield_args_free").orElseThrow(); + MemorySegment ui_spinbox_args_new_addr = lib.find("ui_spinbox_args_new").orElseThrow(); + MemorySegment ui_spinbox_args_set_fill_addr = lib.find("ui_spinbox_args_set_fill").orElseThrow(); + MemorySegment ui_spinbox_args_set_hexpand_addr = lib.find("ui_spinbox_args_set_hexpand").orElseThrow(); + MemorySegment ui_spinbox_args_set_vexpand_addr = lib.find("ui_spinbox_args_set_vexpand").orElseThrow(); + MemorySegment ui_spinbox_args_set_hfill_addr = lib.find("ui_spinbox_args_set_hfill").orElseThrow(); + MemorySegment ui_spinbox_args_set_vfill_addr = lib.find("ui_spinbox_args_set_vfill").orElseThrow(); + MemorySegment ui_spinbox_args_set_override_defaults_addr = lib.find("ui_spinbox_args_set_override_defaults").orElseThrow(); + MemorySegment ui_spinbox_args_set_colspan_addr = lib.find("ui_spinbox_args_set_colspan").orElseThrow(); + MemorySegment ui_spinbox_args_set_rowspan_addr = lib.find("ui_spinbox_args_set_rowspan").orElseThrow(); + MemorySegment ui_spinbox_args_set_name_addr = lib.find("ui_spinbox_args_set_name").orElseThrow(); + MemorySegment ui_spinbox_args_set_style_class_addr = lib.find("ui_spinbox_args_set_style_class").orElseThrow(); + MemorySegment ui_spinbox_args_set_onchange_addr = lib.find("ui_spinbox_args_set_onchange").orElseThrow(); + MemorySegment ui_spinbox_args_set_onchangedata_addr = lib.find("ui_spinbox_args_set_onchangedata").orElseThrow(); + MemorySegment ui_spinbox_args_set_varname_addr = lib.find("ui_spinbox_args_set_varname").orElseThrow(); + MemorySegment ui_spinbox_args_set_intvalue_addr = lib.find("ui_spinbox_args_set_intvalue").orElseThrow(); + MemorySegment ui_spinbox_args_set_doublevalue_addr = lib.find("ui_spinbox_args_set_doublevalue").orElseThrow(); + MemorySegment ui_spinbox_args_set_rangevalue_addr = lib.find("ui_spinbox_args_set_rangevalue").orElseThrow(); + MemorySegment ui_spinbox_args_set_groups_addr = lib.find("ui_spinbox_args_set_groups").orElseThrow(); + MemorySegment ui_spinbox_args_free_addr = lib.find("ui_spinbox_args_free").orElseThrow(); + MemorySegment ui_webview_args_new_addr = lib.find("ui_webview_args_new").orElseThrow(); MemorySegment ui_webview_args_set_fill_addr = lib.find("ui_webview_args_set_fill").orElseThrow(); MemorySegment ui_webview_args_set_hexpand_addr = lib.find("ui_webview_args_set_hexpand").orElseThrow(); @@ -1202,6 +1242,26 @@ class ArgFuncs { textfield_args_set_groups = linker.downcallHandle(ui_textfield_args_set_groups_addr, sigv_mm); textfield_args_free = linker.downcallHandle(ui_textfield_args_free_addr, sigv_m); + spinbox_args_new = linker.downcallHandle(ui_spinbox_args_new_addr, sigm); + spinbox_args_set_fill = linker.downcallHandle(ui_spinbox_args_set_fill_addr, sigv_mb); + spinbox_args_set_hexpand = linker.downcallHandle(ui_spinbox_args_set_hexpand_addr, sigv_mb); + spinbox_args_set_vexpand = linker.downcallHandle(ui_spinbox_args_set_vexpand_addr, sigv_mb); + spinbox_args_set_hfill = linker.downcallHandle(ui_spinbox_args_set_hfill_addr, sigv_mb); + spinbox_args_set_vfill = linker.downcallHandle(ui_spinbox_args_set_vfill_addr, sigv_mb); + spinbox_args_set_override_defaults = linker.downcallHandle(ui_spinbox_args_set_override_defaults_addr, sigv_mb); + spinbox_args_set_colspan = linker.downcallHandle(ui_spinbox_args_set_colspan_addr, sigv_mi); + spinbox_args_set_rowspan = linker.downcallHandle(ui_spinbox_args_set_rowspan_addr, sigv_mi); + spinbox_args_set_name = linker.downcallHandle(ui_spinbox_args_set_name_addr, sigv_mm); + spinbox_args_set_style_class = linker.downcallHandle(ui_spinbox_args_set_style_class_addr, sigv_mm); + spinbox_args_set_onchange = linker.downcallHandle(ui_spinbox_args_set_onchange_addr, sigv_mm); + spinbox_args_set_onchangedata = linker.downcallHandle(ui_spinbox_args_set_onchangedata_addr, sigv_mm); + spinbox_args_set_varname = linker.downcallHandle(ui_spinbox_args_set_varname_addr, sigv_mm); + spinbox_args_set_intvalue = linker.downcallHandle(ui_spinbox_args_set_intvalue_addr, sigv_mm); + spinbox_args_set_doublevalue = linker.downcallHandle(ui_spinbox_args_set_doublevalue_addr, sigv_mm); + spinbox_args_set_rangevalue = linker.downcallHandle(ui_spinbox_args_set_rangevalue_addr, sigv_mm); + spinbox_args_set_groups = linker.downcallHandle(ui_spinbox_args_set_groups_addr, sigv_mm); + spinbox_args_free = linker.downcallHandle(ui_spinbox_args_free_addr, sigv_m); + webview_args_new = linker.downcallHandle(ui_webview_args_new_addr, sigm); webview_args_set_fill = linker.downcallHandle(ui_webview_args_set_fill_addr, sigv_mb); webview_args_set_hexpand = linker.downcallHandle(ui_webview_args_set_hexpand_addr, sigv_mb); diff --git a/ui-java/src/main/java/de/unixwork/ui/Entry.java b/ui-java/src/main/java/de/unixwork/ui/Entry.java new file mode 100644 index 0000000..144a810 --- /dev/null +++ b/ui-java/src/main/java/de/unixwork/ui/Entry.java @@ -0,0 +1,8 @@ +package de.unixwork.ui; + +public class Entry { + public static SpinBoxBuilder spinbox(UiObject obj) { + EntryFuncs ui = EntryFuncs.getInstance(); + return new SpinBoxBuilder(obj, ui.spinbox_create); + } +} diff --git a/ui-java/src/main/java/de/unixwork/ui/EntryFuncs.java b/ui-java/src/main/java/de/unixwork/ui/EntryFuncs.java new file mode 100644 index 0000000..fde9ad8 --- /dev/null +++ b/ui-java/src/main/java/de/unixwork/ui/EntryFuncs.java @@ -0,0 +1,27 @@ +package de.unixwork.ui; + +import java.lang.foreign.*; +import java.lang.invoke.MethodHandle; + +public class EntryFuncs { + static EntryFuncs instance; + + public MethodHandle spinbox_create; + + private EntryFuncs(Linker linker, SymbolLookup lib) { + // void* func(void*, void*) + FunctionDescriptor sigm_mm = FunctionDescriptor.of(ValueLayout.ADDRESS, ValueLayout.ADDRESS, ValueLayout.ADDRESS); + + MemorySegment ui_spinbox_create_addr = lib.find("ui_spinbox_create").orElseThrow(); + + spinbox_create = linker.downcallHandle(ui_spinbox_create_addr, sigm_mm); + } + + static EntryFuncs getInstance() { + if (instance == null) { + Toolkit toolkit = Toolkit.getInstance(); + instance = new EntryFuncs(toolkit.getLinker(), toolkit.getSymbolLookup()); + } + return instance; + } +} diff --git a/ui-java/src/main/java/de/unixwork/ui/SpinBoxBuilder.java b/ui-java/src/main/java/de/unixwork/ui/SpinBoxBuilder.java new file mode 100644 index 0000000..b0a8c72 --- /dev/null +++ b/ui-java/src/main/java/de/unixwork/ui/SpinBoxBuilder.java @@ -0,0 +1,170 @@ +package de.unixwork.ui; + +import java.lang.foreign.Arena; +import java.lang.foreign.MemorySegment; +import java.lang.invoke.MethodHandle; + +public class SpinBoxBuilder extends AbstractWidgetBuilder{ + private boolean fill; + private boolean hexpand; + private boolean vexpand; + private boolean hfill; + private boolean vfill; + private boolean overrideDefaults; + private int colspan; + private int rowspan; + private String name; + private String styleClass; + private UiInteger intValue; + private UiDouble doubleValue; + private UiRange rangeValue; + private String varname; + private EventHandler onChange; + private EventHandler onActivate; + private int[] states; + + public SpinBoxBuilder(UiObject obj, MethodHandle widgetConstructor) { + this.obj = obj; + this.widgetConstructor = widgetConstructor; + this.argsFree = ArgFuncs.getInstance().spinbox_args_free; + } + + public SpinBoxBuilder fill(boolean fill) { + this.fill = fill; + return this; + } + + public SpinBoxBuilder hexpand(boolean hexpand) { + this.hexpand = hexpand; + return this; + } + + public SpinBoxBuilder vexpand(boolean vexpand) { + this.vexpand = vexpand; + return this; + } + + public SpinBoxBuilder hfill(boolean hfill) { + this.hfill = hfill; + return this; + } + + public SpinBoxBuilder vfill(boolean vfill) { + this.vfill = vfill; + return this; + } + + public SpinBoxBuilder overrideDefaults(boolean overrideDefaults) { + this.overrideDefaults = overrideDefaults; + return this; + } + + public SpinBoxBuilder colspan(int colspan) { + this.colspan = colspan; + return this; + } + + public SpinBoxBuilder rowspan(int rowspan) { + this.rowspan = rowspan; + return this; + } + + public SpinBoxBuilder name(String name) { + this.name = name; + return this; + } + + public SpinBoxBuilder styleClass(String styleClass) { + this.styleClass = styleClass; + return this; + } + + public SpinBoxBuilder intValue(UiInteger value) { + this.intValue = value; + return this; + } + + public SpinBoxBuilder doubleValue(UiDouble value) { + this.doubleValue = value; + return this; + } + + public SpinBoxBuilder rangeValue(UiRange value) { + this.rangeValue = value; + return this; + } + + public SpinBoxBuilder varname(String varname) { + this.varname = varname; + return this; + } + + public SpinBoxBuilder onChange(EventHandler onChange) { + this.onChange = onChange; + return this; + } + + public SpinBoxBuilder states(int... states) { + this.states = states; + return this; + } + + public MemorySegment createArgs(Arena arena) throws Throwable { + ArgFuncs ui = ArgFuncs.getInstance(); + + args = (MemorySegment)ui.spinbox_args_new.invoke(); + if(fill) { + ui.spinbox_args_set_fill.invoke(args, fill); + } + if(hexpand) { + ui.spinbox_args_set_hexpand.invoke(args, hexpand); + } + if(vexpand) { + ui.spinbox_args_set_vexpand.invoke(args, vexpand); + } + if(hfill) { + ui.spinbox_args_set_hfill.invoke(args, hfill); + } + if(vfill) { + ui.spinbox_args_set_vfill.invoke(args, vfill); + } + if(overrideDefaults) { + ui.spinbox_args_set_override_defaults.invoke(args, overrideDefaults); + } + if(colspan > 0) { + ui.spinbox_args_set_colspan.invoke(args, colspan); + } + if(rowspan > 0) { + ui.spinbox_args_set_rowspan.invoke(args, rowspan); + } + if(name != null) { + MemorySegment cstr = arena.allocateFrom(name); + ui.spinbox_args_set_name.invoke(args, cstr); + } + if(styleClass != null) { + MemorySegment cstr = arena.allocateFrom(styleClass); + ui.spinbox_args_set_style_class.invoke(args, cstr); + } + + if(onChange != null) { + EventWrapper event = new EventWrapper(obj, onChange); + + // set toolkit args + ui.spinbox_args_set_onchange.invoke(args, event.getCallback()); + ui.spinbox_args_set_onchangedata.invoke(args, event.getUserData()); + } + if(varname != null) { + MemorySegment cstr = arena.allocateFrom(varname); + ui.spinbox_args_set_varname.invoke(args, cstr); + } + if(intValue != null) { + ui.spinbox_args_set_intvalue.invoke(args, intValue.valuePtr); + } else if(doubleValue != null) { + ui.spinbox_args_set_doublevalue.invoke(args, doubleValue.valuePtr); + } else if(rangeValue != null) { + ui.spinbox_args_set_rangevalue.invoke(args, rangeValue.valuePtr); + } + + return args; + } +} diff --git a/ui-kotlin/src/main/kotlin/de/unixwork/ui/kotlin/Toplevel.kt b/ui-kotlin/src/main/kotlin/de/unixwork/ui/kotlin/Toplevel.kt index cf07a27..45ab0dc 100644 --- a/ui-kotlin/src/main/kotlin/de/unixwork/ui/kotlin/Toplevel.kt +++ b/ui-kotlin/src/main/kotlin/de/unixwork/ui/kotlin/Toplevel.kt @@ -5,6 +5,7 @@ import de.unixwork.ui.Button import de.unixwork.ui.Container import de.unixwork.ui.ContainerBuilder import de.unixwork.ui.ContainerUI +import de.unixwork.ui.Entry import de.unixwork.ui.EventHandler import de.unixwork.ui.FrameBuilder import de.unixwork.ui.LabelBuilder @@ -30,6 +31,8 @@ import de.unixwork.ui.Menu import de.unixwork.ui.TabViewType import de.unixwork.ui.TableModel import de.unixwork.ui.TableViewBuilder +import de.unixwork.ui.UiDouble +import de.unixwork.ui.UiRange import de.unixwork.ui.UiText import java.awt.TextArea @@ -1530,6 +1533,72 @@ class Toplevel(obj: UiObject) { ) } + fun spinbox( + varname: String? = null, + intValue: UiInteger? = null, + doubleValue: UiDouble? = null, + rangeValue: UiRange? = null, + fill: Boolean = false, + hexpand: Boolean = false, + vexpand: Boolean = false, + hfill: Boolean = false, + vfill: Boolean = false, + overrideDefaults: Boolean = false, + colspan: Int = -1, + rowspan: Int = -1, + name: String? = null, + styleClass: String? = null, + onChange: EventHandler? = null + ): UiWidget { + val spinbox = Entry.spinbox(ui) + varname?.let { + spinbox.varname(it) + } + intValue?.let { + spinbox.intValue(it) + } + doubleValue?.let { + spinbox.doubleValue(it) + } + rangeValue?.let { + spinbox.rangeValue(it) + } + if(fill) { + spinbox.fill(fill); + } + if(hexpand) { + spinbox.hexpand(true) + } + if(vexpand) { + spinbox.vexpand(true) + } + if(hfill) { + spinbox.hfill(true) + } + if(vfill) { + spinbox.vfill(true) + } + if(colspan > 0) { + spinbox.colspan(colspan) + } + if(rowspan > 0) { + spinbox.rowspan(rowspan) + } + if(overrideDefaults) { + spinbox.overrideDefaults(true) + } + name?.let { + spinbox.name(it) + } + styleClass?.let { + spinbox.styleClass(it) + } + onChange?.let { + spinbox.onChange(onChange) + } + return spinbox.create() + } + fun webview( varname: String? = null, value: WebView? = null,