org.codehaus.griffon.runtime.groovy.artifact

Class AbstractGriffonMvcArtifactScript

java.lang.Object

groovy.lang.GroovyObjectSupport

groovy.lang.Script

org.codehaus.griffon.runtime.groovy.artifact.AbstractGriffonArtifactScript

org.codehaus.griffon.runtime.groovy.artifact.AbstractGriffonMvcArtifactScript

All Implemented Interfaces:

GriffonArtifact, GriffonMvcArtifact, MVCHandler, ResourceHandler, ThreadingHandler, GroovyObject

Direct Known Subclasses:

AbstractGriffonViewScript

public abstract class AbstractGriffonMvcArtifactScript
extends AbstractGriffonArtifactScript
implements GriffonMvcArtifact

Author:

Andres Almiray

Field Summary

Fields inherited from class org.codehaus.griffon.runtime.groovy.artifact.AbstractGriffonArtifactScript

application

Constructor Summary

Constructors

Constructor and Description
AbstractGriffonMvcArtifactScript()

Method Summary

Modifier and Type	Method and Description
List<? extends GriffonMvcArtifact>	createMVC(Map<String,Object> args, String mvcType) Instantiates an MVC group of the specified type with additional variables.
List<? extends GriffonMvcArtifact>	createMVC(Map<String,Object> args, String mvcType, String mvcId) Instantiates an MVC group of the specified type with a particular name.
List<? extends GriffonMvcArtifact>	createMVC(String mvcType) Instantiates an MVC group of the specified type returning only the MVC parts.
List<? extends GriffonMvcArtifact>	createMVC(String mvcType, Map<String,Object> args) Instantiates an MVC group of the specified type with additional variables.
List<? extends GriffonMvcArtifact>	createMVC(String mvcType, String mvcId) Instantiates an MVC group of the specified type with a particular name.
List<? extends GriffonMvcArtifact>	createMVC(String mvcType, String mvcId, Map<String,Object> args) Instantiates an MVC group of the specified type with a particular name.
MVCGroup	createMVCGroup(Map<String,Object> args, String mvcType) Instantiates an MVC group of the specified type with additional variables.
MVCGroup	createMVCGroup(Map<String,Object> args, String mvcType, String mvcId) Instantiates an MVC group of the specified type with a particular name.
MVCGroup	createMVCGroup(String mvcType) Instantiates an MVC group of the specified type.
MVCGroup	createMVCGroup(String mvcType, Map<String,Object> args) Instantiates an MVC group of the specified type with additional variables.
MVCGroup	createMVCGroup(String mvcType, String mvcId) Instantiates an MVC group of the specified type with a particular name.
MVCGroup	createMVCGroup(String mvcType, String mvcId, Map<String,Object> args) Instantiates an MVC group of the specified type with a particular name.
MVCGroup	getMvcGroup()
void	mvcGroupDestroy() Callback for when the group is destroyed and disposed from the application.
void	mvcGroupInit(Map<String,Object> args) Post initialization callback.
void	setMvcGroup(MVCGroup group)
<M extends GriffonModel,V extends GriffonView,C extends GriffonController> void	withMVC(Map<String,Object> args, String mvcType, MVCFunction<M,V,C> handler) Instantiates an MVC group of the specified type then destroys it after it has been handled.
<M extends GriffonModel,V extends GriffonView,C extends GriffonController> void	withMVC(Map<String,Object> args, String mvcType, String mvcId, MVCFunction<M,V,C> handler) Instantiates an MVC group of the specified type then destroys it after it has been handled.
<M extends GriffonModel,V extends GriffonView,C extends GriffonController> void	withMVC(String mvcType, Map<String,Object> args, MVCFunction<M,V,C> handler) Instantiates an MVC group of the specified type then destroys it after it has been handled.
<M extends GriffonModel,V extends GriffonView,C extends GriffonController> void	withMVC(String mvcType, MVCFunction<M,V,C> handler) Instantiates an MVC group of the specified type then destroys it after it has been handled.
<M extends GriffonModel,V extends GriffonView,C extends GriffonController> void	withMVC(String mvcType, String mvcId, Map<String,Object> args, MVCFunction<M,V,C> handler) Instantiates an MVC group of the specified type then destroys it after it has been handled.
<M extends GriffonModel,V extends GriffonView,C extends GriffonController> void	withMVC(String mvcType, String mvcId, MVCFunction<M,V,C> handler) Instantiates an MVC group of the specified type then destroys it after it has been handled.
void	withMVCGroup(Map<String,Object> args, String mvcType, MVCGroupFunction handler) Instantiates an MVC group of the specified type then destroys it after it has been handled.
void	withMVCGroup(Map<String,Object> args, String mvcType, String mvcId, MVCGroupFunction handler) Instantiates an MVC group of the specified type then destroys it after it has been handled.
void	withMVCGroup(String mvcType, Map<String,Object> args, MVCGroupFunction handler) Instantiates an MVC group of the specified type then destroys it after it has been handled.
void	withMVCGroup(String mvcType, MVCGroupFunction handler) Instantiates an MVC group of the specified type then destroys it after it has been handled.
void	withMVCGroup(String mvcType, String mvcId, Map<String,Object> args, MVCGroupFunction handler) Instantiates an MVC group of the specified type then destroys it after it has been handled.
void	withMVCGroup(String mvcType, String mvcId, MVCGroupFunction handler) Instantiates an MVC group of the specified type then destroys it after it has been handled.

Methods inherited from class org.codehaus.griffon.runtime.groovy.artifact.AbstractGriffonArtifactScript

classloader, destroyMVCGroup, getApplication, getArtifactType, getGriffonClass, getLog, getResourceAsStream, getResourceAsURL, getResources, isUIThread, runFuture, runFuture, runInsideUIAsync, runInsideUISync, runInsideUISync, runOutsideUI

Methods inherited from class groovy.lang.Script

evaluate, evaluate, getBinding, getProperty, invokeMethod, print, printf, printf, println, println, run, run, setBinding, setProperty

Methods inherited from class groovy.lang.GroovyObjectSupport

getMetaClass, setMetaClass

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface griffon.core.artifact.GriffonArtifact

getApplication, getGriffonClass, getLog

Methods inherited from interface griffon.core.threading.ThreadingHandler

isUIThread, runFuture, runFuture, runInsideUIAsync, runInsideUISync, runInsideUISync, runOutsideUI

Methods inherited from interface griffon.core.mvc.MVCHandler

destroyMVCGroup

Methods inherited from interface griffon.core.resources.ResourceHandler

classloader, getResourceAsStream, getResourceAsURL, getResources

Constructor Detail

AbstractGriffonMvcArtifactScript

public AbstractGriffonMvcArtifactScript()

Method Detail

setMvcGroup

public void setMvcGroup(@Nonnull
                        MVCGroup group)

getMvcGroup

@Nonnull
public MVCGroup getMvcGroup()

Specified by:

getMvcGroup in interface GriffonMvcArtifact

mvcGroupInit

public void mvcGroupInit(@Nonnull
                         Map<String,Object> args)

Description copied from interface: GriffonMvcArtifact

Post initialization callback.

This callback is called for all artifacts that belong to the same MVC group right after each instance has been created. Each entry on the args Map points either to an MVC member or a variable that was defined using any of the createMVCGroup and/or createMVC methods that can take a Map as parameter.

Specified by:

mvcGroupInit in interface GriffonMvcArtifact

Parameters:

args - a Map of MVC instances or variables keyed by type.

mvcGroupDestroy

public void mvcGroupDestroy()

Description copied from interface: GriffonMvcArtifact

Callback for when the group is destroyed and disposed from the application.

Once an artifact has been "destroyed" it should not be used anymore. The application will remove any references to the group on its cache.

Specified by:

mvcGroupDestroy in interface GriffonMvcArtifact

createMVCGroup

@Nonnull
public MVCGroup createMVCGroup(@Nonnull
                                        Map<String,Object> args,
                                        @Nonnull
                                        String mvcType)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type with additional variables.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

The args Map can contain any value that will be used in one of the following scenarios

• The key matches a member definition; the value will be used as the instance of such member.
• The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.

For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
     }
     'bar' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.BarView'
         controller = 'com.acme.BarController'
     }
 }
 

Notice that groups "foo" and "bar share the same model type, We can make them share the same model instance by creating the groups in the following way:

 MVCGroup fooGroup = createMVCGroup('foo')
 MVCGroup barGroup = createMVCGroup('bar', model: fooGroup.model)
 assert fooGroup.model == barGroup.model
 

Specified by:

createMVCGroup in interface MVCHandler

Overrides:

createMVCGroup in class AbstractGriffonArtifactScript

Parameters:

args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.

mvcType - the type of group to build.

Returns:

an MVCGroup instance of the desired type

createMVCGroup

@Nonnull
public MVCGroup createMVCGroup(@Nonnull
                                        Map<String,Object> args,
                                        @Nonnull
                                        String mvcType,
                                        @Nonnull
                                        String mvcId)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type with a particular name.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

The args Map can contain any value that will be used in one of the following scenarios

• The key matches a member definition; the value will be used as the instance of such member.
• The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.

For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
     }
 }
 

We can create two instances of the same group that share the same model instance in the following way:

 MVCGroup fooGroup1 = createMVCGroup('foo', 'foo1')
 MVCGroup fooGroup2 = createMVCGroup('bar', 'foo2', model: fooGroup1.model)
 assert fooGroup1.model == fooGroup2.model
 

MVC groups must have an unique name.

Specified by:

createMVCGroup in interface MVCHandler

Overrides:

createMVCGroup in class AbstractGriffonArtifactScript

Parameters:

args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.

mvcType - the type of group to build.

mvcId - the name to assign to the built group.

Returns:

an MVCGroup instance of the desired type

createMVCGroup

@Nonnull
public MVCGroup createMVCGroup(@Nonnull
                                        String mvcType)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
     }
 }
 

An instance of the "foo" group can be created as follows

 Map fooGroup = createMVCGroup('foo')
 assert (fooGroup.controller instanceof FooController)
 

Specified by:

createMVCGroup in interface MVCHandler

Overrides:

createMVCGroup in class AbstractGriffonArtifactScript

Parameters:

mvcType - the type of group to build.

Returns:

an MVCGroup instance of the desired type

createMVCGroup

@Nonnull
public MVCGroup createMVCGroup(@Nonnull
                                        String mvcType,
                                        @Nonnull
                                        Map<String,Object> args)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type with additional variables.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

The args Map can contain any value that will be used in one of the following scenarios

• The key matches a member definition; the value will be used as the instance of such member.
• The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.

For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
     }
     'bar' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.BarView'
         controller = 'com.acme.BarController'
     }
 }
 

Notice that groups "foo" and "bar share the same model type, We can make them share the same model instance by creating the groups in the following way:

 MVCGroup fooGroup = createMVCGroup('foo')
 MVCGroup barGroup = createMVCGroup('bar', model: fooGroup.model)
 assert fooGroup.model == barGroup.model
 

Specified by:

createMVCGroup in interface MVCHandler

Overrides:

createMVCGroup in class AbstractGriffonArtifactScript

Parameters:

mvcType - the type of group to build.

args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.

Returns:

an MVCGroup instance of the desired type

createMVCGroup

@Nonnull
public MVCGroup createMVCGroup(@Nonnull
                                        String mvcType,
                                        @Nonnull
                                        String mvcId)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type with a particular name.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
     }
 }
 

An instance of the "foo" group can be created as follows

 MVCGroup fooGroup = createMVCGroup('foo', 'foo' + System.currentTimeMillis())
 assert (fooGroup.controller instanceof FooController)
 

MVC groups must have an unique name.

Specified by:

createMVCGroup in interface MVCHandler

Overrides:

createMVCGroup in class AbstractGriffonArtifactScript

Parameters:

mvcType - the type of group to build.

mvcId - the name to assign to the built group.

Returns:

an MVCGroup instance of the desired type

createMVCGroup

@Nonnull
public MVCGroup createMVCGroup(@Nonnull
                                        String mvcType,
                                        @Nonnull
                                        String mvcId,
                                        @Nonnull
                                        Map<String,Object> args)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type with a particular name.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

The args Map can contain any value that will be used in one of the following scenarios

• The key matches a member definition; the value will be used as the instance of such member.
• The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.

For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
     }
 }
 

We can create two instances of the same group that share the same model instance in the following way:

 MVCGroup fooGroup1 = createMVCGroup('foo', 'foo1')
 MVCGroup fooGroup2 = createMVCGroup('bar', 'foo2', model: fooGroup1.model)
 assert fooGroup1.model == fooGroup2.model
 

MVC groups must have an unique name.

Specified by:

createMVCGroup in interface MVCHandler

Overrides:

createMVCGroup in class AbstractGriffonArtifactScript

Parameters:

mvcType - the type of group to build.

mvcId - the name to assign to the built group.

args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.

Returns:

an MVCGroup instance of the desired type

createMVC

@Nonnull
public List<? extends GriffonMvcArtifact> createMVC(@Nonnull
                                                             Map<String,Object> args,
                                                             @Nonnull
                                                             String mvcType)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type with additional variables.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

The args Map can contain any value that will be used in one of the following scenarios

• The key matches a member definition; the value will be used as the instance of such member.
• The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.

For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
     }
     'bar' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.BarView'
         controller = 'com.acme.BarController'
     }
 }
 

Notice that groups "foo" and "bar share the same model type, We can make them share the same model instance by creating the groups in the following way:

 def (m1, v1, c1) = createMVC('foo')
 def (m2, v2, c2) = createMVC('bar', model: m1)
 assert fm1 == m2
 

Specified by:

createMVC in interface MVCHandler

Overrides:

createMVC in class AbstractGriffonArtifactScript

Parameters:

args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.

mvcType - the type of group to build.

Returns:

a List with the canonical MVC members of the group

createMVC

@Nonnull
public List<? extends GriffonMvcArtifact> createMVC(@Nonnull
                                                             Map<String,Object> args,
                                                             @Nonnull
                                                             String mvcType,
                                                             @Nonnull
                                                             String mvcId)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type with a particular name.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

The args Map can contain any value that will be used in one of the following scenarios

• The key matches a member definition; the value will be used as the instance of such member.
• The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.

For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
     }
 }
 

We can create two instances of the same group that share the same model instance in the following way:

 def (m1, v1, c1) = createMVC('foo', 'foo1')
 def (m2, v2, c2) = createMVC('foo', 'foo2', model: m1)
 assert fm1 == m2
 

MVC groups must have an unique name.

Specified by:

createMVC in interface MVCHandler

Overrides:

createMVC in class AbstractGriffonArtifactScript

Parameters:

args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.

mvcType - the type of group to build.

mvcId - the name to assign to the built group.

Returns:

a List with the canonical MVC members of the group

createMVC

@Nonnull
public List<? extends GriffonMvcArtifact> createMVC(@Nonnull
                                                             String mvcType)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type returning only the MVC parts.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
     }
 }
 

An instance of the "foo" group can be created as follows

 def (m, v, c) = createMVC('foo')
 assert (c instanceof FooController)
 

Specified by:

createMVC in interface MVCHandler

Overrides:

createMVC in class AbstractGriffonArtifactScript

Parameters:

mvcType - the type of group to build.

Returns:

a List with the canonical MVC members of the group

createMVC

@Nonnull
public List<? extends GriffonMvcArtifact> createMVC(@Nonnull
                                                             String mvcType,
                                                             @Nonnull
                                                             Map<String,Object> args)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type with additional variables.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

The args Map can contain any value that will be used in one of the following scenarios

• The key matches a member definition; the value will be used as the instance of such member.
• The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.

For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
     }
     'bar' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.BarView'
         controller = 'com.acme.BarController'
     }
 }
 

Notice that groups "foo" and "bar share the same model type, We can make them share the same model instance by creating the groups in the following way:

 def (m1, v1, c1) = createMVC('foo')
 def (m2, v2, c2) = createMVC('bar', model: m1)
 assert fm1 == m2
 

Specified by:

createMVC in interface MVCHandler

Overrides:

createMVC in class AbstractGriffonArtifactScript

Parameters:

mvcType - the type of group to build.

args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.

Returns:

a List with the canonical MVC members of the group

createMVC

@Nonnull
public List<? extends GriffonMvcArtifact> createMVC(@Nonnull
                                                             String mvcType,
                                                             @Nonnull
                                                             String mvcId)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type with a particular name.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
      }
 }
 

An instance of the "foo" group can be created as follows

 def (m, v, c) = createMVC('foo', 'foo' + System.currenttimeMillis())
 assert (c instanceof FooController)
 

MVC groups must have an unique name.

Specified by:

createMVC in interface MVCHandler

Overrides:

createMVC in class AbstractGriffonArtifactScript

Parameters:

mvcType - the type of group to build.

mvcId - the name to assign to the built group.

Returns:

a List with the canonical MVC members of the group

createMVC

@Nonnull
public List<? extends GriffonMvcArtifact> createMVC(@Nonnull
                                                             String mvcType,
                                                             @Nonnull
                                                             String mvcId,
                                                             @Nonnull
                                                             Map<String,Object> args)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type with a particular name.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

The args Map can contain any value that will be used in one of the following scenarios

• The key matches a member definition; the value will be used as the instance of such member.
• The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.

For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
     }
 }
 

We can create two instances of the same group that share the same model instance in the following way:

 def (m1, v1, c1) = createMVC('foo', 'foo1')
 def (m2, v2, c2) = createMVC('foo', 'foo2', model: m1)
 assert fm1 == m2
 

MVC groups must have an unique name.

Specified by:

createMVC in interface MVCHandler

Overrides:

createMVC in class AbstractGriffonArtifactScript

Parameters:

mvcType - the type of group to build.

mvcId - the name to assign to the built group.

args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.

Returns:

a List with the canonical MVC members of the group

withMVC

public <M extends GriffonModel,V extends GriffonView,C extends GriffonController> void withMVC(@Nonnull
                                                                                               Map<String,Object> args,
                                                                                               @Nonnull
                                                                                               String mvcType,
                                                                                               @Nonnull
                                                                                               MVCFunction<M,V,C> handler)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type then destroys it after it has been handled.

This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

The args Map can contain any value that will be used in one of the following scenarios

• The key matches a member definition; the value will be used as the instance of such member.
• The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
    }
 }
 

An instance of the "foo" group can be used as follows

 Map map = ... // initialized elsewhere
 withMVC("foo", map, new MVCCallable<FooModel, FooView, FooController>() {
    public void call(FooModel m, FooView v, FooController c) {
        m.setSomeProperty(someValue);
        c.invokeAnAction();
    }
 });
 

Specified by:

withMVC in interface MVCHandler

Overrides:

withMVC in class AbstractGriffonArtifactScript

Parameters:

args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.

mvcType - the type of group to build.

handler - a code block used to configure and manage the instantiated group

withMVCGroup

public void withMVCGroup(@Nonnull
                         Map<String,Object> args,
                         @Nonnull
                         String mvcType,
                         @Nonnull
                         MVCGroupFunction handler)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type then destroys it after it has been handled.

This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

The args Map can contain any value that will be used in one of the following scenarios

• The key matches a member definition; the value will be used as the instance of such member.
• The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
    }
 }
 

An instance of the "foo" group can be used as follows

 Map map = ... // initialized elsewhere
 withMVCGroup("foo", map, new MVCGroupCallable() {
    public void call(MVCGroup group) {
        group.getModel().setSomeProperty(someValue);
        group.getController().invokeAnAction();
    }
 });
 

Specified by:

withMVCGroup in interface MVCHandler

Parameters:

args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.

mvcType - the type of group to build.

handler - a code block used to configure and manage the instantiated group

withMVC

public <M extends GriffonModel,V extends GriffonView,C extends GriffonController> void withMVC(@Nonnull
                                                                                               Map<String,Object> args,
                                                                                               @Nonnull
                                                                                               String mvcType,
                                                                                               @Nonnull
                                                                                               String mvcId,
                                                                                               @Nonnull
                                                                                               MVCFunction<M,V,C> handler)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type then destroys it after it has been handled.

This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

The args Map can contain any value that will be used in one of the following scenarios

• The key matches a member definition; the value will be used as the instance of such member.
• The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
     }
 }
 

An instance of the "foo" group can be used as follows

 Map map = ... // initialized elsewhere
 withMVC("foo", "foo1", map, new MVCCallable<FooModel, FooView, FooController>() {
    public void call(FooModel m, FooView v, FooController c) {
        m.setSomeProperty(someValue);
        c.invokeAnAction();
    }
 });
 

MVC groups must have an unique name.

Specified by:

withMVC in interface MVCHandler

Overrides:

withMVC in class AbstractGriffonArtifactScript

Parameters:

args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.

mvcType - the type of group to build.

mvcId - the name to assign to the built group.

handler - a code block used to configure and manage the instantiated group

withMVCGroup

public void withMVCGroup(@Nonnull
                         Map<String,Object> args,
                         @Nonnull
                         String mvcType,
                         @Nonnull
                         String mvcId,
                         @Nonnull
                         MVCGroupFunction handler)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type then destroys it after it has been handled.

This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

The args Map can contain any value that will be used in one of the following scenarios

• The key matches a member definition; the value will be used as the instance of such member.
• The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
     }
 }
 

An instance of the "foo" group can be used as follows

 Map map = ... // initialized elsewhere
 withMVCGroup("foo", "foo1", map, new MVCGroupCallable() {
    public void call(MVCGroup group) {
        group.getModel().setSomeProperty(someValue);
        group.getController().invokeAnAction();
    }
 });
 

MVC groups must have an unique name.

Specified by:

withMVCGroup in interface MVCHandler

Parameters:

args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.

mvcType - the type of group to build.

mvcId - the name to assign to the built group.

handler - a code block used to configure and manage the instantiated group

withMVC

public <M extends GriffonModel,V extends GriffonView,C extends GriffonController> void withMVC(@Nonnull
                                                                                               String mvcType,
                                                                                               @Nonnull
                                                                                               Map<String,Object> args,
                                                                                               @Nonnull
                                                                                               MVCFunction<M,V,C> handler)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type then destroys it after it has been handled.

This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

The args Map can contain any value that will be used in one of the following scenarios

• The key matches a member definition; the value will be used as the instance of such member.
• The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
    }
 }
 

An instance of the "foo" group can be used as follows

 Map map = ... // initialized elsewhere
 withMVC("foo", map, new MVCCallable<FooModel, FooView, FooController>() {
    public void call(FooModel m, FooView v, FooController c) {
        m.setSomeProperty(someValue);
        c.invokeAnAction();
    }
 });
 

Specified by:

withMVC in interface MVCHandler

Overrides:

withMVC in class AbstractGriffonArtifactScript

Parameters:

mvcType - the type of group to build.

args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.

handler - a code block used to configure and manage the instantiated group

withMVCGroup

public void withMVCGroup(@Nonnull
                         String mvcType,
                         @Nonnull
                         Map<String,Object> args,
                         @Nonnull
                         MVCGroupFunction handler)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type then destroys it after it has been handled.

This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

The args Map can contain any value that will be used in one of the following scenarios

• The key matches a member definition; the value will be used as the instance of such member.
• The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
    }
 }
 

An instance of the "foo" group can be used as follows

 Map map = ... // initialized elsewhere
 withMVCGroup("foo", map, new MVCGroupCallable() {
    public void call(MVCGroup group) {
        group.getModel().setSomeProperty(someValue);
        group.getController().invokeAnAction();
    }
 });
 

Specified by:

withMVCGroup in interface MVCHandler

Parameters:

mvcType - the type of group to build.

args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.

handler - a code block used to configure and manage the instantiated group

withMVC

public <M extends GriffonModel,V extends GriffonView,C extends GriffonController> void withMVC(@Nonnull
                                                                                               String mvcType,
                                                                                               @Nonnull
                                                                                               MVCFunction<M,V,C> handler)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type then destroys it after it has been handled.

This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
    }
 }
 

An instance of the "foo" group can be used as follows

 withMVC("foo", new MVCCallable<FooModel, FooView, FooController>() {
     public void call(FooModel m, FooView v, FooController c) {
         m.setSomeProperty(someValue);
         c.invokeAnAction();
     }
 });
 

Specified by:

withMVC in interface MVCHandler

Overrides:

withMVC in class AbstractGriffonArtifactScript

Parameters:

mvcType - the type of group to build.

handler - a code block used to configure and manage the instantiated group

withMVCGroup

public void withMVCGroup(@Nonnull
                         String mvcType,
                         @Nonnull
                         MVCGroupFunction handler)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type then destroys it after it has been handled.

This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
    }
 }
 

An instance of the "foo" group can be used as follows

 withMVC("foo", new MVCGroupCallable() {
     public void call(MVCGroup group) {
         group.getModel().setSomeProperty(someValue);
         group.getController().invokeAnAction();
     }
 });
 

Specified by:

withMVCGroup in interface MVCHandler

Parameters:

mvcType - the type of group to build.

handler - a code block used to configure and manage the instantiated group

withMVC

public <M extends GriffonModel,V extends GriffonView,C extends GriffonController> void withMVC(@Nonnull
                                                                                               String mvcType,
                                                                                               @Nonnull
                                                                                               String mvcId,
                                                                                               @Nonnull
                                                                                               Map<String,Object> args,
                                                                                               @Nonnull
                                                                                               MVCFunction<M,V,C> handler)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type then destroys it after it has been handled.

This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

The args Map can contain any value that will be used in one of the following scenarios

• The key matches a member definition; the value will be used as the instance of such member.
• The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
     }
 }
 

An instance of the "foo" group can be used as follows

 Map map = ... // initialized elsewhere
 withMVC("foo", "foo1", map, new MVCCallable<FooModel, FooView, FooController>() {
    public void call(FooModel m, FooView v, FooController c) {
        m.setSomeProperty(someValue);
        c.invokeAnAction();
    }
 });
 

MVC groups must have an unique name.

Specified by:

withMVC in interface MVCHandler

Overrides:

withMVC in class AbstractGriffonArtifactScript

Parameters:

mvcType - the type of group to build.

mvcId - the name to assign to the built group.

args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.

handler - a code block used to configure and manage the instantiated group

withMVCGroup

public void withMVCGroup(@Nonnull
                         String mvcType,
                         @Nonnull
                         String mvcId,
                         @Nonnull
                         Map<String,Object> args,
                         @Nonnull
                         MVCGroupFunction handler)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type then destroys it after it has been handled.

This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

The args Map can contain any value that will be used in one of the following scenarios

• The key matches a member definition; the value will be used as the instance of such member.
• The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
     }
 }
 

An instance of the "foo" group can be used as follows

 Map map = ... // initialized elsewhere
 withMVCGroup("foo", "foo1", map, new MVCGroupCallable() {
    public void call(MVCGroup group) {
        group.getModel().setSomeProperty(someValue);
        group.getController().invokeAnAction();
    }
 });
 

MVC groups must have an unique name.

Specified by:

withMVCGroup in interface MVCHandler

Parameters:

mvcType - the type of group to build.

mvcId - the name to assign to the built group.

args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.

handler - a code block used to configure and manage the instantiated group

withMVC

public <M extends GriffonModel,V extends GriffonView,C extends GriffonController> void withMVC(@Nonnull
                                                                                               String mvcType,
                                                                                               @Nonnull
                                                                                               String mvcId,
                                                                                               @Nonnull
                                                                                               MVCFunction<M,V,C> handler)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type then destroys it after it has been handled.

This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
     }
 }
 

An instance of the "foo" group can be used as follows

 withMVC("foo", "foo1", new MVCCallable<FooModel, FooView, FooController>() {
     public void call(FooModel m, FooView v, FooController c) {
         m.setSomeProperty(someValue);
         c.invokeAnAction();
     }
 });
 

MVC groups must have an unique name.

Specified by:

withMVC in interface MVCHandler

Overrides:

withMVC in class AbstractGriffonArtifactScript

Parameters:

mvcType - the type of group to build.

mvcId - the name to assign to the built group.

handler - a code block used to configure and manage the instantiated group

withMVCGroup

public void withMVCGroup(@Nonnull
                         String mvcType,
                         @Nonnull
                         String mvcId,
                         @Nonnull
                         MVCGroupFunction handler)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type then destroys it after it has been handled.

This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
     }
 }
 

An instance of the "foo" group can be used as follows

 withMVCGroup("foo", "foo1", new MVCGroupCallable() {
     public void call(MVCGroup group) {
         group.getModel().setSomeProperty(someValue);
         group.getController().invokeAnAction();
     }
 });
 

MVC groups must have an unique name.

Specified by:

withMVCGroup in interface MVCHandler

Parameters:

mvcType - the type of group to build.

mvcId - the name to assign to the built group.

handler - a code block used to configure and manage the instantiated group