summaryrefslogtreecommitdiff
path: root/core/gjs/src
diff options
context:
space:
mode:
Diffstat (limited to 'core/gjs/src')
-rw-r--r--core/gjs/src/astalify.ts452
-rw-r--r--core/gjs/src/gobject.ts178
-rw-r--r--core/gjs/src/jsx/jsx-runtime.ts9
-rw-r--r--core/gjs/src/widgets.ts154
4 files changed, 493 insertions, 300 deletions
diff --git a/core/gjs/src/astalify.ts b/core/gjs/src/astalify.ts
index a568a50..c4cbc5c 100644
--- a/core/gjs/src/astalify.ts
+++ b/core/gjs/src/astalify.ts
@@ -1,58 +1,8 @@
import Binding, { kebabify, snakeify, type Connectable, type Subscribable } from "./binding.js"
-import { Astal, Gtk, Gdk } from "./imports.js"
+import { Astal, Gtk, Gdk, GObject } from "./imports.js"
import { execAsync } from "./process.js"
import Variable from "./variable.js"
-Object.defineProperty(Astal.Box.prototype, "children", {
- get() { return this.get_children() },
- set(v) { this.set_children(v) },
-})
-
-function setChildren(parent: Gtk.Widget, children: Gtk.Widget[]) {
- children = children.flat(Infinity).map(ch => ch instanceof Gtk.Widget
- ? ch
- : new Gtk.Label({ visible: true, label: String(ch) }))
-
- // remove
- if (parent instanceof Gtk.Bin) {
- const ch = parent.get_child()
- if (ch)
- parent.remove(ch)
- }
- else if (parent instanceof Gtk.Container &&
- !(parent instanceof Astal.Box ||
- parent instanceof Astal.Stack)) {
- for(const ch of parent.get_children())
- parent.remove(ch)
- }
-
- // TODO: add more container types
- if (parent instanceof Astal.Box) {
- parent.set_children(children)
- }
-
- else if (parent instanceof Astal.Stack) {
- parent.set_children(children)
- }
-
- else if (parent instanceof Astal.CenterBox) {
- parent.startWidget = children[0]
- parent.centerWidget = children[1]
- parent.endWidget = children[2]
- }
-
- else if (parent instanceof Astal.Overlay) {
- const [child, ...overlays] = children
- parent.set_child(child)
- parent.set_overlays(overlays)
- }
-
- else if (parent instanceof Gtk.Container) {
- for (const ch of children)
- parent.add(ch)
- }
-}
-
function mergeBindings(array: any[]) {
function getValues(...args: any[]) {
let i = 0
@@ -75,204 +25,228 @@ function mergeBindings(array: any[]) {
function setProp(obj: any, prop: string, value: any) {
try {
+ // the setter method has to be used because
+ // array like properties are not bound correctly as props
const setter = `set_${snakeify(prop)}`
if (typeof obj[setter] === "function")
return obj[setter](value)
- if (Object.hasOwn(obj, prop))
- return (obj[prop] = value)
+ return (obj[prop] = value)
}
catch (error) {
console.error(`could not set property "${prop}" on ${obj}:`, error)
}
-
- console.error(`could not set property "${prop}" on ${obj}`)
-}
-
-export type Widget<C extends InstanceType<typeof Gtk.Widget>> = C & {
- className: string
- css: string
- cursor: Cursor
- clickThrough: boolean
- toggleClassName(name: string, on?: boolean): void
- hook(
- object: Connectable,
- signal: string,
- callback: (self: Widget<C>, ...args: any[]) => void,
- ): Widget<C>
- hook(
- object: Subscribable,
- callback: (self: Widget<C>, ...args: any[]) => void,
- ): Widget<C>
-}
-
-function hook(
- self: Gtk.Widget,
- object: Connectable | Subscribable,
- signalOrCallback: string | ((self: Gtk.Widget, ...args: any[]) => void),
- callback?: (self: Gtk.Widget, ...args: any[]) => void,
-) {
- if (typeof object.connect === "function" && callback) {
- const id = object.connect(signalOrCallback, (_: any, ...args: unknown[]) => {
- callback(self, ...args)
- })
- self.connect("destroy", () => {
- (object.disconnect as Connectable["disconnect"])(id)
- })
- }
-
- else if (typeof object.subscribe === "function" && typeof signalOrCallback === "function") {
- const unsub = object.subscribe((...args: unknown[]) => {
- signalOrCallback(self, ...args)
- })
- self.connect("destroy", unsub)
- }
-
- return self
}
-function ctor(self: any, config: any = {}, children: any = []) {
- const { setup, ...props } = config
- props.visible ??= true
-
- // collect bindings
- const bindings = Object.keys(props).reduce((acc: any, prop) => {
- if (props[prop] instanceof Binding) {
- const binding = props[prop]
- delete props[prop]
- return [...acc, [prop, binding]]
- }
- return acc
- }, [])
-
- // collect signal handlers
- const onHandlers = Object.keys(props).reduce((acc: any, key) => {
- if (key.startsWith("on")) {
- const sig = kebabify(key).split("-").slice(1).join("-")
- const handler = props[key]
- delete props[key]
- return [...acc, [sig, handler]]
- }
- return acc
- }, [])
-
- // set children
- children = mergeBindings(children.flat(Infinity))
- if (children instanceof Binding) {
- setChildren(self, children.get())
- self.connect("destroy", children.subscribe((v) => {
- setChildren(self, v)
- }))
- }
- else {
- if (children.length > 0) {
- setChildren(self, children)
+export default function astalify<
+ C extends { new(...args: any[]): Gtk.Widget },
+>(cls: C) {
+ class Widget extends cls {
+ get css(): string { return Astal.widget_get_css(this) }
+ set css(css: string) { Astal.widget_set_css(this, css) }
+ get_css(): string { return this.css }
+ set_css(css: string) { this.css = css }
+
+ get className(): string { return Astal.widget_get_class_names(this).join(" ") }
+ set className(className: string) { Astal.widget_set_class_names(this, className.split(/\s+/)) }
+ get_class_name(): string { return this.className }
+ set_class_name(className: string) { this.className = className }
+
+ get cursor(): Cursor { return Astal.widget_get_cursor(this) as Cursor }
+ set cursor(cursor: Cursor) { Astal.widget_set_cursor(this, cursor) }
+ get_cursor(): Cursor { return this.cursor }
+ set_cursor(cursor: Cursor) { this.cursor = cursor }
+
+ get clickThrough(): boolean { return Astal.widget_get_click_through(this) }
+ set clickThrough(clickThrough: boolean) { Astal.widget_set_click_through(this, clickThrough) }
+ get_click_through(): boolean { return this.clickThrough }
+ set_click_through(clickThrough: boolean) { this.clickThrough = clickThrough }
+
+ declare __no_implicit_destroy: boolean
+ get noImplicitDestroy(): boolean { return this.__no_implicit_destroy }
+ set noImplicitDestroy(value: boolean) { this.__no_implicit_destroy = value }
+
+ _setChildren(children: Gtk.Widget[]) {
+ children = children.flat(Infinity).map(ch => ch instanceof Gtk.Widget
+ ? ch
+ : new Gtk.Label({ visible: true, label: String(ch) }))
+
+ // remove
+ if (this instanceof Gtk.Bin) {
+ const ch = this.get_child()
+ if (ch)
+ this.remove(ch)
+ if (ch && !children.includes(ch) && !this.noImplicitDestroy)
+ ch?.destroy()
+ }
+ else if (this instanceof Gtk.Container) {
+ for (const ch of this.get_children()) {
+ this.remove(ch)
+ if (!children.includes(ch) && !this.noImplicitDestroy)
+ ch?.destroy()
+ }
+ }
+
+ // TODO: add more container types
+ if (this instanceof Astal.Box) {
+ this.set_children(children)
+ }
+
+ else if (this instanceof Astal.Stack) {
+ this.set_children(children)
+ }
+
+ else if (this instanceof Astal.CenterBox) {
+ this.startWidget = children[0]
+ this.centerWidget = children[1]
+ this.endWidget = children[2]
+ }
+
+ else if (this instanceof Astal.Overlay) {
+ const [child, ...overlays] = children
+ this.set_child(child)
+ this.set_overlays(overlays)
+ }
+
+ else if (this instanceof Gtk.Container) {
+ for (const ch of children)
+ this.add(ch)
+ }
}
- }
- // setup signal handlers
- for (const [signal, callback] of onHandlers) {
- if (typeof callback === "function") {
- self.connect(signal, callback)
+ toggleClassName(cn: string, cond = true) {
+ Astal.widget_toggle_class_name(this, cn, cond)
}
- else {
- self.connect(signal, () => execAsync(callback)
- .then(print).catch(console.error))
+
+ hook(
+ object: Connectable,
+ signal: string,
+ callback: (self: this, ...args: any[]) => void,
+ ): this
+ hook(
+ object: Subscribable,
+ callback: (self: this, ...args: any[]) => void,
+ ): this
+ hook(
+ object: Connectable | Subscribable,
+ signalOrCallback: string | ((self: this, ...args: any[]) => void),
+ callback?: (self: this, ...args: any[]) => void,
+ ) {
+ if (typeof object.connect === "function" && callback) {
+ const id = object.connect(signalOrCallback, (_: any, ...args: unknown[]) => {
+ callback(this, ...args)
+ })
+ this.connect("destroy", () => {
+ (object.disconnect as Connectable["disconnect"])(id)
+ })
+ }
+
+ else if (typeof object.subscribe === "function" && typeof signalOrCallback === "function") {
+ const unsub = object.subscribe((...args: unknown[]) => {
+ signalOrCallback(this, ...args)
+ })
+ this.connect("destroy", unsub)
+ }
+
+ return this
}
- }
- // setup bindings handlers
- for (const [prop, binding] of bindings) {
- if (prop === "child" || prop === "children") {
- self.connect("destroy", binding.subscribe((v: any) => {
- setChildren(self, v)
- }))
+ constructor(...params: any[]) {
+ super()
+ const [config] = params
+
+ const { setup, child, children = [], ...props } = config
+ props.visible ??= true
+
+ if (child)
+ children.unshift(child)
+
+ // collect bindings
+ const bindings = Object.keys(props).reduce((acc: any, prop) => {
+ if (props[prop] instanceof Binding) {
+ const binding = props[prop]
+ delete props[prop]
+ return [...acc, [prop, binding]]
+ }
+ return acc
+ }, [])
+
+ // collect signal handlers
+ const onHandlers = Object.keys(props).reduce((acc: any, key) => {
+ if (key.startsWith("on")) {
+ const sig = kebabify(key).split("-").slice(1).join("-")
+ const handler = props[key]
+ delete props[key]
+ return [...acc, [sig, handler]]
+ }
+ return acc
+ }, [])
+
+ // set children
+ const mergedChildren = mergeBindings(children.flat(Infinity))
+ if (mergedChildren instanceof Binding) {
+ this._setChildren(mergedChildren.get())
+ this.connect("destroy", mergedChildren.subscribe((v) => {
+ this._setChildren(v)
+ }))
+ }
+ else {
+ if (mergedChildren.length > 0) {
+ this._setChildren(mergedChildren)
+ }
+ }
+
+ // setup signal handlers
+ for (const [signal, callback] of onHandlers) {
+ if (typeof callback === "function") {
+ this.connect(signal, callback)
+ }
+ else {
+ this.connect(signal, () => execAsync(callback)
+ .then(print).catch(console.error))
+ }
+ }
+
+ // setup bindings handlers
+ for (const [prop, binding] of bindings) {
+ if (prop === "child" || prop === "children") {
+ this.connect("destroy", binding.subscribe((v: any) => {
+ this._setChildren(v)
+ }))
+ }
+ this.connect("destroy", binding.subscribe((v: any) => {
+ setProp(this, prop, v)
+ }))
+ setProp(this, prop, binding.get())
+ }
+
+ Object.assign(this, props)
+ setup?.(this)
}
- self.connect("destroy", binding.subscribe((v: any) => {
- setProp(self, prop, v)
- }))
- setProp(self, prop, binding.get())
}
- Object.assign(self, props)
- setup?.(self)
- return self
-}
-
-function proxify<
- C extends typeof Gtk.Widget,
->(klass: C) {
- Object.defineProperty(klass.prototype, "className", {
- get() { return Astal.widget_get_class_names(this).join(" ") },
- set(v) { Astal.widget_set_class_names(this, v.split(/\s+/)) },
- })
-
- Object.defineProperty(klass.prototype, "css", {
- get() { return Astal.widget_get_css(this) },
- set(v) { Astal.widget_set_css(this, v) },
- })
-
- Object.defineProperty(klass.prototype, "cursor", {
- get() { return Astal.widget_get_cursor(this) },
- set(v) { Astal.widget_set_cursor(this, v) },
- })
-
- Object.defineProperty(klass.prototype, "clickThrough", {
- get() { return Astal.widget_get_click_through(this) },
- set(v) { Astal.widget_set_click_through(this, v) },
- })
-
- Object.assign(klass.prototype, {
- hook: function (obj: any, sig: any, callback: any) {
- return hook(this as InstanceType<C>, obj, sig, callback)
- },
- toggleClassName: function name(cn: string, cond = true) {
- Astal.widget_toggle_class_name(this as InstanceType<C>, cn, cond)
- },
- set_class_name: function (name: string) {
- // @ts-expect-error unknown key
- this.className = name
- },
- set_css: function (css: string) {
- // @ts-expect-error unknown key
- this.css = css
+ GObject.registerClass({
+ GTypeName: `Astal_${cls.name}`,
+ Properties: {
+ "class-name": GObject.ParamSpec.string(
+ "class-name", "", "", GObject.ParamFlags.READWRITE, "",
+ ),
+ "css": GObject.ParamSpec.string(
+ "css", "", "", GObject.ParamFlags.READWRITE, "",
+ ),
+ "cursor": GObject.ParamSpec.string(
+ "cursor", "", "", GObject.ParamFlags.READWRITE, "default",
+ ),
+ "click-through": GObject.ParamSpec.boolean(
+ "click-through", "", "", GObject.ParamFlags.READWRITE, false,
+ ),
+ "no-implicit-destroy": GObject.ParamSpec.boolean(
+ "no-implicit-destroy", "", "", GObject.ParamFlags.READWRITE, false,
+ ),
},
- set_cursor: function (cursor: string) {
- // @ts-expect-error unknown key
- this.cursor = cursor
- },
- set_click_through: function (clickThrough: boolean) {
- // @ts-expect-error unknown key
- this.clickThrough = clickThrough
- },
- })
-
- const proxy = new Proxy(klass, {
- construct(_, [conf, ...children]) {
- // @ts-expect-error abstract class
- return ctor(new klass(), conf, children)
- },
- apply(_t, _a, [conf, ...children]) {
- // @ts-expect-error abstract class
- return ctor(new klass(), conf, children)
- },
- })
+ }, Widget)
- return proxy
-}
-
-export default function astalify<
- C extends typeof Gtk.Widget,
- P extends Record<string, any>,
- N extends string = "Widget",
->(klass: C) {
- // eslint-disable-next-line @typescript-eslint/no-unused-vars
- type Astal<N> = Omit<C, "new"> & {
- new(props?: P, ...children: Gtk.Widget[]): Widget<InstanceType<C>>
- (props?: P, ...children: Gtk.Widget[]): Widget<InstanceType<C>>
- }
-
- return proxify(klass) as unknown as Astal<N>
+ return Widget
}
type BindableProps<T> = {
@@ -282,7 +256,7 @@ type BindableProps<T> = {
type SigHandler<
W extends InstanceType<typeof Gtk.Widget>,
Args extends Array<unknown>,
-> = ((self: Widget<W>, ...args: Args) => unknown) | string | string[]
+> = ((self: W, ...args: Args) => unknown) | string | string[]
export type ConstructProps<
Self extends InstanceType<typeof Gtk.Widget>,
@@ -299,16 +273,18 @@ export type ConstructProps<
cursor?: string
clickThrough?: boolean
}> & {
- onDestroy?: (self: Widget<Self>) => unknown
- onDraw?: (self: Widget<Self>) => unknown
- onKeyPressEvent?: (self: Widget<Self>, event: Gdk.Event) => unknown
- onKeyReleaseEvent?: (self: Widget<Self>, event: Gdk.Event) => unknown
- onButtonPressEvent?: (self: Widget<Self>, event: Gdk.Event) => unknown
- onButtonReleaseEvent?: (self: Widget<Self>, event: Gdk.Event) => unknown
- onRealize?: (self: Widget<Self>) => unknown
- setup?: (self: Widget<Self>) => void
+ onDestroy?: (self: Self) => unknown
+ onDraw?: (self: Self) => unknown
+ onKeyPressEvent?: (self: Self, event: Gdk.Event) => unknown
+ onKeyReleaseEvent?: (self: Self, event: Gdk.Event) => unknown
+ onButtonPressEvent?: (self: Self, event: Gdk.Event) => unknown
+ onButtonReleaseEvent?: (self: Self, event: Gdk.Event) => unknown
+ onRealize?: (self: Self) => unknown
+ setup?: (self: Self) => void
}
+export type BindableChild = Gtk.Widget | Binding<Gtk.Widget>
+
type Cursor =
| "default"
| "help"
diff --git a/core/gjs/src/gobject.ts b/core/gjs/src/gobject.ts
new file mode 100644
index 0000000..2658555
--- /dev/null
+++ b/core/gjs/src/gobject.ts
@@ -0,0 +1,178 @@
+import GObject from "gi://GObject"
+export default GObject
+
+const meta = Symbol("meta")
+
+const { ParamSpec, ParamFlags } = GObject
+
+const kebabify = (str: string) => str
+ .replace(/([a-z])([A-Z])/g, "$1-$2")
+ .replaceAll("_", "-")
+ .toLowerCase()
+
+type SignalDeclaration = {
+ flags?: GObject.SignalFlags
+ accumulator?: GObject.AccumulatorType
+ return_type?: GObject.GType
+ param_types?: Array<GObject.GType>
+}
+
+type PropertyDeclaration =
+ | InstanceType<typeof GObject.ParamSpec>
+ | { $gtype: GObject.GType }
+ | typeof String
+ | typeof Number
+ | typeof Boolean
+ | typeof Object
+
+type GObjectConstructor = {
+ [meta]?: {
+ Properties?: { [key: string]: GObject.ParamSpec }
+ Signals?: { [key: string]: GObject.SignalDefinition }
+ }
+ new(...args: any[]): any
+}
+
+type MetaInfo = GObject.MetaInfo<never, Array<{ $gtype: GObject.GType }>, never>
+
+export function register(options: MetaInfo = {}) {
+ return function (cls: GObjectConstructor) {
+ GObject.registerClass({
+ Signals: { ...cls[meta]?.Signals },
+ Properties: { ...cls[meta]?.Properties },
+ ...options,
+ }, cls)
+ }
+}
+
+export function property(declaration: PropertyDeclaration = Object) {
+ return function (target: any, prop: any, desc?: PropertyDescriptor) {
+ target.constructor[meta] ??= {}
+ target.constructor[meta].Properties ??= {}
+
+ const name = kebabify(prop)
+
+ if (!desc) {
+ let value = defaultValue(declaration)
+
+ Object.defineProperty(target, prop, {
+ get() {
+ return value
+ },
+ set(v) {
+ if (v !== value) {
+ value = v
+ this.notify(name)
+ }
+ },
+ })
+
+ Object.defineProperty(target, `set_${name.replace("-", "_")}`, {
+ value: function (v: any) {
+ this[prop] = v
+ }
+ })
+
+ Object.defineProperty(target, `get_${name.replace("-", "_")}`, {
+ value: function () {
+ return this[prop]
+ }
+ })
+
+ target.constructor[meta].Properties[kebabify(prop)] = pspec(name, ParamFlags.READWRITE, declaration)
+ }
+
+ else {
+ let flags = 0
+ if (desc.get) flags |= ParamFlags.READABLE
+ if (desc.set) flags |= ParamFlags.WRITABLE
+
+ target.constructor[meta].Properties[kebabify(prop)] = pspec(name, flags, declaration)
+ }
+ }
+}
+
+export function signal(...params: Array<{ $gtype: GObject.GType } | typeof Object>):
+ (target: any, signal: any, desc?: PropertyDescriptor) => void
+
+export function signal(declaration?: SignalDeclaration):
+ (target: any, signal: any, desc?: PropertyDescriptor) => void
+
+export function signal(
+ declaration?: SignalDeclaration | { $gtype: GObject.GType } | typeof Object,
+ ...params: Array<{ $gtype: GObject.GType } | typeof Object>
+) {
+ return function (target: any, signal: any, desc?: PropertyDescriptor) {
+ target.constructor[meta] ??= {}
+ target.constructor[meta].Signals ??= {}
+
+ const name = kebabify(signal)
+
+ if (declaration || params.length > 0) {
+ // @ts-expect-error TODO: type assert
+ const arr = [declaration, ...params].map(v => v.$gtype)
+ target.constructor[meta].Signals[name] = {
+ param_types: arr,
+ }
+ }
+ else {
+ target.constructor[meta].Signals[name] = declaration
+ }
+
+ if (!desc) {
+ Object.defineProperty(target, signal, {
+ value: function (...args: any[]) {
+ this.emit(name, ...args)
+ },
+ })
+ }
+ else {
+ const og: ((...args: any[]) => void) = desc.value
+ desc.value = function (...args: any[]) {
+ // @ts-expect-error not typed
+ this.emit(name, ...args)
+ }
+ Object.defineProperty(target, `on_${name.replace("-", "_")}`, {
+ value: function (...args: any[]) {
+ return og(...args)
+ },
+ })
+ }
+ }
+}
+
+function pspec(name: string, flags: number, declaration: PropertyDeclaration) {
+ if (declaration instanceof ParamSpec)
+ return declaration
+
+ switch (declaration) {
+ case String:
+ return ParamSpec.string(name, "", "", flags, "")
+ case Number:
+ return ParamSpec.double(name, "", "", flags, -Number.MAX_VALUE, Number.MAX_VALUE, 0)
+ case Boolean:
+ return ParamSpec.boolean(name, "", "", flags, false)
+ case Object:
+ return ParamSpec.jsobject(name, "", "", flags)
+ default:
+ // @ts-expect-error misstyped
+ return ParamSpec.object(name, "", "", flags, declaration.$gtype)
+ }
+}
+
+function defaultValue(declaration: PropertyDeclaration) {
+ if (declaration instanceof ParamSpec)
+ return declaration.get_default_value()
+
+ switch (declaration) {
+ case String:
+ return "default-string"
+ case Number:
+ return 0
+ case Boolean:
+ return false
+ case Object:
+ default:
+ return null
+ }
+}
diff --git a/core/gjs/src/jsx/jsx-runtime.ts b/core/gjs/src/jsx/jsx-runtime.ts
index a0aafb6..f40dc05 100644
--- a/core/gjs/src/jsx/jsx-runtime.ts
+++ b/core/gjs/src/jsx/jsx-runtime.ts
@@ -16,14 +16,15 @@ export function jsx(
children = children.filter(Boolean)
- if (typeof ctor === "string")
- return (ctors as any)[ctor](props, children)
-
if (children.length === 1)
props.child = children[0]
else if (children.length > 1)
props.children = children
+ if (typeof ctor === "string") {
+ return new ctors[ctor](props)
+ }
+
if (isArrowFunction(ctor))
return ctor(props)
@@ -63,7 +64,7 @@ declare global {
box: Widget.BoxProps
button: Widget.ButtonProps
centerbox: Widget.CenterBoxProps
- circularprogress: Widget.CircularProgressProps,
+ circularprogress: Widget.CircularProgressProps
drawingarea: Widget.DrawingAreaProps
entry: Widget.EntryProps
eventbox: Widget.EventBoxProps
diff --git a/core/gjs/src/widgets.ts b/core/gjs/src/widgets.ts
index 82d3b8f..e14ca0b 100644
--- a/core/gjs/src/widgets.ts
+++ b/core/gjs/src/widgets.ts
@@ -1,18 +1,23 @@
/* eslint-disable max-len */
-import { Astal, Gtk } from "./imports.js"
-import astalify, { type ConstructProps, type Widget } from "./astalify.js"
+import { Astal, GObject, Gtk } from "./imports.js"
+import astalify, { type ConstructProps, type BindableChild } from "./astalify.js"
export { astalify, ConstructProps }
// Box
-export type Box = Widget<Astal.Box>
-export const Box = astalify<typeof Astal.Box, BoxProps, "Box">(Astal.Box)
-export type BoxProps = ConstructProps<Astal.Box, Astal.Box.ConstructorProps>
+Object.defineProperty(Astal.Box.prototype, "children", {
+ get() { return this.get_children() },
+ set(v) { this.set_children(v) },
+})
+
+export type BoxProps = ConstructProps<Box, Astal.Box.ConstructorProps>
+export class Box extends astalify(Astal.Box) {
+ static { GObject.registerClass({ GTypeName: "Box" }, this) }
+ constructor(props?: BoxProps, ...children: Array<BindableChild>) { super({ children, ...props } as any) }
+}
// Button
-export type Button = Widget<Astal.Button>
-export const Button = astalify<typeof Astal.Button, ButtonProps, "Button">(Astal.Button)
-export type ButtonProps = ConstructProps<Astal.Button, Astal.Button.ConstructorProps, {
+export type ButtonProps = ConstructProps<Button, Astal.Button.ConstructorProps, {
onClicked: []
onClick: [event: Astal.ClickEvent]
onClickRelease: [event: Astal.ClickEvent]
@@ -20,97 +25,130 @@ export type ButtonProps = ConstructProps<Astal.Button, Astal.Button.ConstructorP
onHoverLost: [event: Astal.HoverEvent]
onScroll: [event: Astal.ScrollEvent]
}>
+export class Button extends astalify(Astal.Button) {
+ static { GObject.registerClass({ GTypeName: "Button" }, this) }
+ constructor(props?: ButtonProps, child?: BindableChild) { super({ child, ...props } as any) }
+}
// CenterBox
-export type CenterBox = Widget<Astal.CenterBox>
-export const CenterBox = astalify<typeof Astal.CenterBox, CenterBoxProps, "CenterBox">(Astal.CenterBox)
-export type CenterBoxProps = ConstructProps<Astal.CenterBox, Astal.CenterBox.ConstructorProps>
+export type CenterBoxProps = ConstructProps<CenterBox, Astal.CenterBox.ConstructorProps>
+export class CenterBox extends astalify(Astal.CenterBox) {
+ static { GObject.registerClass({ GTypeName: "CenterBox" }, this) }
+ constructor(props?: CenterBoxProps, ...children: Array<BindableChild>) { super({ children, ...props } as any) }
+}
// CircularProgress
-export type CircularProgress = Widget<Astal.CircularProgress>
-export const CircularProgress = astalify<typeof Astal.CircularProgress, CircularProgressProps, "CircularProgress">(Astal.CircularProgress)
-export type CircularProgressProps = ConstructProps<Astal.CircularProgress, Astal.CircularProgress.ConstructorProps>
-
+export type CircularProgressProps = ConstructProps<CircularProgress, Astal.CircularProgress.ConstructorProps>
+export class CircularProgress extends astalify(Astal.CircularProgress) {
+ static { GObject.registerClass({ GTypeName: "CircularProgress" }, this) }
+ constructor(props?: CircularProgressProps, child?: BindableChild) { super({ child, ...props } as any) }
+}
// DrawingArea
-export type DrawingArea = Widget<Gtk.DrawingArea>
-export const DrawingArea = astalify<typeof Gtk.DrawingArea, DrawingAreaProps, "DrawingArea">(Gtk.DrawingArea)
-export type DrawingAreaProps = ConstructProps<Gtk.DrawingArea, Gtk.DrawingArea.ConstructorProps, {
+export type DrawingAreaProps = ConstructProps<DrawingArea, Gtk.DrawingArea.ConstructorProps, {
onDraw: [cr: any] // TODO: cairo types
}>
+export class DrawingArea extends astalify(Gtk.DrawingArea) {
+ static { GObject.registerClass({ GTypeName: "DrawingArea" }, this) }
+ constructor(props?: DrawingAreaProps) { super(props as any) }
+}
// Entry
-export type Entry = Widget<Gtk.Entry>
-export const Entry = astalify<typeof Gtk.Entry, EntryProps, "Entry">(Gtk.Entry)
-export type EntryProps = ConstructProps<Gtk.Entry, Gtk.Entry.ConstructorProps, {
+export type EntryProps = ConstructProps<Entry, Gtk.Entry.ConstructorProps, {
onChanged: []
onActivate: []
}>
+export class Entry extends astalify(Gtk.Entry) {
+ static { GObject.registerClass({ GTypeName: "Entry" }, this) }
+ constructor(props?: EntryProps) { super(props as any) }
+}
// EventBox
-export type EventBox = Widget<Astal.EventBox>
-export const EventBox = astalify<typeof Astal.EventBox, EventBoxProps, "EventBox">(Astal.EventBox)
-export type EventBoxProps = ConstructProps<Astal.EventBox, Astal.EventBox.ConstructorProps, {
+export type EventBoxProps = ConstructProps<EventBox, Astal.EventBox.ConstructorProps, {
onClick: [event: Astal.ClickEvent]
onClickRelease: [event: Astal.ClickEvent]
onHover: [event: Astal.HoverEvent]
onHoverLost: [event: Astal.HoverEvent]
onScroll: [event: Astal.ScrollEvent]
}>
-
-// TODO: Fixed
-// TODO: FlowBox
-
+export class EventBox extends astalify(Astal.EventBox) {
+ static { GObject.registerClass({ GTypeName: "EventBox" }, this) }
+ constructor(props?: EventBoxProps, child?: BindableChild) { super({ child, ...props } as any) }
+}
+
+// // TODO: Fixed
+// // TODO: FlowBox
+//
// Icon
-export type Icon = Widget<Astal.Icon>
-export const Icon = astalify<typeof Astal.Icon, IconProps, "Icon">(Astal.Icon)
-export type IconProps = ConstructProps<Astal.Icon, Astal.Icon.ConstructorProps>
+export type IconProps = ConstructProps<Icon, Astal.Icon.ConstructorProps>
+export class Icon extends astalify(Astal.Icon) {
+ static { GObject.registerClass({ GTypeName: "Icon" }, this) }
+ constructor(props?: IconProps) { super(props as any) }
+}
// Label
-export type Label = Widget<Astal.Label>
-export const Label = astalify<typeof Astal.Label, LabelProps, "Label">(Astal.Label)
-export type LabelProps = ConstructProps<Astal.Label, Astal.Label.ConstructorProps>
+export type LabelProps = ConstructProps<Label, Astal.Label.ConstructorProps>
+export class Label extends astalify(Astal.Label) {
+ static { GObject.registerClass({ GTypeName: "Label" }, this) }
+ constructor(props?: LabelProps) { super(props as any) }
+}
// LevelBar
-export type LevelBar = Widget<Astal.LevelBar>
-export const LevelBar = astalify<typeof Astal.LevelBar, LevelBarProps, "LevelBar">(Astal.LevelBar)
-export type LevelBarProps = ConstructProps<Astal.LevelBar, Astal.LevelBar.ConstructorProps>
+export type LevelBarProps = ConstructProps<LevelBar, Astal.LevelBar.ConstructorProps>
+export class LevelBar extends astalify(Astal.LevelBar) {
+ static { GObject.registerClass({ GTypeName: "LevelBar" }, this) }
+ constructor(props?: LevelBarProps) { super(props as any) }
+}
// TODO: ListBox
// Overlay
-export type Overlay = Widget<Astal.Overlay>
-export const Overlay = astalify<typeof Astal.Overlay, OverlayProps, "Overlay">(Astal.Overlay)
-export type OverlayProps = ConstructProps<Astal.Overlay, Astal.Overlay.ConstructorProps>
+export type OverlayProps = ConstructProps<Overlay, Astal.Overlay.ConstructorProps>
+export class Overlay extends astalify(Astal.Overlay) {
+ static { GObject.registerClass({ GTypeName: "Overlay" }, this) }
+ constructor(props?: OverlayProps, ...children: Array<BindableChild>) { super({ children, ...props } as any) }
+}
// Revealer
-export type Revealer = Widget<Gtk.Revealer>
-export const Revealer = astalify<typeof Gtk.Revealer, RevealerProps, "Revealer">(Gtk.Revealer)
-export type RevealerProps = ConstructProps<Gtk.Revealer, Gtk.Revealer.ConstructorProps>
+export type RevealerProps = ConstructProps<Revealer, Gtk.Revealer.ConstructorProps>
+export class Revealer extends astalify(Gtk.Revealer) {
+ static { GObject.registerClass({ GTypeName: "Revealer" }, this) }
+ constructor(props?: RevealerProps, child?: BindableChild) { super({ child, ...props } as any) }
+}
// Scrollable
-export type Scrollable = Widget<Astal.Scrollable>
-export const Scrollable = astalify<typeof Astal.Scrollable, ScrollableProps, "Scrollable">(Astal.Scrollable)
-export type ScrollableProps = ConstructProps<Astal.Scrollable, Astal.Scrollable.ConstructorProps>
+export type ScrollableProps = ConstructProps<Scrollable, Astal.Scrollable.ConstructorProps>
+export class Scrollable extends astalify(Astal.Scrollable) {
+ static { GObject.registerClass({ GTypeName: "Scrollable" }, this) }
+ constructor(props?: ScrollableProps, child?: BindableChild) { super({ child, ...props } as any) }
+}
// Slider
-export type Slider = Widget<Astal.Slider>
-export const Slider = astalify<typeof Astal.Slider, SliderProps, "Slider">(Astal.Slider)
-export type SliderProps = ConstructProps<Astal.Slider, Astal.Slider.ConstructorProps, {
+export type SliderProps = ConstructProps<Slider, Astal.Slider.ConstructorProps, {
onDragged: []
}>
+export class Slider extends astalify(Astal.Slider) {
+ static { GObject.registerClass({ GTypeName: "Slider" }, this) }
+ constructor(props?: SliderProps) { super(props as any) }
+}
// Stack
-export type Stack = Widget<Astal.Stack>
-export const Stack = astalify<typeof Astal.Stack, StackProps, "Stack">(Astal.Stack)
-export type StackProps = ConstructProps<Astal.Stack, Astal.Stack.ConstructorProps>
+export type StackProps = ConstructProps<Stack, Astal.Stack.ConstructorProps>
+export class Stack extends astalify(Astal.Stack) {
+ static { GObject.registerClass({ GTypeName: "Stack" }, this) }
+ constructor(props?: StackProps, ...children: Array<BindableChild>) { super({ children, ...props } as any) }
+}
// Switch
-export type Switch = Widget<Gtk.Switch>
-export const Switch = astalify<typeof Gtk.Switch, SwitchProps, "Switch">(Gtk.Switch)
-export type SwitchProps = ConstructProps<Gtk.Switch, Gtk.Switch.ConstructorProps>
+export type SwitchProps = ConstructProps<Switch, Gtk.Switch.ConstructorProps>
+export class Switch extends astalify(Gtk.Switch) {
+ static { GObject.registerClass({ GTypeName: "Switch" }, this) }
+ constructor(props?: SwitchProps) { super(props as any) }
+}
// Window
-export type Window = Widget<Astal.Window>
-export const Window = astalify<typeof Astal.Window, WindowProps, "Window">(Astal.Window)
-export type WindowProps = ConstructProps<Astal.Window, Astal.Window.ConstructorProps>
+export type WindowProps = ConstructProps<Window, Astal.Window.ConstructorProps>
+export class Window extends astalify(Astal.Window) {
+ static { GObject.registerClass({ GTypeName: "Window" }, this) }
+ constructor(props?: WindowProps, child?: BindableChild) { super({ child, ...props } as any) }
+}
generated by cgit v1.2.3 (git 2.25.1) at 2025-07-02 02:28:05 +0000