Swing Common UI

// See FilterTableModel example
SwingFilterTableModel<Person, String> tableModel = createFilterTableModel();

FilterTable<Person, String> table =
        FilterTable.builder()
                .model(tableModel)
                .cellRenderer(Person.AGE, Integer.class, renderer -> renderer
                        .horizontalAlignment(SwingConstants.CENTER))
                .doubleClick(Control.command(() ->
                        tableModel.selection().item().optional()
                                .ifPresent(System.out::println)))
                .autoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS)
                .build();

State somethingEnabledState = State.state(true);

CommandControl control = Control.builder()
        .command(() -> System.out.println("Doing something"))
        .caption("Do something")
        .mnemonic('D')
        .enabled(somethingEnabledState)
        .build();

JButton somethingButton = new JButton(control);

Control.ActionCommand actionCommand = actionEvent -> {
  if ((actionEvent.getModifiers() & ActionEvent.SHIFT_MASK) != 0) {
    System.out.println("Doing something else");
  }
};
CommandControl actionControl = Control.builder()
        .action(actionCommand)
        .caption("Do something else")
        .mnemonic('S')
        .build();

JButton somethingElseButton = new JButton(actionControl);

State state = State.state();

ToggleControl toggleStateControl = Control.builder()
        .toggle(state)
        .build();

JToggleButton toggleButton = Components.toggleButton()
        .toggle(toggleStateControl)
        .text("Change state")
        .mnemonic('C')
        .build();

Value<Boolean> booleanValue = Value.nonNull(false);

ToggleControl toggleValueControl = Control.builder()
        .toggle(booleanValue)
        .build();

JCheckBox checkBox = Components.checkBox()
        .toggle(toggleValueControl)
        .text("Change value")
        .mnemonic('V')
        .build();

Value<Boolean> nullableBooleanValue = Value.nullable();

ToggleControl nullableToggleControl = Control.builder()
        .toggle(nullableBooleanValue)
        .build();

NullableCheckBox nullableCheckBox = Components.nullableCheckBox()
        .toggle(nullableToggleControl)
        .build();

Controls controls = Controls.builder()
        .control(Control.builder()
                .command(this::doFirst)
                .caption("First")
                .mnemonic('F'))
        .control(Control.builder()
                .command(this::doSecond)
                .caption("Second")
                .mnemonic('S'))
        .control(Controls.builder()
                .caption("Submenu")
                .control(Control.builder()
                        .command(this::doSubFirst)
                        .caption("Sub-first")
                        .mnemonic('b'))
                .control(Control.builder()
                        .command(this::doSubSecond)
                        .caption("Sub-second")
                        .mnemonic('u')))
        .build();

JMenu menu = Components.menu()
        .controls(controls)
        .build();

Control firstControl = Control.builder()
        .command(this::doFirst)
        .caption("First")
        .mnemonic('F')
        .build();
Control secondControl = Control.builder()
        .command(this::doSecond)
        .caption("Second")
        .mnemonic('S')
        .build();

Controls twoControls = Controls.builder()
        .controls(firstControl, secondControl)
        .build();

JPanel buttonPanel = Components.buttonPanel()
        .controls(twoControls)
        .build();

Event<?> close = Event.event();

JButton closeButton = Components.button()
        .control(Control.builder()
                .command(close::run)
                .caption("Close"))
        .build();

Dialogs.builder()
        .component(closeButton)
        .owner(window)
        .title("Dialog")
        .disposeOnEscape(false)
        .closeObserver(close)
        .show();

ComponentValue<NumberField<Integer>, Integer> component =
        Components.integerField()
                .value(42)
                .buildValue();

Integer input = Dialogs.input()
        .component(component)
        .owner(window)
        .title("Input")
        .valid(State.present(component))
        .show();

Dialogs.exception()
        .owner(window)
        .title("Exception")
        // Don't include system properties
        .systemProperties(false)
        .show(exception);

Dialogs.calendar()
        .owner(window)
        .title("Calendar")
        .selectLocalDate()
        .ifPresent(System.out::println);

Dialogs.progressWorker()
        .task(this::performTask)
        .owner(window)
        .title("Performing task")
        .delay(500, 1000)
        .onSuccess(this::handleResult)
        .onException(this::handleException)
        .execute();

// A non-progress aware task, producing no result
ProgressWorker.Task task = () -> {
  // Perform the task
};

ProgressWorker.builder()
        .task(task)
        .onException(exception ->
                Dialogs.exception()
                        .owner(applicationFrame)
                        .show(exception))
        .execute();

// TaskHandler encapsulates the task and its handlers in a single class.
// Handler interface methods are called first, followed by
// any handlers added via the builder, in the order they were added.
// This enables a layered approach where the handler interface
// handles model-level concerns (logging, state updates) while
// builder handlers handle UI-level concerns (displaying dialogs).
ProgressWorker.TaskHandler task = new TaskHandler() {

  @Override
  public void execute() throws Exception {
    // Perform the task
  }

  // Called first on exception: log the error (model-level)
  @Override
  public void onException(Exception exception) {
    LOG.log(Level.WARNING, exception.getMessage());
  }
};

ProgressWorker.builder()
        .task(task)
        // Called after the handler's onException: display the error (UI-level)
        .onException(exception -> Dialogs.exception()
                .owner(applicationFrame)
                .show(exception))
        .execute();

// A non-progress aware task, producing a result
ProgressWorker.ResultTask<String> task = () -> {
  // Perform the task
  return "Result";
};

ProgressWorker.builder()
        .task(task)
        .onResult(result ->
                showMessageDialog(applicationFrame, result))
        .onException(exception ->
                Dialogs.exception()
                        .owner(applicationFrame)
                        .show(exception))
        .execute();

// ResultTaskHandler encapsulates a result-producing task and its handlers.
// The handler's onResult and onException are called first (model-level),
// then the builder's handlers are called after (UI-level).
ResultTaskHandler<String> task = new ResultTaskHandler<String>() {

  @Override
  public String execute() throws Exception {
    // Perform the task
    return "Result";
  }

  // Called first on success: log the result (model-level)
  @Override
  public void onResult(String result) {
    LOG.log(Level.INFO, result);
  }

  // Called first on exception: log the error (model-level)
  @Override
  public void onException(Exception exception) {
    LOG.log(Level.WARNING, exception.getMessage());
  }
};

ProgressWorker.builder()
        .task(task)
        // Called after the handler's onResult: display the result (UI-level)
        .onResult(result -> showMessageDialog(applicationFrame, result))
        // Called after the handler's onException: display the error (UI-level)
        .onException(exception -> Dialogs.exception()
                .owner(applicationFrame)
                .show(exception))
        .execute();

// A progress aware task, producing no result
ProgressWorker.ProgressTask<String> task = progressReporter -> {
  // Perform the task
  progressReporter.report(42);
  progressReporter.publish("Message");
};

ProgressWorker.builder()
        .task(task)
        .onProgress(progress ->
                System.out.println("Progress: " + progress))
        .onPublish(message ->
                showMessageDialog(applicationFrame, message))
        .onException(exception ->
                Dialogs.exception()
                        .owner(applicationFrame)
                        .show(exception))
        .execute();

// ProgressTaskHandler encapsulates a progress-aware task and its handlers.
// The handler's methods are called first (model-level),
// then the builder's handlers are called after (UI-level).
ProgressTaskHandler<String> task = new ProgressTaskHandler<String>() {

  @Override
  public void execute(ProgressReporter<String> progressReporter) throws Exception {
    // Perform the task
    for (int i = 0; i < maximum(); i++) {
      progressReporter.report(i);
      progressReporter.publish("Message " + i);
    }
  }

  @Override
  public void onProgress(int progress) {
    System.out.println("Progress: " + progress);
  }

  @Override
  public void onPublish(List<String> message) {
    displayMessage(message);
  }

  // Called first on exception: log the error (model-level)
  @Override
  public void onException(Exception exception) {
    LOG.log(Level.WARNING, exception.getMessage());
  }
};

ProgressWorker.builder()
        .task(task)
        // Called after the handler's onException: display the error (UI-level)
        .onException(exception -> Dialogs.exception()
                .owner(applicationFrame)
                .show(exception))
        .execute();

// A reusable, cancellable task, producing a result.
// Displays a progress bar in a dialog while running.
var task = new DemoProgressResultTask();

ProgressWorker.builder()
        .task(task.prepare(142))
        .execute();

static final class DemoProgressResultTask implements ProgressResultTaskHandler<Integer, String> {

  private final JProgressBar progressBar = progressBar()
          .indeterminate(false)
          .stringPainted(true)
          .string("")
          .build();
  // Indicates whether the task has been cancelled
  private final AtomicBoolean cancelled = new AtomicBoolean();
  // A Control for setting the cancelled state
  private final Control cancel = Control.builder()
          .command(() -> cancelled.set(true))
          .caption("Cancel")
          .mnemonic('C')
          .build();
  // A panel containing the progress bar and cancel button
  private final JPanel progressPanel = borderLayoutPanel()
          .center(progressBar)
          .east(button()
                  .control(cancel))
          .build();
  // The dialog displaying the progress panel
  private final JDialog dialog = Dialogs.builder()
          .component(progressPanel)
          .owner(applicationFrame)
          // Trigger the cancel control with the Escape key
          .keyEvent(KeyEvents.builder()
                  .keyCode(VK_ESCAPE)
                  .action(cancel))
          // Prevent the dialog from closing on Escape
          .disposeOnEscape(false)
          .build();

  private int taskSize;

  @Override
  public Integer execute(ProgressReporter<String> progressReporter) throws Exception {
    List<Integer> result = new ArrayList<>();
    for (int i = 0; i < taskSize; i++) {
      Thread.sleep(50);
      if (cancelled.get()) {
        throw new CancelException();
      }
      result.add(i);
      reportProgress(progressReporter, i);
    }

    return result.stream()
            .mapToInt(Integer::intValue)
            .sum();
  }

  @Override
  public int maximum() {
    return taskSize;
  }

  @Override
  public void onStarted() {
    dialog.setVisible(true);
  }

  @Override
  public void onProgress(int progress) {
    progressBar.setValue(progress);
  }

  @Override
  public void onPublish(List<String> strings) {
    progressBar.setString(strings.get(0));
  }

  @Override
  public void onDone() {
    dialog.setVisible(false);
  }

  @Override
  public void onCancelled() {
    showMessageDialog(applicationFrame, "Cancelled");
  }

  @Override
  public void onException(Exception exception) {
    Dialogs.exception()
            .owner(applicationFrame)
            .show(exception);
  }

  @Override
  public void onResult(Integer result) {
    showMessageDialog(applicationFrame, "Result : " + result);
  }

  // Makes this task reusable by resetting the internal state
  private DemoProgressResultTask prepare(int taskSize) {
    this.taskSize = taskSize;
    progressBar.getModel().setMaximum(taskSize);
    cancelled.set(false);

    return this;
  }

  private void reportProgress(ProgressReporter<String> reporter, int progress) {
    reporter.report(progress);
    if (progress < taskSize * 0.5) {
      reporter.publish("Going strong");
    }
    else if (progress > taskSize * 0.5 && progress < taskSize * 0.85) {
      reporter.publish("Half way there");
    }
    else if (progress > taskSize * 0.85) {
      reporter.publish("Almost done");
    }
  }
}