Wise Dialog Architect

Wise Dialog Architect is an open-source, modular system for designing, editing, and running dialogs using a structured, property-driven model.

It combines a visual dialog designer with a runtime execution engine, allowing dialogs to be authored visually, stored as data (such as JSON), and rendered dynamically at runtime, without hard-coding layouts or UI logic.

Built for installer authors, platform engineers, and tool developers, Wise Dialog Architect cleanly separates design-time tooling from runtime execution, making it ideal for modern, extensible Java applications.

Traditional dialog builders often:

• Lock UI definitions into code
• Tie layouts directly to implementation logic
• Make reuse, versioning, and automation difficult

Wise Dialog Architect takes a fundamentally different approach.

Dialogs are data.
The editor is just one way to create them.

Because the entire dialog is model-driven, you can:

• Design dialogs visually
• Generate or modify them programmatically
• Store and version them like any other asset
• Render them anywhere the runtime is embedded

And because it’s open source, you stay in control, no proprietary formats, no vendor lock-in.

Visual Dialog Layout

• Compose dialogs from a palette of controls
• Click-to-place, drag, resize, and align on a live design surface
• Dialog chrome (title, size, frame) is editable just like controls

Property- and Event-Driven Architecture

• Control attributes and behavior are stored as structured key/value data
• Properties and events live in the model, not in UI code
• Design-time and runtime stay perfectly synchronized

Fully Extensible

• Register custom control types using ToolRegistry
• Define how properties bind to Swing components
• Define how events are wired and dispatched
• Provide custom property dialogs, or fall back to the built-in generic editor

Runtime Dialog Execution

• Render dialogs directly from the dialog model
• No designer dependency required at runtime
• Events are dispatched to your application via a clean, structured API
• Ideal for installers, setup flows, admin tools, and embedded utilities

Wise Dialog Architect is delivered as a clean Maven multi-module project, so you only ship what you need.

You can:

• Embed the runtime only to render dialogs
• Embed designer + runtime to build your own editor
• Extend or customize without forking the core

The Designer module provides a complete visual editing experience while remaining UI-agnostic and host-driven.

Design Surface

• Live dialog preview with chrome and client area
• Transparent overlay for selection and resize handles
• Tool-driven behavior (pointer vs placement)

Selection & Interaction

• Select dialogs or individual controls
• Resize via edge and corner handles
• Move controls via drag gestures
• Keyboard focus is managed to avoid accidental component activation

Property Editing

• Dialog-level properties editor (title, size, layout)
• Generic control properties editor (properties + events)
• Host applications can override with control-specific property dialogs

At the core of Wise Dialog Architect is a simple, explicit, and serializable dialog model.

Dialog Model

• Dialog title and dimensions
• List of controls
• Serializable (e.g. JSON via application layer)

Control Model

Each control defines:

• Control type (label, button, etc.)
• Identity (id and name)
• Property map (layout and control-specific attributes)
• Event map (event slot → event identifier)

This makes dialogs:

• Portable
• Versionable
• Scriptable
• Easy to generate or transform outside the editor

Wise Dialog Architect uses explicit bindings, no hidden magic.

Property Sets

• Bind model properties to Swing component state
• Handle layout (x, y, width, height) and behavior
• Keep model and UI synchronized automatically

Event Sets

• Declare event slots (e.g. onClick)
• Wire listeners at runtime
• Dispatch structured events back to the application

Each runtime event includes:

• Source control
• Event type
• Event identifier
• Optional contextual data

• Installer and setup dialog authoring
• Visual tooling inside Java applications
• Data-driven configuration dialogs
• Embeddable dialog editors
• Replacing hard-coded Swing dialogs with maintainable models

Wise Dialog Architect isn’t a toy GUI builder, it’s a dialog architecture.

If you need:

• Long-term maintainability
• Data-driven UI
• Clean separation between design and execution
• An open-source foundation you can trust

Wise Dialog Architect delivers!