The Griffon Guide

$ curl -s get.gvmtool.net | bash

$ gvm install lazybones

bintrayRepositories = [
    "griffon/griffon-lazybones-templates",
    "pledbrook/lazybones-templates"
]

$ lazybones list
Available templates in griffon/griffon-lazybones-templates:

    griffon-javafx-java
    griffon-javafx-groovy
    griffon-lanterna-java
    griffon-lanterna-groovy
    griffon-pivot-java
    griffon-pivot-groovy
    griffon-swing-java
    griffon-swing-groovy
    griffon-plugin

$ lazybones create griffon-swing-groovy console
Creating project from template griffon-swing-groovy (latest) in 'console'
Define value for 'group' [org.example]: console
Define value for 'version' [0.1.0-SNAPSHOT]:
Define value for 'package' [console]:
Define value for 'griffonVersion' [2.0.0.BETA3]:

console
├── griffon-app
│   ├── conf
│   ├── controllers
│   ├── i18n
│   ├── lifecycle
│   ├── models
│   ├── resources
│   ├── services
│   └── views
└── src
    ├── integration-test
    │   └── groovy
    ├── main
    │   ├── groovy
    │   └── resources
    └── test
        ├── groovy
        └── resources

$ ./gradlew run

$ mvn compile exec:java

package console

import griffon.core.artifact.ArtifactManager
import griffon.core.injection.Module
import griffon.core.test.GriffonUnitRule
import griffon.core.test.TestFor
import griffon.inject.DependsOn
import org.codehaus.griffon.runtime.core.injection.AbstractModule
import org.junit.Rule
import org.junit.Test

import javax.annotation.Nonnull
import javax.inject.Inject

import static com.jayway.awaitility.Awaitility.await
import static com.jayway.awaitility.Awaitility.fieldIn
import static java.util.concurrent.TimeUnit.SECONDS
import static org.hamcrest.Matchers.notNullValue

@TestFor(ConsoleController)                                                   (1)
class ConsoleControllerTest {
    private ConsoleController controller                                      (2)

    @Inject
    private ArtifactManager artifactManager                                   (3)

    @Rule
    public final GriffonUnitRule griffon = new GriffonUnitRule()              (4)

    @Test
    void testExecuteScriptAction() {
        // given:                                                             (5)
        ConsoleModel model = artifactManager.newInstance(ConsoleModel.class)
        controller.model = model

        // when:                                                              (6)
        String input = 'var = "Griffon"'
        model.scriptSource = input
        controller.invokeAction('executeScript')

        // then:                                                              (7)
        await().atMost(2, SECONDS)
            .until(fieldIn(model)
            .ofType(Object)
            .andWithName('scriptResult'),
            notNullValue())
        assert input == model.scriptResult
    }

    private static class EchoEvaluator implements Evaluator {                 (8)
        @Override
        Object evaluate(String input) {
            input
        }
    }

    @DependsOn('application')
    private static class TestModule extends AbstractModule {
        @Override
        protected void doConfigure() {
            bind(Evaluator)
                .to(EchoEvaluator)
                .asSingleton()
        }
    }

    @Nonnull
    private List<Module> moduleOverrides() {
        [new TestModule()]
    }
}

$ ./gradlew test

$ mvn test

package sample.swing.groovy

application {
    title = 'Swing + Groovy'
    startupGroups = ['sample']
    autoShutdown = true
}
mvcGroups {
    // MVC Group for "sample"
    'sample' {
        model      = 'sample.swing.groovy.SampleModel'
        view       = 'sample.swing.groovy.SampleView'
        controller = 'sample.swing.groovy.SampleController'
    }
}

package sample.swing.java;

import griffon.util.AbstractMapResourceBundle;
import griffon.util.CollectionUtils;

import javax.annotation.Nonnull;
import java.util.Map;

import static java.util.Arrays.asList;

public class Config extends AbstractMapResourceBundle {
    @Override
    protected void initialize(@Nonnull Map<String, Object> entries) {
        CollectionUtils.map(entries)
            .e("application", CollectionUtils.map()
                .e("title", "Swing + Java")
                .e("startupGroups", asList("sample"))
                .e("autoShutdown", true)
            )
            .e("mvcGroups", CollectionUtils.map()
                .e("sample", CollectionUtils.map()
                    .e("model", "sample.swing.java.SampleModel")
                    .e("view", "sample.swing.java.SampleView")
                    .e("controller", "sample.swing.java.SampleController")
                )
            );
    }
}

application.title = Swing + Groovy
application.startupGroups = sample
application.autoShutdown = true
mvcGroups.sample.model = sample.swing.groovy.SampleModel
mvcGroups.sample.view = sample.swing.groovy.SampleView
mvcGroups.sample.controller = sample.swing.groovy.SampleController

package sample

import griffon.core.artifact.GriffonView
import griffon.core.env.Metadata
import griffon.metadata.ArtifactProviderFor

@ArtifactProviderFor(GriffonView)
class SampleView {
    FactoryBuilderSupport builder

    void initUI() {
        Metadata meta = Metadata.current
        builder.with {
            application(pack: true,
                title: application.configuration['application.title']) {
                label "Hello, I'm ${meta['application.name']}-${meta['application.version']}"
            }
        }
    }
}

package sample

import griffon.core.artifact.GriffonView
import griffon.core.env.Metadata
import griffon.core.env.Environment
import griffon.metadata.ArtifactProviderFor

@ArtifactProviderFor(GriffonView)
class SampleView {
    FactoryBuilderSupport builder

    void initUI() {
        Metadata meta = Metadata.current
        builder.with {
            application(pack: true,
                title: application.configuration['application.title']) {
                gridLayout cols: 1, rows: 2
                label "Hello, I'm ${meta['application.name']}-${meta['application.version']}"
                label "Current environment is ${Environment.current}"
            }
        }
    }
}

package sample

import griffon.core.artifact.GriffonView
import griffon.core.env.Metadata
import griffon.core.env.Environment
import griffon.metadata.ArtifactProviderFor
import static griffon.core.env.GriffonEnvironment.*

@ArtifactProviderFor(GriffonView)
class SampleView {
    FactoryBuilderSupport builder

    void initUI() {
        Metadata meta = Metadata.current
        builder.with {
            application(pack: true,
                title: application.configuration['application.title']) {
                gridLayout cols: 1, rows: 6
                label "Hello, I'm ${meta['application.name']}-${meta['application.version']}"
                label "Current environment is ${Environment.current}"
                label "Griffon version is ${getGriffonVersion()}"
                label "Build date/time is ${getBuildDateTime()}"
                label "JVM version is ${getJvmVersion()}"
                label "OS version is ${getOsVersion()}"
            }
        }
    }
}

public interface Module {
    @Nonnull
    List<Binding<?>> getBindings();

    void configure();
}

package org.example;

import griffon.core.injection.Module;
import org.codehaus.griffon.runtime.core.injection.AbstractModule;
import org.kordamp.jipsy.ServiceProviderFor;

import javax.inject.Named;

@ServiceProviderFor(Module.class)
@Named
public class CustomModule extends AbstractModule {
    @Override
    protected void doConfigure() {
        // bindings
    }
}

package org.example;

import griffon.core.injection.Module;
import org.codehaus.griffon.runtime.core.injection.AbstractModule;
import org.kordamp.jipsy.ServiceProviderFor;

import javax.inject.Named;

@ServiceProviderFor(Module.class)
@Named("custom")
public class CustomModule extends AbstractModule {
    @Override
    protected void doConfigure() {
        // bindings
    }
}

import griffon.core.injection.Module;
import griffon.inject.DependsOn;
import org.codehaus.griffon.runtime.core.injection.AbstractModule;
import org.kordamp.jipsy.ServiceProviderFor;

import javax.inject.Named;

@ServiceProviderFor(Module.class)
@DependsOn("parent-module")
@Named
public class CustomModule extends AbstractModule {
    @Override
    protected void doConfigure() {
        // bindings
    }
}

package sample

import java.awt.event.ActionEvent

import griffon.core.artifact.GriffonController

@griffon.metadata.ArtifactProviderFor(GriffonController)
class SampleController {
    void close(ActionEvent evt) { ... }
    void newAction(ActionEvent evt) { ... }
}

sample.SampleController.action.New.name = New
sample.SampleController.action.Open.name = Open
sample.SampleController.action.Close.name = Close
sample.SampleController.action.Delete.name = Delete
# additional keys per action elided

application.action.Close.name = Cerrar

package com.acme

import griffon.core.artifact.GriffonController
import griffon.core.controller.ActionExecutionStatus
import org.codehaus.griffon.runtime.core.controller.AbstractActionInterceptor

import javax.inject.Named

@Named('tracer')
class TracerActionInterceptor extends AbstractActionInterceptor {
    private final Map<String, Long> TIMES = [:]

    Object[] before(GriffonController controller, String actionName, Object[] args) {
        TIMES[qualifyActionName(controller, actionName)] = System.currentTimeMillis()
        return super.before(controller, actionName, args)
    }

    void after(ActionExecutionStatus status, GriffonController controller, String actionName, Object[] args) {
        String qualifiedActionName = qualifyActionName(controller, actionName)
        long time = System.currentTimeMillis() - TIMES[qualifiedActionName]
        println("Action ${qualifiedActionName} took ${time} ms [${status}]")
    }
}

package com.acme

import griffon.core.injection.Module
import griffon.core.controller.ActionInterceptor
import org.codehaus.griffon.runtime.core.injection.AbstractModule
import org.kordamp.jipsy.ServiceProviderFor

import javax.inject.Named

@ServiceProviderFor(Module)
@Named('application')
public class ApplicationModule extends AbstractModule {
    @Override
    protected void doConfigure() {
        bind(ActionInterceptor)
            .to(TracerActionInterceptor)
            .asSingleton()
    }
}

griffon.controller.action.interceptor.order = ['security', 'scaffolding']

windowManager {
    myWindowName = [
        show: {name, window -> ... },
        hide: {name, window -> ... }
    ]
    myOtherWindowName = [
        show: {name, window -> ... }
    ]
}

windowManager {
    defaultHandler = new MyCustomWindowDisplayHandler()
}

windowManager {
    defaultShow: {name, window -> ... },
    myWindowName = [
        show: {name, window -> ... },
        hide: {name, window -> ... }
    ]
    myOtherWindowName = [
        show: {name, window -> ... }
    ]
}

windowManager {
    startingWindow = 'primary'
}

package sample

import org.codehaus.griffon.runtime.swing.DefaultSwingWindowDisplayHandler

import javax.annotation.Nonnull
import java.awt.Window

import static griffon.swing.support.SwingUtils.centerOnScreen

class CenteringWindowDisplayHandler extends DefaultSwingWindowDisplayHandler {
    @Override
    void show(@Nonnull String name, @Nonnull Window window) {
        centerOnScreen(window)
        super.show(name, window)
    }
}

package sample

import griffon.core.injection.Module
import griffon.inject.DependsOn
import griffon.swing.SwingWindowDisplayHandler
import org.codehaus.griffon.runtime.core.injection.AbstractModule
import org.kordamp.jipsy.ServiceProviderFor

import static griffon.util.AnnotationUtils.named

@DependsOn('swing')
@ServiceProviderFor(Module)
class ApplicationModule extends AbstractModule {
    @Override
    protected void doConfigure() {
        bind(SwingWindowDisplayHandler)
            .withClassifier(named('defaultWindowDisplayHandler'))
            .to(CenteringWindowDisplayHandler)
            .asSingleton()
    }
}

package com.acme

import griffon.core.GriffonApplication
import griffon.core.event.EventHandler

class ApplicationEventHandler implements EventHandler {
    void onBootstrapEnd(GriffonApplication application) {
        println """
            Application configuration has finished loading.
            MVC Groups will be initialized now.
        """.stripIndent(12)
    }
}

package com.acme

import griffon.core.event.EventHandler
import griffon.core.injection.Module
import org.codehaus.griffon.runtime.core.injection.AbstractModule
import org.kordamp.jipsy.ServiceProviderFor

@ServiceProviderFor(Module)
class ApplicationModule extends AbstractModule {
    @Override
    protected void doConfigure() {
        bind(EventHandler)
            .to(ApplicationEventHandler)
            .asSingleton()
    }
}

class MyController {
    void onShutdownStart(application)
        println "${application.configuration['application.title']} is shutting down"
    }
}

class MyController {
    void mvcGroupInit(Map<String, Object> args) {
        application.eventRouter.addEventListener([
            Foo: { println 'got foo!' } as CallableWithArgs
        ])
    }

    void fooAction() {
        // do something
        application.eventRouter.publish('Foo')
    }
}

class MyController {
    void mvcGroupInit(Map<String, Object> args) {
        application.eventRouter.addEventListener('Foo',
            { println 'got foo!' } as CallableWithArgs
        ])
    }

    void fooAction() {
        // do something
        application.eventRouter.publish('Foo')
    }
}

class MyController {
    void mvcGroupInit(Map<String, Object> args) {
        application.eventRouter.addListener(Foo) {
            e -> assert e instanceof Foo
        }
    }

    void fooAction() {
        // do something
        application.eventRouter.publish(new MyController.Foo(this))
    }

    static class Foo extends griffon.core.Event {
        Foo(Object source) { super(source) }
    }
}

famous.quote = This is {0}!
hello.world = @[famous.quote]

assert getApplication()
           .getMessageSource()
           .getMessage('famous.quote', ['Sparta']) == 'This is Sparta!'

assert getApplication()
          .getMessageSource()
          .getMessage('hello.world', ['Griffon']) == 'This is Griffon!'

import javax.swing.Icon
import java.beans.PropertyEditor
import java.beans.PropertyEditorManager
...
Object iconValue = getApplication().getResourceResolver()
                                   .resolveResource('menu.icon', ['large'])
PropertyEditor propertyEditor = PropertyEditorManager.findEditor(Icon)
propertyEditor.setAsText(String.valueOf(iconValue))
Icon icon = propertyEditor.getValue()

action.icon = /img/icons/action-{0}.png
hello.icon = @[action.icon]

assert getApplication()
           .getResourceResolver()
           .resolveResource('action.icon', ['copy']) == '/img/icons/action-copy.png'

assert getApplication()
           .getResourceResolver()
           .resolveResource('hello.icon', ['paste']) == '/img/icons/action-paste.png'

bintrayRepositories = [
    "griffon/griffon-lazybones-templates",
    "pledbrook/lazybones-templates"
]

$ lazybones generate artifact::controller

$ lazybones generate artifact::mvcgroup::com.acme::group

$ ./gradlew test

$ ./gradlew -Dtest.single=EnvironmentTests :griffon-core:test

$ ./gradlew idea

$ git checkout -b mine

$ git checkout master
$ git pull upstream

$ git checkout mine
$ git rebase master

$ git checkout master
$ git merge mine

$ git push

package com.acme;

import griffon.inject.DependsOn;
import groovy.swing.factory.LayoutFactory;
import net.miginfocom.swing.MigLayout;
import groovy.util.Factory;
import org.codehaus.griffon.runtime.core.view.AbstractBuilderCustomizer;

import javax.inject.Named;
import java.util.LinkedHashMap;
import java.util.Map;

@Named("miglayout")
@DependsOn({"swing"})
@SuppressWarnings("rawtypes")
public class MiglayoutBuilderCustomizer extends AbstractBuilderCustomizer {
    @SuppressWarnings("unchecked")
    public MiglayoutBuilderCustomizer() {
        Map<String, Factory> factories = new LinkedHashMap<>();
        factories.put("miglayout", new LayoutFactory(MigLayout.class));
        setFactories(factories);
    }
}

package com.acme;

import griffon.core.injection.Module;
import griffon.inject.DependsOn;
import griffon.util.BuilderCustomizer;
import org.codehaus.griffon.runtime.core.injection.AbstractModule;
import org.kordamp.jipsy.ServiceProviderFor;

import javax.inject.Named;

@ServiceProviderFor(Module.class)
@DependsOn("swing-groovy")
@Named("miglayout-groovy")
public class MiglayoutModule extends AbstractModule {
    @Override
    protected void doConfigure() {
        bind(BuilderCustomizer.class)
            .to(MiglayoutBuilderCustomizer.class)
            .asSingleton();
    }
}

package com.acme

import griffon.core.event.EventHandler

class ApplicationEventHandler implements EventHandler {
    // event handlers as public methods
}

package com.acme

import griffon.core.event.EventHandler
import griffon.core.injection.Module
import org.codehaus.griffon.runtime.core.injection.AbstractModule
import org.kordamp.jipsy.ServiceProviderFor

@ServiceProviderFor(Module)
class ApplicationModule extends AbstractModule {
    @Override
    protected void doConfigure() {
        bind(EventHandler)
            .to(ApplicationEventHandler)
            .asSingleton()
    }
}

package sample

import griffon.core.artifact.GriffonView
import griffon.metadata.ArtifactProviderFor

@ArtifactProviderFor(GriffonView)
class SampleView {
    def builder
    def model

    void initUI() {
        builder.with {
            (1)
        }
    }
}

package sample.swing.java;

import griffon.core.GriffonApplication;
import griffon.core.artifact.GriffonModel;
import griffon.metadata.ArtifactProviderFor;
import org.codehaus.griffon.runtime.core.artifact.AbstractGriffonModel;

import javax.annotation.Nonnull;
import javax.inject.Inject;

@ArtifactProviderFor(GriffonModel.class)
public class SampleModel extends AbstractGriffonModel {
    private String input;                                                (1)
    private String output;                                               (1)

    @Inject
    public SampleModel(@Nonnull GriffonApplication application) {
        super(application);
    }

    public String getInput() {                                           (2)
        return input;
    }

    public void setInput(String input) {
        firePropertyChange("input", this.input, this.input = input);     (3)
    }

    public String getOutput() {                                          (2)
        return output;
    }

    public void setOutput(String output) {
        firePropertyChange("output", this.output, this.output = output); (3)
    }
}

package sample.swing.groovy

import griffon.core.artifact.GriffonModel
import griffon.metadata.ArtifactProviderFor
import griffon.transform.Observable

@ArtifactProviderFor(GriffonModel)
class SampleModel {
    @Observable String input                                             (1)
    @Observable String output                                            (1)
}

package sample.swing.java;

import griffon.core.GriffonApplication;
import griffon.core.artifact.GriffonController;
import griffon.metadata.ArtifactProviderFor;
import org.codehaus.griffon.runtime.core.artifact.AbstractGriffonController;

import javax.annotation.Nonnull;
import javax.inject.Inject;

@ArtifactProviderFor(GriffonController.class)
public class SampleController extends AbstractGriffonController {
    private SampleModel model;                                             (1)

    @Inject
    private SampleService sampleService;                                   (2)

    @Inject
    public SampleController(@Nonnull GriffonApplication application) {
        super(application);
    }

    public void setModel(SampleModel model) {
        this.model = model;
    }

    public void sayHello() {                                               (3)
        final String result = sampleService.sayHello(model.getInput());
        runInsideUIAsync(new Runnable() {                                  (4)
            @Override
            public void run() {
                model.setOutput(result);
            }
        });
    }
}

package sample.swing.groovy

import griffon.core.artifact.GriffonController
import griffon.metadata.ArtifactProviderFor

import javax.inject.Inject

@ArtifactProviderFor(GriffonController)
class SampleController {
    SampleModel model                                                      (1)

    @Inject
    private SampleService sampleService                                    (2)

    void sayHello() {                                                      (3)
        String result = sampleService.sayHello(model.input)
        model.output = result                                              (4)
    }
}

package sample.swing.java;

import griffon.core.GriffonApplication;
import griffon.core.artifact.GriffonService;
import griffon.core.i18n.MessageSource;
import griffon.metadata.ArtifactProviderFor;
import org.codehaus.griffon.runtime.core.artifact.AbstractGriffonService;

import javax.annotation.Nonnull;
import javax.inject.Inject;

import static griffon.util.GriffonNameUtils.isBlank;
import static java.util.Arrays.asList;

@ArtifactProviderFor(GriffonService.class)
public class SampleService extends AbstractGriffonService {
    @Inject
    public SampleService(@Nonnull GriffonApplication application) {
        super(application);
    }

    public String sayHello(String input) {
        MessageSource messageSource = getApplication().getMessageSource();
        if (isBlank(input)) {
            return messageSource.getMessage("greeting.default");
        } else {
            return messageSource.getMessage("greeting.parameterized", asList(input));
        }
    }
}

package sample.swing.groovy

import griffon.core.artifact.GriffonService
import griffon.core.i18n.MessageSource
import griffon.metadata.ArtifactProviderFor

import static griffon.util.GriffonNameUtils.isBlank

@ArtifactProviderFor(GriffonService)
class SampleService {
    String sayHello(String input) {
        MessageSource ms = application.messageSource
        isBlank(input) ? ms.getMessage('greeting.default') : ms.getMessage('greeting.parameterized', [input])
    }
}

package sample.swing.java;

import griffon.core.GriffonApplication;
import griffon.core.artifact.GriffonView;
import griffon.metadata.ArtifactProviderFor;
import org.codehaus.griffon.runtime.swing.artifact.AbstractSwingGriffonView;

import javax.annotation.Nonnull;
import javax.inject.Inject;
import javax.swing.*;
import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;
import java.awt.GridLayout;
import java.awt.Image;
import java.awt.Toolkit;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.Collections;

import static java.util.Arrays.asList;
import static javax.swing.WindowConstants.DO_NOTHING_ON_CLOSE;

@ArtifactProviderFor(GriffonView.class)
public class SampleView extends AbstractSwingGriffonView {
    private SampleController controller;                                         (1)
    private SampleModel model;                                                   (1)

    @Inject
    public SampleView(@Nonnull GriffonApplication application) {
        super(application);
    }

    public void setController(SampleController controller) {
        this.controller = controller;
    }

    public void setModel(SampleModel model) {
        this.model = model;
    }

    @Override
    public void initUI() {
        JFrame window = (JFrame) getApplication()
            .createApplicationContainer(Collections.<String, Object>emptyMap());
        window.setName("mainWindow");
        window.setTitle(getApplication().getConfiguration().getAsString("application.title"));
        window.setSize(320, 120);
        window.setDefaultCloseOperation(DO_NOTHING_ON_CLOSE);
        window.setIconImage(getImage("/griffon-icon-48x48.png"));
        window.setIconImages(asList(
            getImage("/griffon-icon-48x48.png"),
            getImage("/griffon-icon-32x32.png"),
            getImage("/griffon-icon-16x16.png")
        ));
        getApplication().getWindowManager().attach("mainWindow", window);        (2)

        window.getContentPane().setLayout(new GridLayout(4, 1));
        window.getContentPane().add(
            new JLabel(getApplication().getMessageSource().getMessage("name.label"))
        );
        final JTextField nameField = new JTextField();
        nameField.setName("inputField");
        nameField.getDocument().addDocumentListener(new DocumentListener() {     (3)
            @Override
            public void insertUpdate(DocumentEvent e) {
                model.setInput(nameField.getText());
            }

            @Override
            public void removeUpdate(DocumentEvent e) {
                model.setInput(nameField.getText());
            }

            @Override
            public void changedUpdate(DocumentEvent e) {
                model.setInput(nameField.getText());
            }
        });
        window.getContentPane().add(nameField);

        Action action = toolkitActionFor(controller, "sayHello");                (4)
        final JButton button = new JButton(action);
        button.setName("sayHelloButton");
        window.getContentPane().add(button);

        final JLabel outputLabel = new JLabel();
        outputLabel.setName("outputLabel");
        model.addPropertyChangeListener("output", new PropertyChangeListener() { (3)
            @Override
            public void propertyChange(PropertyChangeEvent evt) {
                outputLabel.setText(String.valueOf(evt.getNewValue()));
            }
        });
        window.getContentPane().add(outputLabel);
    }

    private Image getImage(String path) {
        return Toolkit.getDefaultToolkit().getImage(SampleView.class.getResource(path));
    }
}

package sample.swing.groovy

import griffon.core.artifact.GriffonView
import griffon.metadata.ArtifactProviderFor

@ArtifactProviderFor(GriffonView)
class SampleView {
    FactoryBuilderSupport builder                                                              (1)
    SampleModel model                                                                          (1)

    void initUI() {
        builder.with {
            application(title: application.configuration['application.title'],                 (2)
                id: 'mainWindow', size: [320, 160],
                iconImage: imageIcon('/griffon-icon-48x48.png').image,
                iconImages: [imageIcon('/griffon-icon-48x48.png').image,
                    imageIcon('/griffon-icon-32x32.png').image,
                    imageIcon('/griffon-icon-16x16.png').image]) {
                gridLayout(rows: 4, cols: 1)
                label(application.messageSource.getMessage('name.label'))
                textField(id: 'inputField', text: bind(target: model, 'input'))                 (3)
                button(sayHelloAction, id: 'sayHelloButton')                                    (4)
                label(id: 'outputLabel', text: bind { model.output })                           (3)
            }
        }
    }
}

name.label = Please enter your name
greeting.default = Howdy stranger!
greeting.parameterized = Hello {0}

package sample.javafx.java;

import griffon.core.GriffonApplication;
import griffon.core.artifact.GriffonModel;
import griffon.metadata.ArtifactProviderFor;
import javafx.beans.property.SimpleStringProperty;
import javafx.beans.property.StringProperty;
import org.codehaus.griffon.runtime.core.artifact.AbstractGriffonModel;

import javax.annotation.Nonnull;
import javax.inject.Inject;

@ArtifactProviderFor(GriffonModel.class)
public class SampleModel extends AbstractGriffonModel {
    private StringProperty input;                                          (1)
    private StringProperty output;                                         (1)

    @Inject
    public SampleModel(@Nonnull GriffonApplication application) {
        super(application);
    }

    @Nonnull
    public final StringProperty inputProperty() {                          (2)
        if (input == null) {
            input = new SimpleStringProperty(this, "input");
        }
        return input;
    }

    public void setInput(String input) {                                   (3)
        inputProperty().set(input);
    }

    public String getInput() {                                             (3)
        return input == null ? null : inputProperty().get();
    }

    @Nonnull
    public final StringProperty outputProperty() {                         (2)
        if (output == null) {
            output = new SimpleStringProperty(this, "output");
        }
        return output;
    }

    public void setOutput(String output) {                                 (3)
        outputProperty().set(output);
    }

    public String getOutput() {                                            (3)
        return output == null ? null : outputProperty().get();
    }
}

package sample.javafx.groovy

import griffon.core.artifact.GriffonModel
import griffon.metadata.ArtifactProviderFor
import griffon.transform.FXObservable

@ArtifactProviderFor(GriffonModel)
class SampleModel {
    @FXObservable String input                                           (1)
    @FXObservable String output                                          (1)
}

package sample.javafx.java;

import griffon.core.GriffonApplication;
import griffon.core.artifact.GriffonController;
import griffon.metadata.ArtifactProviderFor;
import org.codehaus.griffon.runtime.core.artifact.AbstractGriffonController;

import javax.annotation.Nonnull;
import javax.inject.Inject;

@ArtifactProviderFor(GriffonController.class)
public class SampleController extends AbstractGriffonController {
    private SampleModel model;                                             (1)

    @Inject
    private SampleService sampleService;                                   (2)

    @Inject
    public SampleController(@Nonnull GriffonApplication application) {
        super(application);
    }

    public void setModel(SampleModel model) {
        this.model = model;
    }

    public void sayHello() {                                               (3)
        final String result = sampleService.sayHello(model.getInput());
        runInsideUIAsync(new Runnable() {                                  (4)
            @Override
            public void run() {
                model.setOutput(result);
            }
        });
    }
}

package sample.javafx.groovy

import griffon.core.artifact.GriffonController
import griffon.metadata.ArtifactProviderFor

import javax.inject.Inject

@ArtifactProviderFor(GriffonController)
class SampleController {
    SampleModel model                                                      (1)

    @Inject
    private SampleService sampleService                                    (2)

    void sayHello() {                                                      (3)
        String result = sampleService.sayHello(model.input)
        runInsideUIAsync {                                                 (4)
            model.output = result
        }
    }
}

package sample.javafx.java;

import griffon.core.GriffonApplication;
import griffon.core.artifact.GriffonService;
import griffon.core.i18n.MessageSource;
import griffon.metadata.ArtifactProviderFor;
import org.codehaus.griffon.runtime.core.artifact.AbstractGriffonService;

import javax.annotation.Nonnull;
import javax.inject.Inject;

import static griffon.util.GriffonNameUtils.isBlank;
import static java.util.Arrays.asList;

@ArtifactProviderFor(GriffonService.class)
public class SampleService extends AbstractGriffonService {
    @Inject
    public SampleService(@Nonnull GriffonApplication application) {
        super(application);
    }

    public String sayHello(String input) {
        MessageSource messageSource = getApplication().getMessageSource();
        if (isBlank(input)) {
            return messageSource.getMessage("greeting.default");
        } else {
            return messageSource.getMessage("greeting.parameterized", asList(input));
        }
    }
}