AbstractGriffonArtifactScript (Griffon 2.0.0.RC2)

java.lang.Object
- groovy.lang.GroovyObjectSupport
- - groovy.lang.Script
  - - org.codehaus.griffon.runtime.groovy.artifact.AbstractGriffonArtifactScript

All Implemented Interfaces:

GriffonArtifact, MVCHandler, ResourceHandler, ThreadingHandler, groovy.lang.GroovyObject

Direct Known Subclasses:

AbstractGriffonMvcArtifactScript
```
public abstract class AbstractGriffonArtifactScript
extends groovy.lang.Script
implements GriffonArtifact
```
Author:

Andres Almiray

Constructor Summary

Constructors
Constructor and Description

AbstractGriffonArtifactScript(GriffonApplication application)

Constructors
Constructor and Description
`AbstractGriffonArtifactScript(GriffonApplication application)`

Method Summary

Methods
Modifier and Type	Method and Description
`MVCGroup`	`buildMVCGroup(Map<String,Object> args, String mvcType)` Instantiates an MVC group of the specified type with additional variables.
`MVCGroup`	`buildMVCGroup(Map<String,Object> args, String mvcType, String mvcId)` Instantiates an MVC group of the specified type with a particular name.
`MVCGroup`	`buildMVCGroup(String mvcType)` Instantiates an MVC group of the specified type.
`MVCGroup`	`buildMVCGroup(String mvcType, Map<String,Object> args)` Instantiates an MVC group of the specified type with additional variables.
`MVCGroup`	`buildMVCGroup(String mvcType, String mvcId)` Instantiates an MVC group of the specified type with a particular name.
`MVCGroup`	`buildMVCGroup(String mvcType, String mvcId, Map<String,Object> args)` Instantiates an MVC group of the specified type with a particular name.
`ClassLoader`	`classloader()` Returns the classloader used to resolve resources.
`List<? extends GriffonMvcArtifact>`	`createMVCGroup(Map<String,Object> args, String mvcType)` Instantiates an MVC group of the specified type with additional variables.
`List<? extends GriffonMvcArtifact>`	`createMVCGroup(Map<String,Object> args, String mvcType, String mvcId)` Instantiates an MVC group of the specified type with a particular name.
`List<? extends GriffonMvcArtifact>`	`createMVCGroup(String mvcType)` Instantiates an MVC group of the specified type returning only the MVC parts.
`List<? extends GriffonMvcArtifact>`	`createMVCGroup(String mvcType, Map<String,Object> args)` Instantiates an MVC group of the specified type with additional variables.
`List<? extends GriffonMvcArtifact>`	`createMVCGroup(String mvcType, String mvcId)` Instantiates an MVC group of the specified type with a particular name.
`List<? extends GriffonMvcArtifact>`	`createMVCGroup(String mvcType, String mvcId, Map<String,Object> args)` Instantiates an MVC group of the specified type with a particular name.
`void`	`destroyMVCGroup(String mvcId)` Destroys an MVC group identified by a particular name.
`GriffonApplication`	`getApplication()` Reference to the current `GriffonApplication`
`protected abstract String`	`getArtifactType()`
`GriffonClass`	`getGriffonClass()` Returns the `GriffonClass` associated with this artifact.
`Logger`	`getLog()` Returns a Logger instance suitable for this Artifact.
`InputStream`	`getResourceAsStream(String name)` Returns an input stream for reading the specified resource.
`URL`	`getResourceAsURL(String name)` Finds the resource with the given name.
`List<URL>`	`getResources(String name)` Finds all the resources with the given name.
`boolean`	`isUIThread()` True if the current thread is the UI thread.
`<R> Future<R>`	`runFuture(Callable<R> callable)` Executes a code block as a Future on a default ExecutorService.
`<R> Future<R>`	`runFuture(ExecutorService executorService, Callable<R> callable)` Executes a code block as a Future on an ExecutorService.
`void`	`runInsideUIAsync(Runnable runnable)` Executes a code block asynchronously on the UI thread.
`void`	`runInsideUISync(Runnable runnable)` Executes a code block synchronously on the UI thread.
`void`	`runOutsideUI(Runnable runnable)` Executes a code block outside of the UI thread.
`<M extends GriffonModel,V extends GriffonView,C extends GriffonController> void`	`withMVCGroup(Map<String,Object> args, String mvcType, MVCCallable<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`	`withMVCGroup(Map<String,Object> args, String mvcType, String mvcId, MVCCallable<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`	`withMVCGroup(String mvcType, Map<String,Object> args, MVCCallable<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`	`withMVCGroup(String mvcType, MVCCallable<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`	`withMVCGroup(String mvcType, String mvcId, Map<String,Object> args, MVCCallable<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`	`withMVCGroup(String mvcType, String mvcId, MVCCallable<M,V,C> handler)` Instantiates an MVC group of the specified type then destroys it after it has been handled.

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

- Constructor Detail
  - AbstractGriffonArtifactScript
```
public AbstractGriffonArtifactScript(@Nonnull
                             GriffonApplication application)
```
- Method Detail
  - getApplication
```
@Nonnull
public GriffonApplication getApplication()
```
    Description copied from interface: GriffonArtifact
    
    Reference to the current GriffonApplication
    
    Specified by:
    
    getApplication in interface GriffonArtifact
    
    Returns:
    the currently running application
  - getGriffonClass
```
@Nonnull
public GriffonClass getGriffonClass()
```
    Description copied from interface: GriffonArtifact
    
    Returns the GriffonClass associated with this artifact.
    
    Specified by:
    
    getGriffonClass in interface GriffonArtifact
    
    Returns:
    the GriffonClass associated with this artifact
  - getLog
```
@Nonnull
public Logger getLog()
```
    Description copied from interface: GriffonArtifact
    
    Returns a Logger instance suitable for this Artifact.
    The Logger is configured with the following prefix 'griffon.app.<type>' where <type> stands for the artifact's type.
    Example: the Logger for class com.acme.SampleController will be configured for 'griffon.app.controller.com.acme.SampleController'.
    
    Specified by:
    
    getLog in interface GriffonArtifact
    
    Returns:
    a Logger instance associated with this artifact.
  - getArtifactType
```
@Nonnull
protected abstract String getArtifactType()
```
  - isUIThread
```
public boolean isUIThread()
```
    Description copied from interface: ThreadingHandler
    
    True if the current thread is the UI thread.
    
    Specified by:
    
    isUIThread in interface ThreadingHandler
  - runFuture
```
@Nonnull
public <R> Future<R> runFuture(@Nonnull
                              ExecutorService executorService,
                              @Nonnull
                              Callable<R> callable)
```
    Description copied from interface: ThreadingHandler
    
    Executes a code block as a Future on an ExecutorService.
    
    Specified by:
    
    runFuture in interface ThreadingHandler
  - runFuture
```
@Nonnull
public <R> Future<R> runFuture(@Nonnull
                              Callable<R> callable)
```
    Description copied from interface: ThreadingHandler
    
    Executes a code block as a Future on a default ExecutorService.
    
    Specified by:
    
    runFuture in interface ThreadingHandler
  - runInsideUISync
```
public void runInsideUISync(@Nonnull
                   Runnable runnable)
```
    Description copied from interface: ThreadingHandler
    
    Executes a code block synchronously on the UI thread.
    
    Specified by:
    
    runInsideUISync in interface ThreadingHandler
  - runOutsideUI
```
public void runOutsideUI(@Nonnull
                Runnable runnable)
```
    Description copied from interface: ThreadingHandler
    
    Executes a code block outside of the UI thread.
    
    Specified by:
    
    runOutsideUI in interface ThreadingHandler
  - runInsideUIAsync
```
public void runInsideUIAsync(@Nonnull
                    Runnable runnable)
```
    Description copied from interface: ThreadingHandler
    
    Executes a code block asynchronously on the UI thread.
    
    Specified by:
    
    runInsideUIAsync in interface ThreadingHandler
  - classloader
```
@Nonnull
public ClassLoader classloader()
```
    Description copied from interface: ResourceHandler
    
    Returns the classloader used to resolve resources.
    
    Specified by:
    
    classloader in interface ResourceHandler
    
    Returns:
    a classloader instance
  - getResourceAsURL
```
@Nullable
public URL getResourceAsURL(@Nonnull
                            String name)
```
    Description copied from interface: ResourceHandler
    
    Finds the resource with the given name. A resource is some data (images, audio, text, etc) that can be accessed by class code in a way that is independent of the location of the code.
    
    The name of a resource is a '/'-separated path name that identifies the resource.
    
    Specified by:
    
    getResourceAsURL in interface ResourceHandler
    
    Parameters:
    name - The resource name
    
    Returns:
    A URL object for reading the resource, or null if the resource could not be found.
  - getResources
```
@Nullable
public List<URL> getResources(@Nonnull
                              String name)
```
    Description copied from interface: ResourceHandler
    
    Finds all the resources with the given name. A resource is some data (images, audio, text, etc) that can be accessed by class code in a way that is independent of the location of the code.
    
    The name of a resource is a /-separated path name that identifies the resource.
    
    Specified by:
    
    getResources in interface ResourceHandler
    
    Parameters:
    name - The resource name
    
    Returns:
    An java.util.List of URL objects for the resource. If no resources could be found, the list will be empty. Resources that the class loader doesn't have access to will not be in the list.
  - getResourceAsStream
```
@Nullable
public InputStream getResourceAsStream(@Nonnull
                                       String name)
```
    Description copied from interface: ResourceHandler
    
    Returns an input stream for reading the specified resource.
    
    Specified by:
    
    getResourceAsStream in interface ResourceHandler
    
    Parameters:
    name - The resource name
    
    Returns:
    An input stream for reading the resource, or null if the resource could not be found
  - buildMVCGroup
```
@Nonnull
public MVCGroup buildMVCGroup(@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:
```
 Map fooGroup = buildMVCGroup('foo')
 Map barGroup = buildMVCGroup('bar', model: fooGroup.model)
 assert fooGroup.model == barGroup.model
 
```
    Specified by:
    
    buildMVCGroup 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.
    
    Returns:
    an MVCGroup instance of the desired type
  - createMVCGroup
```
@Nonnull
public List<? extends GriffonMvcArtifact> createMVCGroup(@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) = createMVCGroup('foo')
 assert (c instanceof FooController)
 
```
    Specified by:
    
    createMVCGroup in interface MVCHandler
    
    Parameters:
    mvcType - the type of group to build.
    
    Returns:
    a List with the canonical MVC members of the group
  - withMVCGroup
```
public <M extends GriffonModel,V extends GriffonView,C extends GriffonController> void withMVCGroup(@Nonnull
                                                                                           String mvcType,
                                                                                           @Nonnull
                                                                                           String mvcId,
                                                                                           @Nonnull
                                                                                           MVCCallable<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
```
 withMVCGroup("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:
    
    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
  - createMVCGroup
```
@Nonnull
public List<? extends GriffonMvcArtifact> 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
```
 def (m, v, c) = createMVCGroup('foo', 'foo' + System.currenttimeMillis())
 assert (c instanceof FooController)
 
```
    MVC groups must have an unique name.
    Specified by:
    
    createMVCGroup in interface MVCHandler
    
    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
  - createMVCGroup
```
@Nonnull
public List<? extends GriffonMvcArtifact> 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:
```
 def (m1, v1, c1) = createMVCGroup('foo', 'foo1')
 def (m2, v2, c2) = createMVCGroup('foo', 'foo2', model: m1)
 assert fm1 == m2
 
```
    MVC groups must have an unique name.
    Specified by:
    
    createMVCGroup 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.
    
    Returns:
    a List with the canonical MVC members of the group
  - withMVCGroup
```
public <M extends GriffonModel,V extends GriffonView,C extends GriffonController> void withMVCGroup(@Nonnull
                                                                                           Map<String,Object> args,
                                                                                           @Nonnull
                                                                                           String mvcType,
                                                                                           @Nonnull
                                                                                           String mvcId,
                                                                                           @Nonnull
                                                                                           MVCCallable<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.
    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
  - buildMVCGroup
```
@Nonnull
public MVCGroup buildMVCGroup(@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:
```
 Map fooGroup1 = buildMVCGroup('foo', 'foo1')
 Map fooGroup2 = buildMVCGroup('bar', 'foo2', model: fooGroup1.model)
 assert fooGroup1.model == fooGroup2.model
 
```
    MVC groups must have an unique name.
    Specified by:
    
    buildMVCGroup 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.
    
    Returns:
    an MVCGroup instance of the desired type
  - buildMVCGroup
```
@Nonnull
public MVCGroup buildMVCGroup(@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:
```
 Map fooGroup1 = buildMVCGroup('foo', 'foo1')
 Map fooGroup2 = buildMVCGroup('bar', 'foo2', model: fooGroup1.model)
 assert fooGroup1.model == fooGroup2.model
 
```
    MVC groups must have an unique name.
    Specified by:
    
    buildMVCGroup 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.
    
    Returns:
    an MVCGroup instance of the desired type
  - createMVCGroup
```
@Nonnull
public List<? extends GriffonMvcArtifact> 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:
```
 def (m1, v1, c1) = createMVCGroup('foo')
 def (m2, v2, c2) = createMVCGroup('bar', model: m1)
 assert fm1 == m2
 
```
    Specified by:
    
    createMVCGroup 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.
    
    Returns:
    a List with the canonical MVC members of the group
  - withMVCGroup
```
public <M extends GriffonModel,V extends GriffonView,C extends GriffonController> void withMVCGroup(@Nonnull
                                                                                           String mvcType,
                                                                                           @Nonnull
                                                                                           MVCCallable<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
```
 withMVCGroup("foo", new MVCCallable<FooModel, FooView, FooController>() {
     public void call(FooModel m, FooView v, FooController c) {
         m.setSomeProperty(someValue);
         c.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
  - buildMVCGroup
```
@Nonnull
public MVCGroup buildMVCGroup(@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 = buildMVCGroup('foo')
 assert (fooGroup.controller instanceof FooController)
 
```
    Specified by:
    
    buildMVCGroup in interface MVCHandler
    
    Parameters:
    mvcType - the type of group to build.
    
    Returns:
    an MVCGroup instance of the desired type
  - buildMVCGroup
```
@Nonnull
public MVCGroup buildMVCGroup(@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
```
 Map fooGroup = buildMVCGroup('foo', 'foo' + System.currentTimeMillis())
 assert (fooGroup.controller instanceof FooController)
 
```
    MVC groups must have an unique name.
    Specified by:
    
    buildMVCGroup in interface MVCHandler
    
    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 List<? extends GriffonMvcArtifact> 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:
```
 def (m1, v1, c1) = createMVCGroup('foo')
 def (m2, v2, c2) = createMVCGroup('bar', model: m1)
 assert fm1 == m2
 
```
    Specified by:
    
    createMVCGroup 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.
    
    Returns:
    a List with the canonical MVC members of the group
  - withMVCGroup
```
public <M extends GriffonModel,V extends GriffonView,C extends GriffonController> void withMVCGroup(@Nonnull
                                                                                           Map<String,Object> args,
                                                                                           @Nonnull
                                                                                           String mvcType,
                                                                                           @Nonnull
                                                                                           MVCCallable<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.
    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
  - withMVCGroup
```
public <M extends GriffonModel,V extends GriffonView,C extends GriffonController> void withMVCGroup(@Nonnull
                                                                                           String mvcType,
                                                                                           @Nonnull
                                                                                           Map<String,Object> args,
                                                                                           @Nonnull
                                                                                           MVCCallable<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.
    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
  - buildMVCGroup
```
@Nonnull
public MVCGroup buildMVCGroup(@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:
```
 Map fooGroup = buildMVCGroup('foo')
 Map barGroup = buildMVCGroup('bar', model: fooGroup.model)
 assert fooGroup.model == barGroup.model
 
```
    Specified by:
    
    buildMVCGroup 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.
    
    Returns:
    an MVCGroup instance of the desired type
  - createMVCGroup
```
@Nonnull
public List<? extends GriffonMvcArtifact> 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:
```
 def (m1, v1, c1) = createMVCGroup('foo', 'foo1')
 def (m2, v2, c2) = createMVCGroup('foo', 'foo2', model: m1)
 assert fm1 == m2
 
```
    MVC groups must have an unique name.
    Specified by:
    
    createMVCGroup 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.
    
    Returns:
    a List with the canonical MVC members of the group
  - withMVCGroup
```
public <M extends GriffonModel,V extends GriffonView,C extends GriffonController> void withMVCGroup(@Nonnull
                                                                                           String mvcType,
                                                                                           @Nonnull
                                                                                           String mvcId,
                                                                                           @Nonnull
                                                                                           Map<String,Object> args,
                                                                                           @Nonnull
                                                                                           MVCCallable<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.
    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
  - destroyMVCGroup
```
public void destroyMVCGroup(@Nonnull
                   String mvcId)
```
    Description copied from interface: MVCHandler
    
    Destroys an MVC group identified by a particular name.
    ATTENTION: make sure to call the super implementation if you override this method otherwise group references will not be kept up to date.
    
    Specified by:
    
    destroyMVCGroup in interface MVCHandler
    
    Parameters:
    mvcId - the name of the group to destroy and dispose.

Class AbstractGriffonArtifactScript

Constructor Summary

Method Summary

Methods inherited from class groovy.lang.Script

Methods inherited from class groovy.lang.GroovyObjectSupport

Methods inherited from class java.lang.Object

Constructor Detail

AbstractGriffonArtifactScript

Method Detail

getApplication

getGriffonClass

getLog

getArtifactType

isUIThread

runFuture

runFuture

runInsideUISync

runOutsideUI

runInsideUIAsync

classloader

getResourceAsURL

getResources

getResourceAsStream

buildMVCGroup

createMVCGroup

withMVCGroup

createMVCGroup

createMVCGroup

withMVCGroup

buildMVCGroup

buildMVCGroup

createMVCGroup

withMVCGroup

buildMVCGroup

buildMVCGroup

createMVCGroup

withMVCGroup

withMVCGroup

buildMVCGroup

createMVCGroup

withMVCGroup

destroyMVCGroup