dazscript-framework 0.1.0

package/dialog/builders/node-selection-builder.ts

@@ -0,0 +1,44 @@
+import { Observable } from '@dsf/lib/observable';
+import { WidgetBuilderBase, createWidget } from './widget-builder';
+import { WidgetBuilderContext } from './widgets-builder';
+
+export class NodeSelectionComboBoxBuilder extends WidgetBuilderBase<DzNodeSelectionComboBox> {
+    constructor(context: WidgetBuilderContext) {
+        super(createWidget(context).withArgs(['DzNode', true]).build(DzNodeSelectionComboBox))
+    }
+
+    node(node: Observable<DzNode>): this {
+        this.widget.setNode(node.value)
+        node.connect((node) => {
+            this.widget.setNode(node)
+        })
+        return this
+    }
+
+    nodes(nodes: Observable<DzNode[]>): this {
+        this.widget.setNodes(nodes.value)
+        nodes.connect((nodes) => {
+            this.widget.setNodes(nodes)
+        })
+        return this
+    }
+
+    selected(node: Observable<DzNode>): this {
+        this.widget.setSelectedNode(node.value)
+        node.connect((node) => {
+            this.widget.setSelectedNode(node)
+        })
+        return this
+    }
+
+    bind(node: Observable<DzNode>): this {
+        this.widget.nodeSelectionChanged.scriptConnect(() => {
+            node.value = this.widget.getSelectedNode()
+        })
+        return this
+    }
+
+    build(then?: (comboBox: DzNodeSelectionComboBox) => void): DzNodeSelectionComboBox {
+        return super.build()
+    }
+}

package/dialog/builders/popup-menu-builder.ts

@@ -0,0 +1,47 @@
+import { WidgetBuilderBase, createWidget } from './widget-builder';
+import { WidgetBuilderContext } from './widgets-builder';
+
+export class PopupMenuItem {
+    id?: number
+    text?: string
+    checkbox?: boolean
+    activated?: (id?: number) => void
+}
+
+export class PopupMenuBuilder extends WidgetBuilderBase<DzPopupMenu> {
+    constructor(context: WidgetBuilderContext) {
+        super(createWidget(context).build(DzPopupMenu));
+    }
+
+    parent(parent: DzWidget): this {
+        this.widget.reparent(parent, new Point(0, 0))
+        return this
+    }
+
+    items(...items: PopupMenuItem[]): this {
+        items?.forEach((item, idx) => {
+            if (!item.text) {
+                this.widget.insertSeparator(idx)
+            }
+            else {
+                this.widget.insertTextItem(item.text, item.id ?? idx, idx)
+
+            }
+
+            if (item.activated) this.widget.connectItem(item.id ?? idx, null, item.activated)
+        })
+        return this
+    }
+
+    selected(fn: (idx: number) => void): this {
+        this.widget.activated.scriptConnect((idx) => {
+            fn(idx)
+        })
+        return this
+    }
+
+    build(then?: (popupMenu: DzPopupMenu) => void): DzPopupMenu {
+        then?.(this.widget)
+        return this.widget
+    }
+}

package/dialog/builders/radio-builder.ts

@@ -0,0 +1,43 @@
+import { Observable } from '@dsf/lib/observable';
+import { WidgetBuilderBase, createWidget } from './widget-builder';
+import { WidgetBuilderContext } from './widgets-builder';
+
+export default class RadioButtonBuilder extends WidgetBuilderBase<DzRadioButton> {
+    constructor(context: WidgetBuilderContext) {
+        super(createWidget(context).build(DzRadioButton))
+    }
+
+    label(text: string): this {
+        this.widget.text = text ?? ''
+        return this
+    }
+
+    value(source: boolean | Observable<boolean>): this {
+        if (typeof source === 'boolean') {
+            this.widget.checked = source
+        }
+        else {
+            this.widget.checked = source.value
+            source.connect((value) => {
+                this.widget.checked = value
+            })
+            this.widget.toggled.scriptConnect((value) => {
+                source.value = value
+            })
+        }
+        return this
+    }
+
+    toggled(fn: (value: boolean) => void): this {
+        this.widget.toggled.scriptConnect((value) => {
+            fn(value)
+        })
+        return this
+    }
+
+    build(checkbox?: (checkbox: DzRadioButton) => void): DzRadioButton {
+        checkbox?.(this.widget)
+        return this.widget
+    }
+
+}

package/dialog/builders/splitter-builder.ts

@@ -0,0 +1,90 @@
+import { debug } from '@dsf/common/log';
+import { WidgetBuilderBase, createWidget } from './widget-builder';
+import { WidgetBuilderContext } from './widgets-builder';
+import { Observable } from '@dsf/lib/observable';
+import { getState, restoreState } from '@dsf/helpers/splitter-helper';
+
+export class SplitterBuilder extends WidgetBuilderBase<DzSplitter> {
+    private _items: DzWidget[] = []
+
+    constructor(private context: SplitterBuilderContext) {
+        super(createWidget(context.widgetContext).build(DzSplitter))
+    }
+
+    vertical(): this {
+        this.context.orientation = DzSplitter.Vertical
+        return this
+    }
+
+    horizontal(): this {
+        this.context.orientation = DzSplitter.Horizontal
+        return this
+    }
+
+    items(...items: DzWidget[]): this {
+        this._items = items
+        return this
+    }
+
+    collapsible(...collapsible: boolean[]): this {
+        this.context.collapsible = collapsible
+        return this
+    }
+
+    strech(...strech: number[]): this {
+        this.context.strech = strech
+        return this
+    }
+
+    state(bind: Observable<string>): this {
+        this.context.state = bind
+        return this
+    }
+
+    build(then?: (splitter: DzSplitter) => void): DzSplitter {
+        let splitter = createWidget(this.context.widgetContext).build(DzSplitter)
+        splitter.orientation = this.context.orientation
+
+        this._items?.forEach((widget, index) => {
+            splitter.addWidget(widget)
+            splitter.setCollapsible(index, this.context.collapsible[index] ?? this.context.collapsible[0] ?? false)
+            splitter.setStretchFactor(index, this.context.strech[index] ?? this.context.strech[0] ?? 0)
+        })
+
+        restoreState(splitter, this.context.state?.value);
+        (splitter.getWidget() as QSplitter).splitterMoved.scriptConnect(() => {
+            this.context.state.value = getState(splitter)
+        })
+        this.context.state.connect((state) => {
+            restoreState(splitter, state)
+        })
+
+        this.context.add(splitter, (splitter) => {
+            then?.(splitter)
+        })
+
+        return splitter
+    }
+}
+
+export class SplitterBuilderContext {
+    private _current: DzSplitter
+
+    orientation: number = DzSplitter.Vertical
+    collapsible: boolean[] = []
+    strech: number[] = []
+    state = new Observable<string>()
+
+    get current(): DzSplitter | null {
+        return this._current
+    }
+
+    constructor(public readonly widgetContext: WidgetBuilderContext) { }
+
+    add(splitter: DzSplitter, content: (splitterWidget: DzSplitter) => void): DzSplitter {
+        this._current = splitter
+        content(splitter)
+        this._current = null
+        return splitter
+    }
+}

package/dialog/builders/tab-builder.ts

@@ -0,0 +1,106 @@
+import { Observable } from '@dsf/lib/observable';
+import { IWidgetBuilder } from './widget-builder';
+import LayoutBuilder from './layout-builder';
+import { Direction } from '../shared';
+import { WidgetBuilderContext } from './widgets-builder';
+
+export class TabBuilder implements IWidgetBuilder<DzTabWidget> {
+    private direction: Direction = 'vertical';
+    private titleText: string;
+    private tabIndex_: Observable<number>;
+    private currentChanged: (index: number) => void;
+
+    constructor(private layoutBuilder: LayoutBuilder, private context: TabBuilderContext) {
+    }
+
+    visible(value: boolean | Observable<boolean>): this {
+        this.context.visible = typeof value === 'boolean'
+            ? new Observable(value)
+            : value
+        return this
+    }
+
+    static create(context: TabBuilderContext): TabBuilder {
+        return new TabBuilder(new LayoutBuilder(context.widgetContext), context)
+    }
+
+    horizontal(): this {
+        this.direction = 'horizontal'
+        return this
+    }
+
+    vertical(): this {
+        this.direction = 'vertical'
+        return this
+    }
+
+    title(text: string): this {
+        this.titleText = text;
+        return this;
+    }
+
+    bind(tabNumber: Observable<number>): this {
+        this.tabIndex_ = tabNumber;
+        return this;
+    }
+
+    onChanged(then: (index: number) => void): this {
+        this.currentChanged = then
+        return this
+    }
+
+    build(then?: (layout: DzVBoxLayout | DzHBoxLayout, tabWidget: DzTabWidget) => void): DzTabWidget {
+        return this.context.add((tabWidget) => {
+            let tab = new DzWidget(this.context.widgetContext.dialog)
+            tabWidget.addTab(tab, this.titleText)
+            this.context.widgetContext.layout.addWidget(tabWidget)
+
+            this.layoutBuilder
+                .parent(tab)
+                .direction(this.direction)
+                .build((layout) => {
+                    then?.(layout, tabWidget)
+                })
+
+            if (this.context.visible) {
+                if (this.context.visible.value === false)
+                    tab.hide()
+                this.context.visible.connect((visible) => {
+                    if (visible)
+                        tab.show()
+                    else
+                        tab.hide()
+                })
+            }
+
+            tabWidget["currentChanged(int)"].scriptConnect((index: number) => {
+                if (this.tabIndex_) this.tabIndex_.value = index
+                this.currentChanged?.(index)
+            })
+
+            tabWidget.setCurrentPage(this.tabIndex_?.value ?? 0)
+        });
+    }
+}
+
+export class TabBuilderContext {
+    private counter = 1;
+    private widgets: DzTabWidget[] = [];
+    visible: Observable<boolean>
+
+    constructor(public readonly widgetContext: WidgetBuilderContext) { }
+
+    add(content: (tabWidget: DzTabWidget) => void): DzTabWidget {
+        this.counter++
+        let tabWidget = this.getWidget()
+        content(tabWidget)
+        this.counter--
+        return tabWidget
+    }
+
+    private getWidget(): DzTabWidget {
+        if (this.widgets.length === 0 || this.counter >= this.widgets.length)
+            this.widgets[this.counter] = new DzTabWidget(this.widgetContext.dialog);
+        return this.widgets[this.counter];
+    }
+}

package/dialog/builders/widget-builder.ts

@@ -0,0 +1,109 @@
+import { createUID } from '@dsf/lib/guid';
+import { Observable } from '@dsf/lib/observable';
+import { WidgetBuilderContext } from './widgets-builder';
+
+export abstract class WidgetBuilderBase<T extends DzWidget> implements IWidgetBuilder<T>{
+    constructor(protected readonly widget: T) { }
+
+    enabled<T>(when: boolean | Observable<T>): this {
+        if (typeof when === 'boolean') {
+            this.widget.enabled = when
+        }
+        else {
+            this.widget.enabled = Boolean(when.value)
+            when.connect((value) => {
+                this.widget.enabled = Boolean(value)
+            })
+        }
+        return this
+    }
+
+    focus(): this {
+        this.widget.getWidget().setFocus()
+        return this
+    }
+
+    toolTip(toolTip: string): this {
+        this.widget.toolTip = toolTip
+        this.widget.whatsThis = toolTip
+        return this
+    }
+
+    whatsThis(whatsThis: string): this {
+        this.widget.whatsThis = whatsThis
+        return this
+    }
+
+    visible(value: boolean | Observable<boolean>): this {
+        let observable = typeof value === 'boolean'
+            ? new Observable(value)
+            : value
+
+        if (observable.value)
+            this.widget.show()
+        else
+            this.widget.hide()
+        observable.connect((value) => {
+            if (value)
+                this.widget.show()
+            else
+                this.widget.hide()
+        })
+        return this
+    }
+
+    build(): T {
+        return this.widget
+    }
+}
+
+export interface IWidgetBuilder<T extends DzWidget> {
+    visible(value: boolean | Observable<boolean>): this
+    build(): T
+}
+
+export class WidgetBuilder {
+    private _parent: DzWidget | DzLayout;
+    private _args: any[] | null;
+
+    constructor(public readonly context: WidgetBuilderContext) { }
+
+    parent(parent: DzWidget | DzLayout): this {
+        this._parent = parent;
+        return this;
+    }
+
+    withArgs(widgetArgs: any[]): this {
+        this._args = widgetArgs;
+        return this;
+    }
+
+    build<T extends DzWidget>(type: { new(p0: any, p1?: any, p2?: any, p3?: any): T; }, then?: (widget: T) => void): T {
+        let parent = this._parent ?? this.context.parent;
+        let name = createUID();
+        let widget: T;
+
+        if (parent.inherits("DzLayout")) {
+            let args = this._args;
+            if (!args || args.length === 0) widget = new type(this.context.dialog);
+            else if (args.length === 1) widget = new type(this.context.dialog, args[0]);
+            else if (args.length === 2) widget = new type(this.context.dialog, args[0], args[1]);
+            else if (args.length === 3) widget = new type(this.context.dialog, args[0], args[1], args[2]);
+            else throw Error("DzWidget Arguments out of range");
+            (<DzLayout>parent).addWidget(widget);
+        }
+        else {
+            widget = new type(parent);
+        }
+
+        widget.name = name;
+        then?.(widget);
+
+        return widget;
+    }
+}
+
+export const createWidget = (context: WidgetBuilderContext): WidgetBuilder => {
+    return new WidgetBuilder(context)
+}
+

package/dialog/builders/widgets-builder.ts

@@ -0,0 +1,119 @@
+import { Observable } from '@dsf/lib/observable'
+import { ButtonBuilder } from './button-builder'
+import CheckBoxBuilder from './checkbox-builder'
+import { ComboBoxBuilder } from './combo-box-builder'
+import { ComboEditBuilder } from './combo-edit-builder'
+import GroupBoxBuilder from './groupbox-builder'
+import LabelBuilder from './label-builder'
+import LayoutBuilder from './layout-builder'
+import LineEditBuilder from './line-edit-builder'
+import { ListViewBuilder } from './list-view-builder'
+import { NodeSelectionComboBoxBuilder } from './node-selection-builder'
+import { PopupMenuBuilder } from './popup-menu-builder'
+import RadioButtonBuilder from './radio-builder'
+import { SplitterBuilder, SplitterBuilderContext } from './splitter-builder'
+import { TabBuilder, TabBuilderContext } from './tab-builder'
+import { createWidget } from './widget-builder'
+
+export class WidgetBuilderContext {
+    layout: DzLayout | null
+
+    get parent(): DzWidget | DzLayout {
+        return this.layout ?? this.dialog
+    }
+
+    constructor(public readonly dialog: DzBasicDialog) {
+        this.layout = new LayoutBuilder(this).build()
+    }
+}
+
+export class WidgetsBuilder {
+    private readonly tabsContext: TabBuilderContext
+    private readonly splitterContext: SplitterBuilderContext
+
+    constructor(public readonly context: WidgetBuilderContext) {
+        this.tabsContext = new TabBuilderContext(this.context)
+        this.splitterContext = new SplitterBuilderContext(this.context)
+    }
+
+    vertical(then?: (layout: DzVBoxLayout) => void): DzVBoxLayout {
+        return LayoutBuilder
+            .create(this.context)
+            .direction('vertical')
+            .build(then)
+    }
+
+    horizontal(then?: (layout: DzHBoxLayout) => void): DzHBoxLayout {
+        return LayoutBuilder
+            .create(this.context)
+            .direction('horizontal')
+            .build(then)
+    }
+
+    widget<T extends DzWidget>(type: { new(p0: any, p1?: any, p2?: any, p3?: any): T }, then?: (widget: T) => void): T {
+        return createWidget(this.context).build(type, then)
+    }
+
+    label(text: string): LabelBuilder {
+        return new LabelBuilder(this.context).text(text)
+    }
+
+    button(text?: string): ButtonBuilder {
+        return new ButtonBuilder(this.context).text(text)
+    }
+
+    edit(): LineEditBuilder {
+        return new LineEditBuilder(this.context)
+    }
+
+    checkbox(label?: string): CheckBoxBuilder {
+        return new CheckBoxBuilder(this.context).label(label)
+    }
+
+    radio(label?: string): RadioButtonBuilder {
+        return new RadioButtonBuilder(this.context).label(label)
+    }
+
+    group(title?: string | Observable<string>): GroupBoxBuilder {
+        return new GroupBoxBuilder(this.context).title(title)
+    }
+
+    tab(title?: string): TabBuilder {
+        return TabBuilder.create(this.tabsContext).title(title)
+    }
+
+    splitter(...items: DzWidget[]): SplitterBuilder {
+        return new SplitterBuilder(this.splitterContext).items(...items)
+    }
+
+    contextMenu(): PopupMenuBuilder {
+        return new PopupMenuBuilder(this.context)
+    }
+
+    combo(): ComboBoxBuilder {
+        return new ComboBoxBuilder(this.context)
+    }
+
+    comboEdit(): ComboEditBuilder {
+        return new ComboEditBuilder(this.context)
+    }
+
+    /**
+     *
+     * @returns
+     * @deprecated use list
+     */
+    listView<TItem, TData = TItem>(): ListViewBuilder<TItem, TData> {
+        return new ListViewBuilder(this.context)
+    }
+
+    get list(): { view: <TItem, TData = TItem>() => ListViewBuilder<TItem, TData> } {
+        return {
+            view: <TItem, TData = TItem>() => new ListViewBuilder<TItem, TData>(this.context)
+        }
+    }
+
+    nodeSelection(): NodeSelectionComboBoxBuilder {
+        return new NodeSelectionComboBoxBuilder(this.context)
+    }
+}

package/dialog/input-dialog.ts

@@ -0,0 +1,28 @@
+import { Observable } from '@dsf/lib/observable';
+import { BasicDialog } from './basic-dialog';
+import { InputValidator } from './input-validator';
+
+export class InputDialogModel {
+    value$: Observable<string> = new Observable()
+    validator: InputValidator | null = null
+
+    getNumericValue(): number {
+        return parseFloat(this.value$.value).valueOf()
+    }
+
+    constructor(validator: InputValidator | null = null) {
+        this.validator = validator
+    }
+}
+
+export class InputDialog extends BasicDialog {
+    constructor(title: string, private readonly model: InputDialogModel) {
+        super(title);
+    }
+
+    protected build(): void {
+        let add = this.add
+
+        add.edit().text(this.model.value$).validator(this.model.validator).focus()
+    }
+}

package/dialog/input-validator.ts

@@ -0,0 +1,9 @@
+export enum InputValidator {
+    float,
+    int,
+    regexp,
+    subpath,
+    filename,
+    nodename,
+    nodelabel
+}

package/dialog/shared.ts

@@ -0,0 +1,8 @@
+
+export type Direction = 'vertical' | 'horizontal';
+
+export class DialogProperties {
+    width?: number;
+    height?: number;
+    resizable?: boolean;
+}

package/helpers/action-helper.ts

@@ -0,0 +1,81 @@
+import { debug, warn } from '@dsf/common/log'
+import { mainWindow } from '@dsf/lib/global'
+import { isGUID } from './string-helper'
+
+const actionMgr = mainWindow.getActionMgr()
+
+export const isCustomAction = (action: string | DzAction): boolean => {
+    return typeof action === 'string'
+        ? isGUID(action)
+        : action.inherits('DzCustomAction')
+}
+
+export const findAction = (name: string): DzAction | null => {
+    return isCustomAction(name)
+        ? findCustomAction(name)
+        : actionMgr.findAction(name)
+}
+
+const findCustomAction = (name: string): DzCustomAction | null => {
+    let index = actionMgr.findCustomAction(name)
+    return index >= 0
+        ? actionMgr.getCustomActionByIndex(index)
+        : null
+}
+
+export const triggerAction = (name: string) => {
+    findAction(name)?.trigger()
+}
+
+export const setActionShortcut = (name: string, shortcut: string) => {
+    let action = findAction(name)
+    if (!action) return
+    if (isCustomAction(action)) {
+        actionMgr.setCustomActionShortcut(actionMgr.findCustomAction(name), shortcut)
+        debug(`Shortcut set for Custom Action ${action.text}: ${shortcut}`)
+    }
+    else {
+        actionMgr.setAccel(name, shortcut)
+        debug(`Shortcut set for Action ${action.text}: ${shortcut}`)
+    }
+
+}
+
+export const clearActionShorcut = (name: string) => {
+    let action = findAction(name)
+    if (!action) return
+    if (isCustomAction(action)) {
+        actionMgr.setCustomActionShortcut(actionMgr.findCustomAction(name), '')
+    }
+    else {
+        actionMgr.setAccel(name, '')
+    }
+}
+
+export const getActionPixmap = (action: string, icon: string, maxSize?: number): QPixmap | null => {
+    try {
+        if (!action) return null;
+        let isCustom = isCustomAction(action)
+
+        if (isCustom && icon && typeof icon === 'string' && icon) {
+            let image: DzImageTexture = (App.getImageMgr() as any)['getImage(QString)'](icon)
+            if (image) {
+                let size = image.getOriginalImageSize();
+                let pixmap = size.width > maxSize || size.height > maxSize
+                    ? image.getPreviewPixmap(Math.min(size.width, maxSize), Math.min(size.height, maxSize))
+                    : new Pixmap(image.getFilename())
+
+                return pixmap
+            }
+        }
+        else if (!isCustom) {
+            let pixmap = App.getStyle().actionPixmap(action, 0, 0)
+            return pixmap?.height === 0 ? null : pixmap
+        }
+    } catch (error) {
+        warn(`Error while trying to get icon pixmap: ${error}`)
+    }
+    return null
+}
+
+